# Difference between revisions of "Anonymous function"

(Fixed the Haskell tutorial link) |
Battlmonstr (talk | contribs) (→See also) |
||

Line 56: | Line 56: | ||

* [[Lambda calculus]] |
* [[Lambda calculus]] |
||

* [[Beta reduction]] |
* [[Beta reduction]] |
||

+ | * [http://dobegin.com/lambda-functions-everywhere/ Lambda functions in math and programming] |

## Latest revision as of 14:22, 21 August 2016

An anonymous function is a function without a name. It is a Lambda abstraction and might look like this: `\x -> x + 1`

. (That backslash is Haskell's way of expressing a λ and is supposed to look like a Lambda.)

## Examples

That is a nameless function which increments its parameter, x. So in Hugs or GHCi, I might say:

```
Prompt> (\x -> x + 1) 4
5 :: Integer
```

Or I could make a nameless function of two parameters, x and y:
`\x y -> x + y`

, which could be applied like so:

```
Prompt> (\x y -> x + y) 3 5
8 :: Integer
```

You could also name a lambda expression if you wanted to for some reason:

```
addOne = \x -> x + 1
```

Of course, there are a variety of better ways to write that in Haskell, but you get the idea.

## But why bother?

Sometimes it is more convenient to use a lambda expression rather than giving a function a name. This is often the case when using `map`

and `foldl / foldr`

. So if I wanted to add one to each element of a list, here's one way to do it (without anonymous functions):

```
addOneList lst = map addOne' lst
where addOne' x = x + 1
```

But here's another way, where we pass the anonymous function into map rather than any named function.

```
addOneList' lst = map (\x -> x + 1) lst
```

For completeness it's worth mentioning that this could be better written using a section, in pointfree style:

```
addOneList'' = map (+1)
```

## See also

- Section 3.1 in the Haskell tutorial.
- Closure
- Lambda calculus
- Beta reduction
- Lambda functions in math and programming