Module GenClone

module GenClone: sig .. end

Clonable Generators

Utils to save the internal state of a generator, and restart from this state. This will and should not work on any iterator, but for some of them (e.g. reading from a file, see GenClone.IO) it makes a lot of sense.


type 'a gen = unit -> 'a option 
type 'a t = <
   clone : 'a t; (*

Clone the internal state

*)
   gen : 'a gen; (*

Generator of values tied to this copy

*)
>

A generator that can be cloned as many times as required.

type 'a clonable = 'a t 

Alias to 'a t

Prepend method

type 'a prependable = <
   clone : 'a prependable;
   gen : 'a gen;
   prepend : 'a -> unit; (*

Add value at front position

*)
>
val to_prependable : 'a t -> 'a prependable

Misc

val map : ('a -> 'b) -> 'a t -> 'b t

Low-level Persistency

Example:

      let g = 1 -- 1000 ;;
      val g : int t = <fun>

      let c = g |> MList.of_gen_lazy |> MList.to_clonable;;
      val c : int clonable = <obj>

                c#next |> take 500 |> to_list;;
      - : int list = [1; 2; 3; .....; 500]

      let c' = c#clone ;;
      val c' : int clonable = <obj>

                 c |> to_list;;
      - : int list = [501; 502; ....; 1000]

        c'#gen |> to_list;;   (* c consumed, but not c' *)
      - : int list = [501; 502; ....; 1000]

        c#gen |> to_list;;
      - : int list = []
    

IO

module IO: sig .. end