CS 4110 Programming Languages & Logics. Lecture 17 Programming in the λ-calculus

Transcription

1 CS 4110 Programming Languages & Logics Lecture 17 Programming in the λ-calculus 10 October 2014

2 Announcements 2 Foster Office Hours Enjoy fall break!

3 Review: Church Booleans 3 We can encode TRUE, FALSE, and IF, as follows: TRUE λx. λy. x FALSE λx. λy. y IF λb. λt. λf. b t f

4 Review: Church Booleans 3 We can encode TRUE, FALSE, and IF, as follows: TRUE λx. λy. x FALSE λx. λy. y IF λb. λt. λf. b t f It is easy to see that and IF TRUE v v v IF FALSE v v v

5 Church Numerals 4 Church numerals encode a number n as a function that takes f and x, and applies f to x n times. 0 λf. λx. x 1 λf. λx. f x 2 λf. λx. f (f x)

6 Church Numerals 4 Church numerals encode a number n as a function that takes f and x, and applies f to x n times. 0 λf. λx. x 1 λf. λx. f x 2 λf. λx. f (f x) We can define other functions on integers: SUCC λn. λf. λx. f (n f x)

7 Church Numerals 4 Church numerals encode a number n as a function that takes f and x, and applies f to x n times. 0 λf. λx. x 1 λf. λx. f x 2 λf. λx. f (f x) We can define other functions on integers: SUCC λn. λf. λx. f (n f x) PLUS λn 1. λn 2. n 1 SUCC n 2 TIMES λn 1. λn 2. n 1 PLUS n 2 ZERO

8 Church Numerals 4 Church numerals encode a number n as a function that takes f and x, and applies f to x n times. 0 λf. λx. x 1 λf. λx. f x 2 λf. λx. f (f x) We can define other functions on integers: SUCC λn. λf. λx. f (n f x) PLUS λn 1. λn 2. n 1 SUCC n 2 TIMES λn 1. λn 2. n 1 PLUS n 2 ZERO ISZERO λn. n (λz. false) true

9 Recursive Functions 5 How would we write recursive functions like factorial?

10 Recursive Functions 5 How would we write recursive functions like factorial? We d like to write it like this... FACT λn. IF (ISZERO n) 1 (TIMES n (FACT (PRED n)))

11 Recursive Functions 5 How would we write recursive functions like factorial? We d like to write it like this... FACT λn. IF (ISZERO n) 1 (TIMES n (FACT (PRED n))) In slightly more readable notation this is... FACT λn. if n = 0 then 1 else n FACT (n 1)...but this is an equation, not a definition!

12 Recursion removal trick 6 We can perform a trick to define a function FACT that satisfies the recursive equation on the preveous slide.

13 Recursion removal trick 6 We can perform a trick to define a function FACT that satisfies the recursive equation on the preveous slide. Define a new function FACT : FACT λf. λn. if n = 0 then 1 else n (f f (n 1))

14 Recursion removal trick 6 We can perform a trick to define a function FACT that satisfies the recursive equation on the preveous slide. Define a new function FACT : FACT λf. λn. if n = 0 then 1 else n (f f (n 1)) Then define FACT as FACT applied to itself: FACT FACT FACT

15 Example 7 Let s try evaluating FACT on 3...

16 Example 7 Let s try evaluating FACT on 3... FACT 3

17 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3

18 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3

19 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3 (λn. if n = 0 then 1 else n (FACT FACT (n 1))) 3

20 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3 (λn. if n = 0 then 1 else n (FACT FACT (n 1))) 3 if 3 = 0 then 1 else 3 (FACT FACT (3 1))

21 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3 (λn. if n = 0 then 1 else n (FACT FACT (n 1))) 3 if 3 = 0 then 1 else 3 (FACT FACT (3 1)) 3 (FACT FACT (3 1))

22 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3 (λn. if n = 0 then 1 else n (FACT FACT (n 1))) 3 if 3 = 0 then 1 else 3 (FACT FACT (3 1)) 3 (FACT FACT (3 1))...

