# Hello, λ!

This article was originally published on the Programlabbet Blog2013-12-08. The text has been slightly altered in order tomake more sense in a text-centric setting.As you may already know, functional programming has its roots in a formal system called theLambda calculus(or λ-calculus), which is a model of computation based on the ideas of function abstraction and application through substitution of bound variables. (Don't worry, you'll get the idea soon enough.) Sidenote: λ-calculus was the one of two frameworks that was used in the one of two answers, the other being theTuring machine. This system was created by the British mathematician and cryptanalyst Alan Turing, which is also the theoretical model on which our computers are built upon. Church and Turing gave their answers unknowingly of eachother, but despite this, it was later proven that these two models are equivalent. That is, you can build a Turing- machine in λ-calculus and express λ-calculus on a Turing machine. The system was created by the American mathematician and logician Alonzo Church as a framework for answering theEntscheidungsproblem(lit. "Decision problem") posed by the German mathematician David Hilbert in 1928. This problem can essentially be formulated as the question wether or not there exist a machine that, given a program, can compute if any given input is valid or not, according to the program. So what was the answer to the Entscheidungsproblem? Well, "No". Hilbert is said to have been pretty bummed out by this. There are numerous introductions to λ-calculus (e.g. {1}, {2}, and {3}), however most of them appear to be geared towards the theoretical crowd. In this (very brief) introduction I'll only focus on the parts that are the most relevant to you as a programmer. In order to have a foot in the real world, I'll include examples in lisp as well. (Mind you, most of the stuff I cover here can be expressed in any language where functions are first class values. If your favorite language don't have that, you're fresh out of luck, sonny.)## The λThe fundamental building block is the lambda (λ), which is an operator that yields a functional object, a closure, that can be applied to a value. Let's create a function that adds 1 to its parameter x. Not terribly exciting, but it will serve us well as an example:`λ x . 1 + x`

Easy enough. The parameter resides to the right of the 'λ' and to the left of the period. To the right of the period we have the expression where we may refer to the parameter, a function body. You can also view λ-expressions as templates for transforming expressions. This is expressed in Lisp as:`(lambda (x) (+ 1 x))`

`; => #<function (lambda (y) (+ 1 y))>`

## ApplyingNow, there's a number of things we can do to this expression. For one, we can pass it around like any other value. Another thing is to put it to work by applying a value to it:`(λ x . 1 + x) 2 -β-> 1 + 2`

What we have done here is a computational step, aβ-reduction, which binds the free variable x of the λ-expression to the value 2 and returns the corresponding expression, 1 + 2. Note that we returned an expression and not the value 3. This is because a β-reduction is only one step, much like an instruction of a conventional computer. To get the expected answer, we need to preform another β-reduction:`1 + 2 -β-> 3`

Excellent! This reduction business doesn't really have an equivalent in Lisp:`((lambda (x) (+ 1 x)) 2)`

`; => 3`

The reason for this is that Lisp employ a different evaluation strategy. (That and doing β-reduction for every step is tedious, even though there exist languages that explicitly do that.)## ParametersYou may have noticed that we only have one parameter to work with. How can we get more parameters? Easy, bycurrying:`λ x y . x + y == λ x . (λ y . x + y)`

What happened here? Closure happened here. When applying the outer lambda, it will reduce to a lambda where the x is bound to the given value. Applying that lambda will give us a complete expression:`(λ x y . x + y) 1 2 -β-> λ y . 1 + y -β-> 1 + 2 -β-> 3`

Or as we can say in Lisp:`(((lambda (x) (lambda (y) (+ x y))) 1) 2)`

`; => 3`

Since functions introduce a lexical context (a block where variables live, more or less), the inner function captures x and will thus be known once the inner function is applied. The reason for the convoluted way of passing the parameters is due to the fact that Lisp doesn't actually curry its functions.## Partial applicationWhat happens if we omit the 2 from the previous example?`(λ x y . x + y) 1 -β-> λ y . 1 + y`

`((lambda (x) (lambda (y) (+ x y))) 1)`

`; => #<closure (lambda (y) (+ 1 y))>`

We got a function that adds 1 to a given parameter! The curried function`λ x y . x + y`

can in other words bepartiallyapplicated, that is, the function won't be applied in full unless we supply all the parameters. All the intermediary steps can be passed on to be used elsewhere. Handy! But! As I said, functions in Lisp are not curried, and can't thus be partially applicated, unless you manually curry them yourself.## SummaryNow this has been a very, very brief overview of λ-calculus, though I hope that it has given you some insight into what this whole thing is about. You may think this as a bit silly, playing around with tiny functions. What's the gain in doing that? Depends on who you ask, I'd say. If you'd ask me, I'd say that there are tremendous power in building functions much like you'd build your strings or numbers. Metaprogramming is a breeze, since you can have your code treated as data and your data treated as code. And besides, why should you write the programs when the programs can write themselves for you? {1}: Introduction to Lambda Calculus {2}: A Tutorial Introduction to the Lambda Calculus {3}: A short introduction to the lambda calculus