Con$nuing CPS. COS 326 David Walker Princeton University

Size: px

Start display at page:

Download "Con$nuing CPS. COS 326 David Walker Princeton University"

Abigayle Garrison
5 years ago
Views:

1 Con$nuing CPS COS 326 David Walker Princeton University

2 Last Time We saw that code like this could take up a lot of stack space: let rec sum_to (n:int) : int = if n > 0 then n + sum_to (n-1) else 0

3 Last Time We saw that code like this could take up a lot of stack space: let rec sum_to (n:int) : int = if n > 0 then n + sum_to (n-1) else 0 work to do aeer the recursive call returns == not a tail- recursive func$on

sum_to (n-1) else 0 Every recursive call requires we allocate a

call return_address n = 99 return_address n = 100 return_address

4 Last Time We saw that code like this could take up a lot of stack space: let rec sum_to (n:int) : int = if n > 0 then n + sum_to (n-1) else 0 Every recursive call requires we allocate a stack frame to store the return address + data used aeer the call return_address n = 99 return_address n = 100 return_address state fun s stack -> return (stack.n + s) fun s stack -> return (stack.n + s)

5 Last Time But we can capture the computa$on that happens aeer the call: let rec sum_to (n:int) : int = if n > 0 then n + sum_to (n-1) else 0 fun result - > n + result a func$on that explains what to do next is called a con%nua%on

6 Last Time let rec sum_to (n:int) : int = if n > 0 then n + sum_to (n-1) else 0 Conversion to CPS style: let rec sum_to_cont (n:int) (k:int -> int) : int = if n > 0 then sum_to_cont (n-1) (fun result -> k (n + result)) else 0

7 Many func$ons can be made tail- rec easily: let rec sum_to (n:int) : int = if n > 0 then n + sum_to (n-1) else 0 ;; sum_to 100 let rec sum_to_opt (n:int) (acc:int) : int = if n > 0 then sum_to_opt (n-1) (acc + n) else acc ;; not only did we make the func$on tail- recursive, but we didn t add any stack or linked- list of closures! sum_to_opt 100

8 Many func$ons can be made tail- rec easily: let rec sum_to (n:int) : int = if n > 0 then n + sum_to (n-1) else 0 ;; sum_to 100 let rec sum_to_opt (n:int) (acc:int) : int = if n > 0 then sum_to_opt (n-1) (acc + n) else acc ;; not only did we make the func$on tail- recursive, but we didn t add any stack or linked- list of closures! sum_to_opt 100

9 Some are harder: let rec print_stack (n:int) : unit = if n > 0 then Printf.printf push %d\n n; print_stack (n-1); Printf.printf pop %d\n n else Printf.printf zero ;; print_stack 5 ;; output: push 4 push 3 push 2 push 1 zero pop 1 pop 2 pop 3 pop 4

10 Some are harder: let rec print_stack (n:int) : unit = if n > 0 then Printf.printf push %d\n n; print_stack (n-1); Printf.printf pop %d\n n else Printf.printf zero ;; print_stack 5 ;; output: push 4 push 3 push 2 push 1 zero pop 1 pop 2 pop 3 pop 4 let rec print_stack_cont (n:int) (k:unit -> unit) : unit = ;; print_stack_cont 5 (fun () -> ()) ;;

11 Some are harder: let rec print_stack (n:int) : unit = if n > 0 then Printf.printf push %d\n n; print_stack (n-1); Printf.printf pop %d\n n else Printf.printf zero ;; print_stack 5 ;; output: push 4 push 3 push 2 push 1 zero pop 1 pop 2 pop 3 pop 4 let rec print_stack_cont (n:int) (k:unit -> unit) : unit = if n > 0 then else Printf.printf_cont zero k ;; print_stack_cont 5 (fun () -> ()) ;;

12 Some are harder: let rec print_stack (n:int) : unit = if n > 0 then Printf.printf push %d\n n; print_stack (n-1); Printf.printf pop %d\n n else Printf.printf zero ;; print_stack 5 ;; output: push 4 push 3 push 2 push 1 zero pop 1 pop 2 pop 3 pop 4 let rec print_stack_cont (n:int) (k:unit -> unit) : unit = if n > 0 then Printf.printf_cont push %d\n n (fun () ->... ) else Printf.printf_cont zero k ;; print_stack_cont 5 (fun () -> ()) ;;

