## Functions

Let's write our first function. It simply substracts `1`

from its argument. (Please don't mind the `'`

after `return`

for now.)

```
-- show
import Prelude hiding ((.))
x.f = f(x)
-- /show
apply(f) = \(x) -> f(x)
return'(a) = a
-- show
function(x) = do {
return'(x - 1);
}
main = do {
print(function(42));
}
-- /show
```

## Anonymous Functions

We can also define a function declaring its parameter *after* the equals sign. (A right-hand side argument declaration is surrounded by `\... ->`

.) By doing so the expression on the right-hand side of our function declaration becomes a valid function on its own, which can be used inline, i.e. without an identifier.

```
import Prelude hiding ((.))
x.f = f(x)
apply(f) = \(x) -> f(x)
return'(a) = a
-- show
function = \(x) -> do {
return'(x - 1);
}
main = do {
print(function(42));
print(42.apply(function));
print(42.apply(\(x) -> do {return'(x - 1);}));
}
-- /show
```

An anonymous function is a *lambda expression* in FP lingo. (The `\`

is supposed to resemble a `λ`

.)

## Closures

A closure is a partially applicable function, i.e. a function that accepts a single argument and returns a function, which accepts a single argument and returns a value. (The nesting can be as deep as you like.)

```
import Prelude hiding ((.))
x.f = f(x)
apply(f) = \(x) -> f(x)
return'(a) = a
-- show
closure = \(a) -> do {
return'(
\(b) -> do {
return'(b - a);
}
);
}
partiallyAppliedClosure(x) = do {
return'(x.closure(1));
}
main = do {
print(partiallyAppliedClosure(42));
print(42.apply(partiallyAppliedClosure));
print(42.closure(1));
}
-- /show
```

A closure can be made a function that accepts a tuple of arguments and vice versa. This process is called "(un-)currying".

```
import Prelude hiding ((.))
x.f = f(x)
apply(f) = \(x) -> f(x)
return'(a) = a
-- show
closure = \(a) -> do {
return'(
\(b) -> do {
return'(b - a);
}
);
}
closure' = do { return'(uncurry(closure)); }
function(x, y) = do {
return'(y - 1);
}
function' = do { return'(curry(function)); }
main = do {
print(closure'(1, 42));
print(42.function'(1));
}
-- /show
```

## Operators

At the end of the last tutorial we saw that `x.apply(f)`

can be written as `f `apply` x`

. The reason for that is that `apply`

is a closure with two arguments, a so-called *operator*. You normally see operators like `-`

written between its two arguments like in `42 - 1`

. In order to use an operator written with alphanumeric characters like `closure`

in infix notation, we have to surround it in backticks: `1 `closure` 42`

. In return, we need to surround `-`

in parenthesis in order to treat it like an ordinary closure, i.e. `1.(-)(42)`

.

```
42.closure(1) -- -> 41
1 `closure` 42 -- -> 41
42 - 1 -- -> 41
1.(-)(42) -- -> 41
```

As we can guess, `closure`

*is* `-`

but with its arguments flipped. Since `closure`

is alphanumeric and `-`

is not, this makes `closure`

the alphanumeric equivalent of `-`

, provided that we will use an alphanumeric operator like `closure`

in object-oriented notation and a non-alphanumeric operator like `-`

in infix notation.

```
42.closure(1) -- -> 41
42 - 1 -- -> 41
```

Let's give `closure`

a propper name, `sub`

, and define it in terms of `-`

. As we have seen, `sub`

*is* `-`

but with its arguments flipped, so:

```
sub = do {
return'(flip((-)));
}
42 - 1 -- -> 41
42.sub(1) -- -> 41
```

## Methods

As we have seen in the previous tutorial, we can write a function that takes one argument in object-oriented notation, too. This is the very definition of our `.`

operator: `x.f = f(x)`

. As we are parenthesis-phile, we introduced `apply`

which is yet another convoluted way of function application: `f `apply` x = f(x)`

. Together, `.`

and `apply`

form *inversion of control*.

`x.apply(f) == f(x)`

It is interesting to note that `f(x)`

has parenthesis, whereas `x.f`

doesn't. This is not a necessity, but a choice. We could define `f()`

which looks nice in `x.f()`

, but looks awkward in `f()(x)`

. Therefore, we will avoid empty parenthesis from now on.

```
decrement() = \(x) -> do {
return'(x.sub(1));
}
dec = \(x) -> do {
return'(x.sub(1));
}
42.sub(1) -- -> 41
42.decrement() -- -> 41 :(
42.dec -- -> 41 :)
```

## Function Composition

You may have noticed, that `sub = do { return'(flip((-))); }`

doesn't contain any variable. This style is called "pointfree" in FP lingo. (We could have defined `sub`

as `b `sub` a = do { return'(a - b); }`

, too.)

When define functions in terms of other functions, we often concatenate two functions into one. This is called *function composition*. For example, given the functions `even`

, which returns `True`

or `False`

depending on the argument being even or not, and the function `not`

, which inverts `True`

and `False`

, we can easily define a function `odd`

, both in pointfull and pointfree style:

```
import Prelude hiding ((.))
x.f = f(x)
return'(a) = a
-- show
f `compose` g = \(x) -> do { return'(f(g(x))); }
oddPointfull(x) = do { return'(not(even(x))); }
oddPointfree = do { return'(not `compose` even); }
main = do {
print(42.oddPointfull);
print(42.oddPointfree);
}
-- /show
```

Haskell already has a compose operator of its own, i.e. `.`

, which we hid from the `Prelude`

in the previous tutorial in order to define object-oriented notation. This is why we just had to define our own `compose`

operator.

## Constants

Let's define a constant.

```
import Prelude hiding ((.))
x.f = f(x)
-- show
constant = 42
main = do {
print(constant);
}
-- /show
```

We may have written `constant = do { return'(42); }`

, but this doesn't make sense, since `constant`

is a constant, and not a function, right? Well, in Haskell there is virtually no difference between a constant and the return value of a function, as the same argument applied to the same function will always yield the same return value. In FP lingo, functions are *referentially transparent*. (This has the benefit of return values being cachable - they can be *memoized* in FP lingo.) Therefore, we can treat functions just like constants and ommit the `do { return'( ... ); }`

ceremony.

```
import Prelude hiding ((.))
x.f = f(x)
-- show
f `compose` g = \(x) -> f(g(x))
oddPointfull(x) = not(even(x))
oddPointfree = not `compose` even
main = do {
print(42.oddPointfull);
print(42.oddPointfree);
}
-- /show
```