23 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3 (λn. if n = 0 then 1 else n (FACT FACT (n 1))) 3 if 3 = 0 then 1 else 3 (FACT FACT (3 1)) 3 (FACT FACT (3 1))

24 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3 (λn. if n = 0 then 1 else n (FACT FACT (n 1))) 3 if 3 = 0 then 1 else 3 (FACT FACT (3 1)) 3 (FACT FACT (3 1))

25 Example 7 Let s try evaluating FACT on 3... FACT 3 = (FACT FACT ) 3 = ((λf. λn. if n = 0 then 1 else n (f f (n 1))) FACT ) 3 (λn. if n = 0 then 1 else n (FACT FACT (n 1))) 3 if 3 = 0 then 1 else 3 (FACT FACT (3 1)) 3 (FACT FACT (3 1)) So we have a technique for writing recursive functions: write a function f that takes itself as an argument and define f as f f.

26 Fixpoint combinators 8 There is another way of writing recursive functions... we can express the recursive function as the fixed point of some other, higher-order function, and then take its fixed point.

27 Fixpoint combinators 8 There is another way of writing recursive functions... we can express the recursive function as the fixed point of some other, higher-order function, and then take its fixed point. Consider factorial again. It is a fixed point of the following: G λf. λn. if n = 0 then 1 else n (f (n 1)) Recall that if g if a fixed point of G, then we have G g = g.

28 Fixpoint combinators 8 There is another way of writing recursive functions... we can express the recursive function as the fixed point of some other, higher-order function, and then take its fixed point. Consider factorial again. It is a fixed point of the following: G λf. λn. if n = 0 then 1 else n (f (n 1)) Recall that if g if a fixed point of G, then we have G g = g. There are a number of fixed point combinators, such as the Y combinator. Thus, we can define the factorial function FACT to be simply Y G, the fixed point of G.

29 Y Combinator 9 The (infamous) Y combinator is defined as Y λf. (λx. f (x x)) (λx. f (x x)).

30 Y Combinator 9 The (infamous) Y combinator is defined as Y λf. (λx. f (x x)) (λx. f (x x)). It was discovered by Haskell Curry, and is one of the simplest fixed-point combinators.

31 Y Combinator 9 The (infamous) Y combinator is defined as Y λf. (λx. f (x x)) (λx. f (x x)). It was discovered by Haskell Curry, and is one of the simplest fixed-point combinators. Note how similar its defnition is to omega: omega (λx. x x) (λx. x x)

32 Z Combinator 10 What happens when we evaluate Y G under CBV?

33 Z Combinator 10 What happens when we evaluate Y G under CBV? To avoid this issue, we ll use a slight variant of the Y combinator, Z, which is easier to use under CBV.

34 Z Combinator 10 What happens when we evaluate Y G under CBV? To avoid this issue, we ll use a slight variant of the Y combinator, Z, which is easier to use under CBV. Z λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))

35 Example 11 Let s see Z in action, on our function G

36 Example 11 Let s see Z in action, on our function G FACT

37 Example 11 Let s see Z in action, on our function G FACT = Z G

38 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G

39 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y))

40 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y)

41 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) = (λf. λn. if n = 0 then 1 else n (f (n 1)))

42 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y)

43 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) λn. if n = 0 then 1

44 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) λn. if n = 0 then 1 else n ((λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) (n 1))

45 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) λn. if n = 0 then 1 else n ((λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) (n 1)) = β λn. if n = 0 then 1 else n (λy. (Z G) y) (n 1)

46 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) λn. if n = 0 then 1 else n ((λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) (n 1)) = β λn. if n = 0 then 1 else n (λy. (Z G) y) (n 1) = β λn. if n = 0 then 1 else n (Z G (n 1))

47 Example 11 Let s see Z in action, on our function G FACT = Z G = (λf. (λx. f (λy. x x y)) (λx. f (λy. x x y))) G (λx. G (λy. x x y)) (λx. G (λy. x x y)) G (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) λn. if n = 0 then 1 else n ((λy. (λx. G (λy. x x y)) (λx. G (λy. x x y)) y) (n 1)) = β λn. if n = 0 then 1 else n (λy. (Z G) y) (n 1) = β λn. if n = 0 then 1 else n (Z G (n 1)) = λn. if n = 0 then 1 else n (FACT (n 1))

