anchor.diff:      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 
  +    let rec ofFreshIEnumerator (e : IEnumerator<_>) =
  +      lzy(fun () ->
  +        if e.MoveNext() then
             consc e.Current (ofFreshIEnumerator e)
  -        else 
  +        else
              e.Dispose()
              CellEmpty)
  -      
  +
       let ofSeq (c : IEnumerable<_>) =
  -      ofFreshIEnumerator (c.GetEnumerator()) 
  -      
  +      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 =
  +        let rec revAux r acc =
  +            match r with
  +            | Nil -> acc
  +            | Cons(hd, tl) -> revAux tl (cons hd acc)
           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
  +            | Cons(_, xs') -> drop (n-1) xs'
  +            | Nil -> empty
           else
               xs
   
       let split (ll:LazyList<'T>) n  =
  -        let rec loop z (leftL:'T list) (ll':LazyList<'T>) = 
  +        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)
  
positive.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
  
  
negative.code: 
      let isEmpty (s : LazyList<'T>) = s.IsEmpty
  
      let rec take n s =
        lzy(fun () ->
          if n < 0 then invalidArg "n" "the number must not be negative"
          elif n = 0 then CellEmpty
          else
            match getCell s with
            | CellCons(a,s) -> consc a (take (n-1) s)
            | CellEmpty -> invalidArg "n" "not enough items in the list" )
  
      let rec tryTake n s =
          if n < 0 then None
          elif n = 0 then Some empty
          else
  