# WolframLang: Define Function

By Xah Lee. Date: . Last updated: .
`Function[x, body]`
represent a function with one parameter.

same as

`Function[{x}, body]`

or

`x |-> body`

`Function[{x1, x2 etc}, body]`

represent a function (like lisp lambda) with formal parameters x1, x2 etc. When the function is called, body is evaluated, with formal parameters replaced by arguments. For example, `Function[{x,y}, x+y][3, 4]` return `7`. Function

```f = Function[ {x,y}, x + y ];
f[3, 4] === 7```
`Function[body]`
(Short syntax: `Function[body]` is same as `((body)&)`)

in the body,

• `#` or `#1` → means first parameter.
• `#2` → means second parameter.
• `#3` → means Third parameter.
• etc.
• `##` → means rest parameter.
```f = Function[ # + #2 ];
f[3, 4] === 7
```

## Formal Parameters Syntax Shortcut

Formal parameters in `Function` can be represented by `#`.

`#` or `#1`
first parameter.
`#2`
second parameter.
`#3`
Third parameter.

e.g. The following are equivalent.

• `Function[ #1 + #2 ]`
• `Function[ {x,y}, x + y ]`

`Function[body]` has the short syntax `body&`

e.g. The following are equivalent.

• `( #1 + #2 &)`
• `Function[ #1 + #2 ]`
• `Function[ {x,y}, x + y ]`

This makes the code even shorter, and is often used.

TIP: it's good idea to add parenthesis like this `((body)&)`, when using the short form. Because otherwise you run into operator precedence issue that's hard to remember which operator has higher precedence.

`##` stands for rest parameters in `Function`'s body, useful for define defining function with arbitrary number of parameters.

`##`
Represent rest parameters.
`##n`
Represent rest parameters starting with nth.

e.g. The following are equivalent.

• `Function[{x,y}, {x,y}]`
• `({##}&)`
```mySum = (Plus[##]&);
mySum[1,2,3] === 6```

## Map-Arrow Syntax Shortcut

`x |-> body`
same as `Function[x, body]`
`varList |-> body`
same as `Function[varList, body]`
```(x |-> x+1) === Function[ x, x+1 ]

({x,y} |-> x+y) === Function[ {x,y}, x+y ]```

TIP: it's good idea to add parenthesis to the whole `(x |-> x+1)`. Because otherwise you run into operator precedence ambiguity.

## Named Parameters, Default Values, Polymorphism

If you want function to have named parameters, default values, or polymorphism (meaning, the function behaves differently depending on number of args or their type) , you need to define the function by pattern matching. [see Define Function by Pattern]

## TIP: defining function by pattern matching

in Wolfram tutorials, often you'll see defining function with form like this:

`f[x_, y_] := body`

That works by defining a symbolic expression replacement rule using pattern matching. [see WolframLang: Define Function by Pattern]