anchor.diff:  
       let first p s1 = tryFind p s1
   
  -    let indexNotFound() = raise (new System.Collections.Generic.KeyNotFoundException("An index satisfying the predicate was not found in the collection"))
  +    let indexNotFound () =
  +        raise <| KeyNotFoundException "An index satisfying the predicate was not found in the collection"
   
       let find p s1 =
           match tryFind p s1 with
           | Some a -> a
  -        | None   -> indexNotFound()
  -
  -    let rec scan f acc s1 = 
  -      lzy(fun () -> 
  -        match getCell s1 with
  -        | CellCons(a,b) -> let acc' = f acc a in consc acc (scan f acc' b)
  -        | CellEmpty -> consc acc empty)
  -
  -    let folds f acc s1 = scan f acc s1 // deprecated
  -
  -    let head s = 
  -      match getCell s with
  -      | CellCons(a,_) -> a
  -      | CellEmpty -> invalidArg "s" "the list is empty"
  -
  -    let tail s = 
  -      match getCell s with
  -      | CellCons(_,b) -> b
  -      | CellEmpty -> invalidArg "s" "the list is empty"
  +        | None -> indexNotFound()
  +
  +    let rec scan f acc s1 =
  +        lzy(fun () ->
  +            match getCell s1 with
  +            | CellCons(a,b) -> let acc' = f acc a in consc acc (scan f acc' b)
  +            | CellEmpty -> consc acc empty)
  +
  +    let head s =
  +        match getCell s with
  +        | CellCons(a,_) -> a
  +        | CellEmpty -> invalidArg "s" "the list is empty"
  +
  +    let tail s =
  +        match getCell s with
  +        | CellCons(_,b) -> b
  +        | CellEmpty -> invalidArg "s" "the list is empty"
   
       let isEmpty s =
  -      match getCell s with
  -      | CellCons _ -> false
  -      | CellEmpty -> true
  -
  -    let rec take n s = 
  -      lzy(fun () -> 
  -        if n < 0 then invalidArg "n" "the number must not be negative"
  -        elif n = 0 then CellEmpty 
  +        match getCell s with
  +        | CellCons _ -> false
  +        | CellEmpty -> true
  +
  +    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 skipc n s =
  +        if n = 0 then
  +            force s
           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 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 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)
  +            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 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
  -
  -    let length s = lengthAux 0 s
  -
  -    let toSeq (s: LazyList<'T>) = (s :> IEnumerable<_>)
  +    let rec lengthAux n s =
  +        match getCell s with
  +        | CellEmpty -> n
  +        | CellCons (_, b) ->
  +            lengthAux (n + 1) b
  +
  +    let length s =
  +        lengthAux 0 s
  +
  +    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 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
  +      ofFreshIEnumerator (c.GetEnumerator())
  +      
  +    let (|Cons|Nil|) l =
  +        match getCell l with
  +        | CellCons (a, b) ->
  +            Cons (a, b)
  +        | CellEmpty ->
  +            Nil
  
positive.code: #nowarn "21" // recursive initialization
  #nowarn "40" // recursive initialization
  
  #nowarn "21" // recursive initialization
  #nowarn "40" // recursive initialization
  
  exception UndefinedException
  
  
negative.code: type LazyList<'T> =
      { mutable status : LazyCellStatus< 'T > }
      
      member x.Value =
          match x.status with
          | LazyCellStatus.Value v -> v
          | _ ->
              lock x <| fun () ->
              match x.status with
              | LazyCellStatus.Delayed f ->
                  x.status <- Exception UndefinedException;
                  try
                      let res = f ()
                      x.status <- LazyCellStatus.Value res;
                      res
                  with e ->
                      x.status <- LazyCellStatus.Exception(e);
                      reraise()
              | LazyCellStatus.Value v -> v
              | LazyCellStatus.Exception e -> raise e
      
      member s.GetEnumeratorImpl() =
          let getCell (x : LazyList<'T>) = x.Value
          let toSeq s = s |> Seq.unfold (fun ll -> match getCell ll with CellEmpty -> None | CellCons(a,b) -> Some(a,b))
          (toSeq s).GetEnumerator()
              
      interface IEnumerable<'T> with
          member s.GetEnumerator() =
              s.GetEnumeratorImpl()
  
      interface System.Collections.IEnumerable with
          override s.GetEnumerator() =
              s.GetEnumeratorImpl() :> System.Collections.IEnumerator
  
  
  and 
  