48 Other fixpoint combinators 12 There are many (indeed infinitely many) fixed-point combinators. Here s a cute one: where Y k (L L L L L L L L L L L L L L L L L L L L L L L L L L) L λabcdefghijklmnopqstuvwxyzr. (r (t h i s i s a f i x e d p o i n t c o m b i n a t o r))

49 Turing s Fixpoint Combinator 13 To gain some more intuition for fixpoint combinators, let s derive a combinator Θ originally discovered by Turing.

50 Turing s Fixpoint Combinator 13 To gain some more intuition for fixpoint combinators, let s derive a combinator Θ originally discovered by Turing. Suppose we have a higher order function f, and want the fixed point of f.

51 Turing s Fixpoint Combinator 13 To gain some more intuition for fixpoint combinators, let s derive a combinator Θ originally discovered by Turing. Suppose we have a higher order function f, and want the fixed point of f. We know that Θ f is a fixed point of f, so we have Θ f = f (Θ f).

52 Turing s Fixpoint Combinator 13 To gain some more intuition for fixpoint combinators, let s derive a combinator Θ originally discovered by Turing. Suppose we have a higher order function f, and want the fixed point of f. We know that Θ f is a fixed point of f, so we have Θ f = f (Θ f). This means, that we can write the following recursive equation: Θ = λf. f (Θ f).

53 Turing s Fixpoint Combinator To gain some more intuition for fixpoint combinators, let s derive a combinator Θ originally discovered by Turing. Suppose we have a higher order function f, and want the fixed point of f. We know that Θ f is a fixed point of f, so we have Θ f = f (Θ f). This means, that we can write the following recursive equation: Θ = λf. f (Θ f). Now use the recursion removal trick: Θ λt. λf. f (t t f) Θ Θ Θ 13

54 Example 14 FACT = Θ G

55 Example 14 FACT = Θ G = ((λt. λf. f (t t f)) (λt. λf. f (t t f))) G

56 Example 14 FACT = Θ G = ((λt. λf. f (t t f)) (λt. λf. f (t t f))) G (λf. f ((λt. λf. f (t t f)) (λt. λf. f (t t f)) f)) G

57 Example 14 FACT = Θ G = ((λt. λf. f (t t f)) (λt. λf. f (t t f))) G (λf. f ((λt. λf. f (t t f)) (λt. λf. f (t t f)) f)) G G ((λt. λf. f (t t f)) (λt. λf. f (t t f)) G)

58 Example 14 FACT = Θ G = ((λt. λf. f (t t f)) (λt. λf. f (t t f))) G (λf. f ((λt. λf. f (t t f)) (λt. λf. f (t t f)) f)) G G ((λt. λf. f (t t f)) (λt. λf. f (t t f)) G) = G (Θ G)

59 Example 14 FACT = Θ G = ((λt. λf. f (t t f)) (λt. λf. f (t t f))) G (λf. f ((λt. λf. f (t t f)) (λt. λf. f (t t f)) f)) G G ((λt. λf. f (t t f)) (λt. λf. f (t t f)) G) = G (Θ G) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (Θ G)

60 Example 14 FACT = Θ G = ((λt. λf. f (t t f)) (λt. λf. f (t t f))) G (λf. f ((λt. λf. f (t t f)) (λt. λf. f (t t f)) f)) G G ((λt. λf. f (t t f)) (λt. λf. f (t t f)) G) = G (Θ G) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (Θ G) λn. if n = 0 then 1 else n ((Θ G) (n 1))

61 Example 14 FACT = Θ G = ((λt. λf. f (t t f)) (λt. λf. f (t t f))) G (λf. f ((λt. λf. f (t t f)) (λt. λf. f (t t f)) f)) G G ((λt. λf. f (t t f)) (λt. λf. f (t t f)) G) = G (Θ G) = (λf. λn. if n = 0 then 1 else n (f (n 1))) (Θ G) λn. if n = 0 then 1 else n ((Θ G) (n 1)) = λn. if n = 0 then 1 else n (FACT (n 1))

