anchor.diff:        | CellCons(a,b) -> consc a (append b l2)
   
       let delayed f = lzy(fun () ->  (getCell (f())))
  -    let repeat x = 
  +    let repeat x =
         let rec s = cons x (delayed (fun () -> s)) in s
   
  -    let rec map f s = 
  -      lzy(fun () ->  
  +    let rec map f s =
  +      lzy(fun () ->
           match getCell s with
           | CellEmpty -> CellEmpty
           | CellCons(a,b) -> consc (f a) (map f b))
   
  -    let rec map2 f s1 s2 =  
  -      lzy(fun () -> 
  +    let rec map2 f s1 s2 =
  +      lzy(fun () ->
           match getCell s1, getCell s2  with
           | CellCons(a1,b1),CellCons(a2,b2) -> consc (f a1 a2) (map2 f b1 b2)
           | _ -> CellEmpty)
   
  -    let rec zip s1 s2 = 
  -      lzy(fun () -> 
  +    let rec zip s1 s2 =
  +      lzy(fun () ->
           match getCell s1, getCell s2  with
           | CellCons(a1,b1),CellCons(a2,b2) -> consc (a1,a2) (zip b1 b2)
           | _ -> CellEmpty)
   
  -    let rec concat s1 = 
  -      lzy(fun () -> 
  +    let rec concat s1 =
  +      lzy(fun () ->
           match getCell s1 with
           | CellCons(a,b) -> appendc a (concat b)
           | CellEmpty -> CellEmpty)
  -      
  +
       let rec filter p s1= lzy(fun () ->  filterc p s1)
       and filterc p s1 =
           match getCell s1 with
           | CellCons(a,b) -> if p a then consc a (filter p b) else filterc p b
           | CellEmpty -> CellEmpty
  -      
  +
       let rec tryFind p s1 =
           match getCell s1 with
           | CellCons(a,b) -> if p a then Some a else tryFind p b
  
positive.code:             | CellEmpty -> None
  
      let rec skipc n s =
        if n = 0 then force s 
        else  
          match getCell s with
          | CellCons(_,s) -> skipc (n-1) s
          | CellEmpty -> invalidArg "n" "not enough items in the list"
  
      let rec skip n s = 
        lzy(fun () -> 
          if n < 0 then invalidArg "n" "the value must not be negative"
          else skipc n s)
  
      let rec skipcOpt n s =
        if n = 0 then Some s
        else  
          match getCell s with
          | CellCons(_,s) -> match (skipcOpt (n-1) s) with Some x -> Some x | None -> None
          | CellEmpty -> None
  
      let rec trySkip n s = 
          if n < 0 then None
          else skipcOpt n s
  
      let fold f s l =
          let rec loop s l cont =
              match  getCell l with
              | CellEmpty -> cont s
              | CellCons(x,xs) ->
                  let s = f s x
                  loop s xs (fun s -> cont s)
          loop s l id
  
      let mapAccum f s l =
          let rec loop s l cont =
  
negative.code:                 loop s xs (fun (s,ys) -> cont (s, cons y ys))
          loop s l id
  
      let rec ofList l =
        lzy(fun () ->
          match l with [] -> CellEmpty | h :: t -> consc h (ofList t))
  
      let toList s =
        let rec loop s acc =
            match getCell s with
            | CellEmpty -> List.rev acc
            | CellCons(h,t) -> loop t (h::acc)
        loop s []
  
      let rec iter f s =
        match getCell s with
        | CellEmpty -> ()
        | CellCons(h,t) -> f h; iter f t
  
      let rec copyFrom i a =
        lzy(fun () ->
          if i >= Array.length a then CellEmpty
          else consc a.[i] (copyFrom (i+1) a))
  
      let rec copyTo (arr: _[]) s i =
        match getCell s with
        | CellEmpty -> ()
        | CellCons(a,b) -> arr.[i] <- a; copyTo arr b (i+1)
  
      let ofArray a = copyFrom 0 a
      let toArray s = Array.ofList (toList s)
  
      let rec lengthAux n s =
        match getCell s with
        | CellEmpty -> n
        | CellCons(_,b) -> lengthAux (n+1) b
  