Pure Functions

a pure function in which arguments are specified as # or #1,#2,#3, etc.

Pure functions.

When you use functional operations such as Nest and Map, you always have to specify a function to apply. In all the examples above, we have used the "name" of a function to specify the function. Pure functions allow you to give functions which can be applied to arguments, without having to define explicit names for the functions.

There are several equivalent ways to write pure functions in the Wolfram Language. The idea in all cases is to construct an object which, when supplied with appropriate arguments, computes a particular function. Thus, for example, if fun is a pure function, then fun[a] evaluates the function with argument a.

Here is a pure function that represents the operation of squaring.

In[4]:=

Out[4]=

Supplying the argument n to the pure function yields the square of n.

In[5]:=

Out[5]=

You can use a pure function wherever you would usually give the name of a function.

This sets up a pure function with two arguments and then applies the function to the arguments a and b.

In[8]:=

Out[8]=

If you are going to use a particular function repeatedly, then you can define the function using f[x_]:=body, and refer to the function by its name f. On the other hand, if you only intend to use a function once, you will probably find it better to give the function in pure function form, without ever naming it.

If you are familiar with formal logic or the LISP programming language, you will recognize Wolfram Language pure functions as being like expressions or anonymous functions. Pure functions are also close to the pure mathematical notion of operators.

#

the first variable in a pure function

#n

the nNull variable in a pure function

##

the sequence of all variables in a pure function

##n

the sequence of variables starting with the n one

Short forms for pure functions.

Just as the name of a function is irrelevant if you do not intend to refer to the function again, so also the names of arguments in a pure function are irrelevant. The Wolfram Language allows you to avoid using explicit names for the arguments of pure functions, and instead to specify the arguments by giving "slot numbers" #n. In a Wolfram Language pure function, #n stands for the n argument you supply. # stands for the first argument.

#^2& is a short form for a pure function that squares its argument.

In[9]:=

Out[9]=

This applies a function that takes the first two elements from each list. By using a pure function, you avoid having to define the function separately.

When you use short forms for pure functions, it is very important that you do not forget the ampersand. If you leave the ampersand out, the Wolfram Language will not know that the expression you give is to be used as a pure function.

When you use the ampersand notation for pure functions, you must be careful about the grouping of pieces in your input. As shown in"Operator Input Forms" the ampersand notation has fairly low precedence, which means that you can type expressions like #1+#2& without parentheses. On the other hand, if you want, for example, to set an option to be a pure function, you need to use parentheses, as in option->(fun&).

Pure functions in the Wolfram Language can take any number of arguments. You can use ## to stand for all the arguments that are given, and ##n to stand for the n and subsequent arguments.