Upcoming SlideShare
×

# The Lambda Calculus and The JavaScript

5,734 views

Published on

To be presented at Austin Javascript Meetup 11/01/12.

Published in: Technology
15 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

Views
Total views
5,734
On SlideShare
0
From Embeds
0
Number of Embeds
45
Actions
Shares
0
92
0
Likes
15
Embeds 0
No embeds

No notes for slide

### The Lambda Calculus and The JavaScript

1. 1. orb@nostacktrace.com The Lambda Calculus λ and The JavascriptNorman Richards
2. 2. orb@nostacktrace.com Why lambda calculus? Alan TUring Alonzo CHURCh Invented the turing machine, an Created lambda calculus, the imperative computing model basis for functional programming. We spend all our time studying this guy’s work (because he’s awesome)Norman Richards http://en.wikipedia.org/wiki/Alonzo_Church But if we want to think functionally, http://en.wikipedia.org/wiki/Alan_Turing we should pay attention to this guy too (because he’s also awesome)
3. 3. orb@nostacktrace.com The premise Functional programming is good Using functional techniques will make your code better Understanding lambda calculus will improve your functionalNorman Richards
4. 4. orb@nostacktrace.com A Lambda Expression bound variable This is the argument of the function λx.x body A lambda expression that uses the bound variable and represents the function valueNorman Richards
5. 5. orb@nostacktrace.com A Lambda Expression function(x) { λx.x return x }Norman Richards
6. 6. orb@nostacktrace.com Not a Lambda Expression λy.x free variable This variable isn’t bound, so this expression is meaninglessNorman Richards
7. 7. orb@nostacktrace.com A Lambda Expression function(y) { λy.x return x }Norman Richards These are meaningless
8. 8. orb@nostacktrace.com A Lambda Expression parenthesis Not needed, but used for clarity here λx.(λ.y.x) bound or free? x is bound in the outer expression and free in inner expression.Norman Richards
9. 9. orb@nostacktrace.com A Lambda Expression function(x) { return function(y) { λx.λ.y.x return x } }Norman Richards
10. 10. orb@nostacktrace.com Lambda Application unicorns don’t exist There are no assignments or external references. We’ll use upper-case words to stand for some valid lambda expression, but it must mean something. λx.x UNICORN application by substitution Apply UNICORN to the expression, substituting UNICORN for every occurrence of the bound valueNorman Richards
11. 11. orb@nostacktrace.com Lambda Application The I (identity) combinator Combinatory logic predates lambda calculus, but the models are quite similar. Many lambda expressions are referred to by their equivalent combinator names. function(x) { λx.x UNICORN return x ! UNICORN }(UNICORN); ! UNICORNNorman Richards
12. 12. orb@nostacktrace.com Lambda Application the K (constant) combinator This function takes an input argument and returns a function that returns that same value λx.λy.x UNICORN λy.UNICORN MITT ! λy.UNICORN ! UNICORN always a UNICORNNorman Richards No matter what argument is passed in, the result is always the same. http://leftaction.com/action/ask-kansas-mitt-romney-unicorn
13. 13. orb@nostacktrace.com Lambda Application self-application This function takes a function and applies it to itself. function(f) { λs.(s s) return f(f); }Norman Richards
14. 14. orb@nostacktrace.com Lambda Application Substitute λx.x for s λs.(s s) λx.x function(f) { ! λx.x λx.x return f(f); }(function (x) { ! λx1.x1 λx.x return x; For clarity, rename x as x1 ! λx.x });Norman Richards Substitute λx.x for x1.
15. 15. orb@nostacktrace.com Infinite application λs.(s s) λs.(s s) ! λs.(s s) λs.(s s) ! λs.(s s) λs.(s s) ! … the halting problemNorman Richards Just as you’d expect, there’s no algorithm to determine whether or not a given lambda expression will terminate
16. 16. orb@nostacktrace.com Turing Complete I: λx.x K: λx.λy.x S: λx.λy.λz.x z (y z)Norman Richards http://en.wikipedia.org/wiki/SKI_combinator_calculus
17. 17. orb@nostacktrace.com Actually, just two lambdas S K K UNICORN ! λx.λy.λz.(x z (y z)) K K UNICORN ! λy.λz.(K z (y z)) K UNICORN ! λz.(K z (K z)) UNICORN ! K UNICORN (K UNICORN) ! λx.λy.x UNICORN (K UNICORN) ! λy.UNICORN (K UNICORN)Norman Richards ! UNICORN Thus, S K K is computationally equivalent to identity
18. 18. orb@nostacktrace.com Other Turing Complete things Magic: the Gathering http://www.toothycat.net/ ~hologram/Turing/ C++ Templates The number 110 http://citeseerx.ist.psu.edu/Norman Richards viewdoc/summary? http://mathworld.wolfram.com/ doi=10.1.1.14.3670 Rule110.html
19. 19. orb@nostacktrace.com TURING TARPIT Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy. Alan PerlisNorman Richards http://pu.inf.uni-tuebingen.de/users/klaeren/epigrams.html
20. 20. orb@nostacktrace.com Currying function(x) { return function(y) { return function (z) { A function that returns a FUNCTION return UNICORN; .. that returns a function that returns a function. You can think of this as a function of three arguments. } λx.λy.λz.UNICORN X Y Z } }(X)(Y)(Z);Norman Richards function(x,y,z) { return UNICORN; }(X,Y,Z);
21. 21. orb@nostacktrace.com Currying Sometimes abbreviated Sometimes, you’ll see lambda expressions written like this for clarity. The arguments are still curried. λx y z.UNICORN X Y Z HASKELL CURRY ! λy z.UNICORN Y Z Curry studied combinatory logic, a variant of lambda calculus. ! λz.UNICORN Z ! UNICORNNorman Richards http://www.haskell.org/haskellwiki/Haskell_Brooks_Curry
22. 22. orb@nostacktrace.com data structures CHURCH PAIR ENCODING PAIR takes two arguments, x and y and returns a function that takes another function and applies x and y to it. PAIR: λx.λy.λf.(f x y) BuILDING UP STATE PAIR takes two arguments, x and y and returns a function that takes another function and applies x and y to it.Norman Richards
23. 23. orb@nostacktrace.com data structures PAIR: λx.λy.λf.(f x y) FIRST: λx.λy.x SECOND: λx.λy.y ACCESSOR FUNCTIONS FIRST and SECOND are functions that can beNorman Richards passed to pair. They take two arguments and return the ﬁrst and second, respectively.
24. 24. orb@nostacktrace.com data structures PAIR: λx.λy.λf.(f x y) DOGCAT: PAIR DOG CAT ! λx.λy.λf.(f x y) DOG CAT ! λy.λf.(f DOG y) CAT ! λf.(f DOG CAT)Norman Richards
25. 25. orb@nostacktrace.com data structures DOGCAT: λf.(f DOG CAT) FIRST: λx.λy.x SECOND: λx.λy.y DOGCAT FIRST ! λf.(f DOG CAT) λx.λy.x ! λx.λy.x DOG CATNorman Richards ! λy.DOG CAT ! DOG
26. 26. orb@nostacktrace.com data structures DOGCAT: λf.(f DOG CAT) FIRST: λx.λy.x SECOND: λx.λy.y DOGCAT SECOND ! λf.(f DOG CAT) λx.λy.x ! λx.λy.x DOG CATNorman Richards ! λy.y CAT ! CAT
27. 27. orb@nostacktrace.com data structures RGB: λr.λg.λb.λf.(f r g b) RED: λr.λg.λb.r GREEN: λr.λg.λb.g BLUE: λr.λg.λb.b BLACK_COLOR: RGB 255 255 255Norman Richards WHITE_COLOR: RGB 0 0 0 NuMBERS? We haven’t seen how to construct numbers yet, but for the moment imagine that we did.
28. 28. orb@nostacktrace.com data structures AVERAGE? AVG: λx.λy.??? If we did have numbers, we could probably do math like simple averaging MIX_RGB: λc1.λc2.λf. (f (AVG (c1 RED) (c2 RED)) (AVG (c1 GREEN)(c2 GREEN)) (AVG (c1 BLUE) (c2 BLUE)))Norman Richards OO LAMBDA? MIX_RGB takes two colors and returns a new color that is the mix of the two
29. 29. orb@nostacktrace.com CONDITIONALS COND: λe1.λe2.λc.(c e1 e2) TRUE: λx.λy.x FALSE: λx.λy.y Look familiar? Think of a boolean condition as a PAIR of values. TRUE selects the ﬁrst one and FALSE selects the second one.Norman Richards
31. 31. orb@nostacktrace.com BOOLEAN LOGIC NOT: λx.(COND FALSE TRUE x) AND: λx.λy.(COND y FALSE x) OR: λx.λy.(COND TRUE y x)Norman Richards
32. 32. orb@nostacktrace.com NUMBERS ZERO: λx.x SUCC: λn.λs.(s false n) ONE: SUCC ZERO ! λs.(s false ZERO) TWO: SUCC ONE ! λs.(s false ONE) ! λs.(s false λs.(s false ZERO))Norman Richards PEANO NUMBERS PEANO numbers are based on a zero function and a successor function
33. 33. orb@nostacktrace.com NUMBERS ISZERO ZERO ZERO: λx.x ! λn.(n FIRST) λx.x ISZERO: λn.(n FIRST) ! λx.x FIRST ! FIRSTNorman Richards ! TRUE
34. 34. orb@nostacktrace.com NUMBERS ISZERO: λn.(n FIRST) ONE: λs.(s FALSE ZERO) ISZERO ONE ! λn.(n FIRST) λs.(s FALSE ZERO) ! λs.(s FALSE ZERO) FIRST ! (FIRST FALSE ZERO)Norman Richards ! FALSE
35. 35. orb@nostacktrace.com NUMBERS PRED: λn.(n SECOND) PRED (SUCC NUM) ! λn.(n SECOND) λs.(s FALSE NUM) ! λs.(s FALSE ZERO) SECOND ! SECOND FALSE NUM ! NUMNorman Richards but... ZERO isn’t SUCC of a number
36. 36. orb@nostacktrace.com NUMBERS PRED: λn.(ISZERO n) ZERO (n SECOND) What is Pred of zero? We can at least test for zero and return another number.Norman Richards
37. 37. orb@nostacktrace.com NUMBERS ADD:λx.λy.(ISZERO Y) function add(x,y) { x if (y==0) { (ADD (SUCC X) return x (PRED Y)) } else { return add(x+1,y-1) NOT VALID Recursive deﬁnitions aren’t possible . }Norman Richards Remember, names are just syntactics sugar. All deﬁnitions must be ﬁnite. How do we do this? }
38. 38. orb@nostacktrace.com RECURSION DIVERSION If we could pass the function in Now we’ll make a function of three arguments, the ﬁrst being the function to recurse on ADD 1:λf.λx.λy.(ISZERO Y) x (f f (SUCC X) (PRED Y)) Then we could call it RECURSIVELY Just remember that the function takes threeNorman Richards arguments, so we should pass the function to itself.
39. 39. orb@nostacktrace.com RECURSION DIVERSION ADD 1:λf.λx.λy.(ISZERO Y) x (f f (SUCC X) (PRED Y)) ADD: ADD 1 ADD 1 ! λx.λy.(ISZERO Y) xNorman Richards (ADD 1 ADD1 (SUCC X) (PRED Y)) FINITE DEFINiTION This deﬁnition of ADD is a bit repetitive, but it doesn’t recurse inﬁnitely. If only we could clean this up a bit...