merge from stable (including sequence subtree); 0.3.4

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+# 0.3.4
+
+- subtree for `sequence` repo
+- `CCSequence` is now a copy of `sequence`
+- `CCOpt.wrap{1,2}`
+- `CCList.findi`, `CCArray.findi` and `CCArray.find_idx`
+- better `Format` printers (using break hints)
+- specialize some comparison functions
+- `CCOrd.map`
+
 ## 0.3.3
 
 - readme: add ci hook (to http://ci.cedeela.fr)

HOWTO.md

@@ -0,0 +1,11 @@
+
+## Make a release
+
+1. `make test-all`
+2. merge into `stable` (from now on, proceed on branch `stable`)
+3. update version in `_oasis`
+4. `make update_next_tag` (to update `@since` comments)
+5. update `CHANGELOG.md` (see its end to find the right git command)
+6. commit, tag, and push both to github
+7. new opam package
+

_oasis

@@ -1,6 +1,6 @@
 OASISFormat: 0.4
 Name:        containers
-Version:     0.3.3
+Version:     0.3.4
 Homepage:    https://github.com/c-cube/ocaml-containers
 Authors:     Simon Cruanes
 License:     BSD-2-clause

cgi/containers_cgi.mldylib

@@ -1,4 +0,0 @@
-# OASIS_START
-# DO NOT EDIT (digest: f5192440033c9e32b425a31804bbddaa)
-ToWeb
-# OASIS_STOP

cgi/containers_cgi.mllib

@@ -1,4 +0,0 @@
-# OASIS_START
-# DO NOT EDIT (digest: f5192440033c9e32b425a31804bbddaa)
-ToWeb
-# OASIS_STOP

core/CCArray.ml

@@ -68,6 +68,13 @@ module type S = sig
   (** [find f a] returns [Some y] if there is an element [x] such
       that [f x = Some y], else it returns [None] *)
 
+  val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+  (** Like {!find}, but also pass the index to the predicate function. *)
+
+  val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
+  (** [find p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
+    and [p x] holds. Otherwise returns [None] *)
+
   val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option
   (** Lookup the index of some value in a sorted array.
       @return [None] if the key is not present, or
@@ -160,7 +167,7 @@ let rec _compare cmp a1 i1 j1 a2 i2 j2 =
 
 let rec _find f a i j =
   if i = j then None
-  else match f a.(i) with
+  else match f i a.(i) with
     | Some _ as res -> res
     | None -> _find f a (i+1) j
 
@@ -234,7 +241,7 @@ let _pp_i ~sep pp_item buf a i j =
 
 let _print ~sep pp_item fmt a i j =
   for k = i to j - 1 do
-    if k > i then Format.pp_print_string fmt sep;
+    if k > i then (Format.pp_print_string fmt sep; Format.pp_print_cut fmt ());
     pp_item fmt a.(k)
   done
 
@@ -290,8 +297,14 @@ let reverse_in_place a =
 *)
 
 let find f a =
+  _find (fun _ -> f ) a 0 (Array.length a)
+
+let findi f a =
   _find f a 0 (Array.length a)
 
+let find_idx p a =
+  _find (fun i x -> if p x then Some (i,x) else None) a 0 (Array.length a)
+
 let filter_map f a =
   let rec aux acc i =
     if i = Array.length a
@@ -494,7 +507,12 @@ module Sub = struct
     Sub.reverse_in_place s; a = [| 1; 2; 5; 4; 3; 6 |]
   *)
 
-  let find f a = _find f a.arr a.i a.j
+  let find f a = _find (fun _ -> f) a.arr a.i a.j
+
+  let findi f a = _find (fun i -> f (i-a.i)) a.arr a.i a.j
+
+  let find_idx p a =
+    _find (fun i x -> if p x then Some (i,x) else None) a.arr a.i a.j
 
   let lookup_exn ?(cmp=Pervasives.compare) k a =
     _lookup_exn ~cmp k a.arr a.i (a.j-1)

core/CCArray.mli

@@ -70,6 +70,15 @@ module type S = sig
   (** [find f a] returns [Some y] if there is an element [x] such
       that [f x = Some y], else it returns [None] *)
 
+  val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+  (** Like {!find}, but also pass the index to the predicate function.
+      @since 0.3.4 *)
+
+  val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
+  (** [find p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
+      and [p x] holds. Otherwise returns [None]
+      @since 0.3.4 *)
+
   val lookup : ?cmp:'a ord -> 'a -> 'a t -> int option
   (** Lookup the index of some value in a sorted array.
       @return [None] if the key is not present, or

core/CCBool.ml

@@ -26,9 +26,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 type t = bool
 
-let equal a b = a=b
+let equal (a:bool) b = a=b
 
-let compare a b = Pervasives.compare a b
+let compare (a:bool) b = Pervasives.compare a b
 
 let negate x = not x
 
@@ -36,4 +36,4 @@ type 'a printer = Buffer.t -> 'a -> unit
 type 'a formatter = Format.formatter -> 'a -> unit
 
 let pp buf = Printf.bprintf buf "%B"
-let print fmt = Format.fprintf fmt "%B"
+let print fmt = Format.pp_print_bool fmt

core/CCBool.mli

@@ -29,14 +29,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 type t = bool
 
 val compare : t -> t -> int
+(** Total ordering on booleans, similar to {!Pervasives.compare} *)
 
 val equal : t -> t -> bool
 
 val negate : t -> t
+(** Negation on booleans (functional version of [not]) *)
 
 type 'a printer = Buffer.t -> 'a -> unit
 type 'a formatter = Format.formatter -> 'a -> unit
 
 val pp : t printer
+(** Printer for booleans *)
+
 val print : t formatter
 

core/CCError.ml

@@ -230,5 +230,5 @@ let pp pp_x buf e = match e with
   | `Error s -> Printf.bprintf buf "error(%s)" s
 
 let print pp_x fmt e = match e with
-  | `Ok x -> Format.fprintf fmt "ok(%a)" pp_x x
-  | `Error s -> Format.fprintf fmt "error(%s)" s
+  | `Ok x -> Format.fprintf fmt "@[ok(@,%a)@]" pp_x x
+  | `Error s -> Format.fprintf fmt "@[error(@,%s)@]" s

core/CCError.mli

@@ -85,7 +85,7 @@ val wrap2 : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c t
 
 val wrap3 : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> 'd t
 
-(** {2 APplicative} *)
+(** {2 Applicative} *)
 
 val pure : 'a -> 'a t
 

core/CCInt.ml

@@ -26,9 +26,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 type t = int
 
-let equal a b = a=b
+let equal (a:int) b = a=b
 
-let compare a b = Pervasives.compare a b
+let compare (a:int) b = Pervasives.compare a b
 
 let hash i = i land max_int
 
@@ -46,4 +46,4 @@ let random_small = random 100
 let random_range i j st = i + random (j-i) st
 
 let pp buf = Printf.bprintf buf "%d"
-let print fmt = Format.fprintf fmt "%d"
+let print fmt = Format.pp_print_int fmt

core/CCKList.ml

@@ -361,7 +361,11 @@ let pp ?(sep=",") pp_item buf l =
 let print ?(sep=",") pp_item fmt l =
   let rec pp fmt l = match l() with
     | `Nil -> ()
-    | `Cons (x,l') -> Format.pp_print_string fmt sep; pp_item fmt x; pp fmt l'
+    | `Cons (x,l') ->
+        Format.pp_print_string fmt sep;
+        Format.pp_print_cut fmt ();
+        pp_item fmt x;
+        pp fmt l'
   in
   match l() with
     | `Nil -> ()

core/CCList.ml

@@ -234,19 +234,18 @@ let last n l =
   let len = List.length l in
   if len < n then l else drop (len-n) l
 
-let find_idx p l =
-  let rec search i l = match l with
-  | [] -> None
-  | x::_ when p x -> Some (i, x)
-  | _::xs -> search (i+1) xs
-  in search 0 l
+let findi f l =
+  let rec aux f i = function
+    | [] -> None
+    | x::l' ->
+        match f i x with
+          | Some _ as res -> res
+          | None -> aux f (i+1) l'
+  in aux f 0 l
 
-let rec find f l = match l with
-  | [] -> None
-  | x::l' ->
-      match f x with
-      | Some _ as res -> res
-      | None -> find f l'
+let find f l = findi (fun _ -> f) l
+
+let find_idx p l = findi (fun i x -> if p x then Some (i, x) else None) l
 
 (*$T
   find (fun x -> if x=3 then Some "a" else None) [1;2;3;4] = Some "a"
@@ -679,8 +678,11 @@ let print ?(start="[") ?(stop="]") ?(sep=", ") pp_item fmt l =
     | x::((y::xs) as l) ->
       pp_item fmt x;
       Format.pp_print_string fmt sep;
+      Format.pp_print_cut fmt ();
       print fmt l
     | x::[] -> pp_item fmt x
     | [] -> ()
   in
-  Format.fprintf fmt "@[%s%a%s@]" start print l stop
+  Format.pp_print_string fmt start;
+  print fmt l;
+  Format.pp_print_string fmt stop

core/CCList.mli

@@ -88,15 +88,19 @@ val last : int -> 'a t -> 'a t
 (** [last n l] takes the last [n] elements of [l] (or less if
     [l] doesn't have that many elements *)
 
-val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
-(** [find p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
-    and [p x] holds. Otherwise returns [None] *)
-
 val find : ('a -> 'b option) -> 'a t -> 'b option
 (** [find f l] traverses [l], applying [f] to each element. If for
     some element [x], [f x = Some y], then [Some y] is returned. Otherwise
     the call returns [None] *)
 
+val findi : (int -> 'a -> 'b option) -> 'a t -> 'b option
+(** Like {!find}, but also pass the index to the predicate function.
+    @since 0.3.4 *)
+
+val find_idx : ('a -> bool) -> 'a t -> (int * 'a) option
+(** [find p x] returns [Some (i,x)] where [x] is the [i]-th element of [l],
+    and [p x] holds. Otherwise returns [None] *)
+
 val filter_map : ('a -> 'b option) -> 'a t -> 'b t
 (** Map and remove elements at the same time *)
 

core/CCOpt.ml

@@ -110,6 +110,16 @@ let sequence_l l =
   sequence_l [] = Some []
 *)
 
+let wrap ?(handler=fun _ -> true) f x =
+  try Some (f x)
+  with e ->
+    if handler e then None else raise e
+
+let wrap2 ?(handler=fun _ -> true) f x y =
+  try Some (f x y)
+  with e ->
+    if handler e then None else raise e
+
 let to_list o = match o with
   | None -> []
   | Some x -> [x]

core/CCOpt.mli

@@ -65,6 +65,19 @@ val get_exn : 'a t -> 'a
     @raise Invalid_argument if the option is [None] *)
 
 val sequence_l : 'a t list -> 'a list t
+(** [sequence_l [x1; x2; ...; xn]] returns [Some [y1;y2;...;yn]] if
+    every [xi] is [Some yi]. Otherwise, if the list contains at least
+    one [None], the result is [None]. *)
+
+val wrap : ?handler:(exn -> bool) -> ('a -> 'b) -> 'a -> 'b option
+(** [wrap f x] calls [f x] and returns [Some y] if [f x = y]. If [f x] raises
+    any exception, the result is [None]. This can be useful to wrap functions
+    such as [Map.S.find].
+    @param handler the exception handler, which returns [true] if the
+        exception is to be caught. *)
+
+val wrap2 : ?handler:(exn -> bool) -> ('a -> 'b -> 'c) -> 'a -> 'b -> 'c option
+(** [wrap2 f x y] is similar to {!wrap1} but for binary functions. *)
 
 (** {2 Applicative} *)
 

core/CCOrd.ml

@@ -89,3 +89,5 @@ let array_ ord a1 a2 =
           then aux (i+1) else c
   in
   aux 0
+
+let map f ord a b = ord (f a) (f b)

core/CCOrd.mli

@@ -64,3 +64,11 @@ val list_ : 'a t -> 'a list t
 (** Lexicographic combination on lists *)
 
 val array_ : 'a t -> 'a array t
+
+val map : ('a -> 'b) -> 'b t -> 'a t
+(** [map f ord] is the comparison function that, given objects [x] and [y],
+    projects [x] and [y] using [f] (e.g. using a record field) and then
+    compares those projections with [ord].
+    Example:
+    [map fst CCInt.compare] compares values of type [(int * 'a)]  by their
+      first component. *)

core/CCPersistentHashtbl.ml

@@ -343,7 +343,8 @@ module Make(H : HashedType) : S with type key = H.t = struct
     let first = ref true in
     iter t
       (fun k v ->
-        if !first then first:=false else Format.pp_print_string fmt ", ";
+        if !first then first:=false
+        else (Format.pp_print_string fmt ", "; Format.pp_print_cut fmt ());
         Format.fprintf fmt "%a -> %a" pp_k k pp_v v
       );
     Format.pp_print_string fmt "}"

core/CCSequence.ml

@@ -1,691 +0,0 @@
-(*
-Copyright (c) 2013, Simon Cruanes
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this
-list of conditions and the following disclaimer.  Redistributions in binary
-form must reproduce the above copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other materials provided with
-the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*)
-
-(** {1 Transient iterators, that abstract on a finite sequence of elements.} *)
-
-(** Sequence abstract iterator type *)
-type 'a t = ('a -> unit) -> unit
-
-type 'a sequence = 'a t
-
-type (+'a, +'b) t2 = ('a -> 'b -> unit) -> unit
-  (** Sequence of pairs of values of type ['a] and ['b]. *)
-
-(** Build a sequence from a iter function *)
-let from_iter f = f
-
-(** Call the function repeatedly until it returns None. This
-    sequence is transient, use {!persistent} if needed! *)
-let from_fun f =
-  fun k ->
-    let rec next () =
-      match f () with
-      | None -> ()
-      | Some x -> (k x; next ())
-    in next ()
-
-let empty = fun k -> ()
-
-let singleton x = fun k -> k x
-
-(** Infinite sequence of the same element *)
-let repeat x = fun k -> while true do k x done
-
-(** [iterate f x] is the infinite sequence (x, f(x), f(f(x)), ...) *)
-let iterate f x =
-  let rec iterate k x = k x; iterate k (f x) in
-  from_iter (fun k -> iterate k x)
-
-(** Sequence that calls the given function to produce elements *)
-let forever f =
-  let rec forever k = k (f ()); forever k in
-  from_iter forever
-
-(** Cycle forever through the given sequence. O(n). *)
-let cycle s = fun k -> while true do s k; done
-
-(** Consume the sequence, passing all its arguments to the function *)
-let iter f seq = seq f
-
-(** Iterate on elements and their index in the sequence *)
-let iteri f seq =
-  let r = ref 0 in
-  let k x =
-    f !r x;
-    incr r
-  in seq k
-
-(** Fold over elements of the sequence, consuming it *)
-let fold f init seq =
-  let r = ref init in
-  seq (fun elt -> r := f !r elt);
-  !r
-
-(** Fold over elements of the sequence and their index, consuming it *)
-let foldi f init seq =
-  let i = ref 0 in
-  let r = ref init in
-  seq (fun elt ->
-    r := f !r !i elt;
-    incr i);
-  !r
-
-(** Map objects of the sequence into other elements, lazily *)
-let map f seq =
-  let seq_fun' k = seq (fun x -> k (f x)) in
-  seq_fun'
-
-(** Map objects, along with their index in the sequence *)
-let mapi f seq =
-  let seq_fun' k =
-    let i = ref 0 in
-    seq (fun x -> k (f !i x); incr i) in
-  seq_fun'
-
-(** Filter on elements of the sequence *)
-let filter p seq =
-  let seq_fun' k = seq (fun x -> if p x then k x) in
-  seq_fun'
-
-(** Append two sequences *)
-let append s1 s2 =
-  let seq_fun k = s1 k; s2 k in
-  seq_fun
-
-(** Concatenate a sequence of sequences into one sequence *)
-let concat s =
-  from_iter (fun k ->
-    (* function that is called on every sub-sequence *)
-    let k_seq seq = iter k seq in
-    s k_seq)
-
-let flatten s = concat s
-
-(** Monadic bind. It applies the function to every element of the
-    initial sequence, and calls [concat]. *)
-let flatMap f seq =
-  from_iter
-    (fun k -> seq (fun x -> (f x) k))
-
-let fmap f seq =
-  from_iter
-    (fun k ->
-      seq (fun x -> match f x with
-          | None -> ()
-          | Some y -> k y))
-
-(** Insert the given element between every element of the sequence *)
-let intersperse elem seq =
-  fun k ->
-    let first = ref true in
-    seq (fun x -> (if !first then first := false else k elem); k x)
-
-(** Mutable unrolled list to serve as intermediate storage *)
-module MList = struct
-  type 'a node =
-    | Nil
-    | Cons of 'a array * int ref * 'a node ref
-
-  let of_seq seq =
-    let start = ref Nil in
-    let chunk_size = ref 8 in
-    (* fill the list. prev: tail-reference from previous node *)
-    let prev, cur = ref start, ref Nil in
-    seq
-      (fun x -> match !cur with
-        | Nil ->
-          let n = !chunk_size in
-          if n < 4096 then chunk_size := 2 * !chunk_size;
-          cur := Cons (Array.make n x, ref 1, ref Nil)
-        | Cons (a,n,next) ->
-          assert (!n < Array.length a);
-          a.(!n) <- x;
-          incr n;
-          if !n = Array.length a then begin
-            !prev := !cur;
-            prev := next;
-            cur := Nil
-          end
-      );
-    !prev := !cur;
-    !start
-
-  let rec iter f l = match l with
-    | Nil -> ()
-    | Cons (a, n, tl) ->
-        for i=0 to !n - 1 do f a.(i) done;
-        iter f !tl
-
-  let iteri f l =
-    let rec iteri i f l = match l with
-    | Nil -> ()
-    | Cons (a, n, tl) ->
-        for j=0 to !n - 1 do f (i+j) a.(j) done;
-        iteri (i+ !n) f !tl
-    in iteri 0 f l
-
-  let rec iter_rev f l = match l with
-    | Nil -> ()
-    | Cons (a, n, tl) ->
-        iter_rev f !tl;
-        for i = !n-1 downto 0 do f a.(i) done
-
-  let length l =
-    let rec len acc l = match l with
-      | Nil -> acc
-      | Cons (_, n, tl) -> len (acc+ !n) !tl
-    in len 0 l
-
-  (** Get element by index *)
-  let rec get l i = match l with
-    | Nil -> raise (Invalid_argument "MList.get")
-    | Cons (a, n, _) when i < !n -> a.(i)
-    | Cons (_, n, tl) -> get !tl (i- !n)
-
-  let to_seq l k = iter k l
-
-  let _to_next arg l =
-    let cur = ref l in
-    let i = ref 0 in (* offset in cons *)
-    let rec get_next _ = match !cur with
-      | Nil -> None
-      | Cons (_, n, tl) when !i = !n ->
-          cur := !tl;
-          i := 0;
-          get_next arg
-      | Cons (a, n, _) ->
-          let x = a.(!i) in
-          incr i;
-          Some x
-    in get_next
-
-  let to_gen l = _to_next () l
-
-  let to_stream l =
-    Stream.from (_to_next 42 l)  (* 42=magic cookiiiiiie *)
-end
-
-(** Iterate on the sequence, storing elements in a data structure.
-    The resulting sequence can be iterated on as many times as needed. *)
-let persistent seq =
-  let l = MList.of_seq seq in
-  MList.to_seq l
-
-(** Sort the sequence. Eager, O(n) ram and O(n ln(n)) time. *)
-let sort ?(cmp=Pervasives.compare) seq =
-  (* use an intermediate list, then sort the list *)
-  let l = fold (fun l x -> x::l) [] seq in
-  let l = List.fast_sort cmp l in
-  fun k -> List.iter k l
-
-(** Group equal consecutive elements. *)
-let group ?(eq=fun x y -> x = y) seq =
-  fun k ->
-    let cur = ref [] in
-    seq (fun x ->
-      match !cur with
-      | [] -> cur := [x]
-      | (y::_) as l when eq x y ->
-        cur := x::l  (* [x] belongs to the group *)
-      | (_::_) as l ->
-        k l; (* yield group, and start another one *)
-        cur := [x]);
-    (* last list *)
-    if !cur <> [] then k !cur
-  
-(** Remove consecutive duplicate elements. Basically this is
-    like [fun seq -> map List.hd (group seq)]. *)
-let uniq ?(eq=fun x y -> x = y) seq =
-  fun k ->
-    let has_prev = ref false
-    and prev = ref (Obj.magic 0) in  (* avoid option type, costly *)
-    seq (fun x ->
-      if !has_prev && eq !prev x
-        then ()  (* duplicate *)
-        else begin
-          has_prev := true;
-          prev := x;
-          k x
-        end)
-
-(** Sort the sequence and remove duplicates. Eager, same as [sort] *)
-let sort_uniq ?(cmp=Pervasives.compare) seq =
-  let seq' = sort ~cmp seq in
-  uniq ~eq:(fun x y -> cmp x y = 0) seq'
-
-(** Cartesian product of the sequences. *)
-let product outer inner =
-  let inner = persistent inner in
-  from_iter
-    (fun k ->
-      outer (fun x ->
-        inner (fun y -> k (x,y))))
-
-(** [join ~join_row a b] combines every element of [a] with every
-    element of [b] using [join_row]. If [join_row] returns None, then
-    the two elements do not combine. Assume that [b] allows for multiple
-    iterations. *)
-let join ~join_row s1 s2 =
-  fun k ->
-    s1 (fun a ->
-      s2 (fun b ->
-        match join_row a b with
-        | None -> ()
-        | Some c -> k c))  (* yield the combination of [a] and [b] *)
-
-(** [unfoldr f b] will apply [f] to [b]. If it
-    yields [Some (x,b')] then [x] is returned
-    and unfoldr recurses with [b']. *)
-let unfoldr f b =
-  let rec unfold k b = match f b with
-    | None -> ()
-    | Some (x, b') -> k x; unfold k b'
-  in
-  from_iter (fun k -> unfold k b)
-
-(** Sequence of intermediate results *)
-let scan f acc seq =
-  from_iter
-    (fun k ->
-      k acc;
-      let acc = ref acc in
-      seq (fun elt -> let acc' = f !acc elt in k acc'; acc := acc'))
-
-let max ?(lt=fun x y -> x < y) seq =
-  let ret = ref None in
-  seq (fun x -> match !ret with
-    | None -> ret := Some x
-    | Some y -> if lt y x then ret := Some x);
-  !ret
-
-let min ?(lt=fun x y -> x < y) seq =
-  let ret = ref None in
-  seq (fun x -> match !ret with
-    | None -> ret := Some x
-    | Some y -> if lt x y then ret := Some x);
-  !ret
-
-exception ExitSequence
-
-(** Take at most [n] elements from the sequence *)
-let take n seq =
-  let count = ref 0 in
-  if n = 0 then empty
-    else fun k ->
-      try
-        seq (fun x ->
-          incr count;
-          k x;
-          if !count = n then raise ExitSequence)
-      with ExitSequence -> ()
-
-(** Drop the [n] first elements of the sequence *)
-let drop n seq =
-  let count = ref 0 in
-  fun k -> seq
-    (fun x -> if !count >= n then k x else incr count)
-
-(** Reverse the sequence. O(n) memory. *)
-let rev seq =
-  let l = MList.of_seq seq in
-  from_iter (fun k -> MList.iter_rev k l)
-
-(** Do all elements satisfy the predicate? *)
-let for_all p seq =
-  try
-    seq (fun x -> if not (p x) then raise ExitSequence);
-    true
-  with ExitSequence -> false
-
-(** Exists there some element satisfying the predicate? *)
-let exists p seq =
-  try
-    seq (fun x -> if p x then raise ExitSequence);
-    false
-  with ExitSequence -> true
-
-(** How long is the sequence? *)
-let length seq =
-  let r = ref 0 in
-  seq (fun _ -> incr r);
-  !r
-
-(** Is the sequence empty? *)
-let is_empty seq =
-  try seq (fun _ -> raise ExitSequence); true
-  with ExitSequence -> false
-
-(** {2 Transform a sequence} *)
-
-let empty2 =
-  fun k -> ()
-
-let is_empty2 seq2 =
-  try ignore (seq2 (fun _ _ -> raise ExitSequence)); true
-  with ExitSequence -> false
-
-let length2 seq2 =
-  let r = ref 0 in
-  seq2 (fun _ _ -> incr r);
-  !r
-
-let zip seq2 =
-  fun k -> seq2 (fun x y -> k (x,y))
-
-let unzip seq =
-  fun k -> seq (fun (x,y) -> k x y)
-
-(** Zip elements of the sequence with their index in the sequence *)
-let zip_i seq =
-  fun k ->
-    let r = ref 0 in
-    seq (fun x -> let n = !r in incr r; k n x)
-
-let fold2 f acc seq2 =
-  let acc = ref acc in
-  seq2 (fun x y -> acc := f !acc x y);
-  !acc
-
-let iter2 f seq2 =
-  seq2 f
-
-let map2 f seq2 =
-  fun k -> seq2 (fun x y -> k (f x y))
-
-(** [map2_2 f g seq2] maps each [x, y] of seq2 into [f x y, g x y] *)
-let map2_2 f g seq2 =
-  fun k -> seq2 (fun x y -> k (f x y) (g x y))
-
-(** {2 Basic data structures converters} *)
-
-let to_list seq = List.rev (fold (fun y x -> x::y) [] seq)
-
-let to_rev_list seq = fold (fun y x -> x :: y) [] seq
-  (** Get the list of the reversed sequence (more efficient) *)
-
-let of_list l = from_iter (fun k -> List.iter k l)
-
-let to_array seq =
-  let l = MList.of_seq seq in
-  let n = MList.length l in
-  if n = 0
-    then [||]
-    else begin
-      let a = Array.make n (MList.get l 0) in
-      MList.iteri (fun i x -> a.(i) <- x) l;
-      a
-    end
-
-let of_array a =
-  fun k ->
-    for i = 0 to Array.length a - 1 do
-      k (Array.unsafe_get a i)
-    done
-
-let of_array_i a =
-  fun k ->
-    for i = 0 to Array.length a - 1 do
-      k (i, Array.unsafe_get a i)
-    done
-
-let of_array2 a =
-  fun k ->
-    for i = 0 to Array.length a - 1 do
-      k i (Array.unsafe_get a i)
-    done
-
-(** [array_slice a i j] Sequence of elements whose indexes range
-    from [i] to [j] *)
-let array_slice a i j =
-  assert (i >= 0 && j < Array.length a);
-  fun k ->
-    for idx = i to j do
-      k a.(idx);  (* iterate on sub-array *)
-    done
-
-(** Sequence of elements of a stream (usable only once) *)
-let of_stream s =
-  let seq k = Stream.iter k s in
-  from_iter seq
-
-(** Convert to a stream. The sequence is made persistent. *)
-let to_stream seq =
-  let l = MList.of_seq seq in
-  MList.to_stream l
-
-(** Push elements of the sequence on the stack *)
-let to_stack s seq = iter (fun x -> Stack.push x s) seq
-
-(** Sequence of elements of the stack (same order as [Stack.iter]) *)
-let of_stack s = from_iter (fun k -> Stack.iter k s)
-
-(** Push elements of the sequence into the queue *)
-let to_queue q seq = iter (fun x -> Queue.push x q) seq
-
-(** Sequence of elements contained in the queue, FIFO order *)
-let of_queue q = from_iter (fun k -> Queue.iter k q)
-
-let hashtbl_add h seq =
-  iter (fun (k,v) -> Hashtbl.add h k v) seq
-
-let hashtbl_replace h seq =
-  iter (fun (k,v) -> Hashtbl.replace h k v) seq
-
-let to_hashtbl seq =
-  let h = Hashtbl.create 3 in
-  hashtbl_replace h seq;
-  h
-
-let to_hashtbl2 seq2 =
-  let h = Hashtbl.create 3 in
-  seq2 (fun k v -> Hashtbl.replace h k v);
-  h
-
-let of_hashtbl h =
-  from_iter (fun k -> Hashtbl.iter (fun a b -> k (a, b)) h)
-
-let of_hashtbl2 h =
-  fun k -> Hashtbl.iter k h
-
-let hashtbl_keys h =
-  from_iter (fun k -> Hashtbl.iter (fun a b -> k a) h)
-
-let hashtbl_values h =
-  from_iter (fun k -> Hashtbl.iter (fun a b -> k b) h)
-
-let of_str s = from_iter (fun k -> String.iter k s)
-
-let to_str seq =
-  let b = Buffer.create 64 in
-  iter (fun c -> Buffer.add_char b c) seq;
-  Buffer.contents b
-
-let of_in_channel ic =
-  from_iter (fun k ->
-    try while true do
-      let c = input_char ic in k c
-    done with End_of_file -> ())
-
-(** Copy content of the sequence into the buffer *)
-let to_buffer seq buf =
-  iter (fun c -> Buffer.add_char buf c) seq
-
-(** Iterator on integers in [start...stop] by steps 1 *)
-let int_range ~start ~stop =
-  fun k ->
-    for i = start to stop do k i done
-
-let int_range_dec ~start ~stop =
-  fun k ->
-    for i = start downto stop do k i done
-
-(** Convert the given set to a sequence. The set module must be provided. *)
-let of_set (type s) (type v) m set =
-  let module S = (val m : Set.S with type t = s and type elt = v) in
-  from_iter
-    (fun k -> S.iter k set)
-
-(** Convert the sequence to a set, given the proper set module *)
-let to_set (type s) (type v) m seq =
-  let module S = (val m : Set.S with type t = s and type elt = v) in
-  fold
-    (fun set x -> S.add x set)
-    S.empty seq
-
-type 'a gen = unit -> 'a option
-
-let of_gen g =
-  (* consume the generator to build a MList *)
-  let rec iter1 k = match g () with
-    | None -> ()
-    | Some x -> k x; iter1 k
-  in
-  let l = MList.of_seq iter1 in
-  MList.to_seq l
-
-let to_gen seq =
-  let l = MList.of_seq seq in
-  MList.to_gen l
-
-(** {2 Functorial conversions between sets and sequences} *)
-
-module Set = struct
-  module type S = sig
-    include Set.S
-    val of_seq : elt sequence -> t
-    val to_seq : t -> elt sequence
-  end
-
-  (** Create an enriched Set module from the given one *)
-  module Adapt(X : Set.S) = struct
-    let to_seq set = from_iter (fun k -> X.iter k set)
-
-    let of_seq seq = fold (fun set x -> X.add x set) X.empty seq
-
-    include X
-  end
-
-  (** Functor to build an extended Set module from an ordered type *)
-  module Make(X : Set.OrderedType) = struct
-    module MySet = Set.Make(X)
-    include Adapt(MySet)
-  end
-end
-
-(** {2 Conversion between maps and sequences.} *)
-
-module Map = struct
-  module type S = sig
-    include Map.S
-    val to_seq : 'a t -> (key * 'a) sequence
-    val of_seq : (key * 'a) sequence -> 'a t
-    val keys : 'a t -> key sequence
-    val values : 'a t -> 'a sequence
-  end
-
-  (** Adapt a pre-existing Map module to make it sequence-aware *)
-  module Adapt(M : Map.S) = struct
-    let to_seq m = from_iter (fun k -> M.iter (fun x y -> k (x,y)) m)
-
-    let of_seq seq = fold (fun m (k,v) -> M.add k v m) M.empty seq
-
-    let keys m = from_iter (fun k -> M.iter (fun x _ -> k x) m)
-
-    let values m = from_iter (fun k -> M.iter (fun _ y -> k y) m)
-
-    include M
-  end
-
-  (** Create an enriched Map module, with sequence-aware functions *)
-  module Make(V : Map.OrderedType) : S with type key = V.t = struct
-    module M = Map.Make(V)
-    include Adapt(M)
-  end
-end
-
-(** {2 Infinite sequences of random values} *)
-
-let random_int bound = forever (fun () -> Random.int bound)
-
-let random_bool = forever Random.bool
-
-let random_float bound = forever (fun () -> Random.float bound)
-
-(** Sequence of choices of an element in the array *)
-let random_array a =
-  assert (Array.length a > 0);
-  let seq k =
-    while true do
-      let i = Random.int (Array.length a) in
-      k a.(i);
-    done in
-  from_iter seq
-
-let random_list l = random_array (Array.of_list l)
-
-(** {2 Infix functions} *)
-
-module Infix = struct
-  let (--) i j = int_range ~start:i ~stop:j
-
-  let (--^) i j = int_range_dec ~start:i ~stop:j
-end
-
-include Infix
-
-(** {2 Pretty printing of sequences} *)
-
-(** Pretty print a sequence of ['a], using the given pretty printer
-    to print each elements. An optional separator string can be provided. *)
-let print ?(start="") ?(stop="") ?(sep=", ") pp_elt formatter seq =
-  let first = ref true in
-  Format.pp_print_string formatter start;
-  iter
-    (fun x -> 
-      (if !first then first := false
-        else begin
-          Format.pp_print_string formatter sep;
-          Format.pp_print_cut formatter ();
-        end);
-      pp_elt formatter x)
-    seq;
-  Format.pp_print_string formatter stop;
-  ()
-
-let pp ?(start="") ?(stop="") ?(sep=", ") pp_elt buf seq =
-  let first = ref true in
-  Buffer.add_string buf start;
-  iter
-    (fun x -> 
-      if !first then first := false else Buffer.add_string buf sep;
-      pp_elt buf x)
-    seq;
-  Buffer.add_string buf stop;
-  ()
-
-let to_string ?start ?stop ?sep pp_elt seq =
-  let buf = Buffer.create 25 in
-  pp ?start ?stop ?sep pp_elt buf seq;
-  Buffer.contents buf

core/CCSequence.ml

@@ -0,0 +1 @@
+../sequence/sequence.ml

core/CCSequence.mli

@@ -23,16 +23,16 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *)
 
-(** {1 Transient iterators, that abstract on a finite sequence of elements.} *)
+(** {1 Simple and Efficient Iterators} *)
 
 (** The iterators are designed to allow easy transfer (mappings) between data
-    structures, without defining n^2 conversions between the n types. The
+    structures, without defining [n^2] conversions between the [n] types. The
     implementation relies on the assumption that a sequence can be iterated
     on as many times as needed; this choice allows for high performance
     of many combinators. However, for transient iterators, the {!persistent}
     function is provided, storing elements of a transient iterator
     in memory; the iterator can then be used several times (See further).
-    
+
     Note that some combinators also return sequences (e.g. {!group}). The
     transformation is computed on the fly every time one iterates over
     the resulting sequence. If a transformation performs heavy computation,
@@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     until their result is iterated on. For instance, if one calls {!map}
     on a sequence, one gets a new sequence, but nothing else happens until
     this new sequence is used (by folding or iterating on it).
-    
+
     If a sequence is built from an iteration function that is {b repeatable}
     (i.e. calling it several times always iterates on the same set of
     elements, for instance List.iter or Map.iter), then
@@ -53,8 +53,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     of this memory structure, cheaply and repeatably. *)
 
 type +'a t = ('a -> unit) -> unit
-  (** Sequence iterator type, representing a finite sequence of values
-      of type ['a] that one can iterate on. *)
+  (** A sequence of values of type ['a]. If you give it a function ['a -> unit]
+      it will be applied to every element of the sequence successively. *)
 
 type +'a sequence = 'a t
 
@@ -76,12 +76,34 @@ val empty : 'a t
 val singleton : 'a -> 'a t
   (** Singleton sequence, with exactly one element. *)
 
+val doubleton : 'a -> 'a -> 'a t
+  (** Sequence with exactly two elements
+      @since 0.3.4 *)
+
+val cons : 'a -> 'a t -> 'a t
+  (** [cons x l] yields [x], then yields from [l].
+      Same as [append (singleton x) l]
+      @since 0.3.4 *)
+
+
+val snoc : 'a t -> 'a -> 'a t
+  (** Same as {!cons} but yields the element after iterating on [l]
+      @since 0.3.4 *)
+
+val return : 'a -> 'a t
+  (** Synonym to {!singleton}
+      @since 0.3.4 *)
+
+val pure : 'a -> 'a t
+  (** Synonym to {!singleton}
+      @since 0.3.4 *)
+
 val repeat : 'a -> 'a t
   (** Infinite sequence of the same element. You may want to look
-      at {!take} if you iterate on it. *)
+      at {!take} and the likes if you iterate on it. *)
 
 val iterate : ('a -> 'a) -> 'a -> 'a t
-  (** [iterate f x] is the infinite sequence (x, f(x), f(f(x)), ...) *)
+  (** [iterate f x] is the infinite sequence [x, f(x), f(f(x)), ...] *)
 
 val forever : (unit -> 'b) -> 'b t
   (** Sequence that calls the given function to produce elements.
@@ -97,7 +119,8 @@ val cycle : 'a t -> 'a t
 (** {2 Consume a sequence} *)
 
 val iter : ('a -> unit) -> 'a t -> unit
-  (** Consume the sequence, passing all its arguments to the function *)
+  (** Consume the sequence, passing all its arguments to the function.
+      Basically [iter f seq] is just [seq f]. *)
 
 val iteri : (int -> 'a -> unit) -> 'a t -> unit
   (** Iterate on elements and their index in the sequence *)
@@ -120,6 +143,15 @@ val for_all : ('a -> bool) -> 'a t -> bool
 val exists : ('a -> bool) -> 'a t -> bool
   (** Exists there some element satisfying the predicate? *)
 
+val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
+  (** Is the value a member of the sequence?
+      @param eq the equality predicate to use (default [(=)])
+      @since 0.3.4 *)
+
+val find : ('a -> 'b option) -> 'a t -> 'b option
+  (** Find the first element on which the function doesn't return [None]
+      @since 0.3.4 *)
+
 val length : 'a t -> int
   (** How long is the sequence? Forces the sequence. *)
 
@@ -145,18 +177,43 @@ val flatMap : ('a -> 'b t) -> 'a t -> 'b t
   (** Monadic bind. Intuitively, it applies the function to every element of the
       initial sequence, and calls {!concat}. *)
 
+val flat_map : ('a -> 'b t) -> 'a t -> 'b t
+  (** Alias to {!flatMap} with a more explicit name
+      @since 0.3.4 *)
+
 val fmap : ('a -> 'b option) -> 'a t -> 'b t
   (** Specialized version of {!flatMap} for options.  *)
 
+val filter_map : ('a -> 'b option) -> 'a t -> 'b t
+  (** Alias to {!fmap} with a more explicit name
+      @since 0.3.4 *)
+
 val intersperse : 'a -> 'a t -> 'a t
   (** Insert the single element between every element of the sequence *)
 
+(** {2 Caching} *)
+
 val persistent : 'a t -> 'a t
-  (** Iterate on the sequence, storing elements in a data structure.
+  (** Iterate on the sequence, storing elements in an efficient internal structure..
       The resulting sequence can be iterated on as many times as needed.
       {b Note}: calling persistent on an already persistent sequence
       will still make a new copy of the sequence! *)
 
+val persistent_lazy : 'a t -> 'a t
+  (** Lazy version of {!persistent}. When calling [persistent_lazy s],
+      a new sequence [s'] is immediately returned (without actually consuming
+      [s]) in constant time; the first time [s'] is iterated on,
+      it also consumes [s] and caches its content into a inner data
+      structure that will back [s'] for future iterations.
+
+      {b warning}: on the first traversal of [s'], if the traversal
+      is interrupted prematurely ({!take}, etc.) then [s'] will not be
+      memorized, and the next call to [s'] will traverse [s] again.
+
+      @since 0.3.4 *)
+
+(** {2 Misc} *)
+
 val sort : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
   (** Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.
       It iterates on elements of the argument sequence immediately,
@@ -173,9 +230,14 @@ val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
       like [fun seq -> map List.hd (group seq)]. *)
 
 val product : 'a t -> 'b t -> ('a * 'b) t
-  (** Cartesian product of the sequences. The first one is transformed
-      by calling [persistent] on it, so that it can be traversed
-      several times (outer loop of the product) *)
+  (** Cartesian product of the sequences. When calling [product a b],
+      the caller {b MUST} ensure that [b] can be traversed as many times
+      as required (several times), possibly by calling {!persistent} on it
+      beforehand. *)
+
+val product2 : 'a t -> 'b t -> ('a, 'b) t2
+  (** Binary version of {!product}. Same requirements.
+      @since 0.3.4 *)
 
 val join : join_row:('a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
   (** [join ~join_row a b] combines every element of [a] with every
@@ -183,7 +245,7 @@ val join : join_row:('a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
       the two elements do not combine. Assume that [b] allows for multiple
       iterations. *)
 
-val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t 
+val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t
   (** [unfoldr f b] will apply [f] to [b]. If it
       yields [Some (x,b')] then [x] is returned
       and unfoldr recurses with [b']. *)
@@ -200,13 +262,32 @@ val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
   (** Min element of the sequence, using the given comparison function.
       see {!max} for more details. *)
 
+val head : 'a t -> 'a option
+  (** First element, if any, otherwise [None]
+      @since 0.3.4 *)
+
+val head_exn : 'a t -> 'a
+  (** First element, if any, fails
+      @raise Invalid_argument if the sequence is empty
+      @since 0.3.4 *)
+
 val take : int -> 'a t -> 'a t
   (** Take at most [n] elements from the sequence. Works on infinite
       sequences. *)
 
+val take_while : ('a -> bool) -> 'a t -> 'a t
+  (** Take elements while they satisfy the predicate, then stops iterating.
+      Will work on an infinite sequence [s] if the predicate is false for at
+      least one element of [s].
+      @since 0.3.4 *)
+
 val drop : int -> 'a t -> 'a t
   (** Drop the [n] first elements of the sequence. Lazy. *)
 
+val drop_while : ('a -> bool) -> 'a t -> 'a t
+  (** Predicate version of {!drop}
+      @since 0.3.4 *)
+
 val rev : 'a t -> 'a t
   (** Reverse the sequence. O(n) memory and time, needs the
       sequence to be finite. The result is persistent and does
@@ -239,15 +320,27 @@ val map2_2 : ('a -> 'b -> 'c) -> ('a -> 'b -> 'd) -> ('a, 'b) t2 -> ('c, 'd) t2
 (** {2 Basic data structures converters} *)
 
 val to_list : 'a t -> 'a list
+  (** Convert the sequence into a list. Preserves order of elements.
+      This function is tail-recursive, but consumes 2*n memory.
+      If order doesn't matter to you, consider {!to_rev_list}. *)
 
 val to_rev_list : 'a t -> 'a list
   (** Get the list of the reversed sequence (more efficient than {!to_list}) *)
 
 val of_list : 'a list -> 'a t
 
+val on_list : ('a t -> 'b t) -> 'a list -> 'b list
+(** [on_list f l] is equivalent to [to_list @@ f @@ of_list l].
+    @since 0.3.4
+*)
+
+val to_opt : 'a t -> 'a option
+  (** Alias to {!head}
+      @since 0.3.4 *)
+
 val to_array : 'a t -> 'a array
   (** Convert to an array. Currently not very efficient because
-      and intermediate list is used. *)
+      an intermediate list is used. *)
 
 val of_array : 'a array -> 'a t
 
@@ -260,6 +353,10 @@ val array_slice : 'a array -> int -> int -> 'a t
   (** [array_slice a i j] Sequence of elements whose indexes range
       from [i] to [j] *)
 
+val of_opt : 'a option -> 'a t
+  (** Iterate on 0 or 1 values.
+      @since 0.3.4 *)
+
 val of_stream : 'a Stream.t -> 'a t
   (** Sequence of elements of a stream (usable only once) *)
 
@@ -304,10 +401,20 @@ val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b t
 val of_str : string -> char t
 val to_str :  char t -> string
 
+val concat_str : string t -> string
+  (** Concatenate strings together, eagerly.
+      Also see {!intersperse} to add a separator.
+      @since 0.3.4 *)
+
+exception OneShotSequence
+  (** Raised when the user tries to iterate several times on
+      a transient iterator *)
+
 val of_in_channel : in_channel -> char t
   (** Iterates on characters of the input (can block when one
       iterates over the sequence). If you need to iterate
-      several times on this sequence, use {!persistent}. *)
+      several times on this sequence, use {!persistent}.
+      @raise OneShotSequence when used more than once. *)
 
 val to_buffer : char t -> Buffer.t -> unit
   (** Copy content of the sequence into the buffer *)
@@ -327,6 +434,7 @@ val to_set : (module Set.S with type elt = 'a and type t = 'b) -> 'a t -> 'b
   (** Convert the sequence to a set, given the proper set module *)
 
 type 'a gen = unit -> 'a option
+type 'a klist = unit -> [`Nil | `Cons of 'a * 'a klist]
 
 val of_gen : 'a gen -> 'a t
   (** Traverse eagerly the generator and build a sequence from it *)
@@ -334,6 +442,12 @@ val of_gen : 'a gen -> 'a t
 val to_gen : 'a t -> 'a gen
   (** Make the sequence persistent (O(n)) and then iterate on it. Eager. *)
 
+val of_klist : 'a klist -> 'a t
+  (** Iterate on the lazy list *)
+
+val to_klist : 'a t -> 'a klist
+  (** Make the sequence persistent and then iterate on it. Eager. *)
+
 (** {2 Functorial conversions between sets and sequences} *)
 
 module Set : sig
@@ -341,11 +455,17 @@ module Set : sig
     include Set.S
     val of_seq : elt sequence -> t
     val to_seq : t -> elt sequence
+
+    val to_list : t -> elt list
+      (** @since 0.3.4 *)
+
+    val of_list : elt list -> t
+      (** @since 0.3.4 *)
   end
 
   (** Create an enriched Set module from the given one *)
   module Adapt(X : Set.S) : S with type elt = X.elt and type t = X.t
-    
+
   (** Functor to build an extended Set module from an ordered type *)
   module Make(X : Set.OrderedType) : S with type elt = X.t
 end
@@ -359,6 +479,12 @@ module Map : sig
     val of_seq : (key * 'a) sequence -> 'a t
     val keys : 'a t -> key sequence
     val values : 'a t -> 'a sequence
+
+    val to_list : 'a t -> (key * 'a) list
+      (** @since 0.3.4 *)
+
+    val of_list : (key * 'a) list -> 'a t
+      (** @since 0.3.4 *)
   end
 
   (** Adapt a pre-existing Map module to make it sequence-aware *)
@@ -390,26 +516,95 @@ val random_list : 'a list -> 'a t
 
 module Infix : sig
   val (--) : int -> int -> int t
+    (** [a -- b] is the range of integers from [a] to [b], both included,
+        in increasing order. It will therefore be empty if [a > b]. *)
 
   val (--^) : int -> int -> int t
     (** [a --^ b] is the range of integers from [b] to [a], both included,
         in decreasing order (starts from [a]).
         It will therefore be empty if [a < b]. *)
+
+  val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
+    (** Monadic bind (infix version of {!flat_map}
+        @since 0.3.4 *)
+
+  val (>|=) : 'a t -> ('a -> 'b) -> 'b t
+    (** Infix version of {!map}
+        @since 0.3.4 *)
+
+  val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
+    (** Applicative operator (product+application)
+        @since 0.3.4 *)
+
+  val (<+>) : 'a t -> 'a t -> 'a t
+    (** Concatenation of sequences
+        @since 0.3.4 *)
 end
 
 include module type of Infix
 
+
 (** {2 Pretty printing of sequences} *)
 
-val print : ?start:string -> ?stop:string -> ?sep:string ->
-            (Format.formatter -> 'a -> unit) ->
+val pp_seq : ?sep:string -> (Format.formatter -> 'a -> unit) ->
              Format.formatter -> 'a t -> unit
   (** Pretty print a sequence of ['a], using the given pretty printer
       to print each elements. An optional separator string can be provided. *)
 
-val pp : ?start:string -> ?stop:string -> ?sep:string ->
-         (Buffer.t -> 'a -> unit) ->
-          Buffer.t -> 'a t -> unit
+val pp_buf : ?sep:string -> (Buffer.t -> 'a -> unit) ->
+             Buffer.t -> 'a t -> unit
+  (** Print into a buffer *)
 
-val to_string : ?start:string -> ?stop:string -> ?sep:string ->
-                (Buffer.t -> 'a -> unit) -> 'a t -> string
+val to_string : ?sep:string -> ('a -> string) -> 'a t -> string
+  (** Print into a string *)
+
+(** {2 Basic IO}
+
+Very basic interface to manipulate files as sequence of chunks/lines. The
+sequences take care of opening and closing files properly; every time
+one iterates over a sequence, the file is opened/closed again.
+
+Example: copy a file ["a"] into file ["b"], removing blank lines:
+
+{[
+  Sequence.(IO.lines_of "a" |> filter (fun l-> l<> "") |> IO.write_lines "b");;
+]}
+
+By chunks of [4096] bytes:
+
+{[
+  Sequence.IO.(chunks_of ~size:4096 "a" |> write_to "b");;
+]}
+
+@since 0.3.4 *)
+
+module IO : sig
+  val lines_of : ?mode:int -> ?flags:open_flag list ->
+                string -> string t
+  (** [lines_of filename] reads all lines of the given file. It raises the
+      same exception as would opening the file and read from it, except
+      from [End_of_file] (which is caught). The file is {b always} properly
+      closed.
+      Every time the sequence is iterated on, the file is opened again, so
+      different iterations might return different results
+      @param mode default [0o644]
+      @param flags default: [[Open_rdonly]] *)
+
+  val chunks_of : ?mode:int -> ?flags:open_flag list -> ?size:int ->
+                  string -> string t
+  (** Read chunks of the given [size] from the file. The last chunk might be
+      smaller. Behaves like {!lines_of} regarding errors and options.
+      Every time the sequence is iterated on, the file is opened again, so
+      different iterations might return different results *)
+
+  val write_to : ?mode:int -> ?flags:open_flag list ->
+                 string -> string t -> unit
+  (** [write_to filename seq] writes all strings from [seq] into the given
+      file. It takes care of opening and closing the file.
+      @param mode default [0o644]
+      @param flags used by [open_out_gen]. Default: [[Open_creat;Open_wronly]]. *)
+
+  val write_lines : ?mode:int -> ?flags:open_flag list ->
+                    string -> string t -> unit
+  (** Same as {!write_to}, but intercales ['\n'] between each string *)
+end

core/CCString.ml

@@ -50,7 +50,7 @@ end
 
 type t = string
 
-let equal a b = a=b
+let equal (a:string) b = a=b
 
 let compare = String.compare
 

core/CCVector.ml

@@ -486,10 +486,10 @@ let pp ?(start="[") ?(stop="]") ?(sep=", ") pp_item buf v =
   Buffer.add_string buf stop
 
 let print ?(start="[") ?(stop="]") ?(sep=", ") pp_item fmt v =
-  Format.fprintf fmt "@[%s" start;
+  Format.pp_print_string fmt start;
   iteri
     (fun i x ->
-      if i > 0 then Format.pp_print_string fmt sep;
+      if i > 0 then (Format.pp_print_string fmt sep; Format.pp_print_cut fmt());
       pp_item fmt x
     ) v;
-  Format.fprintf fmt "%s@]" stop
+  Format.pp_print_string fmt stop

core/CCVector.mli

@@ -110,25 +110,28 @@ val member : ?eq:('a -> 'a -> bool) -> 'a -> ('a, _) t -> bool
 (** is the element a member of the vector? *)
 
 val sort : ('a -> 'a -> int) -> ('a, _) t -> ('a, 'mut) t
-(** Sort the vector *)
+(** Sort the vector, returning a copy of it that is sorted
+    w.r.t the given ordering. The vector itself is unchanged. *)
 
 val sort' : ('a -> 'a -> int) -> ('a, rw) t -> unit
-(** Sort the vector in place *)
+(** Sort the vector in place (modifying it). *)
 
 val uniq_sort : ('a -> 'a -> int) -> ('a, rw) t -> unit
-(** Sort the array and remove duplicates, in place*)
+(** Sort the array and remove duplicates, in place (e.e. modifying
+    the vector itself) *)
 
 val iter : ('a -> unit) -> ('a,_) t -> unit
-(** iterate on the vector *)
+(** iterate on the vector's content *)
 
 val iteri : (int -> 'a -> unit) -> ('a,_) t -> unit
-(** iterate on the vector with indexes *)
+(** iterate on the vector, with indexes *)
 
 val map : ('a -> 'b) -> ('a,_) t -> ('b, 'mut) t
-(** map elements of the vector *)
+(** map elements of the vector, yielding a new vector *)
 
 val filter : ('a -> bool) -> ('a,_) t -> ('a, 'mut) t
-(** filter elements from vector *)
+(** filter elements from the vector. [filter p v] leaves [v] unchanged but
+    returns a new vector that only contains elements of [v] satisfying [p]. *)
 
 val filter' : ('a -> bool) -> ('a, rw) t -> unit
 (** Filter elements in place. Does {b NOT} preserve the order
@@ -138,10 +141,10 @@ val fold : ('b -> 'a -> 'b) -> 'b -> ('a,_) t -> 'b
 (** fold on elements of the vector *)
 
 val exists : ('a -> bool) -> ('a,_) t -> bool
-(** existential test *)
+(** existential test (is there an element that satisfies the predicate?) *)
 
 val for_all : ('a -> bool) -> ('a,_) t -> bool
-(** universal test *)
+(** universal test (do all the elements satisfy the predicate?) *)
 
 val find : ('a -> bool) -> ('a,_) t -> 'a option
 (** Find an element that satisfies the predicate *)
@@ -160,15 +163,17 @@ val flat_map' : ('a -> 'b sequence) -> ('a,_) t -> ('b, 'mut) t
 (** Like {!flat_map}, but using {!sequence} for intermediate collections *)
 
 val (>>=) : ('a,_) t -> ('a -> ('b,_) t) -> ('b, 'mut) t
+(** Infix version of {!flat_map} *)
 
 val (>|=) : ('a,_) t -> ('a -> 'b) -> ('b, 'mut) t
+(** Infix version of {!map} *)
 
 val get : ('a,_) t -> int -> 'a
-(** access element, or
+(** access element by its index, or
     @raise Failure if bad index *)
 
 val set : ('a, rw) t -> int -> 'a -> unit
-(** access element, or
+(** modify element at given index, or
     @raise Failure if bad index *)
 
 val remove : ('a, rw) t -> int -> unit
@@ -196,7 +201,9 @@ val unsafe_get_array : ('a, rw) t -> 'a array
     index than [size v] are undefined (do not access!). *)
 
 val (--) : int -> int -> (int, 'mut) t
-(** Range of integers (both included) *)
+(** Range of integers, either ascending or descending (both included,
+    therefore the result is never empty).
+    Example: [1 -- 10] returns the vector [[1;2;3;4;5;6;7;8;9;10]] *)
 
 val of_array : 'a array -> ('a, 'mut) t
 val of_list : 'a list -> ('a, 'mut) t

core/META

@@ -1,6 +1,6 @@
 # OASIS_START
-# DO NOT EDIT (digest: eb8b3792deb258b784b1c656f2fcb136)
-version = "0.3.3"
+# DO NOT EDIT (digest: c0cc05feb3c737cd5d151af31c1723c3)
+version = "0.3.4"
 description = "A modular standard library focused on data structures."
 archive(byte) = "containers.cma"
 archive(byte, plugin) = "containers.cma"
@@ -8,7 +8,7 @@ archive(native) = "containers.cmxa"
 archive(native, plugin) = "containers.cmxs"
 exists_if = "containers.cma"
 package "thread" (
- version = "0.3.3"
+ version = "0.3.4"
  description = "A modular standard library focused on data structures."
  requires = "containers threads"
  archive(byte) = "containers_thread.cma"
@@ -19,7 +19,7 @@ package "thread" (
 )
 
 package "string" (
- version = "0.3.3"
+ version = "0.3.4"
  description = "A modular standard library focused on data structures."
  archive(byte) = "containers_string.cma"
  archive(byte, plugin) = "containers_string.cma"
@@ -29,7 +29,7 @@ package "string" (
 )
 
 package "misc" (
- version = "0.3.3"
+ version = "0.3.4"
  description = "A modular standard library focused on data structures."
  requires = "unix containers"
  archive(byte) = "containers_misc.cma"
@@ -40,7 +40,7 @@ package "misc" (
 )
 
 package "lwt" (
- version = "0.3.3"
+ version = "0.3.4"
  description = "A modular standard library focused on data structures."
  requires = "containers lwt lwt.unix containers.misc"
  archive(byte) = "containers_lwt.cma"
@@ -51,7 +51,7 @@ package "lwt" (
 )
 
 package "cgi" (
- version = "0.3.3"
+ version = "0.3.4"
  description = "A modular standard library focused on data structures."
  requires = "containers CamlGI"
  archive(byte) = "containers_cgi.cma"

sequence/.gitignore

@@ -0,0 +1,9 @@
+.*.swp
+_build
+*.native
+*.docdir
+*.html
+man/
+sequence.install
+setup.log
+setup.data

sequence/.merlin

@@ -0,0 +1,8 @@
+S .
+S bench/
+S tests/
+B _build
+B _build/tests/
+B _build/bench/
+PKG oUnit
+PKG benchmark

sequence/.ocamlinit

@@ -0,0 +1,5 @@
+#directory "_build";;
+#load "sequence.cma";;
+open Sequence.Infix;;
+(* vim:syntax=ocaml
+*)

sequence/CHANGELOG.md

@@ -0,0 +1,75 @@
+# Changelog
+
+## 0.5.2
+
+- bugfix in `take`
+- `on_list` for mapping lists through sequences
+
+## 0.5.1
+
+- `Sequence.IO` module, a very very simple way to read/write files
+- options: `to_opt/of_opt/head/head_exn`
+
+## 0.5
+
+- conversion with `klist`
+- add monadic, choice and applicative infix operators and `>|=`
+- add several functions:
+  * `product2`
+  * `find`, `mem`
+  * `doubleton`, `cons`, `snoc`
+  * `drop_while`, `take_while`...
+  * `concat_str`
+- aliases to existing functions
+- use `delimcc` in a new module, `SequenceInvert`, in order to reverse the
+  control flow (here with conversion to Gen)
+- fix examples, tests and doc (about `product`)
+- reading benchmark for persistent sequences.
+- replace `Bench` with `Benchmark`
+
+## 0.4.1
+
+- `persistent_lazy`
+- use bin_annot
+
+## 0.4
+
+- API change for `persistent`
+- more efficient implementation for `persistent`
+- remove `TypeClass`
+- API change for `min`/`max` (in case the sequence is empty)
+- conversion with `Gen`
+- use Oasis
+
+## 0.3.7
+
+- decreasing int range
+- printing functions
+
+## 0.3.6.1
+
+- documentation
+- bugfixes
+
+## 0.3.6
+
+- `fmap`
+- functors to adapt `Set` and `Map`
+
+## 0.3.5
+
+- tests and benchmarks
+- `join` combinator
+- optimization for `Sequence.persistent`
+
+## 0.3.4
+
+- `sort`, `uniq`, `group` and `sort_uniq` combinators implemented
+- some conversion functions that use `Sequence.t2`
+- infix operators in `Sequence.Infix`
+- `Sequence.t2` type for efficient iteration on pairs of elements
+- some combinators are adapted to `Sequence.t2`
+- `zip`, `unzip` and `zip_i` to convert between `t` and `t2`
+- added `scan` combinator
+
+note: git log --no-merges previous_version..HEAD --pretty=%s

sequence/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012, Simon Cruanes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.  Redistributions in binary
+form must reproduce the above copyright notice, this list of conditions and
+the following disclaimer in the documentation and/or other materials
+provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

sequence/META

@@ -0,0 +1,21 @@
+# OASIS_START
+# DO NOT EDIT (digest: f4f3ee8dc8cda763af26a927b88956e6)
+version = "0.5.2"
+description = "Simple sequence (iterator) datatype and combinators"
+archive(byte) = "sequence.cma"
+archive(byte, plugin) = "sequence.cma"
+archive(native) = "sequence.cmxa"
+archive(native, plugin) = "sequence.cmxs"
+exists_if = "sequence.cma"
+package "invert" (
+ version = "0.5.2"
+ description = "Simple sequence (iterator) datatype and combinators"
+ requires = "sequence delimcc"
+ archive(byte) = "invert.cma"
+ archive(byte, plugin) = "invert.cma"
+ archive(native) = "invert.cmxa"
+ archive(native, plugin) = "invert.cmxs"
+ exists_if = "invert.cma"
+)
+# OASIS_STOP
+

sequence/Makefile

@@ -0,0 +1,67 @@
+# OASIS_START
+# DO NOT EDIT (digest: a3c674b4239234cbbe53afe090018954)
+
+SETUP = ocaml setup.ml
+
+build: setup.data
+	$(SETUP) -build $(BUILDFLAGS)
+
+doc: setup.data build
+	$(SETUP) -doc $(DOCFLAGS)
+
+test: setup.data build
+	$(SETUP) -test $(TESTFLAGS)
+
+all:
+	$(SETUP) -all $(ALLFLAGS)
+
+install: setup.data
+	$(SETUP) -install $(INSTALLFLAGS)
+
+uninstall: setup.data
+	$(SETUP) -uninstall $(UNINSTALLFLAGS)
+
+reinstall: setup.data
+	$(SETUP) -reinstall $(REINSTALLFLAGS)
+
+clean:
+	$(SETUP) -clean $(CLEANFLAGS)
+
+distclean:
+	$(SETUP) -distclean $(DISTCLEANFLAGS)
+
+setup.data:
+	$(SETUP) -configure $(CONFIGUREFLAGS)
+
+configure:
+	$(SETUP) -configure $(CONFIGUREFLAGS)
+
+.PHONY: build doc test all install uninstall reinstall clean distclean configure
+
+# OASIS_STOP
+
+run-tests:
+	./run_tests.native
+
+examples:
+	ocamlbuild examples/test_sexpr.native
+
+push_doc: all doc
+	scp -r sequence.docdir/* cedeela.fr:~/simon/root/software/sequence/
+
+push_stable: all
+	git checkout stable
+	git merge master -m 'merge from master'
+	oasis setup
+	git commit -a -m 'oasis files'
+	git push origin
+	git checkout master
+
+VERSION=$(shell awk '/^Version:/ {print $$2}' _oasis)
+
+update_next_tag:
+	@echo "update version to $(VERSION)..."
+	sed -i "s/NEXT_VERSION/$(VERSION)/g" *.ml *.mli
+	sed -i "s/NEXT_RELEASE/$(VERSION)/g" *.ml *.mli
+
+.PHONY: benchs tests examples update_next_tag push_doc push_stable

sequence/README.md

@@ -0,0 +1,50 @@
+Sequence
+========
+
+Simple sequence abstract datatype, intended to transfer a finite number of
+elements from one data structure to another. Some transformations on sequences,
+like `filter`, `map`, `take`, `drop` and `append` can be performed before the
+sequence is iterated/folded on.
+
+Sequence is not designed to be as general-purpose or flexible as, say,
+Batteries' `Enum.t`. Rather, it aims at providing a very simple and efficient
+way of iterating on a finite number of values, only allocating (most of the time)
+one intermediate closure to do so. For instance, iterating on keys, or values,
+of a `Hashtbl.t`, without creating a list.
+
+Documentation
+=============
+
+See [the online API](http://cedeela.fr/~simon/software/sequence/Sequence.html).
+
+Build
+=====
+
+1. via opam `opam install sequence`
+2. manually (need OCaml >= 3.12): `make all install`
+
+If you have `OUnit` installed, you can build and run tests with
+
+    $ make tests
+    $ ./run_tests.native
+
+If you have `Bench` installed, you can build and run benchmarks with
+
+    $ make benchs
+    $ ./benchs.native
+
+To see how to use the library, check the `examples` directory.
+`tests.ml` has a few examples of how to convert basic data structures into
+sequences, and conversely.
+
+Examples
+========
+
+The module `examples/sexpr.mli` exposes the interface of the S-expression
+example library. It requires OCaml>=4.0 to compile, because of the GADT
+structure used in the monadic parser combinators part of `examples/sexpr.ml`.
+
+License
+=======
+
+Sequence is available under the BSD license.

sequence/_oasis

@@ -0,0 +1,88 @@
+OASISFormat: 0.4
+Name:        sequence
+Version:     0.5.2
+Homepage:    https://github.com/c-cube/sequence
+Authors:     Simon Cruanes
+License:     BSD-2-clause
+LicenseFile: LICENSE
+Plugins:     META (0.3), DevFiles (0.3)
+BuildTools:  ocamlbuild
+
+Synopsis:    Simple sequence (iterator) datatype and combinators
+Description:
+    Simple sequence datatype, intended to transfer a finite number of
+    elements from one data structure to another. Some transformations on sequences,
+    like `filter`, `map`, `take`, `drop` and `append` can be performed before the
+    sequence is iterated/folded on.
+
+Flag bench
+    Description: enable benchmarks (require library Benchmark)
+    Default: false
+
+Flag invert
+    Description: build sequence.invert (requires Delimcc)
+    Default: false
+
+Library "sequence"
+  Path:             .
+  Modules:          Sequence
+
+Library "invert"
+  Path:             invert
+  Build$:           flag(invert)
+  Install$:         flag(invert)
+  Modules:          SequenceInvert
+  FindlibName:      invert
+  FindlibParent:    sequence
+  BuildDepends:     sequence,delimcc
+
+Document sequence
+  Title:                Sequence docs
+  Type:                 ocamlbuild (0.3)
+  BuildTools+:          ocamldoc
+  Install:              true
+  XOCamlbuildPath:      .
+  XOCamlbuildLibraries: sequence
+
+Test all
+  Type:         custom
+  Command:      make run-tests
+  TestTools:    run_tests
+  Run$:         flag(tests)
+
+Executable run_tests
+  Path:             tests/
+  Install:          false
+  CompiledObject:   native
+  MainIs:           run_tests.ml
+  Build$:           flag(tests)
+  BuildDepends:     sequence,oUnit
+
+Executable benchs
+  Path:             bench
+  Install:          false
+  CompiledObject:   native
+  Build$:           flag(bench)
+  BuildDepends:     sequence,benchmark
+  MainIs:           benchs.ml
+
+Executable bench_persistent
+  Path:             bench
+  Install:          false
+  CompiledObject:   native
+  Build$:           flag(bench)
+  BuildDepends:     sequence,benchmark
+  MainIs:           bench_persistent.ml
+
+Executable bench_persistent_read
+  Path:             bench
+  Install:          false
+  CompiledObject:   native
+  Build$:           flag(bench)
+  BuildDepends:     sequence,benchmark
+  MainIs:           bench_persistent_read.ml
+
+SourceRepository head
+  Type: git
+  Location: https://github.com/c-cube/sequence
+  Browser: https://github.com/c-cube/sequence/tree/master/src

sequence/_tags

@@ -0,0 +1,39 @@
+# OASIS_START
+# DO NOT EDIT (digest: e8d5fe31ff471d3c0ec54943fe50d011)
+# Ignore VCS directories, you can use the same kind of rule outside
+# OASIS_START/STOP if you want to exclude directories that contains
+# useless stuff for the build process
+<**/.svn>: -traverse
+<**/.svn>: not_hygienic
+".bzr": -traverse
+".bzr": not_hygienic
+".hg": -traverse
+".hg": not_hygienic
+".git": -traverse
+".git": not_hygienic
+"_darcs": -traverse
+"_darcs": not_hygienic
+# Library sequence
+"sequence.cmxs": use_sequence
+# Library invert
+"invert/invert.cmxs": use_invert
+<invert/*.ml{,i}>: pkg_delimcc
+<invert/*.ml{,i}>: use_sequence
+# Executable run_tests
+"tests/run_tests.native": pkg_oUnit
+"tests/run_tests.native": use_sequence
+<tests/*.ml{,i}>: pkg_oUnit
+<tests/*.ml{,i}>: use_sequence
+# Executable benchs
+"bench/benchs.native": pkg_benchmark
+"bench/benchs.native": use_sequence
+# Executable bench_persistent
+"bench/bench_persistent.native": pkg_benchmark
+"bench/bench_persistent.native": use_sequence
+# Executable bench_persistent_read
+"bench/bench_persistent_read.native": pkg_benchmark
+"bench/bench_persistent_read.native": use_sequence
+<bench/*.ml{,i}>: pkg_benchmark
+<bench/*.ml{,i}>: use_sequence
+# OASIS_STOP
+true: bin_annot

sequence/bench/bench_persistent.ml

@@ -0,0 +1,128 @@
+module MList = struct
+  type 'a t = {
+    content : 'a array;   (* elements of the node *)
+    mutable len : int;    (* number of elements in content *)
+    mutable tl : 'a t;    (* tail *)
+  } (** A list that contains some elements, and may point to another list *)
+
+  let _empty () : 'a t = Obj.magic 0
+    (** Empty list, for the tl field *)
+
+  let make n =
+    assert (n > 0);
+    { content = Array.make n (Obj.magic 0);
+      len = 0;
+      tl = _empty ();
+    }
+
+  let rec is_empty l =
+    l.len = 0 && (l.tl == _empty () || is_empty l.tl)
+
+  let rec iter f l =
+    for i = 0 to l.len - 1 do f l.content.(i); done;
+    if l.tl != _empty () then iter f l.tl
+
+  let iteri f l =
+    let rec iteri i f l =
+      for j = 0 to l.len - 1 do f (i+j) l.content.(j); done;
+      if l.tl != _empty () then iteri (i+l.len) f l.tl
+    in iteri 0 f l
+
+  let rec iter_rev f l =
+    (if l.tl != _empty () then iter_rev f l.tl);
+    for i = l.len - 1 downto 0 do f l.content.(i); done
+
+  let length l =
+    let rec len acc l =
+      if l.tl == _empty () then acc+l.len else len (acc+l.len) l.tl
+    in len 0 l
+
+  (** Get element by index *)
+  let rec get l i =
+    if i < l.len then l.content.(i)
+    else if i >= l.len && l.tl == _empty () then raise (Invalid_argument "MList.get")
+    else get l.tl (i - l.len)
+
+  (** Push [x] at the end of the list. It returns the block in which the
+      element is inserted. *)
+  let rec push x l =
+    if l.len = Array.length l.content
+      then begin (* insert in the next block *)
+        (if l.tl == _empty () then
+          let n = Array.length l.content in
+          l.tl <- make (n + n lsr 1));
+        push x l.tl
+      end else begin  (* insert in l *)
+        l.content.(l.len) <- x;
+        l.len <- l.len + 1;
+        l
+      end
+
+  (** Reverse list (in place), and returns the new head *)
+  let rev l =
+    let rec rev prev l =
+      (* reverse array *)
+      for i = 0 to (l.len-1) / 2 do
+        let x = l.content.(i) in
+        l.content.(i) <- l.content.(l.len - i - 1);
+        l.content.(l.len - i - 1) <- x;
+      done;
+      (* reverse next block *)
+      let l' = l.tl in
+      l.tl <- prev;
+      if l' == _empty () then l else rev l l'
+    in
+    rev (_empty ()) l
+
+  (** Build a MList of elements of the Seq. The optional argument indicates
+      the size of the blocks *)
+  let of_seq ?(size=8) seq =
+    (* read sequence into a MList.t *)
+    let start = make size in
+    let l = ref start in
+    seq (fun x -> l := push x !l);
+    start
+
+  let to_seq l =
+    fun k -> iter k l
+end
+
+(** Store content of the seqerator in an enum *)
+let persistent_mlist seq =
+  let l = MList.of_seq seq in
+  MList.to_seq l
+
+let bench_mlist n =
+  for i = 0 to 100 do
+    let _ = persistent_mlist Sequence.(1 -- n) in
+    ()
+  done
+
+let bench_naive n =
+  for i = 0 to 100 do
+    let l = Sequence.to_rev_list Sequence.(1 -- n) in
+    let _ = Sequence.of_list (List.rev l) in
+    ()
+  done
+
+let bench_current n =
+  for i = 0 to 100 do
+    let _ = Sequence.persistent Sequence.(1 -- n) in
+    ()
+  done
+
+let () =
+  let bench_n n = 
+    Printf.printf "BENCH for %d\n" n;
+    let res = Benchmark.throughputN 5
+      [ "mlist", bench_mlist, n
+      ; "naive", bench_naive, n
+      ; "current", bench_current, n
+      ]
+    in Benchmark.tabulate res
+  in
+  bench_n 100;
+  bench_n 100_000;
+  ()
+
+(* vim:Use benchmark: *)

sequence/bench/bench_persistent_read.ml

@@ -0,0 +1,139 @@
+module MList = struct
+  type 'a t = {
+    content : 'a array;   (* elements of the node *)
+    mutable len : int;    (* number of elements in content *)
+    mutable tl : 'a t;    (* tail *)
+  } (** A list that contains some elements, and may point to another list *)
+
+  let _empty () : 'a t = Obj.magic 0
+    (** Empty list, for the tl field *)
+
+  let make n =
+    assert (n > 0);
+    { content = Array.make n (Obj.magic 0);
+      len = 0;
+      tl = _empty ();
+    }
+
+  let rec is_empty l =
+    l.len = 0 && (l.tl == _empty () || is_empty l.tl)
+
+  let rec iter f l =
+    for i = 0 to l.len - 1 do f l.content.(i); done;
+    if l.tl != _empty () then iter f l.tl
+
+  let iteri f l =
+    let rec iteri i f l =
+      for j = 0 to l.len - 1 do f (i+j) l.content.(j); done;
+      if l.tl != _empty () then iteri (i+l.len) f l.tl
+    in iteri 0 f l
+
+  let rec iter_rev f l =
+    (if l.tl != _empty () then iter_rev f l.tl);
+    for i = l.len - 1 downto 0 do f l.content.(i); done
+
+  let length l =
+    let rec len acc l =
+      if l.tl == _empty () then acc+l.len else len (acc+l.len) l.tl
+    in len 0 l
+
+  (** Get element by index *)
+  let rec get l i =
+    if i < l.len then l.content.(i)
+    else if i >= l.len && l.tl == _empty () then raise (Invalid_argument "MList.get")
+    else get l.tl (i - l.len)
+
+  (** Push [x] at the end of the list. It returns the block in which the
+      element is inserted. *)
+  let rec push x l =
+    if l.len = Array.length l.content
+      then begin (* insert in the next block *)
+        (if l.tl == _empty () then
+          let n = Array.length l.content in
+          l.tl <- make (n + n lsr 1));
+        push x l.tl
+      end else begin  (* insert in l *)
+        l.content.(l.len) <- x;
+        l.len <- l.len + 1;
+        l
+      end
+
+  (** Reverse list (in place), and returns the new head *)
+  let rev l =
+    let rec rev prev l =
+      (* reverse array *)
+      for i = 0 to (l.len-1) / 2 do
+        let x = l.content.(i) in
+        l.content.(i) <- l.content.(l.len - i - 1);
+        l.content.(l.len - i - 1) <- x;
+      done;
+      (* reverse next block *)
+      let l' = l.tl in
+      l.tl <- prev;
+      if l' == _empty () then l else rev l l'
+    in
+    rev (_empty ()) l
+
+  (** Build a MList of elements of the Seq. The optional argument indicates
+      the size of the blocks *)
+  let of_seq ?(size=8) seq =
+    (* read sequence into a MList.t *)
+    let start = make size in
+    let l = ref start in
+    seq (fun x -> l := push x !l);
+    start
+
+  let to_seq l =
+    fun k -> iter k l
+end
+
+(** Store content of the seqerator in an enum *)
+let persistent_mlist seq =
+  let l = MList.of_seq seq in
+  MList.to_seq l
+
+let bench_mlist n =
+  persistent_mlist Sequence.(1 -- n)
+
+let bench_list n =
+  let l = Sequence.to_rev_list Sequence.(1 -- n) in
+  Sequence.of_list (List.rev l)
+
+let bench_naive n =
+  let s = Sequence.(1 -- n) in
+  Sequence.iter ignore s ;
+  s
+
+let bench_current n =
+  Sequence.persistent Sequence.(1 -- n)
+
+let bench_array n =
+  let a = Sequence.to_array Sequence.(1 -- n) in
+  Sequence.of_array a
+
+let read s =
+  Sequence.map (fun x -> x + 1) s
+
+let () =
+  let bench_n n =
+    Printf.printf "BENCH for %d\n" n;
+    let res =
+      let mlist = bench_mlist n in
+      let list = bench_list n in
+      let current = bench_current n in
+      let array = bench_current n in
+      let naive = bench_naive n in
+      Benchmark.throughputN 5
+        [ "mlist",   read, mlist
+        ; "list",    read, list
+        ; "current", read, current
+        ; "array",   read, array
+        ; "naive",   read, naive
+        ]
+    in Benchmark.tabulate res
+  in
+  bench_n 100;
+  bench_n 100_000;
+  ()
+
+(* vim:Use benchmark: *)

sequence/bench/benchs.ml

@@ -0,0 +1,34 @@
+
+module S = Sequence
+open Sequence.Infix
+
+let small = [10;20;50;100;500]
+let medium = small @ [1000;10_000;100_000]
+let big = medium @ [500_000; 1_000_000; 2_000_000]
+
+let bench_fold n =
+  0 -- n |> S.fold (+) 0 |> ignore
+
+let bench_flatmap n =
+  0 -- n |> S.flatMap (fun i -> i -- (i+5)) |> (fun _ -> ())
+
+let bench_product n =
+  S.product (0 -- n) (0 -- n) (fun (i,j) -> ())
+
+let _ =
+  List.iter
+    (fun (name,bench,sizes) ->
+      Format.printf "-------------------------------------------------------@.";
+      Format.printf "bench %s@." name;
+      List.iter
+        (fun n ->
+          let name = name ^ " on " ^ string_of_int n in
+          let res = Benchmark.throughput1 2 ~name bench n in
+          Benchmark.tabulate res;
+        ) sizes
+    )
+    [ "fold", bench_fold, big
+    ; "flatmap", bench_flatmap, medium
+    ; "product", bench_product, small
+    ];
+  ()

sequence/bench/simple_bench.ml

@@ -0,0 +1,11 @@
+
+open Sequence.Infix
+
+let _ =
+  let n = int_of_string Sys.argv.(1) in
+  let seq = 0 -- n in
+  let start = Unix.gettimeofday () in
+  seq |> Sequence.persistent |> Sequence.fold (+) 0 |> ignore;
+  let stop = Unix.gettimeofday () in
+  Format.printf "iter on %d: %.4f@." n (stop -. start);
+  ()

sequence/configure

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+# OASIS_START
+# DO NOT EDIT (digest: dc86c2ad450f91ca10c931b6045d0499)
+set -e
+
+FST=true
+for i in "$@"; do
+  if $FST; then
+    set --
+    FST=false
+  fi
+
+  case $i in
+    --*=*)
+      ARG=${i%%=*}
+      VAL=${i##*=}
+      set -- "$@" "$ARG" "$VAL"
+      ;;
+    *)
+      set -- "$@" "$i"
+      ;;
+  esac
+done
+
+ocaml setup.ml -configure "$@"
+# OASIS_STOP

sequence/examples/sexpr.ml

@@ -0,0 +1,305 @@
+(*
+Zipperposition: a functional superposition prover for prototyping
+Copyright (C) 2012 Simon Cruanes
+
+This is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+*)
+
+(* {1 Basic S-expressions, with printing and parsing} *)
+
+(** S-expression *)
+type t =
+  | Atom of string  (** An atom *)
+  | List of t list  (** A list of S-expressions *)
+
+(** Token that compose a Sexpr once serialized *)
+type token = [`Open | `Close | `Atom of string]
+
+(** {2 Traverse a sequence of tokens} *)
+
+(** Iterate on the S-expression, calling the callback with tokens *)
+let rec iter f s = match s with
+  | Atom a -> f (`Atom a)
+  | List l -> f `Open; iter_list f l; f `Close
+and iter_list f l = match l with
+  | [] -> ()
+  | x::l' -> iter f x; iter_list f l'
+
+(** Traverse. This yields a sequence of tokens *)
+let traverse s = Sequence.from_iter (fun k -> iter k s)
+
+(** Returns the same sequence of tokens, but during iteration, if
+    the structure of the Sexpr corresponding to the sequence
+    is wrong (bad parenthesing), Invalid_argument is raised
+    and iteration is stoped *)
+let validate seq =
+  let depth = ref 0 in
+  Sequence.map
+    (fun tok -> match tok with
+     | `Open -> incr depth; tok
+     | `Close -> if !depth = 0
+      then raise (Invalid_argument "wrong parenthesing")
+      else decr depth; tok
+     | _ -> tok)
+    seq
+
+(** {2 Text <-> tokens} *)
+
+(** Lex: create a sequence of tokens from the given in_channel. *)
+let lex input =
+  let seq_fun k =
+    let in_word = ref false in
+    let buf = Buffer.create 128 in
+    (* loop. TODO handle escaping of (), and "" *)
+    let rec next c =
+      match c with
+      | '(' -> k `Open
+      | ')' -> flush_word(); k `Close
+      | ' ' | '\t' | '\n' -> flush_word ()
+      | c -> in_word := true; Buffer.add_char buf c
+    (* finish the previous word token *)
+    and flush_word () =
+      if !in_word then begin
+        (* this whitespace follows a word *)
+        let word = Buffer.contents buf in
+        Buffer.clear buf;
+        in_word := false;
+        k (`Atom word)
+      end
+    in
+    Sequence.iter next input
+  in 
+  Sequence.from_iter seq_fun
+
+(** Build a Sexpr from a sequence of tokens *)
+let of_seq seq =
+  (* called on every token *)
+  let rec k stack token = match token with
+    | `Open -> `Open :: stack
+    | `Close -> collapse [] stack
+    | `Atom a -> (`Expr (Atom a)) :: stack
+  (* collapse last list into an `Expr *)
+  and collapse acc stack = match stack with
+  | `Open::stack' -> `Expr (List acc) :: stack'
+  | `Expr a::stack' -> collapse (a :: acc) stack'
+  | _ -> assert false
+  in
+  (* iterate on the sequence, given an empty initial stack *)
+  let stack = Sequence.fold k [] seq in
+  (* stack should contain exactly one expression *)
+  match stack with
+  | [`Expr expr] -> expr
+  | [] -> failwith "no Sexpr could be parsed"
+  | _ -> failwith "too many elements on the stack"
+
+(** {2 Printing} *)
+
+(** Print a token on the given formatter *)
+let pp_token formatter token = match token with
+  | `Open -> Format.fprintf formatter "@[("
+  | `Close -> Format.fprintf formatter ")@]"
+  | `Atom s -> Format.pp_print_string formatter s
+
+(** Print a sequence of Sexpr tokens on the given formatter *)
+let pp_tokens formatter tokens =
+  let first = ref true in
+  let last = ref false in
+  Sequence.iter
+    (fun token ->
+      (match token with
+      | `Open -> (if not !first then Format.fprintf formatter " "); first := true
+      | `Close -> first := false; last := true
+      | _ -> if !first then first := false else Format.fprintf formatter " ");
+      pp_token formatter token;
+      if !last then last := false)
+    tokens
+
+(** Pretty-print the S-expr. If [indent] is true, the S-expression
+    is printed with indentation. *)
+let pp_sexpr ?(indent=false) formatter s =
+  if indent
+    then Format.fprintf formatter "@[<hov 4>%a@]" pp_tokens (traverse s)
+    else pp_tokens formatter (traverse s)
+
+(** {2 Serializing} *)
+
+let output_seq name subexpr k =
+  k `Open;
+  k (`Atom name);
+  Sequence.iter k subexpr;
+  k `Close
+
+let output_str name str k =
+  k `Open;
+  k (`Atom name);
+  k (`Atom str);
+  k `Close
+
+(** {2 Parsing} *)
+
+(** Monadic combinators for parsing data from a sequence of tokens,
+    without converting to concrete S-expressions.
+
+    The [one] parser can raise ParseFailure if it fails to parse
+    the atomic type. *)
+
+(** parser that returns a 'a *)
+type 'a parser =
+  | Return : 'a -> 'a parser
+  | One : (token -> 'a) -> 'a parser
+  | Zero : (token -> 'a parser) -> 'a parser
+  (* | Maybe of (token -> 'a option) *)
+  | Bind : ('b parser * ('b -> 'a parser)) -> 'a parser
+  | Fail : string -> 'a parser
+
+exception ParseFailure of string
+
+let (>>=) p f = Bind (p, f)
+
+let (>>) p p' = p >>= fun _ -> p'
+
+let return x = Return x
+
+let fail reason = Fail reason
+
+let one f = One f
+
+let skip = One (fun _ -> ())
+
+let lookahead f = Zero f
+
+let left = One (function | `Open -> ()
+                         | _ -> raise (ParseFailure "expected '('"))
+
+let right = One (function | `Close -> ()
+                          | _ -> raise (ParseFailure "expected ')'"))
+
+let pair f g =
+  f >>= fun x ->
+  g >>= fun y ->
+  return (x, y)
+
+let triple f g h =
+  f >>= fun x ->
+  g >>= fun y ->
+  h >>= fun z ->
+  return (x, y, z)
+
+(** [(name,p) ^|| p'] behaves as p if the next token is [`Atom name], and
+    like [p'] otherwise *)
+let (^||) (name,p) p' =
+  lookahead
+    (fun token -> match token with
+    | `Atom s when s = name -> skip >> p ()
+    | _ -> p')
+
+(** Maps the value returned by the parser *)
+let map p f = p >>= fun x -> return (f x)
+
+let p_str = one
+  (function | `Atom s -> s | _ -> raise (ParseFailure "expected string"))
+
+let p_int = one
+  (function | `Atom s -> (try int_of_string s
+                          with Failure _ -> raise (ParseFailure "expected int"))
+              | _ -> raise (ParseFailure "expected int"))
+
+let p_bool = one
+  (function | `Atom s -> (try bool_of_string s
+                          with Failure _ -> raise (ParseFailure "expected bool"))
+              | _ -> raise (ParseFailure "expected bool"))
+
+let p_float = one
+  (function | `Atom s -> (try float_of_string s
+                          with Failure _ -> raise (ParseFailure "expected float"))
+              | _ -> raise (ParseFailure "expected float"))
+
+let many p =
+  let rec elements token =
+    match token with
+    | `Close -> return []
+    | _ ->
+      p >>= fun x ->
+      lookahead elements >>= fun l ->
+      return (x :: l)
+  in
+  left >> lookahead elements >>= fun l -> right >> return l
+
+let many1 p =
+  p >>= fun x ->
+  many p >>= fun l ->
+  return (x::l)
+
+(** parsing state that returns a 'a *)
+type 'a state =
+  | Bottom : 'a state
+  | Push : ('b parser * ('b -> 'a state)) -> 'a state
+
+(** Actually parse the sequence of tokens, with a callback to be called
+    on every parsed value. The callback decides whether to push another
+    state or whether to continue. *)
+let parse_k p tokens k =
+  let rec state = Push(p, fun x -> match k x with `Stop -> Bottom | `Continue -> state) in
+  (* Token handler. It also takes the current parser. *)
+  let rec one_step state token =
+    match reduce state with
+    | Bottom ->  (* should not happen, unless there are too many tokens *)
+      raise (ParseFailure "unexpected ')'")
+    | Push (Return _, cont) ->
+      assert false (* should be reduced *)
+    | Push (Zero f, cont) ->
+      let p' = f token in
+      let state' = Push (p', cont) in
+      one_step state' token  (* do not consume token *)
+    | Push (One f, cont) ->
+      let x = f token in
+      let state' = cont x in
+      reduce state'  (* consume token *)
+    (* | Maybe f, _ -> let x = f token in (Obj.magic cont) x *)
+    | Push (Bind (p', cont'), cont) ->
+      let cont'' x =
+        let p'' = cont' x in
+        Push (p'', cont)
+      in
+      let state' = Push (p', cont'') in
+      one_step state' token  (* do not consume token *)
+    | Push (Fail reason, _) -> raise (ParseFailure reason)
+  (* Reduce parser state *)
+  and reduce state = match state with
+    | Push (Return x, cont) ->
+      let state' = cont x in
+      reduce state'
+    | _ -> state
+  in
+  (* iterate on the tokens *)
+  ignore (Sequence.fold one_step state tokens)
+
+(** Parse one value *)
+let parse p tokens =
+  let res = ref None in
+  parse_k p tokens (fun x -> res := Some x; `Stop);
+  (* return result *)
+  match !res with
+  | None -> raise (ParseFailure "incomplete input")
+  | Some x -> x
+
+(** Parse a sequence of values *)
+let parse_seq p tokens =
+  let seq_fun k =
+    parse_k p tokens (fun x -> k x; `Continue)
+  in
+  Sequence.from_iter seq_fun
+

sequence/examples/sexpr.mli

@@ -0,0 +1,132 @@
+(*
+Zipperposition: a functional superposition prover for prototyping
+Copyright (C) 2012 Simon Cruanes
+
+This is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+*)
+
+(* {1 Basic S-expressions, with printing and parsing} *)
+
+type t =
+  | Atom of string  (** An atom *)
+  | List of t list  (** A list of S-expressions *)
+  (** S-expression *)
+
+type token = [`Open | `Close | `Atom of string]
+  (** Token that compose a Sexpr once serialized *)
+
+(** {2 Traverse a sequence of tokens} *)
+
+val iter : (token -> unit) -> t -> unit
+  (** Iterate on the S-expression, calling the callback with tokens *)
+
+val traverse : t -> token Sequence.t
+  (** Traverse. This yields a sequence of tokens *)
+
+val validate : token Sequence.t -> token Sequence.t
+  (** Returns the same sequence of tokens, but during iteration, if
+      the structure of the Sexpr corresponding to the sequence
+      is wrong (bad parenthesing), Invalid_argument is raised
+      and iteration is stoped *)
+
+(** {2 Text <-> tokens} *)
+
+val lex : char Sequence.t -> token Sequence.t
+  (** Lex: create a sequence of tokens from the given sequence of chars. *)
+
+val of_seq : token Sequence.t -> t
+  (** Build a Sexpr from a sequence of tokens, or raise Failure *)
+
+(** {2 Printing} *)
+
+val pp_token : Format.formatter -> token -> unit
+  (** Print a token on the given formatter *)
+
+val pp_tokens : Format.formatter -> token Sequence.t -> unit
+  (** Print a sequence of Sexpr tokens on the given formatter *)
+
+val pp_sexpr : ?indent:bool -> Format.formatter -> t -> unit
+  (** Pretty-print the S-expr. If [indent] is true, the S-expression
+      is printed with indentation. *)
+
+(** {2 Serializing} *)
+
+val output_seq : string -> token Sequence.t -> (token -> unit) -> unit
+  (** print a pair "(name @,sequence)" *)
+
+val output_str : string -> string -> (token -> unit) -> unit
+  (** print a pair "(name str)" *)
+
+(** {2 Parsing} *)
+
+(** Monadic combinators for parsing data from a sequence of tokens,
+    without converting to concrete S-expressions. *)
+
+type 'a parser
+
+exception ParseFailure of string
+
+val (>>=) : 'a parser -> ('a -> 'b parser) -> 'b parser
+  (** Monadic bind: computes a parser from the result of
+      the first parser *)
+
+val (>>) : 'a parser -> 'b parser -> 'b parser
+  (** Like (>>=), but ignores the result of the first parser *)
+
+val return : 'a -> 'a parser
+  (** Parser that consumes no input and return the given value *)
+
+val fail : string -> 'a parser
+  (** Fails parsing with the given message *)
+
+val one : (token -> 'a) -> 'a parser
+  (** consumes one token with the function *)
+
+val skip : unit parser
+  (** Skip the token *)
+
+val lookahead : (token -> 'a parser) -> 'a parser
+  (** choose parser given current token *)
+
+val left : unit parser
+  (** Parses a `Open *)
+
+val right : unit parser
+  (** Parses a `Close *)
+
+val pair : 'a parser -> 'b parser -> ('a * 'b) parser
+val triple : 'a parser -> 'b parser -> 'c parser -> ('a * 'b * 'c) parser
+
+val (^||) : (string * (unit -> 'a parser)) -> 'a parser -> 'a parser
+  (** [(name,p) ^|| p'] behaves as [p ()] if the next token is [`Atom name], and
+      like [p'] otherwise *)
+
+val map : 'a parser -> ('a -> 'b) -> 'b parser
+  (** Maps the value returned by the parser *)
+
+val p_str : string parser
+val p_int : int parser
+val p_bool : bool parser
+
+val many : 'a parser -> 'a list parser
+val many1 : 'a parser -> 'a list parser
+
+val parse : 'a parser -> token Sequence.t -> 'a
+  (** Parses exactly one value from the sequence of tokens. Raises
+      ParseFailure if anything goes wrong. *)
+
+val parse_seq : 'a parser -> token Sequence.t -> 'a Sequence.t
+  (** Parses a sequence of values *)

sequence/examples/test_sexpr.ml

@@ -0,0 +1,131 @@
+
+(** {2 Test sequences} *)
+
+(** print a list of items using the printing function *)
+let pp_list ?(sep=", ") pp_item formatter l = 
+  Sequence.pp_seq ~sep pp_item formatter (Sequence.of_list l)
+
+(** Set of integers *)
+module ISet = Set.Make(struct type t = int let compare = compare end)
+let iset = (module ISet : Set.S with type elt = int and type t = ISet.t)
+
+module OrderedString = struct type t = string let compare = compare end
+module SMap = Sequence.Map.Make(OrderedString)
+
+let my_map = SMap.of_seq (Sequence.of_list ["1", 1; "2", 2; "3", 3; "answer", 42])
+
+let sexpr = "(foo bar (bazz quux hello 42) world (zoo foo bar (1 2 (3 4))))"
+
+type term = | Lambda of term | Const of string | Var of int | Apply of term * term
+
+let random_term () =
+  let max = 10
+  and num = ref 0 in
+  let rec build depth =
+    if depth > 4 || !num > max then Const (random_const ()) else
+    match Random.int 6 with
+    | 0 -> if depth > 0 then Var (Random.int depth) else Const (random_const ())
+    | 1 -> incr num; Lambda (build (depth+1))
+    | 2 -> Const (random_const ())
+    | _ -> incr num; Apply ((build depth), (build depth))
+  and random_const () = [|"a"; "b"; "c"; "f"; "g"; "h"|].(Random.int 6)
+  in build 0
+
+let rec sexpr_of_term t =
+  let f t k = match t with
+    | Var i -> Sexpr.output_str "var" (string_of_int i) k
+    | Lambda t' -> Sexpr.output_seq "lambda" (sexpr_of_term t') k
+    | Apply (t1, t2) -> Sexpr.output_seq "apply" (Sequence.append (sexpr_of_term t1) (sexpr_of_term t2)) k
+    | Const s -> Sexpr.output_str "const" s k
+  in Sequence.from_iter (f t)
+
+let term_parser =
+  let open Sexpr in
+  let rec p_term () =
+    left >>
+    (("lambda", p_lambda) ^|| ("var", p_var) ^|| ("const", p_const) ^||
+      ("apply", p_apply) ^|| fail "bad term") >>= fun x ->
+    right >> return x
+  and p_apply () =
+    p_term () >>= fun x ->
+    p_term () >>= fun y ->
+    return (Apply (x,y))
+  and p_var () = p_int >>= fun i -> return (Var i)
+  and p_const () = p_str >>= fun s -> return (Const s)
+  and p_lambda () = p_term () >>= fun t -> return (Lambda t)
+  in p_term ()
+
+let term_of_sexp seq = Sexpr.parse term_parser seq
+
+let test_term () =
+  let t = random_term () in
+  Format.printf "@[<h>random term: %a@]@." Sexpr.pp_tokens (sexpr_of_term t);
+  let tokens = sexpr_of_term t in
+  let t' = term_of_sexp tokens in
+  Format.printf "@[<h>parsed: %a@]@." Sexpr.pp_tokens (sexpr_of_term t');
+  ()
+
+let _ =
+  (* lists *)
+  let l = [0;1;2;3;4;5;6] in
+  let l' = Sequence.to_list
+    (Sequence.filter (fun x -> x mod 2 = 0) (Sequence.of_list l)) in
+  let l'' = Sequence.to_list
+    (Sequence.take 3 (Sequence.drop 1 (Sequence.of_list l))) in
+  let h = Hashtbl.create 3 in
+  for i = 0 to 5 do
+    Hashtbl.add h i (i*i);
+  done;
+  let l2 = Sequence.to_list
+    (Sequence.map (fun (x, y) -> (string_of_int x) ^ " -> " ^ (string_of_int y))
+      (Sequence.of_hashtbl h))
+  in
+  let l3 = Sequence.to_list (Sequence.rev (Sequence.int_range ~start:0 ~stop:42)) in
+  let set = List.fold_left (fun set x -> ISet.add x set) ISet.empty [4;3;100;42] in
+  let l4 = Sequence.to_list (Sequence.of_set iset set) in
+  Format.printf "l=@[<h>[%a]@]@." (pp_list Format.pp_print_int) l;
+  Format.printf "l'=@[<h>[%a]@]@." (pp_list Format.pp_print_int) l';
+  Format.printf "l''=@[<h>[%a]@]@." (pp_list Format.pp_print_int) l'';
+  Format.printf "l2=@[<h>[%a]@]@." (pp_list Format.pp_print_string) l2;
+  Format.printf "l3=@[<h>[%a]@]@." (pp_list Format.pp_print_int) l3;
+  Format.printf "s={@[<h>%a@]}@." (Sequence.pp_seq Format.pp_print_int) (Sequence.of_set iset set);
+  Format.printf "l4=@[<h>[%a]@]@." (pp_list Format.pp_print_int) l4;
+  Format.printf "l3[:5]+l4=@[<h>[%a]@]@." (Sequence.pp_seq Format.pp_print_int)
+    (Sequence.of_array
+      (Sequence.to_array (Sequence.append
+        (Sequence.take 5 (Sequence.of_list l3)) (Sequence.of_list l4))));
+  (* sequence, persistent, etc *)
+  let seq = Sequence.int_range ~start:0 ~stop:100000 in
+  let seq' = Sequence.persistent seq in
+  let stream = Sequence.to_stream seq' in
+  Format.printf "test length [0..100000]: persistent1 %d, stream %d, persistent2 %d"
+    (Sequence.length seq') (Sequence.length (Sequence.of_stream stream)) (Sequence.length seq');
+  (* maps *)
+  Format.printf "@[<h>map: %a@]@."
+    (Sequence.pp_seq (fun formatter (k,v) -> Format.fprintf formatter "\"%s\" -> %d" k v))
+    (SMap.to_seq my_map);
+  let module MyMapSeq = Sequence.Map.Adapt(Map.Make(OrderedString)) in
+  let my_map' = MyMapSeq.of_seq (Sequence.of_list ["1", 1; "2", 2; "3", 3; "answer", 42]) in
+  Format.printf "@[<h>map: %a@]@."
+    (Sequence.pp_seq (fun formatter (k,v) -> Format.fprintf formatter "\"%s\" -> %d" k v))
+    (MyMapSeq.to_seq my_map');
+  (* sum *)
+  let n = 1000000 in
+  let sum = Sequence.fold (+) 0 (Sequence.take n (Sequence.repeat 1)) in
+  Format.printf "%dx1 = %d@." n sum;
+  assert (n=sum);
+  (* sexpr *)
+  let s = Sexpr.of_seq (Sexpr.lex (Sequence.of_str sexpr)) in
+  let s = Sexpr.of_seq (Sequence.map
+    (function | `Atom s -> `Atom (String.capitalize s) | tok -> tok)
+    (Sexpr.traverse s))
+  in
+  Format.printf "@[<hov2>transform @[<h>%s@] into @[<h>%a@]@]@." sexpr (Sexpr.pp_sexpr ~indent:false) s;
+  Format.printf "@[<hv2> cycle:%a@]@." Sexpr.pp_tokens
+    (Sequence.concat (Sequence.take 10 (Sequence.repeat (Sexpr.traverse s))));
+  (* sexpr parsing/printing *)
+  for i = 0 to 20 do
+    Format.printf "%d-th term test@." i;
+    test_term ();
+  done;
+  ()

sequence/invert/.merlin

@@ -0,0 +1,2 @@
+REC
+PKG delimcc

sequence/invert/invert.mldylib

@@ -0,0 +1,4 @@
+# OASIS_START
+# DO NOT EDIT (digest: d74492d261fcc87665b60e0331c04236)
+SequenceInvert
+# OASIS_STOP

sequence/invert/invert.mllib

@@ -0,0 +1,4 @@
+# OASIS_START
+# DO NOT EDIT (digest: d74492d261fcc87665b60e0331c04236)
+SequenceInvert
+# OASIS_STOP

sequence/invert/sequenceInvert.ml

@@ -0,0 +1,62 @@
+(*
+Copyright (c) 2014, Simon Cruanes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.  Redistributions in binary
+form must reproduce the above copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other materials provided with
+the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*)
+
+(** {1 Interface to Delimcc (Invert control flow)} *)
+
+type 'a gen = unit -> 'a option
+
+type 'a res =
+  | Start
+  | Yield of 'a
+  | Stop
+
+let _ret_none () = None
+let _ret_unit () = ()
+
+let to_gen seq =
+  let p = Delimcc.new_prompt () in
+  let _next = ref None in
+  ignore (Delimcc.push_prompt p
+    (fun () ->
+      Delimcc.take_subcont p (fun c () -> _next := Some c; Start);
+      seq
+        (fun x ->
+          Delimcc.take_subcont p (fun c () -> _next := Some c; Yield x)
+        );
+      _next := None;
+      Stop
+    ));
+  (* call next subcont *)
+  let rec next () =
+    match !_next with
+    | None -> None
+    | Some f ->
+        begin match Delimcc.push_delim_subcont f _ret_unit with
+        | Start -> next ()
+        | Yield x -> Some x
+        | Stop -> None
+        end
+  in
+  next

sequence/invert/sequenceInvert.mli

@@ -0,0 +1,32 @@
+(*
+Copyright (c) 2014, Simon Cruanes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.  Redistributions in binary
+form must reproduce the above copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other materials provided with
+the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*)
+
+(** {1 Interface to Delimcc (Invert control flow)} *)
+
+type 'a gen = unit -> 'a option
+
+val to_gen : 'a Sequence.t -> 'a gen
+(** Use delimited continuations to iterate on the sequence step by step.
+    Relatively costly but still useful *)

sequence/myocamlbuild.ml

@@ -0,0 +1,610 @@
+(* OASIS_START *)
+(* DO NOT EDIT (digest: c4bb6d2ca42efb069d5612eb2bbcf244) *)
+module OASISGettext = struct
+(* # 22 "src/oasis/OASISGettext.ml" *)
+
+
+  let ns_ str =
+    str
+
+
+  let s_ str =
+    str
+
+
+  let f_ (str: ('a, 'b, 'c, 'd) format4) =
+    str
+
+
+  let fn_ fmt1 fmt2 n =
+    if n = 1 then
+      fmt1^^""
+    else
+      fmt2^^""
+
+
+  let init =
+    []
+
+
+end
+
+module OASISExpr = struct
+(* # 22 "src/oasis/OASISExpr.ml" *)
+
+
+
+
+
+  open OASISGettext
+
+
+  type test = string
+
+
+  type flag = string
+
+
+  type t =
+    | EBool of bool
+    | ENot of t
+    | EAnd of t * t
+    | EOr of t * t
+    | EFlag of flag
+    | ETest of test * string
+
+
+
+  type 'a choices = (t * 'a) list
+
+
+  let eval var_get t =
+    let rec eval' =
+      function
+        | EBool b ->
+            b
+
+        | ENot e ->
+            not (eval' e)
+
+        | EAnd (e1, e2) ->
+            (eval' e1) && (eval' e2)
+
+        | EOr (e1, e2) ->
+            (eval' e1) || (eval' e2)
+
+        | EFlag nm ->
+            let v =
+              var_get nm
+            in
+              assert(v = "true" || v = "false");
+              (v = "true")
+
+        | ETest (nm, vl) ->
+            let v =
+              var_get nm
+            in
+              (v = vl)
+    in
+      eval' t
+
+
+  let choose ?printer ?name var_get lst =
+    let rec choose_aux =
+      function
+        | (cond, vl) :: tl ->
+            if eval var_get cond then
+              vl
+            else
+              choose_aux tl
+        | [] ->
+            let str_lst =
+              if lst = [] then
+                s_ "<empty>"
+              else
+                String.concat
+                  (s_ ", ")
+                  (List.map
+                     (fun (cond, vl) ->
+                        match printer with
+                          | Some p -> p vl
+                          | None -> s_ "<no printer>")
+                     lst)
+            in
+              match name with
+                | Some nm ->
+                    failwith
+                      (Printf.sprintf
+                         (f_ "No result for the choice list '%s': %s")
+                         nm str_lst)
+                | None ->
+                    failwith
+                      (Printf.sprintf
+                         (f_ "No result for a choice list: %s")
+                         str_lst)
+    in
+      choose_aux (List.rev lst)
+
+
+end
+
+
+# 132 "myocamlbuild.ml"
+module BaseEnvLight = struct
+(* # 22 "src/base/BaseEnvLight.ml" *)
+
+
+  module MapString = Map.Make(String)
+
+
+  type t = string MapString.t
+
+
+  let default_filename =
+    Filename.concat
+      (Sys.getcwd ())
+      "setup.data"
+
+
+  let load ?(allow_empty=false) ?(filename=default_filename) () =
+    if Sys.file_exists filename then
+      begin
+        let chn =
+          open_in_bin filename
+        in
+        let st =
+          Stream.of_channel chn
+        in
+        let line =
+          ref 1
+        in
+        let st_line =
+          Stream.from
+            (fun _ ->
+               try
+                 match Stream.next st with
+                   | '\n' -> incr line; Some '\n'
+                   | c -> Some c
+               with Stream.Failure -> None)
+        in
+        let lexer =
+          Genlex.make_lexer ["="] st_line
+        in
+        let rec read_file mp =
+          match Stream.npeek 3 lexer with
+            | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] ->
+                Stream.junk lexer;
+                Stream.junk lexer;
+                Stream.junk lexer;
+                read_file (MapString.add nm value mp)
+            | [] ->
+                mp
+            | _ ->
+                failwith
+                  (Printf.sprintf
+                     "Malformed data file '%s' line %d"
+                     filename !line)
+        in
+        let mp =
+          read_file MapString.empty
+        in
+          close_in chn;
+          mp
+      end
+    else if allow_empty then
+      begin
+        MapString.empty
+      end
+    else
+      begin
+        failwith
+          (Printf.sprintf
+             "Unable to load environment, the file '%s' doesn't exist."
+             filename)
+      end
+
+
+  let rec var_expand str env =
+    let buff =
+      Buffer.create ((String.length str) * 2)
+    in
+      Buffer.add_substitute
+        buff
+        (fun var ->
+           try
+             var_expand (MapString.find var env) env
+           with Not_found ->
+             failwith
+               (Printf.sprintf
+                  "No variable %s defined when trying to expand %S."
+                  var
+                  str))
+        str;
+      Buffer.contents buff
+
+
+  let var_get name env =
+    var_expand (MapString.find name env) env
+
+
+  let var_choose lst env =
+    OASISExpr.choose
+      (fun nm -> var_get nm env)
+      lst
+end
+
+
+# 237 "myocamlbuild.ml"
+module MyOCamlbuildFindlib = struct
+(* # 22 "src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml" *)
+
+
+  (** OCamlbuild extension, copied from
+    * http://brion.inria.fr/gallium/index.php/Using_ocamlfind_with_ocamlbuild
+    * by N. Pouillard and others
+    *
+    * Updated on 2009/02/28
+    *
+    * Modified by Sylvain Le Gall
+    *)
+  open Ocamlbuild_plugin
+
+
+  (* these functions are not really officially exported *)
+  let run_and_read =
+    Ocamlbuild_pack.My_unix.run_and_read
+
+
+  let blank_sep_strings =
+    Ocamlbuild_pack.Lexers.blank_sep_strings
+
+
+  let exec_from_conf exec =
+    let exec =
+      let env_filename = Pathname.basename BaseEnvLight.default_filename in
+      let env = BaseEnvLight.load ~filename:env_filename ~allow_empty:true () in
+      try
+        BaseEnvLight.var_get exec env
+      with Not_found ->
+        Printf.eprintf "W: Cannot get variable %s\n" exec;
+        exec
+    in
+    let fix_win32 str =
+      if Sys.os_type = "Win32" then begin
+        let buff = Buffer.create (String.length str) in
+        (* Adapt for windowsi, ocamlbuild + win32 has a hard time to handle '\\'.
+         *)
+        String.iter
+          (fun c -> Buffer.add_char buff (if c = '\\' then '/' else c))
+          str;
+        Buffer.contents buff
+      end else begin
+        str
+      end
+    in
+      fix_win32 exec
+
+  let split s ch =
+    let buf = Buffer.create 13 in
+    let x = ref [] in
+    let flush () =
+      x := (Buffer.contents buf) :: !x;
+      Buffer.clear buf
+    in
+      String.iter
+        (fun c ->
+           if c = ch then
+             flush ()
+           else
+             Buffer.add_char buf c)
+        s;
+      flush ();
+      List.rev !x
+
+
+  let split_nl s = split s '\n'
+
+
+  let before_space s =
+    try
+      String.before s (String.index s ' ')
+    with Not_found -> s
+
+  (* ocamlfind command *)
+  let ocamlfind x = S[Sh (exec_from_conf "ocamlfind"); x]
+
+  (* This lists all supported packages. *)
+  let find_packages () =
+    List.map before_space (split_nl & run_and_read "ocamlfind list")
+
+
+  (* Mock to list available syntaxes. *)
+  let find_syntaxes () = ["camlp4o"; "camlp4r"]
+
+
+  let well_known_syntax = [
+    "camlp4.quotations.o";
+    "camlp4.quotations.r";
+    "camlp4.exceptiontracer";
+    "camlp4.extend";
+    "camlp4.foldgenerator";
+    "camlp4.listcomprehension";
+    "camlp4.locationstripper";
+    "camlp4.macro";
+    "camlp4.mapgenerator";
+    "camlp4.metagenerator";
+    "camlp4.profiler";
+    "camlp4.tracer"
+  ]
+
+
+  let dispatch =
+    function
+      | After_options ->
+          (* By using Before_options one let command line options have an higher
+           * priority on the contrary using After_options will guarantee to have
+           * the higher priority override default commands by ocamlfind ones *)
+          Options.ocamlc     := ocamlfind & A"ocamlc";
+          Options.ocamlopt   := ocamlfind & A"ocamlopt";
+          Options.ocamldep   := ocamlfind & A"ocamldep";
+          Options.ocamldoc   := ocamlfind & A"ocamldoc";
+          Options.ocamlmktop := ocamlfind & A"ocamlmktop";
+          Options.ocamlmklib := ocamlfind & A"ocamlmklib"
+
+      | After_rules ->
+
+          (* When one link an OCaml library/binary/package, one should use
+           * -linkpkg *)
+          flag ["ocaml"; "link"; "program"] & A"-linkpkg";
+
+          (* For each ocamlfind package one inject the -package option when
+           * compiling, computing dependencies, generating documentation and
+           * linking. *)
+          List.iter
+            begin fun pkg ->
+              let base_args = [A"-package"; A pkg] in
+              (* TODO: consider how to really choose camlp4o or camlp4r. *)
+              let syn_args = [A"-syntax"; A "camlp4o"] in
+              let args =
+              (* Heuristic to identify syntax extensions: whether they end in
+                 ".syntax"; some might not.
+               *)
+                if Filename.check_suffix pkg "syntax" ||
+                   List.mem pkg well_known_syntax then
+                  syn_args @ base_args
+                else
+                  base_args
+              in
+              flag ["ocaml"; "compile";  "pkg_"^pkg] & S args;
+              flag ["ocaml"; "ocamldep"; "pkg_"^pkg] & S args;
+              flag ["ocaml"; "doc";      "pkg_"^pkg] & S args;
+              flag ["ocaml"; "link";     "pkg_"^pkg] & S base_args;
+              flag ["ocaml"; "infer_interface"; "pkg_"^pkg] & S args;
+            end
+            (find_packages ());
+
+          (* Like -package but for extensions syntax. Morover -syntax is useless
+           * when linking. *)
+          List.iter begin fun syntax ->
+          flag ["ocaml"; "compile";  "syntax_"^syntax] & S[A"-syntax"; A syntax];
+          flag ["ocaml"; "ocamldep"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
+          flag ["ocaml"; "doc";      "syntax_"^syntax] & S[A"-syntax"; A syntax];
+          flag ["ocaml"; "infer_interface"; "syntax_"^syntax] &
+                S[A"-syntax"; A syntax];
+          end (find_syntaxes ());
+
+          (* The default "thread" tag is not compatible with ocamlfind.
+           * Indeed, the default rules add the "threads.cma" or "threads.cmxa"
+           * options when using this tag. When using the "-linkpkg" option with
+           * ocamlfind, this module will then be added twice on the command line.
+           *
+           * To solve this, one approach is to add the "-thread" option when using
+           * the "threads" package using the previous plugin.
+           *)
+          flag ["ocaml"; "pkg_threads"; "compile"] (S[A "-thread"]);
+          flag ["ocaml"; "pkg_threads"; "doc"] (S[A "-I"; A "+threads"]);
+          flag ["ocaml"; "pkg_threads"; "link"] (S[A "-thread"]);
+          flag ["ocaml"; "pkg_threads"; "infer_interface"] (S[A "-thread"]);
+          flag ["ocaml"; "package(threads)"; "compile"] (S[A "-thread"]);
+          flag ["ocaml"; "package(threads)"; "doc"] (S[A "-I"; A "+threads"]);
+          flag ["ocaml"; "package(threads)"; "link"] (S[A "-thread"]);
+          flag ["ocaml"; "package(threads)"; "infer_interface"] (S[A "-thread"]);
+
+      | _ ->
+          ()
+end
+
+module MyOCamlbuildBase = struct
+(* # 22 "src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *)
+
+
+  (** Base functions for writing myocamlbuild.ml
+      @author Sylvain Le Gall
+    *)
+
+
+
+
+
+  open Ocamlbuild_plugin
+  module OC = Ocamlbuild_pack.Ocaml_compiler
+
+
+  type dir = string
+  type file = string
+  type name = string
+  type tag = string
+
+
+(* # 62 "src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *)
+
+
+  type t =
+      {
+        lib_ocaml: (name * dir list * string list) list;
+        lib_c:     (name * dir * file list) list;
+        flags:     (tag list * (spec OASISExpr.choices)) list;
+        (* Replace the 'dir: include' from _tags by a precise interdepends in
+         * directory.
+         *)
+        includes:  (dir * dir list) list;
+      }
+
+
+  let env_filename =
+    Pathname.basename
+      BaseEnvLight.default_filename
+
+
+  let dispatch_combine lst =
+    fun e ->
+      List.iter
+        (fun dispatch -> dispatch e)
+        lst
+
+
+  let tag_libstubs nm =
+    "use_lib"^nm^"_stubs"
+
+
+  let nm_libstubs nm =
+    nm^"_stubs"
+
+
+  let dispatch t e =
+    let env =
+      BaseEnvLight.load
+        ~filename:env_filename
+        ~allow_empty:true
+        ()
+    in
+      match e with
+        | Before_options ->
+            let no_trailing_dot s =
+              if String.length s >= 1 && s.[0] = '.' then
+                String.sub s 1 ((String.length s) - 1)
+              else
+                s
+            in
+              List.iter
+                (fun (opt, var) ->
+                   try
+                     opt := no_trailing_dot (BaseEnvLight.var_get var env)
+                   with Not_found ->
+                     Printf.eprintf "W: Cannot get variable %s\n" var)
+                [
+                  Options.ext_obj, "ext_obj";
+                  Options.ext_lib, "ext_lib";
+                  Options.ext_dll, "ext_dll";
+                ]
+
+        | After_rules ->
+            (* Declare OCaml libraries *)
+            List.iter
+              (function
+                 | nm, [], intf_modules ->
+                     ocaml_lib nm;
+                     let cmis =
+                       List.map (fun m -> (String.uncapitalize m) ^ ".cmi")
+                                intf_modules in
+                     dep ["ocaml"; "link"; "library"; "file:"^nm^".cma"] cmis
+                 | nm, dir :: tl, intf_modules ->
+                     ocaml_lib ~dir:dir (dir^"/"^nm);
+                     List.iter
+                       (fun dir ->
+                          List.iter
+                            (fun str ->
+                               flag ["ocaml"; "use_"^nm; str] (S[A"-I"; P dir]))
+                            ["compile"; "infer_interface"; "doc"])
+                       tl;
+                     let cmis =
+                       List.map (fun m -> dir^"/"^(String.uncapitalize m)^".cmi")
+                                intf_modules in
+                     dep ["ocaml"; "link"; "library"; "file:"^dir^"/"^nm^".cma"]
+                         cmis)
+              t.lib_ocaml;
+
+            (* Declare directories dependencies, replace "include" in _tags. *)
+            List.iter
+              (fun (dir, include_dirs) ->
+                 Pathname.define_context dir include_dirs)
+              t.includes;
+
+            (* Declare C libraries *)
+            List.iter
+              (fun (lib, dir, headers) ->
+                   (* Handle C part of library *)
+                   flag ["link"; "library"; "ocaml"; "byte"; tag_libstubs lib]
+                     (S[A"-dllib"; A("-l"^(nm_libstubs lib)); A"-cclib";
+                        A("-l"^(nm_libstubs lib))]);
+
+                   flag ["link"; "library"; "ocaml"; "native"; tag_libstubs lib]
+                     (S[A"-cclib"; A("-l"^(nm_libstubs lib))]);
+
+                   flag ["link"; "program"; "ocaml"; "byte"; tag_libstubs lib]
+                     (S[A"-dllib"; A("dll"^(nm_libstubs lib))]);
+
+                   (* When ocaml link something that use the C library, then one
+                      need that file to be up to date.
+                    *)
+                   dep ["link"; "ocaml"; "program"; tag_libstubs lib]
+                     [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
+
+                   dep  ["compile"; "ocaml"; "program"; tag_libstubs lib]
+                     [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
+
+                   (* TODO: be more specific about what depends on headers *)
+                   (* Depends on .h files *)
+                   dep ["compile"; "c"]
+                     headers;
+
+                   (* Setup search path for lib *)
+                   flag ["link"; "ocaml"; "use_"^lib]
+                     (S[A"-I"; P(dir)]);
+              )
+              t.lib_c;
+
+              (* Add flags *)
+              List.iter
+              (fun (tags, cond_specs) ->
+                 let spec = BaseEnvLight.var_choose cond_specs env in
+                 let rec eval_specs =
+                   function
+                     | S lst -> S (List.map eval_specs lst)
+                     | A str -> A (BaseEnvLight.var_expand str env)
+                     | spec -> spec
+                 in
+                   flag tags & (eval_specs spec))
+              t.flags
+        | _ ->
+            ()
+
+
+  let dispatch_default t =
+    dispatch_combine
+      [
+        dispatch t;
+        MyOCamlbuildFindlib.dispatch;
+      ]
+
+
+end
+
+
+# 594 "myocamlbuild.ml"
+open Ocamlbuild_plugin;;
+let package_default =
+  {
+     MyOCamlbuildBase.lib_ocaml =
+       [("sequence", [], []); ("invert", ["invert"], [])];
+     lib_c = [];
+     flags = [];
+     includes = []
+  }
+  ;;
+
+let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;
+
+# 609 "myocamlbuild.ml"
+(* OASIS_STOP *)
+Ocamlbuild_plugin.dispatch dispatch_default;;

sequence/sequence.ml

@@ -0,0 +1,772 @@
+(*
+Copyright (c) 2013, Simon Cruanes
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.  Redistributions in binary
+form must reproduce the above copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other materials provided with
+the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*)
+
+(** {1 Transient iterators, that abstract on a finite sequence of elements.} *)
+
+(** Sequence abstract iterator type *)
+type 'a t = ('a -> unit) -> unit
+
+type 'a sequence = 'a t
+
+type (+'a, +'b) t2 = ('a -> 'b -> unit) -> unit
+  (** Sequence of pairs of values of type ['a] and ['b]. *)
+
+(** Build a sequence from a iter function *)
+let from_iter f = f
+
+let rec from_fun f k = match f () with
+  | None -> ()
+  | Some x -> k x; from_fun f k
+
+let empty k = ()
+
+let singleton x k = k x
+let return x k = k x
+let pure f k = k f
+
+let doubleton x y k = k x; k y
+
+let cons x l k = k x; l k
+let snoc l x k = l k; k x
+
+let repeat x k = while true do k x done
+
+let rec iterate f x k =
+  k x;
+  iterate f (f x) k
+
+let rec forever f k =
+  k (f ());
+  forever f k
+
+let cycle s k = while true do s k; done
+
+let iter f seq = seq f
+
+let iteri f seq =
+  let r = ref 0 in
+  seq
+    (fun x ->
+      f !r x;
+      incr r)
+
+let fold f init seq =
+  let r = ref init in
+  seq (fun elt -> r := f !r elt);
+  !r
+
+let foldi f init seq =
+  let i = ref 0 in
+  let r = ref init in
+  seq
+    (fun elt ->
+      r := f !r !i elt;
+      incr i);
+  !r
+
+let map f seq k = seq (fun x -> k (f x))
+
+let mapi f seq k =
+  let i = ref 0 in
+  seq (fun x -> k (f !i x); incr i)
+
+let filter p seq k = seq (fun x -> if p x then k x)
+
+let append s1 s2 k = s1 k; s2 k
+
+let concat s k = s (fun s' -> s' k)
+
+let flatten s = concat s
+
+let flatMap f seq k = seq (fun x -> f x k)
+
+let flat_map = flatMap
+
+let fmap f seq k =
+  seq (fun x -> match f x with
+      | None -> ()
+      | Some y -> k y
+      )
+
+let filter_map = fmap
+
+let intersperse elem seq k =
+  let first = ref true in
+  seq (fun x -> (if !first then first := false else k elem); k x)
+
+(** Mutable unrolled list to serve as intermediate storage *)
+module MList = struct
+  type 'a node =
+    | Nil
+    | Cons of 'a array * int ref * 'a node ref
+
+  (* build and call callback on every element *)
+  let of_seq_with seq k =
+    let start = ref Nil in
+    let chunk_size = ref 8 in
+    (* fill the list. prev: tail-reference from previous node *)
+    let prev, cur = ref start, ref Nil in
+    seq
+      (fun x ->
+        k x;  (* callback *)
+        match !cur with
+        | Nil ->
+          let n = !chunk_size in
+          if n < 4096 then chunk_size := 2 * !chunk_size;
+          cur := Cons (Array.make n x, ref 1, ref Nil)
+        | Cons (a,n,next) ->
+          assert (!n < Array.length a);
+          a.(!n) <- x;
+          incr n;
+          if !n = Array.length a then begin
+            !prev := !cur;
+            prev := next;
+            cur := Nil
+          end
+      );
+    !prev := !cur;
+    !start
+
+  let of_seq seq =
+    of_seq_with seq (fun _ -> ())
+
+  let is_empty = function
+    | Nil -> true
+    | Cons _ -> false
+
+  let rec iter f l = match l with
+    | Nil -> ()
+    | Cons (a, n, tl) ->
+        for i=0 to !n - 1 do f a.(i) done;
+        iter f !tl
+
+  let iteri f l =
+    let rec iteri i f l = match l with
+    | Nil -> ()
+    | Cons (a, n, tl) ->
+        for j=0 to !n - 1 do f (i+j) a.(j) done;
+        iteri (i+ !n) f !tl
+    in iteri 0 f l
+
+  let rec iter_rev f l = match l with
+    | Nil -> ()
+    | Cons (a, n, tl) ->
+        iter_rev f !tl;
+        for i = !n-1 downto 0 do f a.(i) done
+
+  let length l =
+    let rec len acc l = match l with
+      | Nil -> acc
+      | Cons (_, n, tl) -> len (acc+ !n) !tl
+    in len 0 l
+
+  (** Get element by index *)
+  let rec get l i = match l with
+    | Nil -> raise (Invalid_argument "MList.get")
+    | Cons (a, n, _) when i < !n -> a.(i)
+    | Cons (_, n, tl) -> get !tl (i- !n)
+
+  let to_seq l k = iter k l
+
+  let _to_next arg l =
+    let cur = ref l in
+    let i = ref 0 in (* offset in cons *)
+    let rec get_next _ = match !cur with
+      | Nil -> None
+      | Cons (_, n, tl) when !i = !n ->
+          cur := !tl;
+          i := 0;
+          get_next arg
+      | Cons (a, n, _) ->
+          let x = a.(!i) in
+          incr i;
+          Some x
+    in get_next
+
+  let to_gen l = _to_next () l
+
+  let to_stream l =
+    Stream.from (_to_next 42 l)  (* 42=magic cookiiiiiie *)
+
+  let to_klist l =
+    let rec make (l,i) () = match l with
+      | Nil -> `Nil
+      | Cons (_, n, tl) when i = !n -> make (!tl,0) ()
+      | Cons (a, n, _) -> `Cons (a.(i), make (l,i+1))
+    in make (l,0)
+end
+
+let persistent seq =
+  let l = MList.of_seq seq in
+  MList.to_seq l
+
+type 'a lazy_state =
+  | LazySuspend
+  | LazyCached of 'a t
+
+let persistent_lazy (seq:'a t) =
+  let r = ref LazySuspend in
+  fun k ->
+    match !r with
+    | LazyCached seq' -> seq' k
+    | LazySuspend ->
+        (* here if this traversal is interruted, no caching occurs *)
+        let seq' = MList.of_seq_with seq k in
+        r := LazyCached (MList.to_seq seq')
+
+let sort ?(cmp=Pervasives.compare) seq =
+  (* use an intermediate list, then sort the list *)
+  let l = fold (fun l x -> x::l) [] seq in
+  let l = List.fast_sort cmp l in
+  fun k -> List.iter k l
+
+let group ?(eq=fun x y -> x = y) seq k =
+  let cur = ref [] in
+  seq (fun x ->
+    match !cur with
+    | [] -> cur := [x]
+    | (y::_) as l when eq x y ->
+      cur := x::l  (* [x] belongs to the group *)
+    | (_::_) as l ->
+      k l; (* yield group, and start another one *)
+      cur := [x]);
+  (* last list *)
+  if !cur <> [] then k !cur
+
+let uniq ?(eq=fun x y -> x = y) seq k =
+  let has_prev = ref false
+  and prev = ref (Obj.magic 0) in  (* avoid option type, costly *)
+  seq (fun x ->
+    if !has_prev && eq !prev x
+      then ()  (* duplicate *)
+      else begin
+        has_prev := true;
+        prev := x;
+        k x
+      end)
+
+let sort_uniq (type elt) ?(cmp=Pervasives.compare) seq =
+  let module S = Set.Make(struct
+    type t = elt
+    let compare = cmp
+  end) in
+  let set = fold (fun acc x -> S.add x acc) S.empty seq in
+  fun k -> S.iter k set
+
+let product outer inner k =
+  outer (fun x ->
+    inner (fun y -> k (x,y))
+  )
+
+let product2 outer inner k =
+  outer (fun x ->
+    inner (fun y -> k x y)
+  )
+
+let join ~join_row s1 s2 k =
+  s1 (fun a ->
+    s2 (fun b ->
+      match join_row a b with
+      | None -> ()
+      | Some c -> k c
+      )
+    )  (* yield the combination of [a] and [b] *)
+
+let rec unfoldr f b k = match f b with
+  | None -> ()
+  | Some (x, b') ->
+      k x;
+      unfoldr f b' k
+
+let scan f acc seq k =
+  k acc;
+  let acc = ref acc in
+  seq (fun elt -> let acc' = f !acc elt in k acc'; acc := acc')
+
+let max ?(lt=fun x y -> x < y) seq =
+  let ret = ref None in
+  seq (fun x -> match !ret with
+    | None -> ret := Some x
+    | Some y -> if lt y x then ret := Some x);
+  !ret
+
+let min ?(lt=fun x y -> x < y) seq =
+  let ret = ref None in
+  seq (fun x -> match !ret with
+    | None -> ret := Some x
+    | Some y -> if lt x y then ret := Some x);
+  !ret
+
+exception ExitSequence
+
+let head seq =
+  let r = ref None in
+  try
+    seq (fun x -> r := Some x; raise ExitSequence); None
+  with ExitSequence -> !r
+
+let head_exn seq =
+  match head seq with
+  | None -> invalid_arg "Sequence.head_exn"
+  | Some x -> x
+
+let take n seq k =
+  let count = ref 0 in
+  try
+    seq (fun x ->
+      if !count = n then raise ExitSequence;
+      incr count;
+      k x;
+    )
+  with ExitSequence -> ()
+
+let take_while p seq k =
+  try
+    seq (fun x -> if p x then k x else raise ExitSequence)
+  with ExitSequence -> ()
+
+let drop n seq k =
+  let count = ref 0 in
+  seq (fun x -> if !count >= n then k x else incr count)
+
+let drop_while p seq k =
+  let drop = ref true in
+  seq (fun x ->
+    if !drop
+    then if p x then () else (drop := false; k x)
+    else k x)
+
+let rev seq =
+  let l = MList.of_seq seq in
+  fun k -> MList.iter_rev k l
+
+let for_all p seq =
+  try
+    seq (fun x -> if not (p x) then raise ExitSequence);
+    true
+  with ExitSequence -> false
+
+(** Exists there some element satisfying the predicate? *)
+let exists p seq =
+  try
+    seq (fun x -> if p x then raise ExitSequence);
+    false
+  with ExitSequence -> true
+
+let mem ?(eq=(=)) x seq = exists (eq x) seq
+
+let find f seq =
+  let r = ref None in
+  begin try
+    seq (fun x -> match f x with
+      | None -> ()
+      | Some _ as res -> r := res
+    );
+  with ExitSequence -> ()
+  end;
+  !r
+
+let length seq =
+  let r = ref 0 in
+  seq (fun _ -> incr r);
+  !r
+
+let is_empty seq =
+  try seq (fun _ -> raise ExitSequence); true
+  with ExitSequence -> false
+
+(** {2 Transform a sequence} *)
+
+let empty2 k = ()
+
+let is_empty2 seq2 =
+  try ignore (seq2 (fun _ _ -> raise ExitSequence)); true
+  with ExitSequence -> false
+
+let length2 seq2 =
+  let r = ref 0 in
+  seq2 (fun _ _ -> incr r);
+  !r
+
+let zip seq2 k = seq2 (fun x y -> k (x,y))
+
+let unzip seq k = seq (fun (x,y) -> k x y)
+
+let zip_i seq k =
+  let r = ref 0 in
+  seq (fun x -> let n = !r in incr r; k n x)
+
+let fold2 f acc seq2 =
+  let acc = ref acc in
+  seq2 (fun x y -> acc := f !acc x y);
+  !acc
+
+let iter2 f seq2 = seq2 f
+
+let map2 f seq2 k = seq2 (fun x y -> k (f x y))
+
+let map2_2 f g seq2 k =
+  seq2 (fun x y -> k (f x y) (g x y))
+
+(** {2 Basic data structures converters} *)
+
+let to_list seq = List.rev (fold (fun y x -> x::y) [] seq)
+
+let to_rev_list seq = fold (fun y x -> x :: y) [] seq
+
+let of_list l k = List.iter k l
+
+let on_list f l =
+  to_list (f (of_list l))
+
+let to_opt = head
+
+let of_opt o k = match o with
+  | None -> ()
+  | Some x -> k x
+
+let to_array seq =
+  let l = MList.of_seq seq in
+  let n = MList.length l in
+  if n = 0
+    then [||]
+    else begin
+      let a = Array.make n (MList.get l 0) in
+      MList.iteri (fun i x -> a.(i) <- x) l;
+      a
+    end
+
+let of_array a k =
+  for i = 0 to Array.length a - 1 do
+    k (Array.unsafe_get a i)
+  done
+
+let of_array_i a k =
+  for i = 0 to Array.length a - 1 do
+    k (i, Array.unsafe_get a i)
+  done
+
+let of_array2 a k =
+  for i = 0 to Array.length a - 1 do
+    k i (Array.unsafe_get a i)
+  done
+
+let array_slice a i j k =
+  assert (i >= 0 && j < Array.length a);
+  for idx = i to j do
+    k a.(idx);  (* iterate on sub-array *)
+  done
+
+let of_stream s k = Stream.iter k s
+
+let to_stream seq =
+  let l = MList.of_seq seq in
+  MList.to_stream l
+
+let to_stack s seq = iter (fun x -> Stack.push x s) seq
+
+let of_stack s k = Stack.iter k s
+
+let to_queue q seq = seq (fun x -> Queue.push x q)
+
+let of_queue q k = Queue.iter k q
+
+let hashtbl_add h seq =
+  seq (fun (k,v) -> Hashtbl.add h k v)
+
+let hashtbl_replace h seq =
+  seq (fun (k,v) -> Hashtbl.replace h k v)
+
+let to_hashtbl seq =
+  let h = Hashtbl.create 3 in
+  hashtbl_replace h seq;
+  h
+
+let to_hashtbl2 seq2 =
+  let h = Hashtbl.create 3 in
+  seq2 (fun k v -> Hashtbl.replace h k v);
+  h
+
+let of_hashtbl h k = Hashtbl.iter (fun a b -> k (a, b)) h
+
+let of_hashtbl2 h k = Hashtbl.iter k h
+
+let hashtbl_keys h k = Hashtbl.iter (fun a b -> k a) h
+
+let hashtbl_values h k = Hashtbl.iter (fun a b -> k b) h
+
+let of_str s k = String.iter k s
+
+let to_str seq =
+  let b = Buffer.create 64 in
+  iter (fun c -> Buffer.add_char b c) seq;
+  Buffer.contents b
+
+let concat_str seq =
+  let b = Buffer.create 64 in
+  iter (Buffer.add_string b) seq;
+  Buffer.contents b
+
+exception OneShotSequence
+
+let of_in_channel ic =
+  let first = ref true in
+  fun k ->
+    if not !first
+    then raise OneShotSequence
+    else (
+      first := false;
+      try
+        while true do
+          let c = input_char ic in k c
+        done
+      with End_of_file -> ()
+    )
+
+let to_buffer seq buf =
+  seq (fun c -> Buffer.add_char buf c)
+
+(** Iterator on integers in [start...stop] by steps 1 *)
+let int_range ~start ~stop k =
+  for i = start to stop do k i done
+
+let int_range_dec ~start ~stop k =
+  for i = start downto stop do k i done
+
+let of_set (type s) (type v) m set =
+  let module S = (val m : Set.S with type t = s and type elt = v) in
+  fun k -> S.iter k set
+
+let to_set (type s) (type v) m seq =
+  let module S = (val m : Set.S with type t = s and type elt = v) in
+  fold
+    (fun set x -> S.add x set)
+    S.empty seq
+
+type 'a gen = unit -> 'a option
+type 'a klist = unit -> [`Nil | `Cons of 'a * 'a klist]
+
+let of_gen g =
+  (* consume the generator to build a MList *)
+  let rec iter1 k = match g () with
+    | None -> ()
+    | Some x -> k x; iter1 k
+  in
+  let l = MList.of_seq iter1 in
+  MList.to_seq l
+
+let to_gen seq =
+  let l = MList.of_seq seq in
+  MList.to_gen l
+
+let rec of_klist l k = match l() with
+  | `Nil -> ()
+  | `Cons (x,tl) -> k x; of_klist tl k
+
+let to_klist seq =
+  let l = MList.of_seq seq in
+  MList.to_klist l
+
+(** {2 Functorial conversions between sets and sequences} *)
+
+module Set = struct
+  module type S = sig
+    include Set.S
+    val of_seq : elt sequence -> t
+    val to_seq : t -> elt sequence
+    val to_list : t -> elt list
+    val of_list : elt list -> t
+  end
+
+  (** Create an enriched Set module from the given one *)
+  module Adapt(X : Set.S) = struct
+    let to_seq set k = X.iter k set
+
+    let of_seq seq = fold (fun set x -> X.add x set) X.empty seq
+
+    let of_list l = of_seq (of_list l)
+
+    let to_list set = to_list (to_seq set)
+
+    include X
+  end
+
+  (** Functor to build an extended Set module from an ordered type *)
+  module Make(X : Set.OrderedType) = struct
+    module MySet = Set.Make(X)
+    include Adapt(MySet)
+  end
+end
+
+(** {2 Conversion between maps and sequences.} *)
+
+module Map = struct
+  module type S = sig
+    include Map.S
+    val to_seq : 'a t -> (key * 'a) sequence
+    val of_seq : (key * 'a) sequence -> 'a t
+    val keys : 'a t -> key sequence
+    val values : 'a t -> 'a sequence
+    val to_list : 'a t -> (key * 'a) list
+    val of_list : (key * 'a) list -> 'a t
+  end
+
+  (** Adapt a pre-existing Map module to make it sequence-aware *)
+  module Adapt(M : Map.S) = struct
+    let to_seq m = from_iter (fun k -> M.iter (fun x y -> k (x,y)) m)
+
+    let of_seq seq = fold (fun m (k,v) -> M.add k v m) M.empty seq
+
+    let keys m = from_iter (fun k -> M.iter (fun x _ -> k x) m)
+
+    let values m = from_iter (fun k -> M.iter (fun _ y -> k y) m)
+
+    let of_list l = of_seq (of_list l)
+
+    let to_list x = to_list (to_seq x)
+
+    include M
+  end
+
+  (** Create an enriched Map module, with sequence-aware functions *)
+  module Make(V : Map.OrderedType) : S with type key = V.t = struct
+    module M = Map.Make(V)
+    include Adapt(M)
+  end
+end
+
+(** {2 Infinite sequences of random values} *)
+
+let random_int bound = forever (fun () -> Random.int bound)
+
+let random_bool = forever Random.bool
+
+let random_float bound = forever (fun () -> Random.float bound)
+
+let random_array a k =
+  assert (Array.length a > 0);
+  while true do
+    let i = Random.int (Array.length a) in
+    k a.(i);
+  done
+
+let random_list l = random_array (Array.of_list l)
+
+(** {2 Infix functions} *)
+
+module Infix = struct
+  let (--) i j = int_range ~start:i ~stop:j
+
+  let (--^) i j = int_range_dec ~start:i ~stop:j
+
+  let (>>=) x f = flat_map f x
+
+  let (>|=) x f = map f x
+
+  let (<*>) funs args k =
+    funs (fun f -> args (fun x -> k (f x)))
+
+  let (<+>) = append
+end
+
+include Infix
+
+(** {2 Pretty printing of sequences} *)
+
+(** Pretty print a sequence of ['a], using the given pretty printer
+    to print each elements. An optional separator string can be provided. *)
+let pp_seq ?(sep=", ") pp_elt formatter seq =
+  let first = ref true in
+  seq
+    (fun x ->
+      (if !first then first := false
+        else begin
+          Format.pp_print_string formatter sep;
+          Format.pp_print_cut formatter ();
+        end);
+      pp_elt formatter x)
+
+let pp_buf ?(sep=", ") pp_elt buf seq =
+  let first = ref true in
+  seq
+    (fun x ->
+      if !first then first := false else Buffer.add_string buf sep;
+      pp_elt buf x)
+
+let to_string ?sep pp_elt seq =
+  let buf = Buffer.create 25 in
+  pp_buf ?sep (fun buf x -> Buffer.add_string buf (pp_elt x)) buf seq;
+  Buffer.contents buf
+
+(** {2 Basic IO} *)
+
+module IO = struct
+  let lines_of ?(mode=0o644) ?(flags=[Open_rdonly]) filename =
+    fun k ->
+      let ic = open_in_gen flags mode filename in
+      try
+        while true do
+          let line = input_line ic in
+          k line
+        done
+      with
+      | End_of_file -> close_in ic
+      | e -> close_in_noerr ic; raise e
+
+  let chunks_of ?(mode=0o644) ?(flags=[]) ?(size=1024) filename =
+    fun k ->
+      let ic = open_in_gen flags mode filename in
+      try
+        let buf = String.create size in
+        let n = ref 0 in
+        let stop = ref false in
+        while not !stop do
+          n := 0;
+          (* try to read [size] chars. If [input] returns [0] it means
+              the end of file, so we stop, but first we yield the current chunk *)
+          while !n < size && not !stop do
+            let n' = input ic buf !n (size - !n) in
+            if n' = 0 then stop := true else n := !n + n';
+          done;
+          if !n > 0
+            then k (String.sub buf 0 !n)
+        done;
+        close_in ic
+      with e ->
+        close_in_noerr ic;
+        raise e
+
+  let write_to ?(mode=0o644) ?(flags=[Open_creat;Open_wronly]) filename seq =
+    let oc = open_out_gen flags mode filename in
+    try
+      seq (fun s -> output oc s 0 (String.length s));
+      close_out oc
+    with e ->
+      close_out oc;
+      raise e
+
+  let write_lines ?mode ?flags filename seq =
+    write_to ?mode ?flags filename (snoc (intersperse "\n" seq) "\n")
+end

sequence/sequence.mldylib

@@ -0,0 +1,4 @@
+# OASIS_START
+# DO NOT EDIT (digest: 3ff39d3acb327553070a64ef0cb321d5)
+Sequence
+# OASIS_STOP

sequence/sequence.mli

@@ -0,0 +1,592 @@
+(*
+copyright (c) 2013, simon cruanes
+all rights reserved.
+
+redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.  redistributions in binary
+form must reproduce the above copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other materials provided with
+the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*)
+
+(** {1 Simple and Efficient Iterators} *)
+
+(** The iterators are designed to allow easy transfer (mappings) between data
+    structures, without defining [n^2] conversions between the [n] types. The
+    implementation relies on the assumption that a sequence can be iterated
+    on as many times as needed; this choice allows for high performance
+    of many combinators. However, for transient iterators, the {!persistent}
+    function is provided, storing elements of a transient iterator
+    in memory; the iterator can then be used several times (See further).
+
+    Note that some combinators also return sequences (e.g. {!group}). The
+    transformation is computed on the fly every time one iterates over
+    the resulting sequence. If a transformation performs heavy computation,
+    {!persistent} can also be used as intermediate storage.
+
+    Most functions are {b lazy}, i.e. they do not actually use their arguments
+    until their result is iterated on. For instance, if one calls {!map}
+    on a sequence, one gets a new sequence, but nothing else happens until
+    this new sequence is used (by folding or iterating on it).
+
+    If a sequence is built from an iteration function that is {b repeatable}
+    (i.e. calling it several times always iterates on the same set of
+    elements, for instance List.iter or Map.iter), then
+    the resulting {!t} object is also repeatable. For {b one-time iter functions}
+    such as iteration on a file descriptor or a {!Stream},
+    the {!persistent} function can be used to iterate and store elements in
+    a memory structure; the result is a sequence that iterates on the elements
+    of this memory structure, cheaply and repeatably. *)
+
+type +'a t = ('a -> unit) -> unit
+  (** A sequence of values of type ['a]. If you give it a function ['a -> unit]
+      it will be applied to every element of the sequence successively. *)
+
+type +'a sequence = 'a t
+
+type (+'a, +'b) t2 = ('a -> 'b -> unit) -> unit
+  (** Sequence of pairs of values of type ['a] and ['b]. *)
+
+(** {2 Build a sequence} *)
+
+val from_iter : (('a -> unit) -> unit) -> 'a t
+  (** Build a sequence from a iter function *)
+
+val from_fun : (unit -> 'a option) -> 'a t
+  (** Call the function repeatedly until it returns None. This
+      sequence is transient, use {!persistent} if needed! *)
+
+val empty : 'a t
+  (** Empty sequence. It contains no element. *)
+
+val singleton : 'a -> 'a t
+  (** Singleton sequence, with exactly one element. *)
+
+val doubleton : 'a -> 'a -> 'a t
+  (** Sequence with exactly two elements *)
+
+val cons : 'a -> 'a t -> 'a t
+  (** [cons x l] yields [x], then yields from [l].
+      Same as [append (singleton x) l] *)
+
+val snoc : 'a t -> 'a -> 'a t
+  (** Same as {!cons} but yields the element after iterating on [l] *)
+
+val return : 'a -> 'a t
+  (** Synonym to {!singleton} *)
+
+val pure : 'a -> 'a t
+  (** Synonym to {!singleton} *)
+
+val repeat : 'a -> 'a t
+  (** Infinite sequence of the same element. You may want to look
+      at {!take} and the likes if you iterate on it. *)
+
+val iterate : ('a -> 'a) -> 'a -> 'a t
+  (** [iterate f x] is the infinite sequence [x, f(x), f(f(x)), ...] *)
+
+val forever : (unit -> 'b) -> 'b t
+  (** Sequence that calls the given function to produce elements.
+      The sequence may be transient (depending on the function), and definitely
+      is infinite. You may want to use {!take} and {!persistent}. *)
+
+val cycle : 'a t -> 'a t
+  (** Cycle forever through the given sequence. Assume the given sequence can
+      be traversed any amount of times (not transient).  This yields an
+      infinite sequence, you should use something like {!take} not to loop
+      forever. *)
+
+(** {2 Consume a sequence} *)
+
+val iter : ('a -> unit) -> 'a t -> unit
+  (** Consume the sequence, passing all its arguments to the function.
+      Basically [iter f seq] is just [seq f]. *)
+
+val iteri : (int -> 'a -> unit) -> 'a t -> unit
+  (** Iterate on elements and their index in the sequence *)
+
+val fold : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b
+  (** Fold over elements of the sequence, consuming it *)
+
+val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'b
+  (** Fold over elements of the sequence and their index, consuming it *)
+
+val map : ('a -> 'b) -> 'a t -> 'b t
+  (** Map objects of the sequence into other elements, lazily *)
+
+val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
+  (** Map objects, along with their index in the sequence *)
+
+val for_all : ('a -> bool) -> 'a t -> bool
+  (** Do all elements satisfy the predicate? *)
+
+val exists : ('a -> bool) -> 'a t -> bool
+  (** Exists there some element satisfying the predicate? *)
+
+val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> bool
+  (** Is the value a member of the sequence?
+      @param eq the equality predicate to use (default [(=)])
+      @since 0.5 *)
+
+val find : ('a -> 'b option) -> 'a t -> 'b option
+  (** Find the first element on which the function doesn't return [None]
+      @since 0.5 *)
+
+val length : 'a t -> int
+  (** How long is the sequence? Forces the sequence. *)
+
+val is_empty : 'a t -> bool
+  (** Is the sequence empty? Forces the sequence. *)
+
+(** {2 Transform a sequence} *)
+
+val filter : ('a -> bool) -> 'a t -> 'a t
+  (** Filter on elements of the sequence *)
+
+val append : 'a t -> 'a t -> 'a t
+  (** Append two sequences. Iterating on the result is like iterating
+      on the first, then on the second. *)
+
+val concat : 'a t t -> 'a t
+  (** Concatenate a sequence of sequences into one sequence. *)
+
+val flatten : 'a t t -> 'a t
+  (** Alias for {!concat} *)
+
+val flatMap : ('a -> 'b t) -> 'a t -> 'b t
+  (** Monadic bind. Intuitively, it applies the function to every element of the
+      initial sequence, and calls {!concat}. *)
+
+val flat_map : ('a -> 'b t) -> 'a t -> 'b t
+  (** Alias to {!flatMap} with a more explicit name
+      @since 0.5 *)
+
+val fmap : ('a -> 'b option) -> 'a t -> 'b t
+  (** Specialized version of {!flatMap} for options.  *)
+
+val filter_map : ('a -> 'b option) -> 'a t -> 'b t
+  (** Alias to {!fmap} with a more explicit name
+      @since 0.5 *)
+
+val intersperse : 'a -> 'a t -> 'a t
+  (** Insert the single element between every element of the sequence *)
+
+(** {2 Caching} *)
+
+val persistent : 'a t -> 'a t
+  (** Iterate on the sequence, storing elements in an efficient internal structure..
+      The resulting sequence can be iterated on as many times as needed.
+      {b Note}: calling persistent on an already persistent sequence
+      will still make a new copy of the sequence! *)
+
+val persistent_lazy : 'a t -> 'a t
+  (** Lazy version of {!persistent}. When calling [persistent_lazy s],
+      a new sequence [s'] is immediately returned (without actually consuming
+      [s]) in constant time; the first time [s'] is iterated on,
+      it also consumes [s] and caches its content into a inner data
+      structure that will back [s'] for future iterations.
+
+      {b warning}: on the first traversal of [s'], if the traversal
+      is interrupted prematurely ({!take}, etc.) then [s'] will not be
+      memorized, and the next call to [s'] will traverse [s] again. *)
+
+(** {2 Misc} *)
+
+val sort : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
+  (** Sort the sequence. Eager, O(n) ram and O(n ln(n)) time.
+      It iterates on elements of the argument sequence immediately,
+      before it sorts them. *)
+
+val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a t -> 'a t
+  (** Sort the sequence and remove duplicates. Eager, same as [sort] *)
+
+val group : ?eq:('a -> 'a -> bool) -> 'a t -> 'a list t
+  (** Group equal consecutive elements. *)
+
+val uniq : ?eq:('a -> 'a -> bool) -> 'a t -> 'a t
+  (** Remove consecutive duplicate elements. Basically this is
+      like [fun seq -> map List.hd (group seq)]. *)
+
+val product : 'a t -> 'b t -> ('a * 'b) t
+  (** Cartesian product of the sequences. When calling [product a b],
+      the caller {b MUST} ensure that [b] can be traversed as many times
+      as required (several times), possibly by calling {!persistent} on it
+      beforehand. *)
+
+val product2 : 'a t -> 'b t -> ('a, 'b) t2
+  (** Binary version of {!product}. Same requirements.
+      @since 0.5 *)
+
+val join : join_row:('a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
+  (** [join ~join_row a b] combines every element of [a] with every
+      element of [b] using [join_row]. If [join_row] returns None, then
+      the two elements do not combine. Assume that [b] allows for multiple
+      iterations. *)
+
+val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a t
+  (** [unfoldr f b] will apply [f] to [b]. If it
+      yields [Some (x,b')] then [x] is returned
+      and unfoldr recurses with [b']. *)
+
+val scan : ('b -> 'a -> 'b) -> 'b -> 'a t -> 'b t
+  (** Sequence of intermediate results *)
+
+val max : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
+  (** Max element of the sequence, using the given comparison function.
+      @return None if the sequence is empty, Some [m] where [m] is the maximal
+      element otherwise *)
+
+val min : ?lt:('a -> 'a -> bool) -> 'a t -> 'a option
+  (** Min element of the sequence, using the given comparison function.
+      see {!max} for more details. *)
+
+val head : 'a t -> 'a option
+  (** First element, if any, otherwise [None]
+      @since 0.5.1 *)
+
+val head_exn : 'a t -> 'a
+  (** First element, if any, fails
+      @raise Invalid_argument if the sequence is empty
+      @since 0.5.1 *)
+
+val take : int -> 'a t -> 'a t
+  (** Take at most [n] elements from the sequence. Works on infinite
+      sequences. *)
+
+val take_while : ('a -> bool) -> 'a t -> 'a t
+  (** Take elements while they satisfy the predicate, then stops iterating.
+      Will work on an infinite sequence [s] if the predicate is false for at
+      least one element of [s]. *)
+
+val drop : int -> 'a t -> 'a t
+  (** Drop the [n] first elements of the sequence. Lazy. *)
+
+val drop_while : ('a -> bool) -> 'a t -> 'a t
+  (** Predicate version of {!drop} *)
+
+val rev : 'a t -> 'a t
+  (** Reverse the sequence. O(n) memory and time, needs the
+      sequence to be finite. The result is persistent and does
+      not depend on the input being repeatable. *)
+
+(** {2 Binary sequences} *)
+
+val empty2 : ('a, 'b) t2
+
+val is_empty2 : (_, _) t2 -> bool
+
+val length2 : (_, _) t2 -> int
+
+val zip : ('a, 'b) t2 -> ('a * 'b) t
+
+val unzip : ('a * 'b) t -> ('a, 'b) t2
+
+val zip_i : 'a t -> (int, 'a) t2
+  (** Zip elements of the sequence with their index in the sequence *)
+
+val fold2 : ('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) t2 -> 'c
+
+val iter2 : ('a -> 'b -> unit) -> ('a, 'b) t2 -> unit
+
+val map2 : ('a -> 'b -> 'c) -> ('a, 'b) t2 -> 'c t
+
+val map2_2 : ('a -> 'b -> 'c) -> ('a -> 'b -> 'd) -> ('a, 'b) t2 -> ('c, 'd) t2
+  (** [map2_2 f g seq2] maps each [x, y] of seq2 into [f x y, g x y] *)
+
+(** {2 Basic data structures converters} *)
+
+val to_list : 'a t -> 'a list
+  (** Convert the sequence into a list. Preserves order of elements.
+      This function is tail-recursive, but consumes 2*n memory.
+      If order doesn't matter to you, consider {!to_rev_list}. *)
+
+val to_rev_list : 'a t -> 'a list
+  (** Get the list of the reversed sequence (more efficient than {!to_list}) *)
+
+val of_list : 'a list -> 'a t
+
+val on_list : ('a t -> 'b t) -> 'a list -> 'b list
+(** [on_list f l] is equivalent to [to_list @@ f @@ of_list l].
+    @since 0.5.2
+*)
+
+val to_opt : 'a t -> 'a option
+  (** Alias to {!head}
+      @since 0.5.1 *)
+
+val to_array : 'a t -> 'a array
+  (** Convert to an array. Currently not very efficient because
+      an intermediate list is used. *)
+
+val of_array : 'a array -> 'a t
+
+val of_array_i : 'a array -> (int * 'a) t
+  (** Elements of the array, with their index *)
+
+val of_array2 : 'a array -> (int, 'a) t2
+
+val array_slice : 'a array -> int -> int -> 'a t
+  (** [array_slice a i j] Sequence of elements whose indexes range
+      from [i] to [j] *)
+
+val of_opt : 'a option -> 'a t
+  (** Iterate on 0 or 1 values.
+      @since 0.5.1 *)
+
+val of_stream : 'a Stream.t -> 'a t
+  (** Sequence of elements of a stream (usable only once) *)
+
+val to_stream : 'a t -> 'a Stream.t
+  (** Convert to a stream. linear in memory and time (a copy is made in memory) *)
+
+val to_stack : 'a Stack.t -> 'a t -> unit
+  (** Push elements of the sequence on the stack *)
+
+val of_stack : 'a Stack.t -> 'a t
+  (** Sequence of elements of the stack (same order as [Stack.iter]) *)
+
+val to_queue : 'a Queue.t -> 'a t -> unit
+  (** Push elements of the sequence into the queue *)
+
+val of_queue : 'a Queue.t -> 'a t
+  (** Sequence of elements contained in the queue, FIFO order *)
+
+val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
+  (** Add elements of the sequence to the hashtable, with
+      Hashtbl.add *)
+
+val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) t -> unit
+  (** Add elements of the sequence to the hashtable, with
+      Hashtbl.replace (erases conflicting bindings) *)
+
+val to_hashtbl : ('a * 'b) t -> ('a, 'b) Hashtbl.t
+  (** Build a hashtable from a sequence of key/value pairs *)
+
+val to_hashtbl2 : ('a, 'b) t2 -> ('a, 'b) Hashtbl.t
+  (** Build a hashtable from a sequence of key/value pairs *)
+
+val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) t
+  (** Sequence of key/value pairs from the hashtable *)
+
+val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) t2
+  (** Sequence of key/value pairs from the hashtable *)
+
+val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a t
+val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b t
+
+val of_str : string -> char t
+val to_str :  char t -> string
+
+val concat_str : string t -> string
+  (** Concatenate strings together, eagerly.
+      Also see {!intersperse} to add a separator.
+      @since 0.5 *)
+
+exception OneShotSequence
+  (** Raised when the user tries to iterate several times on
+      a transient iterator *)
+
+val of_in_channel : in_channel -> char t
+  (** Iterates on characters of the input (can block when one
+      iterates over the sequence). If you need to iterate
+      several times on this sequence, use {!persistent}.
+      @raise OneShotSequence when used more than once. *)
+
+val to_buffer : char t -> Buffer.t -> unit
+  (** Copy content of the sequence into the buffer *)
+
+val int_range : start:int -> stop:int -> int t
+  (** Iterator on integers in [start...stop] by steps 1. Also see
+      {!(--)} for an infix version. *)
+
+val int_range_dec : start:int -> stop:int -> int t
+  (** Iterator on decreasing integers in [stop...start] by steps -1.
+      See {!(--^)} for an infix version *)
+
+val of_set : (module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a t
+  (** Convert the given set to a sequence. The set module must be provided. *)
+
+val to_set : (module Set.S with type elt = 'a and type t = 'b) -> 'a t -> 'b
+  (** Convert the sequence to a set, given the proper set module *)
+
+type 'a gen = unit -> 'a option
+type 'a klist = unit -> [`Nil | `Cons of 'a * 'a klist]
+
+val of_gen : 'a gen -> 'a t
+  (** Traverse eagerly the generator and build a sequence from it *)
+
+val to_gen : 'a t -> 'a gen
+  (** Make the sequence persistent (O(n)) and then iterate on it. Eager. *)
+
+val of_klist : 'a klist -> 'a t
+  (** Iterate on the lazy list *)
+
+val to_klist : 'a t -> 'a klist
+  (** Make the sequence persistent and then iterate on it. Eager. *)
+
+(** {2 Functorial conversions between sets and sequences} *)
+
+module Set : sig
+  module type S = sig
+    include Set.S
+    val of_seq : elt sequence -> t
+    val to_seq : t -> elt sequence
+    val to_list : t -> elt list
+    val of_list : elt list -> t
+  end
+
+  (** Create an enriched Set module from the given one *)
+  module Adapt(X : Set.S) : S with type elt = X.elt and type t = X.t
+
+  (** Functor to build an extended Set module from an ordered type *)
+  module Make(X : Set.OrderedType) : S with type elt = X.t
+end
+
+(** {2 Conversion between maps and sequences.} *)
+
+module Map : sig
+  module type S = sig
+    include Map.S
+    val to_seq : 'a t -> (key * 'a) sequence
+    val of_seq : (key * 'a) sequence -> 'a t
+    val keys : 'a t -> key sequence
+    val values : 'a t -> 'a sequence
+    val to_list : 'a t -> (key * 'a) list
+    val of_list : (key * 'a) list -> 'a t
+  end
+
+  (** Adapt a pre-existing Map module to make it sequence-aware *)
+  module Adapt(M : Map.S) : S with type key = M.key and type 'a t = 'a M.t
+
+  (** Create an enriched Map module, with sequence-aware functions *)
+  module Make(V : Map.OrderedType) : S with type key = V.t
+end
+
+(** {2 Infinite sequences of random values} *)
+
+val random_int : int -> int t
+  (** Infinite sequence of random integers between 0 and
+      the given higher bound (see Random.int) *)
+
+val random_bool : bool t
+  (** Infinite sequence of random bool values *)
+
+val random_float : float -> float t
+
+val random_array : 'a array -> 'a t
+  (** Sequence of choices of an element in the array *)
+
+val random_list : 'a list -> 'a t
+  (** Infinite sequence of random elements of the list. Basically the
+      same as {!random_array}. *)
+
+(** {2 Infix functions} *)
+
+module Infix : sig
+  val (--) : int -> int -> int t
+    (** [a -- b] is the range of integers from [a] to [b], both included,
+        in increasing order. It will therefore be empty if [a > b]. *)
+
+  val (--^) : int -> int -> int t
+    (** [a --^ b] is the range of integers from [b] to [a], both included,
+        in decreasing order (starts from [a]).
+        It will therefore be empty if [a < b]. *)
+
+  val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
+    (** Monadic bind (infix version of {!flat_map}
+        @since 0.5 *)
+
+  val (>|=) : 'a t -> ('a -> 'b) -> 'b t
+    (** Infix version of {!map}
+        @since 0.5 *)
+
+  val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
+    (** Applicative operator (product+application)
+        @since 0.5 *)
+
+  val (<+>) : 'a t -> 'a t -> 'a t
+    (** Concatenation of sequences
+        @since 0.5 *)
+end
+
+include module type of Infix
+
+
+(** {2 Pretty printing of sequences} *)
+
+val pp_seq : ?sep:string -> (Format.formatter -> 'a -> unit) ->
+             Format.formatter -> 'a t -> unit
+  (** Pretty print a sequence of ['a], using the given pretty printer
+      to print each elements. An optional separator string can be provided. *)
+
+val pp_buf : ?sep:string -> (Buffer.t -> 'a -> unit) ->
+             Buffer.t -> 'a t -> unit
+  (** Print into a buffer *)
+
+val to_string : ?sep:string -> ('a -> string) -> 'a t -> string
+  (** Print into a string *)
+
+(** {2 Basic IO}
+
+Very basic interface to manipulate files as sequence of chunks/lines. The
+sequences take care of opening and closing files properly; every time
+one iterates over a sequence, the file is opened/closed again.
+
+Example: copy a file ["a"] into file ["b"], removing blank lines:
+
+{[
+  Sequence.(IO.lines_of "a" |> filter (fun l-> l<> "") |> IO.write_lines "b");;
+]}
+
+By chunks of [4096] bytes:
+
+{[
+  Sequence.IO.(chunks_of ~size:4096 "a" |> write_to "b");;
+]}
+
+@since 0.5.1 *)
+
+module IO : sig
+  val lines_of : ?mode:int -> ?flags:open_flag list ->
+                string -> string t
+  (** [lines_of filename] reads all lines of the given file. It raises the
+      same exception as would opening the file and read from it, except
+      from [End_of_file] (which is caught). The file is {b always} properly
+      closed.
+      Every time the sequence is iterated on, the file is opened again, so
+      different iterations might return different results
+      @param mode default [0o644]
+      @param flags default: [[Open_rdonly]] *)
+
+  val chunks_of : ?mode:int -> ?flags:open_flag list -> ?size:int ->
+                  string -> string t
+  (** Read chunks of the given [size] from the file. The last chunk might be
+      smaller. Behaves like {!lines_of} regarding errors and options.
+      Every time the sequence is iterated on, the file is opened again, so
+      different iterations might return different results *)
+
+  val write_to : ?mode:int -> ?flags:open_flag list ->
+                 string -> string t -> unit
+  (** [write_to filename seq] writes all strings from [seq] into the given
+      file. It takes care of opening and closing the file.
+      @param mode default [0o644]
+      @param flags used by [open_out_gen]. Default: [[Open_creat;Open_wronly]]. *)
+
+  val write_lines : ?mode:int -> ?flags:open_flag list ->
+                    string -> string t -> unit
+  (** Same as {!write_to}, but intercales ['\n'] between each string *)
+end

sequence/sequence.mllib

@@ -0,0 +1,4 @@
+# OASIS_START
+# DO NOT EDIT (digest: 3ff39d3acb327553070a64ef0cb321d5)
+Sequence
+# OASIS_STOP

sequence/sequence.odocl

@@ -0,0 +1,4 @@
+# OASIS_START
+# DO NOT EDIT (digest: 3ff39d3acb327553070a64ef0cb321d5)
+Sequence
+# OASIS_STOP

sequence/tests/run_tests.ml

@@ -0,0 +1,9 @@
+
+open OUnit
+
+let suite =
+    "run_tests" >:::
+      [ Test_sequence.suite; ]
+
+let _ =
+  OUnit.run_test_tt_main suite

sequence/tests/test_sequence.ml

@@ -0,0 +1,228 @@
+
+open OUnit
+
+module S = Sequence
+open Sequence.Infix
+
+let pp_ilist l =
+  let b = Buffer.create 15 in
+  Format.bprintf b "@[<h>%a@]" (S.pp_seq Format.pp_print_int) (S.of_list l);
+  Buffer.contents b
+
+let test_empty () =
+  let seq = S.empty in
+  OUnit.assert_bool "empty" (S.is_empty seq);
+  OUnit.assert_bool "empty"
+    (try S.iter (fun _ -> raise Exit) seq; true with Exit -> false);
+  ()
+
+let test_repeat () =
+  let seq = S.repeat "hello" in
+  OUnit.assert_equal ["hello"; "hello"; "hello"]
+    (seq |> S.take 3 |> S.to_list);
+  ()
+
+let test_concat () =
+  let s1 = (1 -- 5) in
+  let s2 = (6 -- 10) in
+  let l = [1;2;3;4;5;6;7;8;9;10] in
+  OUnit.assert_equal l (S.to_list (S.append s1 s2));
+  ()
+
+let test_fold () =
+  let n = (1 -- 10)
+    |> S.fold (+) 0 in
+  OUnit.assert_equal 55 n;
+  ()
+
+let test_foldi () =
+  let l = ["hello"; "world"]
+    |> S.of_list
+    |> S.foldi (fun acc i x -> (i,x) :: acc) [] in
+  OUnit.assert_equal [1, "world"; 0, "hello"] l;
+  ()
+
+let test_exists () =
+  (1 -- 100)
+    |> S.exists (fun x -> x = 59)
+    |> OUnit.assert_bool "exists";
+  (1 -- 100)
+    |> S.exists (fun x -> x < 0)
+    |> (fun x -> not x)
+    |> OUnit.assert_bool "not exists";
+  ()
+
+let test_length () =
+  (1 -- 1000) |> S.length |> OUnit.assert_equal 1000
+
+let test_concat () =
+  1 -- 1000
+    |> S.map (fun i -> (i -- (i+1)))
+    |> S.concat
+    |> S.length
+    |> OUnit.assert_equal 2000
+
+let test_flatMap () =
+  1 -- 1000
+    |> S.flatMap (fun i -> (i -- (i+1)))
+    |> S.length
+    |> OUnit.assert_equal 2000
+
+let test_intersperse () =
+  1 -- 100
+    |> (fun seq -> S.intersperse 0 seq)
+    |> S.take 10
+    |> S.to_list
+    |> OUnit.assert_equal [1;0;2;0;3;0;4;0;5;0]
+
+let test_not_persistent () =
+  let printer = pp_ilist in
+  let stream = Stream.from (fun i -> if i < 5 then Some i else None) in
+  let seq = S.of_stream stream in
+  OUnit.assert_equal ~printer [0;1;2;3;4] (seq |> S.to_list);
+  OUnit.assert_equal ~printer [] (seq |> S.to_list);
+  ()
+
+let test_persistent () =
+  let printer = pp_ilist in
+  let stream = Stream.from (fun i -> if i < 5 then Some i else None) in
+  let seq = S.of_stream stream in
+  (* consume seq into a persistent version of itself *)
+  let seq' = S.persistent seq in
+  OUnit.assert_equal ~printer [] (seq |> S.to_list);
+  OUnit.assert_equal ~printer [0;1;2;3;4] (seq' |> S.to_list);
+  OUnit.assert_equal ~printer [0;1;2;3;4] (seq' |> S.to_list);
+  OUnit.assert_equal ~printer [0;1;2;3;4] (seq' |> S.to_stream |> S.of_stream |> S.to_list);
+  ()
+
+let test_big_persistent () =
+  let printer = pp_ilist in
+  let seq = 0 -- 10_000 in
+  let seq' = S.persistent seq in
+  OUnit.assert_equal 10_001 (S.length seq');
+  OUnit.assert_equal 10_001 (S.length seq');
+  OUnit.assert_equal ~printer [0;1;2;3] (seq' |> S.take 4 |> S.to_list);
+  ()
+
+let test_sort () =
+  1 -- 100
+    |> S.sort ~cmp:(fun i j -> j - i)
+    |> S.take 4
+    |> S.to_list
+    |> OUnit.assert_equal [100;99;98;97]
+
+let test_sort_uniq () =
+  [42;1;2;3;4;5;4;3;2;1]
+    |> S.of_list
+    |> S.sort_uniq
+    |> S.to_list
+    |> OUnit.assert_equal [1;2;3;4;5;42]
+
+let test_group () =
+  [1;2;3;3;2;2;3;4]
+    |> S.of_list |> S.group |> S.to_list
+    |> OUnit.assert_equal [[1];[2];[3;3];[2;2];[3];[4]]
+
+let test_uniq () =
+  [1;2;2;3;4;4;4;3;3]
+    |> S.of_list |> S.uniq |> S.to_list
+    |> OUnit.assert_equal [1;2;3;4;3]
+
+let test_product () =
+  let stream = Stream.from (fun i -> if i < 3 then Some i else None) in
+  let a = S.of_stream stream in
+  let b = S.of_list ["a";"b";"c"] in
+  let s = S.product a b |> S.map (fun (x,y) -> y,x)
+    |> S.to_list |> List.sort compare in
+  OUnit.assert_equal ["a",0; "a", 1; "a", 2;
+                      "b",0; "b", 1; "b", 2;
+                      "c",0; "c", 1; "c", 2;] s
+
+let test_join () =
+  let s1 = (1 -- 3) in
+  let s2 = S.of_list ["1"; "2"] in
+  let join_row i j =
+    if string_of_int i = j then Some (string_of_int i ^ " = " ^ j) else None
+  in
+  let s = S.join ~join_row s1 s2 in
+  OUnit.assert_equal ["1 = 1"; "2 = 2"] (S.to_list s);
+  ()
+
+let test_scan () =
+  1 -- 5 
+    |> S.scan (+) 0
+    |> S.to_list
+    |> OUnit.assert_equal ~printer:pp_ilist [0;1;3;6;10;15]
+
+let test_drop () =
+  1 -- 5 |> S.drop 2 |> S.to_list |> OUnit.assert_equal [3;4;5]
+
+let test_rev () =
+  1 -- 5 |> S.rev |> S.to_list |> OUnit.assert_equal [5;4;3;2;1]
+
+let test_unfoldr () =
+  let f x = if x < 5 then Some (string_of_int x,x+1) else None in
+  S.unfoldr f 0
+    |> S.to_list
+    |> OUnit.assert_equal ["0"; "1"; "2"; "3"; "4"]
+
+let test_hashtbl () =
+  let h = 1 -- 5
+    |> S.zip_i
+    |> S.to_hashtbl2 in
+  0 -- 4
+    |> S.iter (fun i -> OUnit.assert_equal (i+1) (Hashtbl.find h i));
+  OUnit.assert_equal [0;1;2;3;4] (S.hashtbl_keys h |> S.sort |> S.to_list);
+  ()
+
+let test_buff () =
+  let b = Buffer.create 4 in
+  "hello world"
+    |> S.of_str |> S.rev |> S.map Char.uppercase
+    |> (fun seq -> S.to_buffer seq b);
+  OUnit.assert_equal "DLROW OLLEH" (Buffer.contents b);
+  ()
+
+let test_int_range () =
+  OUnit.assert_equal ~printer:pp_ilist [1;2;3;4] S.(to_list (1--4));
+  OUnit.assert_equal ~printer:pp_ilist [10;9;8;7;6] S.(to_list (10 --^ 6));
+  OUnit.assert_equal ~printer:pp_ilist [] S.(to_list (10--4));
+  OUnit.assert_equal ~printer:pp_ilist [] S.(to_list (10 --^ 60));
+  ()
+
+let test_take () =
+  let l = S.(to_list (take 0 (of_list [1]))) in
+  OUnit.assert_equal ~printer:pp_ilist [] l;
+  let l = S.(to_list (take 5 (of_list [1;2;3;4;5;6;7;8;9;10]))) in
+  OUnit.assert_equal ~printer:pp_ilist [1;2;3;4;5] l;
+  ()
+
+let suite =
+  "test_sequence" >:::
+    [ "test_empty" >:: test_empty;
+      "test_repeat" >:: test_repeat;
+      "test_concat" >:: test_concat;
+      "test_fold" >:: test_fold;
+      "test_foldi" >:: test_foldi;
+      "test_exists" >:: test_exists;
+      "test_length" >:: test_length;
+      "test_concat" >:: test_concat;
+      "test_flatMap" >:: test_flatMap;
+      "test_intersperse" >:: test_intersperse;
+      "test_not_persistent" >:: test_not_persistent;
+      "test_persistent" >:: test_persistent;
+      "test_big_persistent" >:: test_big_persistent;
+      "test_sort" >:: test_sort;
+      "test_sort_uniq" >:: test_sort;
+      "test_group" >:: test_group;
+      "test_uniq" >:: test_uniq;
+      "test_product" >:: test_product;
+      "test_join" >:: test_join;
+      "test_scan" >:: test_scan;
+      "test_drop" >:: test_drop;
+      "test_rev" >:: test_rev;
+      "test_unfoldr" >:: test_unfoldr;
+      "test_hashtbl" >:: test_hashtbl;
+      "test_int_range" >:: test_int_range;
+      "test_take" >:: test_take;
+    ]

setup.ml

@@ -1,7 +1,7 @@
 (* setup.ml generated for the first time by OASIS v0.4.4 *)
 
 (* OASIS_START *)
-(* DO NOT EDIT (digest: baa9973b38a97689412be8397df50548) *)
+(* DO NOT EDIT (digest: 42feaefec6d88da4eb0905255ba7d50b) *)
 (*
    Regenerated by OASIS v0.4.4
    Visit http://oasis.forge.ocamlcore.org for more information and
@@ -6856,7 +6856,7 @@ let setup_t =
           alpha_features = [];
           beta_features = [];
           name = "containers";
-          version = "0.3.3";
+          version = "0.3.4";
           license =
             OASISLicense.DEP5License
               (OASISLicense.DEP5Unit
@@ -7741,7 +7741,7 @@ let setup_t =
        };
      oasis_fn = Some "_oasis";
      oasis_version = "0.4.4";
-     oasis_digest = Some ">\"\nZ{\234\192R\1690\0047v\140\218\145";
+     oasis_digest = Some "u\218H\140/QR\161\227\201l\128vo\253\189";
      oasis_exec = None;
      oasis_setup_args = [];
      setup_update = false

tests/threads/test_future.ml

@@ -3,6 +3,8 @@
 
 open OUnit
 
+module Future = CCFuture
+
 let test_mvar () =
   let box = Future.MVar.empty () in
   let f = Future.spawn (fun () -> Future.MVar.take box + 1) in
@@ -13,10 +15,9 @@ let test_mvar () =
   ()
 
 let test_parallel () =
-  let open Gen.Infix in
-  let l = 1 -- 300
-    |> Gen.map (fun _ -> Future.spawn (fun () -> Thread.delay 0.1; 1))
-    |> Gen.to_list in
+  let l = CCSequence.(1 -- 300)
+    |> CCSequence.map (fun _ -> Future.spawn (fun () -> Thread.delay 0.1; 1))
+    |> CCSequence.to_list in
   let l' = List.map Future.get l in
   OUnit.assert_equal 300 (List.fold_left (+) 0 l');
   ()