A Substructural Type System for Delimited Continuations

Transcription

1 1 A Substructural Type System for Delimited Continuations Oleg Kiselyov (FNMOC) Chung-chieh Shan (Rutgers University) TLCA June 27, 2007

2 ? 2

3 Summary Small-step abstract interpretation type systems for ((delimited) control) effects formalize as a substructural logic Slogan Types are abstract expressions (Cousot) The colon is a turnstile (Lambek) 3

4 Outline Delimited continuations Answer types Types as abstract interpretation Substructural logic The λξ 0 -calculus with small-step typing 4

5 Reset # is the identity continuation (reset [ ]). $ plugs in a term. # $ Goldilocks said: (# $ This porridge is too hot. ) # $ Goldilocks said: (# $ This porridge is too hot. ) # $ Goldilocks said: (# $ This porridge is too hot. ) # $ Goldilocks said: This porridge is too hot. # $ Goldilocks said: This porridge is too hot. Goldilocks said: This porridge is too hot. 5

6 Shift 0 ξ 0 k. removes and binds k to a continuation. # $ Goldilocks said: (# $ This porridge is (ξ 0 k.(k $ too hot ) (k $ too cold ) (k $ just right )). ) # $ Goldilocks said: ((# $ This porridge is too hot. ) (# $ This porridge is too cold. ) (# $ This porridge is just right. )) Goldilocks said: This porridge is too hot. This porridge is too cold. This porridge is just right. 6

7 Applications Try/catch/reset; throw/abort. # $ Goldilocks said: (# $ Porridge (ξ 0 k. Ouch! ) is my favorite food. ) # $ Goldilocks said: Ouch! 7

8 Applications Try/catch/reset; throw/abort. # $ Goldilocks said: (# $ Porridge (ξ 0 k. Ouch! ) is my favorite food. ) # $ Goldilocks said: Ouch! Delimited continuations are useful for: backtracking search representing monads CPS transformation partial evaluation Web interactions mobile code linguistics We need multiple answer types, not just string. 7

9 8 Outline Delimited continuations Answer types Types as abstract interpretation Substructural logic The λξ 0 -calculus with small-step typing

