λλλλλ

data made λ
λλ λλ
λ
λ λ
out of λ
λ
λ λ
λ
λ

functions λ
λ
λ λ λ
λλλλ λ
λ λ
λλ λλ
λλλλλ
#ylj2016
@KenScambler For faster
monads!
Diogenes of Sinope
412 – 323 BC
 • Simplest man of all time
• Obnoxious hobo
• Lived in a barrel

Diogenes of Sinope
412 – 323 BC
I’ve been using this bowl
like a sucker!
Um….
what
 [a, b, c, d]
"abcd"

IF x THEN y ELSE z

INT
WHILE cond {…}

λa -> b STRUCT {
BOOL fields…
}
 Strings are
[a, b, c, d]
pretty much
arrays
IF x THEN y ELSE z

INT
WHILE cond {…}

λa -> b STRUCT {
BOOL fields…
}
Recursion can [a, b, c, d]
do loops
IF x THEN y ELSE z

INT

λa -> b STRUCT {
BOOL fields…
}
 Recursive data
structures can do
lists IF x THEN y ELSE z

INT

[a,b,c,d]
λa -> b STRUCT {
BOOL fields…
}
Ints can do bools
IF x THEN y ELSE z

INT

[a,b,c,d]
λa -> b STRUCT {
fields…
}
 IF x THEN y ELSE z

INT

[a,b,c,d]
λa -> b STRUCT {
fields…
}
λa -> b

[a,b,c,d]
STRUCT
 λa -> b
Lambda calculus
Alonzo Church
1903 - 1995
 λa -> b
Lambda calculus
Alonzo Church
1903 - 1995
Church encoding
We can make any
data structure out of
functions!
Booleans

Bool
Church booleans

Bool result
Church booleans
If we define everything you
can do with a structure, isn’t
that the same as defining
Bool result
the structure itself?
TRUE
or
FALSE
 “What we do if
it’s true”

TRUE result
or
FALSE
 “What we do if
it’s false”

TRUE
or
FALSE result
TRUE result
or result
FALSE result
() result
result
() result
result
result
result
The Church encoding
of a boolean is:

r r r
type CBool = forall r. r -> r -> r

cTrue :: CBool
cTrue x y = x

cFalse :: CBool
cFalse x y = y

cNot :: CBool -> CBool

cNot cb = cb cFalse cTrue

cAnd :: CBool -> CBool -> CBool

cAnd cb1 cb2 = cb1 cb2 cFalse

cOr :: CBool -> CBool -> CBool

cOr cb1 cb2 = cb1 cTrue cb2
Natural numbers
0
1
2
3
4
…
Natural numbers
0
0 +1
0 +1 +1
0 +1 +1 +1
0 +1 +1 +1 +1
…
Natural numbers
0 Natural
0 +1 numbers form
0 +1 +1 a data
structure!
0 +1 +1 +1
0 +1 +1 +1 +1
…
Giuseppe Peano
1858 - 1932
 Natural Peano numbers

Nat = Succ(Nat)
or
Zero

Giuseppe Peano
1858 - 1932
 Now lets turn it
into functions!
Nat = Succ(Nat)
or
Zero
 “If it’s a successor”

Succ(Nat) result
or
Zero
Succ(Nat)
or “If it’s zero”
Zero result
Succ(Nat) result
or result
Zero result
Nat result
result
() result
Nat result
result
result
Nat result
() result
Nat
() result
Nat
()
Nat
()
Nat
result result
result
result
 The Church encoding
of natural numbers is:

(r r) r r
type CNat = forall r. (r -> r) -> r -> r

c0, c1, c2, c3, c4 :: CNat

c0 f z = z
c1 f z = f z
c2 f z = f (f z)
c3 f z = f (f (f z))
c4 f z = f (f (f (f z)))

cSucc :: CNat -> CNat

cSucc cn f = f . cn f

cPlus :: CNat -> CNat -> CNat

cPlus cn1 cn2 f = cn1 f . cn2 f

cMult :: CNat -> CNat -> CNat

