anchor.diff:  type LazyList<'T> =
       { mutable status : LazyCellStatus< 'T > }
       
  -    member x.Value = 
  -        match x.status with 
  +    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() = 
  +        | _ ->
  +            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 = Seq.unfold (fun ll -> match getCell ll with CellEmpty -> None | CellCons(a,b) -> Some(a,b)) s 
  +        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()
  +        member s.GetEnumerator() =
  +            s.GetEnumeratorImpl()
   
       interface System.Collections.IEnumerable with
  -        override s.GetEnumerator() = (s.GetEnumeratorImpl() :> System.Collections.IEnumerator)
  +        override s.GetEnumerator() =
  +            s.GetEnumeratorImpl() :> System.Collections.IEnumerator
   
   
   and 
  
positive.code: 
      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 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"
  
      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 
          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)
  
      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<_>)
  
      // 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
  
negative.code: #nowarn "21" // recursive initialization
  #nowarn "40" // recursive initialization
  
  
  exception UndefinedException
  
  