type 'a continuation = ('a -> 'b) -> 'b
c_unit (x:'a) = fun (p:'a -> 'b) -> p x
c_bind (u:('a -> 'b) -> 'b) (f: 'a -> ('c -> 'd) -> 'd): ('c -> 'd) -> 'd =
-fun (k:'a -> 'b) -> u (fun (x:'a) -> f x k)
+ fun (k:'a -> 'b) -> u (fun (x:'a) -> f x k)
</pre>
How similar is it to the List monad? Let's examine the type
instantiate the type of the list' monad using the Ocaml list type:
type 'a c_list = ('a -> 'a list) -> 'a list
- let c_list_unit x = fun f -> f x;;
- let c_list_bind u f = fun k -> u (fun x -> f x k);;
-Have we really discovered that lists are secretly continuations?
-Or have we merely found a way of simulating lists using list
+Have we really discovered that lists are secretly continuations? Or
+have we merely found a way of simulating lists using list
continuations? Both perspectives are valid, and we can use our
intuitions about the list monad to understand continuations, and vice
-versa. The connections will be expecially relevant when we consider
-indefinites and Hamblin semantics on the linguistic side, and
-non-determinism on the list monad side.
+versa (not to mention our intuitions about primitive recursion in
+Church numerals too). The connections will be expecially relevant
+when we consider indefinites and Hamblin semantics on the linguistic
+side, and non-determinism on the list monad side.
Refunctionalizing zippers
-------------------------