62 Definitional Translation 15 We have seen how to encode a number of high-level language constructs booleans, conditionals, natural numbers, and recursion in λ-calculus.

63 Definitional Translation 15 We have seen how to encode a number of high-level language constructs booleans, conditionals, natural numbers, and recursion in λ-calculus. In definitional translation, where we define the meaning of language constructs by translation to another language.

64 Definitional Translation 15 We have seen how to encode a number of high-level language constructs booleans, conditionals, natural numbers, and recursion in λ-calculus. In definitional translation, where we define the meaning of language constructs by translation to another language. This is a form of denotational semantics, but instead of the target being mathematical objects, it is a simpler programming language (such as λ-calculus).

65 Definitional Translation 15 We have seen how to encode a number of high-level language constructs booleans, conditionals, natural numbers, and recursion in λ-calculus. In definitional translation, where we define the meaning of language constructs by translation to another language. This is a form of denotational semantics, but instead of the target being mathematical objects, it is a simpler programming language (such as λ-calculus). For each language construct, we define an operational semantics directly, and then give an alternate semantics by translation to a simpler language.

66 Review: Call-by-Value Recall the syntax and CBV semantics of λ-calculus: e ::= x λx. e e 1 e 2 v ::= λx. e e 1 e 1 e e e 1 e 2 e 1 e 2 v e v e (λx. e) v e{v/x} β Note that there are two kinds of rules: congruence rules that specify evaluation order and computation rules that specify the interesting reductions. 16

67 Evaluation Contexts 17 Evaluation contexts are a simple mechanism that separates out these two kinds of rules.

68 Evaluation Contexts 17 Evaluation contexts are a simple mechanism that separates out these two kinds of rules. An evaluation context E (sometimes written E[ ]) is an expression with a hole in it, that is with a single occurrence of the special symbol [ ] (called the hole ) in place of a subexpression.

69 Evaluation Contexts 17 Evaluation contexts are a simple mechanism that separates out these two kinds of rules. An evaluation context E (sometimes written E[ ]) is an expression with a hole in it, that is with a single occurrence of the special symbol [ ] (called the hole ) in place of a subexpression. Evaluation contexts are defined using a BNF grammar that is similar to the grammar used to define the language. E ::= [ ] E e v E

70 Evaluation Contexts 17 Evaluation contexts are a simple mechanism that separates out these two kinds of rules. An evaluation context E (sometimes written E[ ]) is an expression with a hole in it, that is with a single occurrence of the special symbol [ ] (called the hole ) in place of a subexpression. Evaluation contexts are defined using a BNF grammar that is similar to the grammar used to define the language. E ::= [ ] E e v E We write E[e] to mean the evaluation context E where the hole has been replaced with the expression e.

71 Examples 18

72 Examples 18 E 1 = [ ] (λx. x) E 1 [λy. y y] = (λy. y y) λx. x

73 Examples 18 E 1 = [ ] (λx. x) E 1 [λy. y y] = (λy. y y) λx. x E 2 = (λz. z z) [ ] E 2 [λx. λy. x] = (λz. z z) (λx. λy. x)

74 Examples 18 E 1 = [ ] (λx. x) E 1 [λy. y y] = (λy. y y) λx. x E 2 = (λz. z z) [ ] E 2 [λx. λy. x] = (λz. z z) (λx. λy. x) E 3 = ([ ] λx. x x) ((λy. y) (λy. y)) E 3 [λf. λg. f g] = ((λf. λg. f g) λx. x x) ((λy. y) (λy. y))

75 CBV With Evaluation Contexts 19 With evaluation contexts, we can define the evaluation semantics for the pure CBV λ-calculus with just two rules, one for evaluation contexts, and one for β-reduction.

76 CBV With Evaluation Contexts 19 With evaluation contexts, we can define the evaluation semantics for the pure CBV λ-calculus with just two rules, one for evaluation contexts, and one for β-reduction. First we define the contexts: E ::= [ ] E e v E

