diff --git a/sequence.ml b/sequence.ml
index 037ea1f..496ea08 100644
--- a/sequence.ml
+++ b/sequence.ml
@@ -241,6 +241,13 @@ module MList = struct
 
   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
 
 (** Iterate on the sequence, storing elements in a data structure.
@@ -601,6 +608,7 @@ let to_set (type s) (type v) m seq =
     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 *)
@@ -615,6 +623,14 @@ 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
diff --git a/sequence.mli b/sequence.mli
index 601bb59..7b3af7a 100644
--- a/sequence.mli
+++ b/sequence.mli
@@ -174,8 +174,10 @@ val filter_map : ('a -> 'b option) -> 'a t -> 'b t
 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! *)
@@ -191,6 +193,8 @@ val persistent_lazy : 'a t -> 'a t
       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,
@@ -369,6 +373,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 *)
@@ -376,6 +381,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