; Lambda Calculus ; --------------- ; Lambda Calculus is a form of programming in which there are two basic ; operations: ; 1. Defining a function that accepts one argument and returns one argument. ; Markup: [lambda][variable].[return expression] ; 2. Executing a lambda expression on another lambda expression: ; Markup: ([function] [argument]) ; Examples: (define identity (lambda (a) a)) (define second-argument (lambda (a) (lambda (b) (lambda (c) b)))) (define another-example (lambda (f) (f f))) ; Note that as in Scheme, the returned lambdas remember all the variables ; with which they were called. So for example: (((second-argument 5) 6) 7) ; Will propagate into: ; (lambda (b) (lambda (c) b)) while remembering that a = 5 ; And in turn into ; (lambda (c) b) while remembering that a = 5 and b = 6 ; And into ; b while remembering that a = 5 and b = 6 and c = 7 ; Which is in turn equal to 6 ; Currying: ; --------- ; ; We can create functions of more than one argument in Lambda Calculus ; using a technique called Currying. What it means is that instead of having ; one function that accepts several arguments, we have several nested ; lambdas. ; ; Here's an example: ; ; Instead of writing: (define my-func (lambda (x y) (+ (* 2 x) (* 3 y)) ) ) ; and invoking it with (define ret (my-func 5 6)) ; We can define: (define my-func (lambda (x) (lambda (y) (+ (* 2 x) (* 3 y)) ) ) ) ; and invoke it with (define ret ((my-func 5) 6)) ; I.e: by making one function call for every argument. ; This technique simplifies the lambda calculus grammar and allows ; us to only deal with functions (and function calls) of one argument