2012 05-08-lambda-draft

Implementing Untyped λ-Calculus

in Haskell

slide: Jaiyalas
Lin Jen-Shin (godfat) 1 / 94


godfat.org/slide/2012-05-08-
lambda-draft.pdf

2 / 94

Who Am I?

Who Am I?

3 / 94

Who Am I?

What I learned?

▶ 2007∼present: (learning) Haskell
▶ 2006∼present: Ruby
▶ 2005∼2008: C++
▶ 2001∼2004: C

4 / 94

Who Am I?

What I worked?

▶ roodo.com
▶ cardinalblue.com

5 / 94

Who Am I?

Where you can ﬁnd me

▶ github.com/godfat
▶ twitter.com/godfat
▶ proﬁles.google.com/godfat

6 / 94

Who Am I?

How I started to learn Haskell

▶ PLT at ssh://bbs@ptt.cc

7 / 94

Who Am I?


▶ IIS at Sinica

7 / 94

Who Am I?


▶ IIS at Sinica
▶ FLOLAC

7 / 94


Table of Contents

▶ What can Haskell do?
▶ What is λ-Calculus?
▶ Why Implement λ-Calculus?
▶ Let's Implement λ-Calculus
▶ Questions?
▶ References

8 / 94

What can Haskell do?

dummy

▶ Questions?
▶ References

9 / 94


Deﬁned in 1990

10 / 94


Successor of
Miranda from
1985

11 / 94


Haskell 98

12 / 94


Haskell 2010

13 / 94


GHC (Glasgow Haskell Compiler)

▶ STM (Software Transactional Memory)

14 / 94



▶ Template Haskell

14 / 94



▶ Template Haskell
▶ GADT (Generalized Algebraic Data Type)

14 / 94


Notable Projects

▶ Audrey Tang's (唐鳳) Pugs

15 / 94


Notable Projects

▶ xmonad

15 / 94


Notable Projects

▶ xmonad
▶ Darcs

15 / 94


Parallelism vs Concurrency?

▶ par-tutorial

16 / 94



▶ par-tutorial
▶ Parallelism ̸= Concurrency

16 / 94



▶ par-tutorial
▶ Parallelism ̸= Concurrency
▶ Parallelism is not concurrency

16 / 94

What is λ-Calculus?

dummy

▶ Questions?
▶ References

17 / 94



An important formal system
for functional programming

18 / 94

Turing Machine

Turing Machine

19 / 94

Turing Machine

by Alan Turing
in 1936

20 / 94

Turing Machine

21 / 94

Turing Machine

Turing Machine

▶ Inﬁnite tape which stores symbols (memory)

22 / 94

Turing Machine

Turing Machine

▶ Finite action table which represents
(state, symbol) → action (program)

22 / 94

Turing Machine

Turing Machine

▶ Robotic arm (CPU with a register which stores
current state)

22 / 94

Turing Machine

Turing Machine

current state)
■ Read the symbol on the tape at current position

22 / 94

Turing Machine

Turing Machine

current state)
■ Write a symbol on the tape at current position

22 / 94

Turing Machine

Turing Machine

current state)
■ Write a symbol on the tape at current position
■ Move the tape left or right

22 / 94

Turing Machine

Turing Complete

23 / 94


So what is
λ-calculus?

24 / 94


Alligator Eggs!

http://worrydream.com/AlligatorEggs/

25 / 94


by Alonzo Church
in 1930s

26 / 94


Also Turing
complete

27 / 94


but why?

28 / 94

λ-Complete

Deﬁne
λ-Complete

29 / 94

λ-Complete

Whatever
λ-calculus can do

30 / 94

λ-Complete

Implement Turing machine in λ-calculus

31 / 94

λ-Complete

λ-Complete

▶ So λ-calculus can do anything TM can do

32 / 94

λ-Complete

λ-Complete

▶ Plus what λ-calculus can do without a TM

32 / 94

λ-Complete

λ-Complete

▶ Plus what λ-calculus can do without a TM
▶ Thus λ-calculus is Turing complete

32 / 94

λ-Complete

On the other
hand...

33 / 94

λ-Complete

Implement λ-calculus in Turing machine

34 / 94

λ-Complete

So Turing
machine is also
λ-complete

35 / 94

λ-Complete

They have the same computability

36 / 94


What exactly is λ-calculus?

▶ (λx. x+1)

37 / 94



▶ (λx. x+1)
▶ (λx. x+1) 1

37 / 94



▶ (λx. x+1)
▶ (λx. x+1) 1
▶ = (1+1)

37 / 94



▶ (λx. x+1)
▶ (λx. x+1) 1
▶ = (1+1)
▶ = 2

