Delimited Control with Multiple Prompts in Theory and Practice Paul - - PowerPoint PPT Presentation

1/27

Delimited Control with Multiple Prompts in Theory and Practice Paul Downen Zena M. Ariola

University of Oregon

HOPE’14 — August 31, 2014

2/27

Crash course on control

3/27

Separating a redex from its evaluation context 1 + 2 + (3 × 4)

3/27

Separating a redex from its evaluation context 1 + 2 + (3 × 4) 1 + 2 + 3 × 4

3/27

Separating a redex from its evaluation context 1 + 2 + (3 × 4) 1 + 2 + 3 × 4 ⇓ 1 + 2 + 12 1 + 2 + 12

4/27

Classical control: Abortive continuations

1 + 2 + call/cc(λk.3 × (k 4))

4/27

Classical control: Abortive continuations

1 + 2 + call/cc(λk.3 × (k 4)) 1 + 2 + call/cc(λk.3 × (k 4))

4/27

Classical control: Abortive continuations

1 + 2 + call/cc(λk.3 × (k 4)) 1 + 2 + call/cc(λk.3 × (k 4)) ⇓ k : 1 + 2 + 3 × (k 4) 1 + 2 + 3 × (k 4)

4/27

Classical control: Abortive continuations

1 + 2 + call/cc(λk.3 × (k 4)) 1 + 2 + call/cc(λk.3 × (k 4)) ⇓ k : 1 + 2 + 3 × (k 4) 1 + 2 + 3 × (k 4) 1 + 2 + 3 × k 4

4/27

Classical control: Abortive continuations

1 + 2 + call/cc(λk.3 × (k 4)) 1 + 2 + call/cc(λk.3 × (k 4)) ⇓ k : 1 + 2 + 3 × (k 4) 1 + 2 + 3 × (k 4) 1 + 2 + 3 × k 4 ⇓ 1 + 2 + 4 1 + 2 + 4

5/27

Delimited control: Composable continuations

1 + #( 2 + F(λk.3 × (k 4)) )

5/27

Delimited control: Composable continuations

1 + #( 2 + F(λk.3 × (k 4)) ) 1 + # 2 + F(λk.3 × (k 4))

5/27

Delimited control: Composable continuations

1 + #( 2 + F(λk.3 × (k 4)) ) 1 + # k : 2 + F(λk.3 × (k 4)) ⇓ 1 + #

• 3 × (k 4)

1 + #( 3 × (k 4) )

5/27

Delimited control: Composable continuations

1 + #( 2 + F(λk.3 × (k 4)) ) 1 + # k : 2 + F(λk.3 × (k 4)) ⇓ 1 + #

• 3 × (k 4)

1 + #( 3 × (k 4) ) 1 + # 3 × k 4

5/27

Delimited control: Composable continuations

1 + #( 2 + F(λk.3 × (k 4)) ) 1 + # k : 2 + F(λk.3 × (k 4)) ⇓ 1 + #

• 3 × (k 4)

1 + #( 3 × (k 4) ) 1 + # 3 × k 4 ⇓ 1 + # 3 × 2 + 4 1 + #( 3 × (2 + 4) )

6/27

A zoo of delimited control

• perators

7/27

