λ-calculus and church encodings

Præsentationer af emnet: "λ-calculus and church encodings"— Præsentationens transcript:

1 λ-calculus and church encodings
Compiling to λ λ-calculus and church encodings

2 e ::= (lambda (x) e) | (e e) | x

3 Alonzo Church

4 β Ω = (U U) = ((λ (u) (u u)) Ω (λ (u) (u u)))

5

6

7 Church encoding

8 e ::= (letrec ([x (lambda (x …) e)])) | (let ([x e] …) e)
| (if e e e) | (+ e e) | (* e e) | (cons e e) | (car e) | (cdr e) | d d ::= ℕ | #t | #f | ‘() x ::= <vars>

9 e ::= (letrec ([x (lambda (x …) e)])) | (let ([x e] …) e)
| (if e e e) | (+ e e) | (* e e) | (cons e e) | (car e) | (cdr e) | d d ::= ℕ | #t | #f | ‘() x ::= <vars> e ::= ) e) )

10 Desugaring Let

11 (let ([x e] …) ebody)

12 (let ([x e] …) ebody) ((λ (x …) ebody) e …)

13 Currying

14 Gottlob Frege Moses Schönfinkel

15 (λ (x) (λ (y) (λ (z) e))) (λ (x y z) e) (λ (x) e) (λ (x) e) (λ () e) (λ (_) e)

16 (f a b c d) ((((f a) b) c) d) (f a) (f a) (f) (f f)

17 e ::= (letrec ([x (lambda (x) e)]))
| (e e) | x | (if e e e) | ((+ e) e) | ((* e) e) | ((cons e) e) | (car e) | (cdr e) | d d ::= ℕ | #t | #f | ‘() x ::= <vars>

18 Conditionals & Booleans