13 Some are harder: let rec print_stack (n:int) : unit = if n > 0 then Printf.printf push %d\n n; print_stack (n-1); Printf.printf pop %d\n n else Printf.printf zero ;; print_stack 5 ;; output: push 4 push 3 push 2 push 1 zero pop 1 pop 2 pop 3 pop 4 let rec print_stack_cont (n:int) (k:unit -> unit) : unit = if n > 0 then Printf.printf_cont push %d\n n (fun () -> print_stack (n-1) (fun () ->...)) else Printf.printf_cont zero k ;; print_stack_cont 5 (fun () -> ()) ;;

$Some are harder: let rec print_stack (n:int) : unit = if n > 0 then Printf.printf push %d\n n; print_stack (n-1); Printf.printf pop %d\n n else Printf.$

14 Some are harder: let rec print_stack (n:int) : unit = if n > 0 then Printf.printf push %d\n n; print_stack (n-1); Printf.printf pop %d\n n else Printf.printf zero ;; print_stack 5 ;; output: push 4 push 3 push 2 push 1 zero pop 1 pop 2 pop 3 pop 4 let rec print_stack_cont (n:int) (k:unit -> unit) : unit = if n > 0 then Printf.printf_cont push %d\n n (fun () -> print_stack (n-1) (fun () -> Printf.printf_cont pop %d\n n k)) else Printf.printf_cont zero k ;; print_stack_cont 5 (fun () -> ()) ;;

15 ANOTHER EXAMPLE

16 Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> Node (i+j, incr left i, incr right i) ;; Hint: It is a livle easier to put the con$nua$ons in the order in which they are called.

17 Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> Node (i+j, incr left i, incr right i) ;; type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) (k: tree -> tree) : tree = match t with Leaf -> Leaf Node (j,left,right) -> let t1 = incr left i in let t2 = incr right i in Node (i+j, t1, t2)

Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> Node (i+j, incr left i,

18 Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> Node (i+j, incr left i, incr right i) ;; type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) (k: tree -> tree) : tree = match t with Leaf -> Leaf Node (j,left,right) -> let t1 = incr left i in let t2 = incr right i in Node (i+j, t1, t2) called A- Normal Form (no func$on calls as args to other func$on calls)

Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> let t1 = incr left i in

19 Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> let t1 = incr left i in let t2 = incr right i in Node (i+j, t1, t2) type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) (k: tree -> tree) : tree = match t with Leaf -> k Leaf Node (j,left,right) -> let t1 = incr left i in let t2 = incr right i in Node (i+j, t1, t2))

20 Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> let t1 = incr left i in let t2 = incr right i in Node (i+j, t1, t2) type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) (k: tree -> tree) : tree = match t with Leaf -> k Leaf Node (j,left,right) -> incr left i (fun result1 -> let t1 = result1 in let t2 = incr right i in Node (i+j, t1, t2))

type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) (k: tree -> tree) : tree = match t with Leaf -> k Leaf

