CS 4110 Programming Languages & Logics. Lecture 27 Recursive Types

Transcription

1 CS 4110 Programming Languages & Logics Lecture 27 Recursive Types 4 November 2016

2 Announcements 2 My office hours are at the normal time today but canceled on Monday Guest lecture by Seung Hee Han on Monday

3 Recursive Types 3 Many languages support data types that refer to themselves: Java class Tree { Tree leftchild, rightchild; int data; }

4 Recursive Types 3 Many languages support data types that refer to themselves: Java class Tree { Tree leftchild, rightchild; int data; } OCaml type tree = Leaf Node of tree * tree * int

5 Recursive Types 3 Many languages support data types that refer to themselves: Java class Tree { Tree leftchild, rightchild; int data; } OCaml type tree = Leaf Node of tree * tree * int λ-calculus? tree = unit + int tree tree

6 Recursive Type Equations 4 We would like tree to be a solution of the equation: α = unit + int α α However, no such solution exists with the types we have so far...

7 Unwinding Equations 5 We could unwind the equation: α = unit + int α α

8 Unwinding Equations 5 We could unwind the equation: α = unit + int α α = unit + int (unit + int α α) (unit + int α α)

9 Unwinding Equations 5 We could unwind the equation: α = unit + int α α = unit + int (unit + int α α) (unit + int α α) = unit + int (unit + int (unit + int α α) (unit + int α α)) (unit + int (unit + int α α) (unit + int α α))

10 Unwinding Equations 5 We could unwind the equation: α = unit + int α α = unit + int (unit + int α α) (unit + int α α) = unit + int (unit + int (unit + int α α) (unit + int α α)) (unit + int (unit + int α α) (unit + int α α)) =

11 Unwinding Equations We could unwind the equation: α = unit + int α α = unit + int (unit + int α α) (unit + int α α) = unit + int (unit + int (unit + int α α) (unit + int α α)) (unit + int (unit + int α α) (unit + int α α)) = If we take the limit of this process, we have an infinite tree. 5

12 Infinite Types 6 Think of this as an infinite labeled graph whose nodes are labeled with the type constructors, +, int, and unit. This infinite tree is a solution of our equation, and this is what we take as the type tree.

13 µ Types 7 We ll specify potentially-infinite solutions to type equations using a finite syntax based on the fixed-point type constructor µ. µα. τ

14 µ Types 7 We ll specify potentially-infinite solutions to type equations using a finite syntax based on the fixed-point type constructor µ. µα. τ Here s a tree type satisfying our original equation: tree µα. unit + int α α.

15 Static Semantics (Equirecursive) 8 We ll define two treatments of recursive types. With equirecursive types, a recursive type is equal to its unfolding: µα. τ is a solution to α = τ, so: µα. τ = τ{µα. τ/α}

16 Static Semantics (Equirecursive) 8 We ll define two treatments of recursive types. With equirecursive types, a recursive type is equal to its unfolding: µα. τ is a solution to α = τ, so: µα. τ = τ{µα. τ/α} Two typing rules let us switch between folded and unfolded: Γ e : τ{µα. τ/α} Γ e : µα. τ µ-intro Γ e : µα. τ Γ e : τ{µα. τ/α} µ-elim

17 Isorecursive Types 9 Alternatively, isorecursive types avoid infinite type trees. The type µα. τ is distinct but transformable to and from τ{µα. τ/α}.

18 Isorecursive Types 9 Alternatively, isorecursive types avoid infinite type trees. The type µα. τ is distinct but transformable to and from τ{µα. τ/α}. Converting between the two uses explicit fold and unfold operations: unfold µα. τ : µα. τ τ{µα. τ/α} fold µα. τ : τ{µα. τ/α} µα. τ

19 Static Semantics (Isorecursive) 10 The typing rules introduce and eliminate µ-types: Γ e : τ{µα. τ/α} Γ fold e : µα. τ µ-intro Γ e : µα. τ Γ unfold e : τ{µα. τ/α} µ-elim