77 CBV With Evaluation Contexts With evaluation contexts, we can define the evaluation semantics for the pure CBV λ-calculus with just two rules, one for evaluation contexts, and one for β-reduction. First we define the contexts: E ::= [ ] E e v E Then we define the small-step rules: e e E[e] E[e ] (λx. e) v e{v/x} β 19

78 CBN With Evaluation Contexts 20 We can also define the semantics of CBN λ-calculus with evaluation contexts.

79 CBN With Evaluation Contexts 20 We can also define the semantics of CBN λ-calculus with evaluation contexts. First we define the contexts: E ::= [ ] E e

80 CBN With Evaluation Contexts We can also define the semantics of CBN λ-calculus with evaluation contexts. First we define the contexts: E ::= [ ] E e Then we define the small-step rules: e e E[e] E[e ] (λx. e) e e{e /x} β 20

81 Multiple Arguments 21 Our syntax for functions only allows function with a single argument: λx. e.

82 Multiple Arguments 21 Our syntax for functions only allows function with a single argument: λx. e. We can define a language that allows functions to have multiple arguments. e ::= x λx 1,..., x n. e e 0 e 1... e n Here, a function λx 1,..., x n. e takes n arguments, with names x 1 through x n. In a multi argument application e 0 e 1... e n, we expect e 0 to evaluate to an n-argument function, and e 1,..., e n are the arguments that we will give the function.

83 Multiple Arguments We can define a CBV operational semantics for the multi-argument λ-calculus as follows. E ::= [ ] v 0... v i 1 E e i+1... e n e e E[e] E[e ] (λx 1,..., x n. e 0 ) v 1... v n e 0 {v 1 /x 1 }{v 2 /x 2 }... {v n /x n } β Note that the evaluation contexts ensure that we evaluate multi-argument applications e 0 e 1... e n from left to right. 22

84 Definitional Translation 23 The multi-argument λ-calculus isn t any more expressive that the pure λ-calculus.

85 Definitional Translation 23 The multi-argument λ-calculus isn t any more expressive that the pure λ-calculus. We can define a translation T [[ ]] that takes an expression in the multi-argument λ-calculus and returns an equivalent expression in the pure λ-calculus.

86 Definitional Translation 23 The multi-argument λ-calculus isn t any more expressive that the pure λ-calculus. We can define a translation T [[ ]] that takes an expression in the multi-argument λ-calculus and returns an equivalent expression in the pure λ-calculus. T [[x]] = x T [[λx 1,..., x n. e]] = λx λx n. T [[e]] T [[e 0 e 1 e 2... e n ]] = (... ((T [[e 0 ]] T [[e 1 ]]) T [[e 2 ]])... T [[e n ]])

87 Currying 24 This process of rewriting a function that takes multiple arguments as a chain of functions that each take a single argument is called currying.

88 Currying 24 This process of rewriting a function that takes multiple arguments as a chain of functions that each take a single argument is called currying. Consider a mathematical function that takes two arguments, the first from domain A and the second from domain B, and returns a result from domain C.

89 Currying 24 This process of rewriting a function that takes multiple arguments as a chain of functions that each take a single argument is called currying. Consider a mathematical function that takes two arguments, the first from domain A and the second from domain B, and returns a result from domain C. We can describe this function, using mathematical notation for function domains, as an element of A B C.

90 Currying 24 This process of rewriting a function that takes multiple arguments as a chain of functions that each take a single argument is called currying. Consider a mathematical function that takes two arguments, the first from domain A and the second from domain B, and returns a result from domain C. We can describe this function, using mathematical notation for function domains, as an element of A B C. Currying this function produces an element of A (B C).

91 Currying This process of rewriting a function that takes multiple arguments as a chain of functions that each take a single argument is called currying. Consider a mathematical function that takes two arguments, the first from domain A and the second from domain B, and returns a result from domain C. We can describe this function, using mathematical notation for function domains, as an element of A B C. Currying this function produces an element of A (B C). That is, the curried version takes an argument from domain A, and returns a function that takes an argument from domain B and produces a result of domain C. 24