body& or Function[body]
is a pure (or "anonymous") function. The formal parameters are # (or #1), #2, etc.
x|->body or xbody or Function[x,body]
is a pure function with a single formal parameter x.
{x1,x2,…}|->body or {x1,x2,…}body or Function[{x1,x2,…},body]
is a pure function with a list of formal parameters.
Function[params,body,attrs]
is a pure function that is treated as having attributes attrs for purposes of evaluation.
Function 
body& or Function[body]
is a pure (or "anonymous") function. The formal parameters are # (or #1), #2, etc.
x|->body or xbody or Function[x,body]
is a pure function with a single formal parameter x.
{x1,x2,…}|->body or {x1,x2,…}body or Function[{x1,x2,…},body]
is a pure function with a list of formal parameters.
Function[params,body,attrs]
is a pure function that is treated as having attributes attrs for purposes of evaluation.
Details
- When Function[body] or body& is applied to a set of arguments, # (or #1) is replaced by the first argument, #2 by the second, and so on. #0 is replaced by the function itself.
- If there are more arguments supplied than # i in the function, the remaining arguments are ignored. »
- ## stands for the sequence of all arguments supplied. »
- ## n stands for arguments from number n onward. »
- When applied to an association, #name is equivalent to #["name"], and picks out elements in the association.
- In the form #name, the characters in name can be any combination of alphanumeric characters not beginning with digits.
- The character is entered as
|->
,
fn
or \[Function]. - Function is analogous to λ in LISP or formal logic.
- Function has attribute HoldAll. The function body is evaluated only after the formal parameters have been replaced by arguments.
- The named formal parameters xi in Function[{x1,…},body] are treated as local, and are renamed xi$ when necessary to avoid confusion with actual arguments supplied to the function. »
- Function constructs can be nested in any way. Each is treated as a scoping construct, with named inner variables being renamed if necessary. »
- In Function[params,body,attrs], attrs can be a single attribute or a list of attributes. »
- Function[Null,body,attrs] represents a function in which the parameters in body are given using # etc.
Examples
open all close allBasic Examples (4)
Pure function with one parameter:
Function[u, 3 + u][x]Function[3 + #][x](3 + #)&[x]Pure function with two parameters:
Function[{u, v}, u ^ 2 + v ^ 4][x, y](#1 ^ 2 + #2 ^ 4)&[x, y]f = (3 + #)&{f[a], f[b]}Pick out named arguments from an association:
f[#u, #v, #u]&[<|"u" -> x, "v" -> y|>]Scope (15)
Use a Pure Function as an Argument (5)
Map a pure function over a list:
g[#, # ^ 2]& /@ {x, y, z}Select[{1, -1, 2, -2, 3}, # > 0&]Use a pure function as a predicate:
Cases[{1, -1, 2, -2, 3}, _Integer ? (# > 0&)]Create an array from a pure function:
Array[1 + # ^ 2&, 10]Sort by comparing the second part of each element:
Sort[{{a, 2}, {c, 1}, {d, 3}}, #1[[2]] < #2[[2]]&]Use a Pure Function as an Option Value (3)
Specify a custom comparison function in FixedPoint:
FixedPoint[(# + 2 / # ) / 2&, 1`20, SameTest -> (Abs[#1 - #2] < 1*^-10&)]Specify a custom color function:
DensityPlot[Sin[x y], {x, 0, 3}, {y, 0, 3}, ColorFunction -> (RGBColor[1 - #, #, 1 - #]&)]Provide a custom distance function:
Nearest[{1, 2, 4, 8, 16}, 5, DistanceFunction -> ((#1 - #2) ^ 2&)]Return a Pure Function as a Result (4)
Derivative of a pure function:
Function[x, x ^ 2]'Derivative of Tan:
Tan'Solutions of differential equations may be expressed as pure functions:
DSolve[{y'[x] == ay[x], y[0] == 1}, y, x]Difference equations may return pure functions:
RSolve[{a[n + 1] - 2a[n] == 1, a[0] == 1}, a, n]Function and Associations (3)
#name is effectively a short form of #["name"]:
#x&[<|"x" -> a, "y" -> b|>]#["x"]&[<|"x" -> a, "y" -> b|>]#name always refers to the association in the first argument:
#y&[<|"x" -> 1, "y" -> 2|>, <|"x" -> 3, "y" -> 4|>]Extract from an association slot other than the first:
#2["y"]&[<|"x" -> 1, "y" -> 2|>, <|"x" -> 3, "y" -> 4|>]Generalizations & Extensions (4)
f[##]&[a, b, c, d]f[X, ##, Y, ##]&[a, b, c, d]## n stands for arguments n and onward:
f[##2]&[a, b, c, d]f[##1, X, ##2, Y, ##3, Z, ##4]&[a, b, c, d]Create a pure function with attribute Listable:
Function[{u}, g[u], Listable][{a, b, c}]Function[{u}, g[u]][{a, b, c}]#0 stands for the whole pure function:
f[#0]&[x]A recursive definition for factorial using #0:
f = If[#1 == 1, 1, #1 #0[#1 - 1]]&f[10]Applications (3)
Turn a function that takes several arguments into one that takes a list of arguments:
cplus = Plus@@#&cplus[{a, b, c}]A function that returns a function that multiplies its argument by n:
makef[n_] := Function[x, n x]f2 = makef[2]f2[5]Preserve arguments in unevaluated form:
Select[Hold[x, $MaxMachineNumber], Function[symbol, Context[symbol] === "System`", HoldAll]]Properties & Relations (11)
#1 uses only the first argument supplied; the rest are ignored:
f[#1]&[x, y, z]Not using any arguments results in a constant pure function:
17& /@ {1, 2, 3}Replacements can be done inside pure functions:
(p + #)& /. p -> q%[x]Formal parameters are renamed whenever there is a possibility of confusion:
Function[{x}, Function[{y}, f[x, y]]][y]Function[{x}, Function[{y}, f[x, y]]][a]Function[{x}, Function[{y}, Function[{z}, f[x, y, z]]]][a]The names of the parameters do not matter:
Function[x, Function[y, x ^ y]][x][y]Function[y, Function[x, y ^ x]][x][y]However, reusing a name introduces a new scope:
Function[x, Function[x, x ^ x]][x][y]Nested functions take their arguments one at a time:
Function[x, Function[y, x ^ y]][a][b]Function[{x, y}, x ^ y][a, b]f[#]& is the same as simply f in the univariate case:
f[#]&[a]In general, f[##]& is the same as f:
f[##]&[a, b, c]Turn a formula involving a variable
into a pure function:
formula = (1 + x) ^ 2;Function[x, Evaluate[formula]]Use a formula in Table:
Table[i ^ 2, {i, 10}]Use the corresponding pure function in an equivalent Array expression:
Array[# ^ 2&, 10]Special-purpose function constructs include InterpolatingFunction:
f = Interpolation[{1, 2, 4, 5, 6}]f[4]f = Compile[{x}, x ^ 2]f[5.0]f = Nearest[{1, 2, 3, 4, 5}]f[3.1]f = LinearSolve[{{1, 2}, {3, 4}}]f[{5, 6}]Possible Issues (4)
& binds more loosely than ->, so it usually needs parentheses in rules:
FullForm[x -> y&]FullForm[x -> (y&)]& binds more loosely than ?, so it usually needs parentheses in pattern tests:
Cases[{1, 2, 3, 4}, _ ? (OddQ[# / 2]&)]Function does not evaluate its body until the function is applied:
(# + # + #)&%[a]Supplying fewer than the required number of arguments generates an error:
#2&[x]Neat Examples (2)
Define the recursion operator of recursion theory [more info]:
r[g_, h_] = If[#1 == 0, g[##2], h[#0[#1 - 1, ##2], #1 - 1, ##2]]&Use it to define the factorial function:
r[1&, #1(#2 + 1)&][10]Newton's formula for finding a zero of a function:
NewtonZero[f_, x0_] := FixedPoint[# - f[#] / f'[#]&, x0]NewtonZero[BesselJ[2, #]&, 5.0]See Also
Apply Construct CurryApplied ApplyTo CompiledFunction InterpolatingFunction Slot SlotSequence FunctionCompile IncrementalFunction
Characters: \[Function]
Function Repository: ExpressionToFunction
Related Workflows
- Apply a Function to Cells in a Notebook
History
Introduced in 1988 (1.0) | Updated in 2008 (7.0) ▪ 2014 (10.0) ▪ 2020 (12.2)
Text
Wolfram Research (1988), Function, Wolfram Language function, https://reference.wolfram.com/language/ref/Function.html (updated 2020).
CMS
Wolfram Language. 1988. "Function." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2020. https://reference.wolfram.com/language/ref/Function.html.
APA
Wolfram Language. (1988). Function. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/Function.html
BibTeX
@misc{reference.wolfram_2026_function, author="Wolfram Research", title="{Function}", year="2020", howpublished="\url{https://reference.wolfram.com/language/ref/Function.html}", note=[Accessed: 13-June-2026]}
BibLaTeX
@online{reference.wolfram_2026_function, organization={Wolfram Research}, title={Function}, year={2020}, url={https://reference.wolfram.com/language/ref/Function.html}, note=[Accessed: 13-June-2026]}