20 Dynamic Semantics 11 We also need to augment the operational semantics: unfold (fold e) e Intuitively, to access data in a recursive type µα. τ, we need to unfold it first. And the only way that values of type µα. τ could have been created is via fold.

21 Example 12 Here s a recursive type for lists of numbers: intlist µα. unit + int α.

22 Example 12 Here s a recursive type for lists of numbers: intlist µα. unit + int α. Here s how to add up the elements of an intlist: let sum = fix (λf:intlist intlist λl:intlist. case unfold l of (λu : unit. 0) (λp : int intlist. (#1 p) + f (#2 p)))

23 Encoding Numbers 13 Recursive types let us encode the natural numbers!

24 Encoding Numbers 13 Recursive types let us encode the natural numbers! A natural number is either 0 or the successor of a natural number: nat µα. unit + α

25 Encoding Numbers 13 Recursive types let us encode the natural numbers! A natural number is either 0 or the successor of a natural number: nat µα. unit + α 0 fold (inl unit+nat ())

26 Encoding Numbers 13 Recursive types let us encode the natural numbers! A natural number is either 0 or the successor of a natural number: nat µα. unit + α 0 fold (inl unit+nat ()) 1 fold (inr unit+nat 0) 2 fold (inr unit+nat 1),.

27 Encoding Numbers 13 Recursive types let us encode the natural numbers! A natural number is either 0 or the successor of a natural number: nat µα. unit + α 0 fold (inl unit+nat ()) 1 fold (inr unit+nat 0) 2 fold (inr unit+nat 1), The successor function has type nat nat:. (λx : nat. fold (inr unit+nat x))

28 Self-Application and Ω 14 Recall Ω defined as: ω λx. x x Ω ω ω. Ω was impossible to type... until now!

29 Self-Application and Ω 14 Recall Ω defined as: ω λx. x x Ω ω ω. Ω was impossible to type... until now! x is a function. Let s say it has the type σ τ.

30 Self-Application and Ω 14 Recall Ω defined as: ω λx. x x Ω ω ω. Ω was impossible to type... until now! x is a function. Let s say it has the type σ τ. x is used as the argument to this function, so it must have type σ.

31 Self-Application and Ω 14 Recall Ω defined as: ω λx. x x Ω ω ω. Ω was impossible to type... until now! x is a function. Let s say it has the type σ τ. x is used as the argument to this function, so it must have type σ. So let s write a type equation: σ = σ τ

32 Self-Application and Ω 15 Putting these pieces together, the fully typed ω term is: ω λx : µα. (α τ). (unfold x) x

33 Self-Application and Ω 15 Putting these pieces together, the fully typed ω term is: ω λx : µα. (α τ). (unfold x) x The type of ω is (µα. (α τ)) τ. So the type of fold ω is µα. (α τ).

34 Self-Application and Ω 15 Putting these pieces together, the fully typed ω term is: ω λx : µα. (α τ). (unfold x) x The type of ω is (µα. (α τ)) τ. So the type of fold ω is µα. (α τ). Now we can define Ω = ω (fold ω). It has type τ.

35 Self-Application and Ω 16 We can even write ω in OCaml: # type u = Fold of (u -> u);; type u = Fold of (u -> u) # let omega = fun x -> match x with Fold f -> f x;; val omega : u -> u = <fun> # omega (Fold omega);;...runs forever until you hit control-c

36 Encoding λ-calculus 17 With recursive types, we can type everything in the untyped lambda calculus!

37 Encoding λ-calculus 17 With recursive types, we can type everything in the untyped lambda calculus! Every λ-term can be applied as a function to any other λ-term. So let s define an untyped type: U µα. α α

38 Encoding λ-calculus With recursive types, we can type everything in the untyped lambda calculus! Every λ-term can be applied as a function to any other λ-term. So let s define an untyped type: U µα. α α The full translation is: [[x]] x [[e 0 e 1 ]] (unfold [[e 0 ]]) [[e 1 ]] [[λx. e]] fold λx : U. [[e]] Every untyped term maps to a term of type U. 17