# Lecture 011

Continuation: all the stuff I will do later. (stack)

• initial continuation: final purpose

add: int -> int -> (int -> 'a) -> 'a)
fun add x y k = k (x+y)
fun mult x y k = k (x*y)


continuation passing style () continuation passing transformation: flip code inside out

(* (2+3)*4 *)
add 2 3 (fn r => mult r 4 (fun r' => r'))


## Mult List

fun multList [] = 1
| multList (x::xs) = x * multList xs


Make it tail recursive

fun tMultList ([], acc) = acc
| tMultList (x::xs, acc) = tMultList(xs, x+acc)
fun multList' L = tMultList (L, 1)


Tail Recursive and with continuation, but not much faster, because there is still allocation of function

fun cmultList [] k = k 1
| cmultList (x::xs) k = cmultList xs (fn y => k (x * y))
fun multlist'' L = cmultlist L (fun y -> y)


Optimize for 0 in multiplication: we can say for sure the result is always 0 if one of the input is 0.

(*
REQUIRES: k total, k 0 = 0
ENSURES cmultlist L k ~= k (multlist L)
*)
fun cmultList' [] k = k 1
| cmultList' (x::xs) k =
if x <> 0 then cmultList' xs (fn y => k (x * y)) else 0


In order traversal match of Tree

(*prefix: int tree -> int list -> (int list -> bool) -> bool
REUIQRES: k total
ENSURES: prefix T L k => true iff L = L1 @ L2 (for some L1, L2) such that inorder (T, []) ~= L1 and k L2 ~= true

*)
fun prefix Empty L k = k L
| prefix (Node (l, x, r)) L k =
prefix l L (fn [] => false
| y :: ys => x = y andalso prefix r ys k)

fun treematch' T L = prefix T L (fn [] => true | _ => false_)


a style like handling exception

(* search: ('a -> bool) -> 'a tree -> ('a -> 'b) -> (unit -> 'b ) -> 'b *)
fun search p Empty sk fk = fk ()
| search p (Node(l, x, r)) sk fk =
if p(x) then sk x
else search p l sk (fn () => search p r sk fk)


so that you can do

search (fn n => n mod 2 = 0) T SOME (fn () => NONE)
search (fn n => n mod 2 = 0) T Int.toString (fn () => "NONE")
search (fn n => n mod 2 = 0) T (fn x => x) (fn () => 0)


## CPS

fun find x = fn () => x;