19 (if #t eT eF) (if #f eT eF) eT eF

20 ((λ (t f) t) (if #t eT eF) ((λ (t f) f) (if #f eT eF) ((λ (t f) t) vT vF) ((λ (t f) f) vT vF) vT vF

21 ((λ (t f) t) eT Ω)

22 ((λ (t f) (t)) (λ () eT) (λ () Ω))
vT

23 Turn all values into verbs!
(Focus on the behaviors that are implicit in values.)

24 e ::= (letrec ([x (lambda (x) e)]))
| (e e) | x | ((+ e) e) | ((* e) e) | ((cons e) e) | (car e) | (cdr e) | d d ::= ℕ | ‘() x ::= <vars>

25 Natural Numbers

26 (λ (f) (λ (x) (fN x))) 0: (λ (f) (λ (x) x)) 1: (λ (f) (λ (x) (f x))) 2: (λ (f) (λ (x) (f (f x)))) 3: (λ (f) (λ (x) (f (f (f x)))))

27 church+ = (λ (n) (λ (m) (λ (f) (λ (x) …))))

28 church+ = (λ (n) (λ (m) (λ (f) (λ (x) ((n f) ((m f) x))))))

29 church* = (λ (n) (λ (m) (λ (f) (λ (x) …))))

30 church* = (λ (n) (λ (m) (λ (f) (λ (x) ((n (m f)) x)))))

31 M fN = fN*M

32 e ::= (letrec ([x (lambda (x) e)]))
| (e e) | x | ((cons e) e) | (car e) | (cdr e) | d d ::= ‘() x ::= <vars>

33 Lists

34 We need to be able to case-split.
The fundamental problem: We need to be able to case-split. The solution: We take two callbacks as with #t, #f!

35 ‘() = (λ (when-cons) (λ (when-null)
(cons a b) = (λ (when-cons) (λ (when-null) (when-cons a b)))

36 e ::= (letrec ([x (lambda (x) e)]))
| (e e) | x x ::= <vars>

37 Y combinator

38 (letrec ([fact (λ (n) (if (= n 0) 1 (* n (fact (- n 1)))))]) (fact 5))

39 (letrec ([fact (λ (fact) (λ (n)
(if (= n 0) 1 (* n (fact (- n 1)))))]) (fact 5))

40 (letrec ([mk (λ (fact) (λ (n)
(if (= n 0) 1 (* n (fact (- n 1)))))]) ((mk mk) 5))

41 (letrec ([mk (λ (mk) (λ (n)
(if (= n 0) 1 (* n ((mk mk) (- n 1)))))]) ((mk mk) 5))

42 Y

43 (It’s a fixed-point combinator!)
(Y f) = f (Y f) (It’s a fixed-point combinator!)

44

45 Y = (U (λ (y) (λ (f) (f (λ (x) (((y y) f) x)))))

46 (letrec ([fact (Y (λ (fact) (λ (n)
(if (= n 0) 1 (* n (fact (- n 1)))))]) (fact 5))

47 e ::= (lambda (x) e) | (e e) | x

48 De-churching (define (church->nat cv) )
(define (church->list cv) (define (church->bool cv)

49 De-churching (define (church->nat cv) ((cv add1) 0))
(define (church->list cv) ) (define (church->bool cv)

50 De-churching (define (church->nat cv) ((cv add1) 0))
(define (church->list cv) ((cv (λ (car) (λ (cdr) (cons car (church->list cdr))))) (λ (na) ‘()))) (define (church->bool cv) )

51 De-churching (define (church->nat cv) ((cv add1) 0))
(define (church->list cv) ((cv (λ (car) (λ (cdr) (cons car (church->list cdr))))) (λ (na) ‘()))) (define (church->bool cv) ((cv (λ () #t)) (λ () #f)))

52 (letrec ([map (λ (f lst)
(if (null? lst) '() (cons (f (car lst)) (map f (cdr lst)))))]) (map (λ (x) (+ 1 x)) '(0 5 3)))

53 > (map church->nat (church->list lst)) '(1 6 4)
(define lst (((((((((λ (Y-comb) (λ (church:null?) (λ (church:cons) (λ (church:car) (λ (church:cdr) (λ (church:+) (λ (church:*) (λ (church:not) ((λ (map) ((map (λ (x) ((church:+ (λ (f) (λ (x) (f x)))) x))) ((church:cons (λ (f) (λ (x) x))) ((church:cons (λ (f) (λ (x) (f (f (f (f (f x)))))))) (λ (f) (λ (x) (f (f (f x)))))) (λ (when-cons) (λ (when-null) (when-null (λ (x) x))))))))) (Y-comb (λ (map) (λ (lst) (((church:null? lst) (λ (unused) (when-null (λ (x) x)))))) ((church:cons (f (church:car lst))) ((map f) (church:cdr lst)))))))))))))))))) ((λ (y) (λ (mk) (mk (λ (x) (((y y) mk) x))))) (λ (y) (λ (mk) (mk (λ (x) (((y y) mk) x))))))) (λ (pair) ((pair (λ (a) (λ (b) (λ (ft) (λ (ff) (ff (λ (x) x))))))) (λ (unused) (λ (ft) (λ (ff) (ft (λ (x) x)))))))) (λ (b) (λ (when-cons) (λ (when-null) ((when-cons a) b)))))) ((pair (λ (a) (λ (b) a))) (λ (unused) (λ (x) x))))) ((pair (λ (a) (λ (b) b))) (λ (unused) (λ (x) x))))) (λ (n0) (λ (n1) (λ (f) (λ (x) ((n1 f) ((n0 f) x))))))) (λ (n0) (λ (n1) (λ (f) (λ (x) ((n0 (n1 f)) x)))))) (λ (bool) ((bool (λ (unused) (λ (ft) (λ (ff) (ff (λ (x) x)))))) (λ (unused) (λ (ft) (λ (ff) (ft (λ (x) x))))))))) > (map church->nat (church->list lst)) '(1 6 4)

54 Now we can write a church encoder!