Lambda Calculus

## De lambda calculus

De lambda calculus is een formeel systeem dat de basis vormt voor functionele programmeertalen. Het is turingvolledig, wat betekend dat je er elk computerprogramma mee kunt schrijven.

### Voordelen

De lambda calculus als programmeertaal (een functionele programmeertaal) heeft vele voordelen die conventionele imperatieve programmeertalen niet hebben. Zo heeft het een sterke wiskundige basis, waardoor het beter formeel te beschrijven en bewijzen is. Een ander voordeel is dat het parallellisering mogelijk maakt zonder dat daar extra moeite voor gedaan hoeft te worden. Verder is het makkelijker om over het programma te redeneren en is er correctness garanties mogelijk zijn door strong typing.

## Hoe werkt de lambda calculus

De lambda calculus bestaat uit 3 syntactische elementen.

* Variabelen, zoals x en y.
* Abstracties, wat functions zijn die een argument accepteren.
* Applications, wat het aanroepen van een function is met een argument.

Een function in de lamdba calculus wordt aangeduid met de kleine griekse letter lambda λ. Een function neemt één argument en applies dit op zichzelf. Een simpele function ziet er als volgt uit:

```
( λx -> x )

```

Deze function neemt een argument als x en vervang elke x met dat argument. Dit is hoe een lambda programma wordt opgelost, door het vervangen van variabelen met argumenten. Deze argumenten zijn andere functions.

Een argument aan een function geven ziet er als volgend uit. Ook word er op elke lijn een stap in de oplossing gezet. Relevante variabelen zijn dikgedrukt, en relevante argumenten onderstreept.

```
(( λ**x** -> **x** ) 33)

```

```
(33)

```

In de bovenstaande functie werd 33 als argument gegeven aan x. Vervolgens werd de opvolgende x vervangen door 33.

Het is ook mogelijk om een functie te creëren die twee of meer argumenten neemt. Dit doe je alsvolgt.

```
( λa -> ( λb -> ( a + b)))

```

Deze functie neemt twee argumenten, a en b. Als eerste wordt a gegeven, vervolgens b. Het geven van argumenten aan deze functie ziet er zo uit:

```
((( λa -> ( λb -> ( a + b))) 7) 6)

```

Om te begrijpen wat hier gebeurt kunnen we de functie ontleden in twee delen door haakjes te tellen.

```
((( λa ->  ( λb -> ( a + b))) 7) 6)

```

De functie b is een stukje code op zichzelf dat deel uitmaakt van de functie a. Je begint met vereenvoudigen binnen de haakjes, maar functie b kan niet vereenvoudigt worden, dus stuiten wij op het eerste argument: 7. In de volgende stappen lopen wij door hoe deze functie wordt opgelost. Relevante variabelen zijn dikgedrukt (net zo dik als jeff), en relevante argumenten onderstreept.

```
((( **λa** -> ( λb -> ( **a** + b ))) 7) 6)

```

```
(( λb -> ( 7 + b )) 6)

```

```
(( **λb** -> ( 7 + **b** )) 6)

```

```
( 7 + 6 )

```

```
13

```

Het is ook mogelijk om een functie als argument te geven aan een functie. Hieronder een voorbeeld en hoe hij opgelost wordt.

```
(λ a -> a a )(λ b -> b )

```

```
(λ **a** -> **a a** )(λ b -> b )

```

```
(λ b -> b )(λ b -> b )

```

```
(λ **b** -> **b** )(λ b -> b )

```

```
(λ b -> b )

```

Om schrijven te besparen en leesbaarheid beter te maken, worden kortere notaties gebruikt. Hieronder enkele voorbeelden en hun kortere notaties.

Functies met meerdere argumenten

```
(λ a -> (λ b -> ( a + b ))

```

*Hetzelfde als*

```
(λ a b -> ( a + b ))

```

Functies met meerdere argumenten.

```
(((λ a b -> ( a + b ))10)20)

```

*Hetzelfde als*

```
(λ a b - > ( a + b )) 10 20

```