21 Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> incr left i (fun result1 -> let t1 = result1 in let t2 = incr right i in Node (i+j, t1, t2)) type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) (k: tree -> tree) : tree = match t with Leaf -> k Leaf Node (j,left,right) -> incr left i (fun result1 -> let t1 = result1 in incr right i (fun result2 -> let t2 = result2 in Node (i+j, t1, t2))

Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> incr left i (fun result1

22 Challenge: CPS Convert the incr func$on type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) : tree = match t with Leaf -> Leaf Node (j,left,right) -> incr left i (fun result1 -> let t1 = result1 in incr right i (fun result2 -> let t2 = result2 in Node (i+j, t1, t2)) type tree = Leaf Node of int * tree * tree ;; let rec incr (t:tree) (i:int) (k: tree -> tree) : tree = match t with Leaf -> k Leaf Node (j,left,right) -> incr left i (fun result1 -> let t1 = result1 in incr right i (fun result2 -> let t2 = result2 in k (Node (i+j, t1, t2)))

23 In general let g input = f3 (f2 (f1 input)) Direct Style let g input = let x1 = f1 input in let x2 = f2 x1 in f3 x2 A- normal Form let g input k = f1 input (fun x1 -> f2 x1 (fun x2 -> f3 x2 k)) CPS converted

24 CORRECTNESS OF A CPS TRANSFORM

type cont = int -> int;; Are the two func$ons the same?

= match l with [] -> 0 hd::tail -> hd + sum tail CPS is prevy tricky.

25 type cont = int -> int;; Are the two func$ons the same? let rec sum_cont (l:int list) (k:cont): int = match l with [] -> k 0 hd::tail -> sum_cont tail (fun s -> k (hd + s)) let sum2 (l:int list) : int = sum_cont l (fun s -> s) let rec sum (l:int list) : int = match l with [] -> 0 hd::tail -> hd + sum tail CPS is prevy tricky. Let's try to prove a theorem: for all l:int list, sum_cont l (fun x -> x) == sum l

26 AVemp$ng a Proof Theorem: For all l:int list, sum_cont l (fun s -> s) == sum l Proof: By induction on the structure of the list l. case l = []... case: hd::tail IH: sum_cont tail (fun s -> s) == sum tail

27 AVemp$ng a Proof Theorem: For all l:int list, sum_cont l (fun s -> s) == sum l Proof: By induction on the structure of the list l. case l = []... case: hd::tail IH: sum_cont tail (fun s -> s) == sum tail == sum_cont (hd::tail) (fun s -> s)

28 AVemp$ng a Proof Theorem: For all l:int list, sum_cont l (fun s -> s) == sum l Proof: By induction on the structure of the list l. case l = []... case: hd::tail IH: sum_cont tail (fun s -> s) == sum tail sum_cont (hd::tail) (fun s -> s) == sum_cont tail (fn s' -> (fn s -> s) (hd + s')) (eval)

29 AVemp$ng a Proof Theorem: For all l:int list, sum_cont l (fun s -> s) == sum l Proof: By induction on the structure of the list l. case l = []... case: hd::tail IH: sum_cont tail (fun s -> s) == sum tail sum_cont (hd::tail) (fun s -> s) == sum_cont tail (fn s' -> (fn s -> s) (hd + s')) (eval) == sum_cont tail (fn s' -> hd + s') (eval)

.. case: hd::tail IH: sum_cont tail (fun s -> s) == sum tail sum_cont (hd::tail) (fun s -> s) == sum_cont tail (fn s' -> (fn s -> s) (hd +

30 Need to Generalize the Theorem and IH Theorem: For all l:int list, sum_cont l (fun s -> s) == sum l Proof: By induction on the structure of the list l. case l = []... case: hd::tail IH: sum_cont tail (fun s -> s) == sum tail sum_cont (hd::tail) (fun s -> s) == sum_cont tail (fn s' -> (fn s -> s) (hd + s')) (eval) == sum_cont tail (fn s' -> hd + s') (eval) == darn! we'd like to use the IH, but we can't! we might like: not the iden$ty con$nua$on (fun s - > s) like the IH requires sum_cont tail (fn s' - > hd + s') == sum tail... but that's not even true

31 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l)

32 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] must prove: for all k:int->int, sum_cont [] k == k (sum [])

33 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] must prove: for all k:int->int, sum_cont [] k == k (sum []) pick an arbitrary k:

34 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] must prove: for all k:int->int, sum_cont [] k == k (sum []) pick an arbitrary k: sum_cont [] k

35 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] must prove: for all k:int->int, sum_cont [] k == k (sum []) pick an arbitrary k: sum_cont [] k == match [] with [] -> k 0 hd::tail ->... (eval) == k 0 (eval)

36 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] must prove: for all k:int->int, sum_cont [] k == k (sum []) pick an arbitrary k: sum_cont [] k == match [] with [] -> k 0 hd::tail ->... (eval) == k 0 (eval) == k (sum [])

37 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] must prove: for all k:int->int, sum_cont [] k == k (sum []) pick an arbitrary k: sum_cont [] k == match [] with [] -> k 0 hd::tail ->... (eval) == k 0 (eval) == k (0) (eval, reverse) == k (match [] with [] -> 0 hd::tail ->...) (eval, reverse) == k (sum []) case done!

