# WolframLang: Define Function

`Function[`

`x`,`body`]-
same as
`Function[{`

`x`},`body`] `Function[{`

`x1`,`x2``etc`},`body`]-
(Short syntax:
`Function[{`

is same as`x`,`y`},`x`+`y`]`Function[#1+#2]`

or`#1+#2&`

)

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`

. Functionf = Function[ {x,y}, x + y ]; 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[`

has the
short syntax
`body`]`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
`((`

, when using the short form.
Because otherwise you run into operator precedence ambiguity.
`body`)&)

### Variadic Function, Rest Parameters

To write a function with`Function`

for arbitrary number of parameters,
use `##`

.
`##`

- Represent rest parameters.
`##`

`n`- Represent rest parameters starting with
`n`th.

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`](aaa |-> bbb) === Function[ aaa, bbb ] (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]

However, you can define ANY function by using
`Function`

.
It's not necessary to use pattern matching.
If you code a lot WolframLang, it's best to avoid using pattern matching when you can.
Because pattern matching is significantly slower, and too much pattern matching makes your function unpredicable.