The Lambda Calculus and The JavaScript

orb@nostacktrace.com

The Lambda Calculus
λ and
The Javascript
Norman Richards


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)

The premise

Functional programming is good

Using functional techniques will make your code better

Understanding lambda calculus will improve your functional
Norman Richards

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 value
Norman Richards

A Lambda Expression

function(x) {
λx.x return x
}
Norman Richards

Not a Lambda Expression

λy.x
free variable
This variable isn’t bound, so this
expression is meaningless
Norman Richards

A Lambda Expression

function(y) {
λy.x return x
}
Norman Richards

These are
meaningless

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

A Lambda Expression

function(x) {
return function(y) {
λx.λ.y.x return x
}
}
Norman Richards

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 value
Norman Richards

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);

! UNICORN
Norman Richards

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 UNICORN
Norman Richards

No matter what argument is passed
in, the result is always the same.

http://leftaction.com/action/ask-kansas-mitt-romney-unicorn

Lambda Application

self-application
This function takes a function and
applies it to itself.

function(f) {
λs.(s s) return f(f);
}
Norman Richards

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.

Infinite application

λs.(s s) λs.(s s)
! λs.(s s) λs.(s s)
! λs.(s s) λs.(s s)
! …
the halting problem
Norman Richards

Just as you’d expect, there’s no algorithm to
determine whether or not a given lambda
expression will terminate

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

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

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

TURING TARPIT

Beware of the Turing tar-pit in which everything is
possible but nothing of interest is easy.

Alan Perlis
Norman Richards

http://pu.inf.uni-tuebingen.de/users/klaeren/epigrams.html

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);

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
! UNICORN
Norman Richards

http://www.haskell.org/haskellwiki/Haskell_Brooks_Curry

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

data structures

FIRST: λx.λy.x
SECOND: λx.λy.y

ACCESSOR FUNCTIONS
FIRST and SECOND are functions that can be
Norman Richards

passed to pair. They take two arguments and
return the ﬁrst and second, respectively.

data structures


DOGCAT: PAIR DOG CAT
! λx.λy.λf.(f x y) DOG CAT
! λy.λf.(f DOG y) CAT
! λf.(f DOG CAT)
Norman Richards

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 CAT
Norman Richards

! λy.DOG CAT
! DOG

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 CAT
Norman Richards

! λy.y CAT
! CAT

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 255
Norman 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.


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

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

CONDITIONALS
COND DEAD ALIVE QUBIT
! λe1.λe2.λc.(c e1 e2) DEAD ALIVE QUBIT
! QUBIT DEAD ALIVE

! TRUE DEAD ALIVE ! FALSE DEAD ALIVE
! λx.λy.x DEAD ALIVE ! λx.λy.y DEAD ALIVE
Norman Richards

! DEAD ! ALIVE

https://www.coursera.org/course/qcomp

BOOLEAN LOGIC

NOT: λx.(COND FALSE TRUE x)
AND: λx.λy.(COND y FALSE x)
OR: λx.λy.(COND TRUE y x)
Norman Richards

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

NUMBERS

ISZERO ZERO
ZERO: λx.x ! λn.(n FIRST) λx.x
ISZERO: λn.(n FIRST) ! λx.x FIRST
! FIRST
Norman Richards

! TRUE

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

NUMBERS

PRED: λn.(n SECOND)

PRED (SUCC NUM)
! λn.(n SECOND) λs.(s FALSE NUM)
! λs.(s FALSE ZERO) SECOND
! SECOND FALSE NUM
! NUM
Norman Richards

but...
ZERO isn’t SUCC of a number

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

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 definitions aren’t possible . }
Norman Richards

Remember, names are just syntactics sugar. All
definitions must be finite. How do we do this? }

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 three
Norman Richards

arguments, so we should pass the function to itself.

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)
x
Norman 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...

BEHOLD, the Y combinator
Y: λf.(λs.(f (s s)) (λs.(f (s s)))

ADD 1: λf.λx.λy.(ISZERO Y) X
(F (SUCC X) (PRED Y))

ADD: Y ADD 1

! λs.(ADD 1 (s s)) (λs.(ADD1 (s s))

! ADD1 (λs.(ADD1 (s s)) λs.(ADD1 (s s)))
Norman Richards

! ADD1 (Y ADD1)

! ADD1 ADD Y self replicates
This is similar to the hand prior call, except that
the replication state is in the passed function.

CHURCH NUMBERs

ZERO: λf.λx.x
ONE: λf.λx.f x
TWO: λf.λx.f (f x)
THREE: λf.λx.f (f (f x))
FOUR: λf.λx.f (f (f (f x)))
repeated function application
Norman Richards

Church numbers take a function and an argument
and apply the function to the argument n times.
So N is deﬁned by doing something N times.

CHURCH NUMBERs
ZERO: λn.(n λx.FALSE TRUE)
SUCC: λn.λf.λx.f (n f x)
ADD: λm.λn.λf.λx.m f (n f x)
MUL: λm.λn.λf.m (n f)
POW: λm.λn.m n
PRED: λn.λf.λx.n (λg.λh. h (g f))
λu.x λu.u
Norman Richards

No recursion for simple math
Church numbers have some very simple
operations, Operations like subtraction are more
complex than Peano numbers.

And the rest is functional

An introduction to
Functional Programming
Through Lambda Calculus

Greg Michaelson
Norman Richards

http://www.amazon.com/dp/0486478831

Leisure
https://github.com/zot/Leisure

•Lambda Calculus engine written in Javascript
•Intended for programming
•REPL environment with node.js
•Runs in the browser
Norman Richards

http://tinyconcepts.com/invaders.html


λ thank you
Norman Richards

http://www.slideshare.net/normanrichards/the-lambda-calculus-and-the-javascript

The Lambda Calculus and The JavaScript

More Related Content

Similar to The Lambda Calculus and The JavaScript

More from Norman Richards

Recently uploaded

The Lambda Calculus and The JavaScript