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:     let toSeq (s: LazyList<'T>) = (s :> IEnumerable<_>)
  
      // Note: this doesn't dispose of the IEnumerator if the iteration is not run to the end
      let rec ofFreshIEnumerator (e : IEnumerator<_>) = 
        lzy(fun () -> 
          if e.MoveNext() then 
            consc e.Current (ofFreshIEnumerator e)
          else 
             e.Dispose()
             CellEmpty)
        
      let ofSeq (c : IEnumerable<_>) =
        ofFreshIEnumerator (c.GetEnumerator()) 
        
      let (|Cons|Nil|) l = match getCell l with CellCons(a,b) -> Cons(a,b) | CellEmpty -> Nil
  
  
      let rec private revAux r acc =
          match r with
          | Nil -> acc
          | Cons(hd, tl) -> revAux tl (cons hd acc)
  
      let rev r =
          revAux r empty
  
      let rec drop n xs =
          if n < 0 then invalidArg "n" "n was negative"
          elif n > 0 then
              match xs with
              | Cons(x, xs') -> drop (n-1) xs'
              | _ -> EmptyValue<'T>.Value
          else
              xs
  
      let split (ll:LazyList<'T>) n  =
          let rec loop z (leftL:'T list) (ll':LazyList<'T>) = 
              match z with
              | 0 -> leftL, (ll'.Tail)
              | _ -> loop (z - 1)  ((ll'.Head)::leftL) (ll'.Tail)
  
negative.code: // First version copied from the F# Power Pack
  // https://raw.github.com/fsharp/powerpack/master/src/FSharp.PowerPack/LazyList.fs
  
  // (c) Microsoft Corporation 2005-2009.
  
  namespace FSharpx.Collections
  
  