38 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] ===> done! case l = hd::tail IH: for all k':int->int, sum_cont tail k' == k' (sum tail) MP: for all k:int->int, sum_cont (hd::tail) k == k (sum (hd::tail))

Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] ===> done!

39 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] ===> done! case l = hd::tail IH: for all k':int->int, sum_cont tail k' == k' (sum tail) MP: for all k:int->int, sum_cont (hd::tail) k == k (sum (hd::tail)) Pick an arbitrary k, sum_cont (hd::tail) k

40 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] ===> done! case l = hd::tail IH: for all k':int->int, sum_cont tail k' == k' (sum tail) MP: for all k:int->int, sum_cont (hd::tail) k == k (sum (hd::tail)) Pick an arbitrary k, sum_cont (hd::tail) k == sum_cont tail (fun s -> k (hd + x)) (eval)

41 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] ===> done! case l = hd::tail IH: for all k':int->int, sum_cont tail k' == k' (sum tail) MP: for all k:int->int, sum_cont (hd::tail) k == k (sum (hd::tail)) Pick an arbitrary k, sum_cont (hd::tail) k == sum_cont tail (fun s -> k (hd + x)) (eval) == (fun s -> k (hd + s)) (sum tail) (IH with IH quantifier k' replacing (fun x -> k (hd+x))

42 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] ===> done! case l = hd::tail IH: for all k':int->int, sum_cont tail k' == k' (sum tail) MP: for all k:int->int, sum_cont (hd::tail) k == k (sum (hd::tail)) Pick an arbitrary k, sum_cont (hd::tail) k == sum_cont tail (fun s -> k (hd + x)) (eval) == (fun s -> k (hd + s)) (sum tail) (IH with IH quantifier k' replacing (fun x -> k (hd+x)) == k (hd + (sum tail)) (eval, since sum total and sum tail valuable)

43 Need to Generalize the Theorem and IH for all l:int list, for all k:int->int, sum_cont l k == k (sum l) Proof: By induction on the structure of the list l. case l = [] ===> done! case l = hd::tail IH: for all k':int->int, sum_cont tail k' == k' (sum tail) MP: for all k:int->int, sum_cont (hd::tail) k == k (sum (hd::tail)) Pick an arbitrary k, sum_cont (hd::tail) k == sum_cont tail (fun s -> k (hd + x)) (eval) == (fun s -> k (hd + s)) (sum tail) (IH) == k (hd + (sum tail)) (eval) == k (sum (hd:tail)) (eval sum, reverse) case done! QED!

44 Finishing Up Ok, now what we have is a proof of this theorem: for all l:int list, for all k:int->int, sum_cont l k == k (sum l) We can use that general theorem to get what we really want: for all l:int list, sum2 l == sum_cont l (fun s -> s) (by eval sum2) == (fun s -> s) (sum l) (by theorem, instantiating k with (fun s -> s) == sum l So, we've show that the func$on sum2, which is tail- recursive, is func$onally equivalent to the non- tail- recursive func$on sum.

45 SUMMARY

46 Summary of the CPS Proof We tried to prove the specific theorem we wanted: for all l:int list, sum_cont l (fun s -> s) == sum l But it didn't work because in the middle of the proof, the IH didn't apply - - inside our func$on we had the wrong kind of con$nua$on - - not (fun s - > s) like our IH required. So we had to prove a more general theorem about all con$nua$ons. for all l:int list, for all k:int->int, sum_cont l k == k (sum l) This is a common occurrence - - generalizing the induc%on hypothesis - - and it requires human ingenuity. It's why proving theorems is hard. It's also why wri$ng programs is hard - - you have to make the proofs and programs work more generally, around every itera$on of a loop.

A Functional Space Model. COS 326 David Walker Princeton University

A Functional Space Model. COS 326 David Walker Princeton University A Functional Space Model COS 326 David Walker Princeton University Data type representations: Last Time type tree = Leaf Node of int * tree * tree Leaf: Node(i, left, right): 0 Node 3 left right This Time