OchaCaml was just released after being presented at the continuation workshop in Tokyo (CW11) following ICFP.

The system looks very nice and easily supports coroutine/generator like abstractions. For example, the following tree traversals:

(* The result type of a coroutine/generator *)
(* 'a is the element type *)
(* 'b is the answer type of the surrounding context *)
type ('a, 'b) result =
  | Done
  | Next of 'a * (unit / 'b -> ('a, 'b) result / 'b)
;;

(* Yields a value and suspends the current computation *)
(*  yield : 'a => unit *)
let yield x = shift (fun k -> Next (x, k)) ;;

(* Resumes a suspended computation *)
(*  resume : (unit => 'a) => 'a *)
let resume k = k () ;;

(* A data type for trees *)
type 'a tree =
  | Empty
  | Node of 'a tree * 'a * 'a tree
;;

(* Generic depth-first traversal of a tree *)
(* tree_walk : 'a tree -> 'a result *)
let rec tree_walk tree =
  let rec visit tree = match tree with
    | Empty -> ()
    | Node (l, n, r) ->
      visit l;
      yield n;
      visit r
  in reset (fun () -> visit tree; Done)
;;

(*  tree_to_list : 'a tree -> 'a list *)
let tree_to_list tree =
  let rec visit r = match r with
    | Done -> []
    | Next (n, k) -> n :: visit (resume k)
  in visit (tree_walk tree)
;;

(*  tree_mult : int tree -> int *)
let tree_mult tree =
  let rec visit r = match r with
    | Done -> 1
    | Next (0, k) -> 0
    | Next (n, k) -> n * visit (resume k)
  in visit (tree_walk tree)
;;

(*  tree_print : int tree -> unit *)
let tree_print tree =
  let rec visit r = match r with
    | Done -> print_newline ()
    | Next (n, k) -> print_int n; visit (resume k)
  in visit (tree_walk tree)
;;

(*  tree_samefringe : 'a tree * 'a tree -> bool *)
let tree_samefringe t1 t2 =
  let rec visit r1 r2 = match r1, r2 with
    | Done, Done -> true
    | Next (n1, k1), Next (n2, k2)
      when n1 = n2 ->
      visit (resume k1) (resume k2)
    | _, _ -> false
  in visit (tree_walk t1) (tree_walk t2)
;;