37 / 94


Does it look like Lisp?

(λf.(λx.f (x x)) (λx.f (x x)))

38 / 94

Church Encoding

Church Encoding

39 / 94

Church Encoding

Natural Numbers

▶ 0 ≡ λf.λx. x
▶ 1 ≡ λf.λx. f x
▶ ...
▶ n ≡ λf.λx. fn x

40 / 94

Church Encoding

Computation with Natural Numbers

▶ succ ≡ λn.λf.λx. f (n f x)
▶ plus ≡ λm.λn.λf.λx. m f (n f x)

41 / 94

Church Encoding

Booleans

▶ true ≡ λa.λb. a
▶ false ≡ λa.λb. b

42 / 94

Church Encoding

Computation with Booleans

▶ and ≡ λm.λn. m n m
▶ or ≡ λm.λn. m m n
▶ not ≡ λm.λa.λb. m b a
▶ if ≡ λm.λa.λb. m a b

43 / 94


Recursion?
No problems

44 / 94

Y combinator

Y combinator

▶ Discovered by Haskell Curry
▶ y = (λf.(λx.f (x x)) (λx.f (x x)))

45 / 94

Y combinator

Y combinator

▶ y = (λf.(λx.f (x x)) (λx.f (x x)))
▶ y f = (λf.(λx.f (x x)) (λx.f (x x))) f

45 / 94

Y combinator

Y combinator

▶ y = (λf.(λx.f (x x)) (λx.f (x x)))
▶ y f = (λf.(λx.f (x x)) (λx.f (x x))) f
▶ y f = f (y f)

45 / 94

Y combinator

Paul Graham,
I know what is
Y combinator!

46 / 94

Fixed Point Combinator


▶ Strict languages need some delay
▶ Z = (λx.f (λv.((x x) v))) (λx.f (λv.((x x) v)))
▶ Discovered by Alan Turing
▶ Θ = (λx.λy. (y (x x y))) (λx.λy. (y (x x y)))

47 / 94



▶ Constructed by Jan Willem Klop
▶ Yk = (L L L L L L L L L L L . . .)

where L = λabcdefghijklmnopqstuvwxyzr. (r (thisisafixedpointcombinator))

48 / 94

Why Implement λ-Calculus?

dummy

▶ Questions?
▶ References

49 / 94


dummy

▶ My interest in researching
programming languages

50 / 94


dummy

▶ Implementing λ-calculus in Haskell
could teach us a lot in

50 / 94


dummy

▶ Implementing λ-calculus in Haskell
could teach us a lot in
▶ It's my most inﬂuential Haskell exercise

50 / 94


dummy

Let's Learn Haskell The Hard Way
You a Haskell For Great Good!

51 / 94


But before we
started...

52 / 94


dummy

▶ No parsing here

53 / 94


dummy

▶ No parsing here
▶ Parse tree (S-expression) interpreter only

53 / 94


dummy

▶ No parsing here
▶ Haskell is also good at parsing

53 / 94


dummy

▶ No parsing here
▶ Haskell is also good at parsing
▶ e.g. parser combinator and parsec

53 / 94

Let's Implement λ-Calculus

dummy

▶ Questions?
▶ References

54 / 94


First Expression and evaluate (source)
module Main where
.
data Expression = Literal Integer
| Plus Expression Expression
.
evaluate :: Expression -> Integer
evaluate (Literal i) = i
evaluate (Plus expr0 expr1) =
evaluate expr0 + evaluate expr1
.
test0 = evaluate (Literal 1)
test1 = evaluate (Plus (Literal 1) (Literal 2))
test2 = evaluate (Plus (Plus (Literal 1)
(Literal 2))
(Literal 3))
55 / 94


module Main where
.
.
.
(Literal 2))
(Literal 3))
56 / 94


module Main where
.
.
.
(Literal 2))
(Literal 3))
57 / 94


module Main where
.
.
.
(Literal 2))
(Literal 3))
58 / 94


Algebraic Datatypes
module Main where
.
.
Think of interface and subclasses if you like OOP
.
(Literal 2))
(Literal 3))
59 / 94


Pattern Matching
module Main where
.
.
.
Think of dynamic cast or instanceof with a switch if you like OOP
(Literal 2))
(Literal 3))
60 / 94


module Main where
.
.
.
(Literal 2))
(Literal 3))
61 / 94


Variable and Environment (source)
module Main where
.
| Variable String
.
type Environment = [(String, Integer)]
.
evaluate :: Expression -> Environment -> Integer
evaluate (Literal i) env = i
evaluate (Plus expr0 expr1) env =
evaluate expr0 env + evaluate expr1 env
evaluate (Variable name) env =
case lookup name env of (Just i) -> i

