anchor.diff:              | CellEmpty -> None
   
       let rec skipc n s =
  -      if n = 0 then force s 
  -      else  
  +      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 () -> 
  +    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  
  +      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 = 
  +    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 =
  +        let rec loop s l =
               match  getCell l with
  -            | CellEmpty -> cont s
  +            | CellEmpty -> s
               | CellCons(x,xs) ->
                   let s = f s x
  -                loop s xs (fun s -> cont s)
  -        loop s l id
  +                loop s xs
  +        loop s l
   
       let mapAccum f s l =
           let rec loop s l cont =
  
positive.code:       | CellCons(a,b) -> consc a (append b l2)
  
      let delayed f = lzy(fun () ->  (getCell (f())))
      let repeat x = 
        let rec s = cons x (delayed (fun () -> s)) in s
  
      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 () -> 
          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 () -> 
          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 () -> 
          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
  
negative.code: 
      let tryUncons (s : LazyList<'T>) = s.TryUncons
  
      let rec unfold f z =
        lzy(fun () ->
            match f z with
            | None       -> CellEmpty
            | Some (x,z) -> CellCons (x,unfold f z))
  