25 Ways to Apply Functions

 25 Ways to Apply Functions
f@x is the same as f[x]:
f@x

It’s often convenient to write out chains of functions using @:
f@g@h@x

Avoiding the brackets can make code easier to type, and read:

There’s a third way to write f[x] in the Wolfram Language: as an “afterthought”, in the form x//f.
Apply f “as an afterthought” to x:
x // f

You can have a sequence of “afterthoughts”:
x // f // g // h

A particularly common use of // is to apply N (for numerical evaluation) “as an afterthought”.
Apply numerical evaluation “as an afterthought”:
2 Pi^3 + 1 // N

In working with the Wolfram Language, a powerful notation that one ends up using all the time is /@, which means “apply to each element”.
Apply f to each element in a list:
f /@ {1, 2, 3}

f usually would just get applied to the whole list:
f[{1, 2, 3}]

Framed is a function that displays a frame around something.
Display x framed:
Framed[x]

Applying Framed to a list just puts a frame around the whole list.
Apply Framed to a whole list:
Framed[{x, y, z}]

@ does exactly the same thing:
Framed@{x, y, z}

Now use /@ to apply Framed to each element in the list:
Framed /@ {x, y, z}

The same thing works with any other function. For example, apply the function Hue separately to each number in a list.
/@ applies Hue separately to each number in the list:
Hue /@ {0.1, 0.2, 0.3, 0.4}

Here’s what the /@ is doing:
{Hue[0.1], Hue[0.2], Hue[0.3], Hue[0.4]}

It’s the same story with Range, though now the output is a list of lists.
/@ applies Range separately to each number, producing a list of lists:
Range /@ {3, 2, 5, 6, 7}

Here’s the equivalent, all written out:
{Range[3], Range[2], Range[5], Range[6], Range[7]}

Given a list of lists, /@ is what one needs to do an operation separately to each sublist.
Apply PieChart separately to each list in a list of lists:
PieChart /@ {{1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 4, 4, 4}, {1, 2, 1, 2, 1, 2}}

Apply Length to each element, getting the length of each sublist:
Length /@ {{a, a}, {a, a, b, c}, {a, a, b, b, b, b}, {a, a, a}, {c, c}}

Applying Length to the whole list just gives the total number of sublists:
Length@{{a, a}, {a, a, b, c}, {a, a, b, b, b, b}, {a, a, a}, {c, c}}

Apply Reverse to each element, getting three different reversed lists:
Reverse /@ {{a, b, c}, {x, y, z}, {1, 2, 3, 4}}

Apply Reverse to the whole list, reversing its elements:
Reverse@{{a, b, c}, {x, y, z}, {1, 2, 3, 4}}

As always, the form with brackets is exactly equivalent:
Reverse[{{a, b, c}, {x, y, z}, {1, 2, 3, 4}}]

Some calculational functions are listable, which means they automatically apply themselves to elements in a list.
N is listable, so you don’t have to use /@ to get it applied to each element in a list:
N[{1/3, 1/4, 1/5, 1/6}]

The same is true with Prime:
Prime[{10, 100, 1000, 10000}]

A function like Graphics definitely isn’t listable.
This makes a single graphic with three objects in it:
Graphics[{Circle[], RegularPolygon[7], Style[RegularPolygon[3], Orange]}]

Graphics /@ {Circle[], RegularPolygon[7], Style[RegularPolygon[3], Orange]}

When you enter f/@{1,2,3}, the Wolfram Language interprets it as Map[f,{1,2,3}]. f/@x is usually read as “map f over x”.
The internal interpretation of f/@{1, 2, 3}:
Map[f, {1, 2, 3}]

 f@x equivalent to f[x] x//f equivalent to f[x] f/@{a,b,c} apply f separately to each element of the list Map[ f,{a,b,c}] alternative form of /@ Framed[expr] put a frame around something
25.1Use /@ and Range to reproduce the result of Table[f[n], {n, 5}]»
Expected output:
 Out[]=
25.2Use /@ twice to generate Table[f[g[n]], {n, 10}]»
Expected output:
 Out[]=
25.3Use // to create a[b[c[d[x]]]]»
Expected output:
 Out[]=
25.4Make a list of letters of the alphabet, with a frame around each one. »
Expected output:
 Out[]=
25.5Color negate an image of each planet, giving a list of the results. »
Expected output:
 Out[]=
25.6Use /@ to draw separate maps of each country in the G5. »
Expected output:
 Out[]=
25.7Binarize each flag in Europe, and make an image collage of the result. »
Expected output:
 Out[]=
25.8Find a list of the dominant colors in images of the planets, putting the results for each planet in a column. »
Expected output:
 Out[]=
25.9Find the total of the letter numbers given by LetterNumber for the letters in the word “wolfram”. »
Expected output:
 Out[]=
Why not always use f@x instead of f[x]?
f@x is a fine equivalent to f[x], but the equivalent of f[1+1] is f@(1+1), and in that case, f[1+1] is shorter and easier to understand.
Why is /@ called Map?
It comes from math. Given a set {1, 2, 3}, f/@{1, 2, 3} can be thought of as mapping of this set to another one.
How does one say "//" and "/@"?
Typically “slash slash” and “slash at”.
When do I need to use parentheses with @, // and /@?
It’s determined by the precedence or binding of different operators. @ binds tighter than +, so f@1+1 means f[1]+1 not f@(1+1)or f[1+1]. // binds looser than +, so 1/2+1/3//N means (1/2+1/3)//N. In a notebook you can find how things are grouped by repeatedly clicking on your input, and seeing how the selection expands.