62 / 94


module Main where
.
| Variable String
.
.

63 / 94


module Main where
.
| Variable String
.
.

64 / 94


module Main where
.
| Variable String
.
.

65 / 94



test0 = evaluate (Variable "var") [("var", 1)]
test1 = evaluate (Plus (Variable "var") (Literal
2)) [("var", 1)]

66 / 94


Type Alias
module Main where
.
| Variable Name
.
type Name = String
type Environment = [(Name, Integer)]
.
67 / 94


Pair of a and b

("var", 2) :: (String, Integer)
(2, "var") :: (Integer, String)

68 / 94


List of a

[1,2,3] :: [Integer]
["a","b","c"] :: [String]
[("var", 1)] :: [(String, Integer)]

69 / 94


Curried Functions


70 / 94


Curried Functions

evaluate :: Expression -> (Environment -> Integer)

71 / 94


Uncurried Functions

evaluate :: (Expression, Environment) -> Integer

72 / 94


Uncurried Functions

threeArguments ::
(String, String, String) -> Integer

73 / 94


Curried Function

threeArguments ::
String -> String -> String -> Integer

74 / 94


Curried Function

threeArguments ::
String -> (String -> String -> Integer)

75 / 94


Curried Function

threeArguments ::
String -> (String -> (String -> Integer))

76 / 94


(->) is
right-associative

77 / 94


Partially Applied Function

filter :: (a -> Bool) -> [a] -> [a]
.
above60 :: [a] -> [a]
above60 = filter (>=60)
.
above60 [1..65] -- [60,61,62,63,64,65]

78 / 94


Partially Applied Function

map :: (a -> b) -> [a] -> [b]
.
div2 :: [Integer] -> [Integer]
div2 = map (`div`2)
.
div2 [1..5] -- [0,1,1,2,2]

79 / 94


Function Composition

(.) :: (b -> c) -> (a -> b) -> a -> c
.
above60AndDiv2 :: [Integer] -> [Integer]
above60AndDiv2 = div2 . above60
.
above60AndDiv2 [1..65] -- [30,30,31,31,32,32]

80 / 94


Function Composition

compose :: (b -> c) -> (a -> b) -> a -> c
compose g f x = g (f x)

81 / 94


Curried functions make function composition powerful,
function composition makes curried function even more useful.

82 / 94


List of Partially Applied Functions

mapPlus = map (+) -- think of [(+), (+), ...]
.
mapPlus1to5 = mapPlus [1..5]
-- think of [(1+), (2+), ...]
.
map ($1) mapPlus1to5 -- [2,3,4,5,6]
.
.
-- applicative functor style
(+) <$> [1..5] <*> [1] -- [2,3,4,5,6]

83 / 94


Exception Handling

| Variable Name
.
type Name = String
.
type Value = Maybe Integer
.
evaluate :: Expression -> Environment -> Value

84 / 94


Exception Handling

| Variable Name
.
type Name = String
.
type Value = Maybe Integer
.
evaluate :: Expression -> Environment -> Value
evaluate (Literal i) env = Just i
evaluate (Variable name) env = lookup name env

85 / 94


Exception Handling

let val0 = evaluate expr0 env
val1 = evaluate expr1 env
in
case val0 of
(Nothing) -> Nothing
(Just i0) -> case val1 of
(Nothing) -> Nothing
(Just i1) -> Just (i0 + i1)

86 / 94


Maybe Monad with do notation

do
val0 <- evaluate expr0 env
val1 <- evaluate expr1 env
return (val0 + val1)

87 / 94


Do notation underneath

evaluate expr0 env >>= val0 ->
evaluate expr1 env >>= val1 -> return (val0 +
val1)

88 / 94


liftM2

evaluate expr0 env `plus` evaluate expr1 env where
plus = liftM2 (+)

89 / 94


Sorry! To be
continued...

90 / 94


Peek the ﬁnal work

https://github.com/godfat/sandbox/blob/master/haskell/fpug/01/la

91 / 94


We're hiring

cblue.tw/jobs

92 / 94


Feel free to ask me questions online

▶ github.com/godfat
▶ twitter.com/godfat
▶ proﬁles.google.com/godfat

93 / 94


References

▶ To be listed...
▶

▶

▶

▶

▶

94 / 94

2012 05-08-lambda-draft

Recommended

Recommended

More Related Content

Similar to 2012 05-08-lambda-draft

Similar to 2012 05-08-lambda-draft (20)

More from Lin Jen-Shin

More from Lin Jen-Shin (9)

Recently uploaded

Recently uploaded (20)

2012 05-08-lambda-draft