cMult cn1 cn2 = cn1 . cn2
type CNat = forall r. (r -> r) -> r -> r

c0, c1, c2, c3, c4 :: CNat

c0 f = id
c1 f = f
c2 f = f . f
c3 f = f . f . f
c4 f = f . f . f . f

cSucc :: CNat -> CNat

cSucc cn f = f . cn f

cPlus :: CNat -> CNat -> CNat

cPlus cn1 cn2 f = cn1 f . cn2 f

cMult :: CNat -> CNat -> CNat

cMult cn1 cn2 = cn1 . cn2
 Performance
Native ints Peano numbers Church numbers

addition O(n) O(1)

O(n2) O(1)
multiplication

O(n) O(n)
print
 Performance
Native ints Peano numbers Church numbers

addition O(n) O(1)

O(n2) O(1)
multiplication

O(n) O(n)
print
Church encoding cheat sheet
A a r

A|B (a r) (b r) r
(A, B) (a b r) r

Singleton r

Recursion r r
 Cons lists

List a = Cons(a, List a)

or

Nil
Cons(a, List a) result
or result
Nil result
(a, List a) result
result
() result
(a, result) result
result
result
a result result
result
result
 The Church encoding
of lists is:

(a r r) r r
 The Church encoding
of lists is:

(a r r) r r

AKA: foldr
 Functors
a
 Functors
a
f a
 Functors
a
f a
f (f a)
They compose!
 Functors
a
f a What if we make a
f (f a) “Church numeral” out of
f (f (f a)) them?
 Free monads
a
f a
f (f a)
f (f (f a))
f (f (f (f a)))
Free monad >>=

a
Free monad >>=

a
fmap
Free monad >>=

f a
Free monad >>=

f a
fmap
Free monad >>=

f a
fmap
Free monad >>=

f (f a)
Free monad >>=

f (f a)
fmap
Free monad >>=

f (f a)
fmap
Free monad >>=

f (f a)
fmap
Free monad >>=

f (f (f a))
Free monad >>=

f (f (f a))
fmap
Free monad >>=

f (f (f a))
fmap
Free monad >>=

f (f (f a))
fmap
Free monad >>=

f (f (f a))
fmap
λn  [n+1, n*2]
3
λn  [n+1, n*2]
4 6
λn  [n+1, n*2]
4 6 fmap
λn  [n+1, n*2]

5 8 7 12
λn  [n+1, n*2]
fmap

5 8 7 12
λn  [n+1, n*2]

5 8 7 12 fmap
λn  [n+1, n*2]

6 10 9 16 8 14 13 24
λn  Wrap [Pure (n+1), Pure (n*2)]

3
λn  Wrap [Pure (n+1), Pure (n*2)]

3 >>=
λn  Wrap [Pure (n+1), Pure (n*2)]

4 6
λn  Wrap [Pure (n+1), Pure (n*2)]

4 6 >>=
λn  Wrap [Pure (n+1), Pure (n*2)]

4 6 fmap
λn  Wrap [Pure (n+1), Pure (n*2)]

4 6 >>=
λn  Wrap [Pure (n+1), Pure (n*2)]

5 8 7 12
λn  Wrap [Pure (n+1), Pure (n*2)]

>>=

5 8 7 12
λn  Wrap [Pure (n+1), Pure (n*2)]

fmap

5 8 7 12
λn  Wrap [Pure (n+1), Pure (n*2)]

5 8 7 12 >>=
λn  Wrap [Pure (n+1), Pure (n*2)]

5 8 7 12 fmap
λn  Wrap [Pure (n+1), Pure (n*2)]

5 8 7 12 >>=
λn  Wrap [Pure (n+1), Pure (n*2)]

6 10 9 16 8 14 13 24
 Free monads

Free a = Wrap f (Free f a)

or

Pure a
Wrap f (Free f a) result
or result
Pure a result
f (Free f a) result
result
a result
f result result
result
a result
 The Church encoding
of free monads is:

(f r r) (a r) r
 Bind is constant time!

(f r r) (a r) r
>>=
CFree f b
λa -> b
λa -> b
∴
λa -> b
∴