10 Answer types in the CPS transformation 1 < 2 { (bool T) T }} { λk. (int T) T {}}{ (λk. k1) (λx. (int T) T {}}{ (λk. k2) (λy. k(x < y) }{{} )) } {{ T } } {{ T } T 9

11 Answer types in the CPS transformation 1 < 2 { (bool T) T }} { λk. (int T) T {}}{ (λk. k1) (λx. (int T) T {}}{ (λk. k2) (λy. k(x < y) }{{} )) } {{ T } } {{ T } T 9

12 Answer types in the CPS transformation 1 < 2 { (bool T) T }} { λk. (int T) T {}}{ (λk. k1) (λx. (int T) T {}}{ (λk. k2) (λy. k(x < y) }{{} )) } {{ T } } {{ T } T 9

13 Answer types in the CPS transformation 1 < 2 (ξ 0 k. Ouch! ) < 2 { (bool T) string }} { λk. (int T) string {}}{ (λk. Ouch! ) (λx. (int T) T {}}{ (λk. k2) (λy. k(x < y) }{{} )) } {{ T } } {{ T } string 9

14 Answer types in the CPS transformation 1 < 2 (ξ 0 k. Ouch! ) < 2 1 < (ξ 0 k. c ) { (bool T) char }} { (int char) char {}}{ (int T) char {}}{ λk. (λk. k1) (λx. (λk. c ) (λy. k(x < y) }{{} )) } {{ T } } {{ char } char 9

15 Answer types in the CPS transformation 1 < 2 (ξ 0 k. Ouch! ) < 2 1 < (ξ 0 k. c ) (ξ 0 k. Ouch! ) < (ξ 0 k. c ) { (bool T) string }} { (int char) string {}}{ (int T) char {}}{ λk. (λk. Ouch! ) (λx. (λk. c ) (λy. k(x < y) }{{} )) } {{ T } } {{ char } string Evaluation order chains together initial and final answer types. 9

16 10 Desideratum 1: Changing the answer type Need to change the answer type to: create functions find list prefixes represent parameterized monads analyze questions and polarity in natural language Ghani & Johann, generalized continuations yesterday newtype Ran g h a = Ran ( b. (a g b) h b)

17 Desideratum 1: Changing the answer type Need to change the answer type to: create functions find list prefixes represent parameterized monads analyze questions and polarity in natural language Ghani & Johann, generalized continuations yesterday newtype Ran g h a = Ran ( b. (a g b) h b) For example (Danvy & Filinski): [x σ]ρ, α E : τ, β ρ, δ λx. E : (σ/α τ/β), δ. The 4-ary type constructor / / fits exactly two answer types. 10

18 Desideratum 1: Changing the answer type Need to change the answer type to: create functions find list prefixes represent parameterized monads analyze questions and polarity in natural language Ghani & Johann, generalized continuations yesterday newtype Ran g h a = Ran ( b. (a g b) h b) For example (Danvy & Filinski): (τ α) β {}}{ [x σ]ρ, α E : τ, β ρ, δ λx. E : (σ/α τ/β), δ. }{{} σ (τ α) β The 4-ary type constructor / / fits exactly two answer types. 10

19 11 Desideratum 2: Reaching beyond the nearest delimiter Need to reach beyond the nearest delimiter to: combine multiple monadic effects normalize λ-terms with sums simulate exceptions and mutable references simulate dynamic binding encode process calculi?

20 12 Lacuna Unfortunately No existing type system subsumes all others. Answer types (effect annotations) on judgments and arrows obscure logical interpretation.

21 Lacuna Unfortunately No existing type system subsumes all others. Answer types (effect annotations) on judgments and arrows obscure logical interpretation. Our new system allows an arbitrary number of changing answer types, using small-step abstract interpretation and only binary connectives. 12

22 Lacuna ξ 0 k. Ouch! : (int T) string Our new system allows an arbitrary number of changing answer types, using small-step abstract interpretation and only binary connectives. 12

23 Lacuna ξ 0 k. Ouch! : (int T) string Our new system allows an arbitrary number of changing answer types, using small-step abstract interpretation and only binary connectives. 12

24 Lacuna ξ 0 k. Ouch! : (int T) string 1 < 2 : bool 1 < 2 : (bool T) T (ξ 0 k. Ouch! ) < 2 : (bool T) string (ξ 0 k. Ouch! ) < (ξ 0 k. c ) : (bool T) string Our new system allows an arbitrary number of changing answer types, using small-step abstract interpretation and only binary connectives. 12

25 13 Outline Delimited continuations Answer types Types as abstract interpretation Substructural logic The λξ 0 -calculus with small-step typing

26 Big step Operational semantics < true Abstract interpretation 1 : int 2 : int 3 : int 4 : int : int : int < : bool For control effects, need small steps. 14

27 Small step Operational semantics true true 3 < 7 true 3 < true < true time Abstract interpretation [x : int] 1 [y : int] 2 [z : bool] 3 3 x < y : bool 2 x < : bool < : bool bool : bool int < int : bool int < : bool < : bool An abstract value is a linear hypothesis. The colon is a turnstile. 14

28 15 Abstract expressions and abstract evaluation contexts Plugging works in both directions. (U T) $ U : T S $ (S T) : T Also need hypothetical reasoning.

29 16 Abstract expressions and abstract evaluation contexts Ouch! : string ξ 0 k. Ouch! : (int ) string c : char ξ 0 k. c : (int T) char (bool T) $ bool : T (bool T) $ ( < ) : T (bool T) $ int < (ξ 0 k. c ) : char (bool T) $ (ξ 0 k. Ouch! ) < : string 1 < 2 : bool

30 16 Abstract expressions and abstract evaluation contexts [k : bool T] 1 [z : bool] 2 k $ z : T 2 k $ (1 < 2) : T 1 1 < 2 : (bool T) T Ouch! : string ξ 0 k. Ouch! : (int ) string c : char ξ 0 k. c : (int T) char (bool T) $ bool : T (bool T) $ ( 1 < 2 ) : T (bool T) $ int < (ξ 0 k. c ) : char (bool T) $ (ξ 0 k. Ouch! ) < : string 1 < 2 : (bool T) T Duality between and ; bool is a subtype of (bool T) T.

31 16 Abstract expressions and abstract evaluation contexts Ouch! : string ξ 0 k. Ouch! : (int T ) string c : char ξ 0 k. c : (int T) char (bool T) $ bool : T (bool T) $ (int < 2 ) : T (bool T) $ int < (ξ 0 k. c ) : char (bool T) $ (ξ 0 k. Ouch! ) < 2 : string (ξ 0 k. Ouch! ) < 2 : (bool T) string Typing derivation is CPS transformation; ξ 0 is abstraction like λ.

32 Abstract expressions and abstract evaluation contexts Ouch! : string ξ 0 k. Ouch! : (int char) string c : char ξ 0 k. c : (int T) char (bool T) $ bool : T (bool T) $ (int < int) : T (bool T) $ int < (ξ 0 k. c ) : char (bool T) $ (ξ 0 k. Ouch! ) < (ξ 0 k. c ) : string (ξ 0 k. Ouch! ) < (ξ 0 k. c ) : (bool T) string time The rest is details: to abstractly decompose an expression into a redex and an evaluation context, use substructural logic. 16

33 Outline Delimited continuations Answer types Types as abstract interpretation Substructural logic The λξ 0 -calculus with small-step typing 17

34 18 Directionality controls combination An expression is a structure. Juxtaposition is tensor, but neither commutative nor associative. Natural deduction: T, T are types, E, F are structures of types. T : T AF : T E : T F : T\T \I F : T\T \E EF : T FA : T /I F : T /T F : T /T E : T /E FE : T saw : (person\bool)/person Bob : person /E Alice : person saw Bob : person\bool \E Alice (saw Bob) : bool T T is T /T.

35 Modes construct syntax The type of woman cannot be person\bool or bool/person. AnF : T E : T F : T\ n T \ n I F : T\ n T \ n E EnF : T FnA : T / n I F : T / n T F : T / n T E : T /n E FnE : T The new binary mode n is internal (unspeakable). Alice : person woman : person\ n bool \n E Alice n woman : bool Modes interact through stipulated structural rules. 19

36 Modes construct syntax A binary mode without products AnF : T E : T F : T\ n T \ n I F : T\ n T \ n E EnF : T A unary mode with products FnA : T / n I F : T / n T F : T / n T E : T /n E FnE : T E : T I E : T E : T E E : T E : T I E : T E : T Γ[ T ] : T E Γ[E] : T For delimited continuations, reify evaluation contexts as coterms. We add two binary modes for coterms:, ; a nullary mode for coterms: # a binary mode for plugging: $ a unary mode for values: (implicit) 19

37 Modes construct syntax A binary mode without products AnF : T E : T F : T\ n T \ n I F : T\ n T \ n E EnF : T A unary mode with products FnA : T / n I F : T / n T F : T / n T E : T /n E FnE : T E : T I E : T E : T E E : T E : T I E : T E : T Γ[ T ] : T E Γ[E] : T For delimited continuations, reify evaluation contexts as coterms. We add two binary modes for coterms: E, C C [ ]E C; V C V[ ] a nullary mode for coterms: # reset [ ] a binary mode for plugging: C $ E C[E] a unary mode for values: V 19

38 Structural rules express evaluation order C $ FE = E, C $ F C $ VE = C; V $ E V = # $ V Γ[C $ FE] : T ========== Γ[E, C $ F] : T Γ[C $ VE] : T ========== Γ[C; V $ E] : T Γ[V] : T ========= Γ[# $ V] : T # $ V 1 (V 2 V 3 ) V 4 = (V 4, #) $ V 1 (V 2 V 3 ) = V 2 V 3, (V 4, #) $ V 1 = (V 4, #); V 1 $ V2 V 3 Our coterm type T T is T / $ T. Our impure term type T T is T\ $ T. 20

39 21 Outline Delimited continuations Answer types Types as abstract interpretation Substructural logic The λξ 0 -calculus with small-step typing

40 Terms E, F ::= V FE C $ E ξ 0 k. E Values V ::= x λx. E Coterms C ::= k # E, C C; V Types T ::= U S T Pure types U ::= U T string int Cotypes S ::= U T Transitions C 1 $ $ C n $ (λx. E)V C 1 $ $ C n $ E{x V} C 1 $ $ C n $ C $ (ξ 0 k. E) C 1 $ $ C n $ E{k C} 22

41 Reset: dynamic semantics Alternate between refocusing and reducing. # $ Goldilocks said: (# $ This porridge is too hot. ) = #; ( Goldilocks said: ) $ (#; ( This porridge is ) $ too hot. ) #; ( Goldilocks said: ) $ (#; ( This porridge is ) $ too hot. ) = #; ( Goldilocks said: ) $ (# $ This porridge is too hot. ) #; ( Goldilocks said: ) $ (# $ This porridge is too hot. ) = # $ Goldilocks said: This porridge is too hot. # $ Goldilocks said: This porridge is too hot. = Goldilocks said: This porridge is too hot. 23

42 Shift 0 : dynamic semantics # $ Goldilocks said: (# $ This porridge is (ξ 0 k.(k $ too hot ) (k $ too cold ) (k $ just right )). ) = #; ( Goldilocks said: ) $ (., (#; ( This porridge is ))); $ ξ0 k.(k $ too hot ) (k $ too cold ) (k $ just right ) #; ( Goldilocks said: ) $ (((., (#; ( This porridge is ))); ) $ too hot ) (((., (#; ( This porridge is ))); ) $ too cold ) (((., (#; ( This porridge is ))); ) $ just right ) = #; ( Goldilocks said: ) $ (# $ This porridge is too hot. ) (# $ This porridge is too cold. ) (# $ This porridge is just right. ) 24

43 Terms E, F ::= V FE C $ E ξ 0 k. E Values V ::= x λx. E Coterms C ::= k # E, C C; V Types T ::= U S T Pure types U ::= U T string int Cotypes S ::= U T [x : U] E : T λ λx. E : U T F : U T FE : T [x : U] Vx : T I V : U T E : U E [k : S] E : T ξ 0 k. E : S T ξ 0 [k : S] k $ E : T I E : S T C : S E : S T E C $ E : T [x : U] F : U E[x] : T E[U] E[F] : T [x : U] C $ x : T I C : U T C : U T E : U E C $ E : T 25

44 26 Reset: static semantics Compute cotype by hypothetical reasoning. [x : string] # $ Tpi x. : string = (., (#; ( Tpi ))); $ x : string I (., (#; ( Tpi ))); : string string too hot : string (., (#; ( Tpi ))); $ too hot : string = E # $ Tpi too hot. : string

45 26 Shift 0 : static semantics Compute cotype by hypothetical reasoning. [x : string] # $ Tpi x. : string = (., (#; ( Tpi ))); $ x : string I (., (#; ( Tpi ))); : string string ξ 0 k. (k $ too hot ) : (string string) string E (., (#; ( Tpi ))); $ too hot : string = # $ Tpi too hot. : string

46 Type checking algorithm Implemented in Twelf. [k : string bool] 1 x : char 1 (ξ 0 k : string bool. x ) (string bool) char [x : string] 2 [n : int] 3 length x int int bool n : bool 3 int bool length x : bool int bool ; length x : bool 2 ; length (ξ 0 k : string bool. x ) (int bool) char length(ξ 0 k : string bool. x ) (int bool) char Say that length is a string int function. 27

47 Type checking algorithm Implemented in Twelf. [k : string bool] 1 x : char 1 (ξ 0 k : string bool. x ) (string bool) char [x : string] 2 [n : int] 3 length x int int bool n : bool 3 int bool length x : bool int bool ; length x : bool 2 ; length (ξ 0 k : string bool. x ) (int bool) char length(ξ 0 k : string bool. x ) (int bool) char Tridirectional type-checking? 27

48 Summary Small-step abstract interpretation type systems for ((delimited) control) effects formalize as a substructural logic Slogan Types are abstract expressions (Cousot) The colon is a turnstile (Lambek) Discoveries Binding and evaluation contexts are related, but the latter is linear. The typing derivation of a direct-style program desugars it into continuation-passing style. Code online small-step-typechecking.tar.gz 28