Design decisions E[#(E ′[F V ])]

◮ Does F remove # surrounding E ′ ? ◮ Does continuation guard its call-site with a #?

8/27

A family of operators: ∗F∗

E[#( E ′[ +F + V ] )] → E[#( V k )] where k x = #( E ′[ x ] ) E[#( E ′[ +F − V ] )] → E[#( V k )] where k x = E ′[ x ] E[#( E ′[ −F + V ] )] → E[ V k ] where k = #( E ′[ x ] ) E[#( E ′[ −F − V ] )] → E[ V k ] where k x = E ′[ x ]

8/27

A family of operators: +F∗ vs −F∗

E[#( E ′[ +F + V ] )] → E[#( V k )] where k x = #( E ′[ x ] ) E[#( E ′[ +F − V ] )] → E[#( V k )] where k x = E ′[ x ] E[#( E ′[ −F + V ] )] → E[ V k ] where k = #( E ′[ x ] ) E[#( E ′[ −F − V ] )] → E[ V k ] where k x = E ′[ x ]

8/27

A family of operators: ∗F+ vs ∗F−

E[#( E ′[ +F + V ] )] → E[#( V k )] where k x = #( E ′[ x ] ) E[#( E ′[ +F − V ] )] → E[#( V k )] where k x = E ′[ x ] E[#( E ′[ −F + V ] )] → E[ V k ] where k = #( E ′[ x ] ) E[#( E ′[ −F − V ] )] → E[ V k ] where k x = E ′[ x ]

9/27

A family of operators

◮ +F+: shift (S) and reset ( ) of Danvy and

Filinski

◮ +F−: control (F) and prompt (#) of Felleisen ◮ −F+: shift0 (S0) and reset0 ( 0) ◮ −F−: control0 (F0) and prompt0 (#0)

10/27

shift = control?

List traversal two ways (Biernacki et al., 2005) Straverse xs = visit xs where visit [] = [] visit (x :: xs) = visit (S(λk. x :: ( k xs ) )) Ftraverse xs = #(visit xs) where visit [] = [] visit (x :: xs) = visit (F(λk. x :: ( k xs ) )) What’s the difference?

10/27

shift = control

List traversal two ways (Biernacki et al., 2005) Straverse xs = visit xs where visit [] = [] visit (x :: xs) = visit (S(λk. x :: ( k xs ) )) Ftraverse xs = #(visit xs) where visit [] = [] visit (x :: xs) = visit (F(λk. x :: ( k xs ) )) What’s the difference? Straverse [1, 2, 3] →∗ [1, 2, 3] list copy Ftraverse [1, 2, 3] →∗ [3, 2, 1] list reverse

11/27

shift = shift0?

Continuation swap two ways swap x = S(λk1.S(λk2.k1 (k2 x))) swap0 x = S0(λk1.S0(λk2.k1 (k2 x))) What’s the difference?

11/27

shift = shift0

Continuation swap two ways swap x = S(λk1.S(λk2.k1 (k2 x))) swap0 x = S0(λk1.S0(λk2.k1 (k2 x))) What’s the difference? 10 + 2 × (swap 1) →∗ 10 + k1 (k2 1) →∗ 12 where k1 x = 2 × x k2 x = x identity function 10 + 2 × (swap0 1)00 →∗ k1 (k2 1) →∗ 22 where k1 x = 2 × x0 k2 x = 10 + x0 Context switch

12/27

Theory vs. Practice Theory

◮ Focus on ∗F+ operators ◮ shift and reset are heavily studied ◮ shift0 and reset0 recently gaining interest ◮ Both have theories with desirable properties

◮ Simple continuation-passing style semantics ◮ Sound and complete axiomatizations ◮ Error-free type and effect systems ◮ “Observational purity”

12/27

Theory vs. Practice Practice

◮ Focus on ∗F− operators ◮ Major implementations of delimited control

◮ Racket: control and prompt ◮ Haskell library CC-delcont: control0 and prompt0 ◮ OCaml library delcontcc: control0 and prompt0

◮ Practical extensions of delimited control

◮ Integrated into languages with other effects ◮ Multiple prompts

12/27

Theory vs. Practice Practice

◮ Focus on ∗F− operators ◮ Major implementations of delimited control

◮ Racket: control and prompt ◮ Haskell library CC-delcont: control0 and prompt0 ◮ OCaml library delcontcc: control0 and prompt0

◮ Practical extensions of delimited control

◮ Integrated into languages with other effects ◮ Multiple prompts

13/27

Giving prompts a name

14/27

Multiple prompts

◮ Multiple prompts, referred to by name ◮ Similar to exception handling

◮ F

α: go to nearest prompt (handler) for

α

◮ #

α: delimit (handle) control effects for

α

15/27

Multiple prompts: Dynamic continuations

#

γ(1 + # β( 2 + # α(3 + F β (λk.4 × (k 5)) ) ))

15/27

Multiple prompts: Dynamic continuations

#

γ(1 + # β( 2 + # α(3 + F β (λk.4 × (k 5)) ) ))

#

γ(1 + # β )

2 + #

α(3 + )

F

β (λk.4 × (k 5))

15/27

Multiple prompts: Dynamic continuations

#

γ(1 + # β( 2 + # α(3 + F β (λk.4 × (k 5)) ) ))

#

γ(1 + # β )

k : 2 + #

α(3 + )

F

β (λk.4 × (k 5))

⇓ #

γ(1 + # β )

• 4 × (k 5)

#

γ(1 + #

β( 4 × (k 5) ))

15/27

Multiple prompts: Dynamic continuations

#

γ(1 + # β( 2 + # α(3 + F β (λk.4 × (k 5)) ) ))

#

γ(1 + # β )

k : 2 + #

α(3 + )

F

β (λk.4 × (k 5))

⇓ #

γ(1 + # β )

• 4 × (k 5)

#

γ(1 + #

β( 4 × (k 5) )) #

γ(1 + # β )

4 × k 5

15/27

Multiple prompts: Dynamic continuations

#

γ(1 + # β( 2 + # α(3 + F β (λk.4 × (k 5)) ) ))

#

γ(1 + # β )

k : 2 + #

α(3 + )

F

β (λk.4 × (k 5))

⇓ #

γ(1 + # β )

• 4 × (k 5)

#

γ(1 + #

β( 4 × (k 5) )) #

γ(1 + # β )

4 × k 5 ⇓ #

γ(1 + # β )

4 × 2 + #

α(3 + 5)

#

γ(1 + #

• β(4 × (2 + #

α(3 + 5))))

16/27

Putting practice to theory

17/27

Multiple prompts via marked stacks

◮ Monadic Framework for Delimited Continuations

(Dybvig et al., 2007)

◮ control0 and prompt0 style control with multiple

prompts

◮ Use hybrid abstract/concrete continuation monad

◮ Stack of ordinary continuations ◮ Special markers representing prompts

18/27

Multiple prompts via dynamic binding

◮ Systematic Approach to Delimited Control with

Multiple Prompts (Downen and Ariola, 2012)

◮ shift0 and reset0 style control with multiple

prompts

◮ λ

µ0: Conservative extension of CBV Parigot’s λµ (i.e., λ-calculus with call/cc)

◮ Dynamic continuation variables ◮ Splitting/joining dynamic environment of continuations

19/27

Comparing the two frameworks

◮ Biggest mismatch comes down to representation

• f meta-contexts

◮ Monadic framework: marked stack

MetaCont = [Ident + Cont] [k3, α3, α2, k2, k1, α1]

◮ λ

µ0: dynamic environment MetaCont = [Ident ∗ Cont] [ α3 → k3, α2 → k2, α1 → k1]

20/27

Dynamic environment to marked stack

◮ Embed λ

µ0 into Monadic Framework

◮ Flatten [Ident ∗ Cont] to [Ident + Cont]? ◮ Easy!

[ α3 → k3, α2 → k2, α1 → k1] = [k3, α3, k2, α2, k1, α1]

21/27

Marked stack to dynamic environment

◮ Embed Monadic Framework into λ

µ

◮ Restore [Iden + Cont] to [Ident ∗ Cont] ◮ Not so easy. . .

22/27

Distinguished return

◮ Reserve one dynamic continuation variable (

tp)

◮ “Return” value by sending it to

tp

◮ “Empty” continuation k

tp “returns” input to

tp

◮ Continuations associated with

tp (next return point)

◮ Prompts associated with empty continuation k

tp (skip other

prompts, go to next return point)

◮ Embedding back into environment!

[k3, α3, α2, k2, k1, α1] = [ tp → k3, α3 → k

tp,

α2 → k

tp,

• tp → k2,

tp → k1, α1 → k

tp]

23/27

From practice to theory

◮ Embedding from Monadic Framework to λ

µ0

◮ With multiple prompts, shift0 and reset0 style

control implements control0 and prompt0

◮ Corollary: shift0 and reset0 style control with 2

prompts implements control0 and prompt0

24/27

Simulation of ∗F− style operators # ≡ Prompt handler for F0, F ≡ Traces of “naked” context composition E ::= | E M | V E | M E[#(E ′[F0V ])] → E[V k] where k = λx.E[x] E[#(E ′[FV ])] → E[#(V k)] where k = λx.E[x]

25/27

Dynamic traversal

#( E[ visit(x :: xs) ] ) →∗ #(x :: E[visit xs]) Ftraverse [1, 2, 3] → #( visit [1, 2, 3] ) →∗ #( 1 :: visit [2, 3] ) →∗ #( 2 :: 1 :: visit [3] ) →∗ #( 3 :: 2 :: 1 :: visit [] ) → #(3 :: 2 :: 1 :: []) →∗ [3, 2, 1]

25/27

Dynamic traversal

#( E[ visit(x :: xs) ] ) →∗ #(x :: E[visit xs]) Ftraverse [1, 2, 3] → #( visit [1, 2, 3] ) →∗ #( 1 :: visit [2, 3] ) →∗ #( 2 :: 1 :: visit [3] ) →∗ #( 3 :: 2 :: 1 :: visit [] ) → #(3 :: 2 :: 1 :: []) →∗ [3, 2, 1]

25/27

Dynamic traversal

#( E[ visit(x :: xs) ] ) →∗ #(x :: E[visit xs]) Ftraverse [1, 2, 3] → #( visit [1, 2, 3] ) →∗ #( 1 :: visit [2, 3] ) →∗ #( 2 :: 1 :: visit [3] ) →∗ #( 3 :: 2 :: 1 :: visit [] ) → #(3 :: 2 :: 1 :: []) →∗ [3, 2, 1]

25/27

Dynamic traversal

#( E[ visit(x :: xs) ] ) →∗ #(x :: E[visit xs]) Ftraverse [1, 2, 3] → #( visit [1, 2, 3] ) →∗ #( 1 :: visit [2, 3] ) →∗ #( 2 :: 1 :: visit [3] ) →∗ #( 3 :: 2 :: 1 :: visit [] ) → #(3 :: 2 :: 1 :: []) →∗ [3, 2, 1]

26/27

Questions?

27/27

References

• D. Biernacki, O. Danvy, and K. Millikin. A dynamic

continuation-passing style for dynamic delimited

• continuations. BRICS, Department of Computer

Science, Univ., 2005.

• P. Downen and Z. M. Ariola. A systematic approach

to delimited control with multiple prompts. In Procedings of the 21st European Symposium on Programming, pages 234–253. Springer, 2012.

• R. K. Dybvig, S. P. Jones, and A. Sabry. A monadic

framework for delimited continuations. Journal of Functional Programming, 17(06):687–730, 2007.