anchor.diff:      //
       | Empty
       //
  -    | Cons of 'T * LazyList<'T>
  +    | Cons of 'T * LazyList<'T>    
   
   /// LazyLists are possibly-infinite, cached sequences.  See also IEnumerable/Seq for
   /// uncached sequences. LazyLists normally involve delayed computations without 
  
positive.code:                 None
              | Cons (hd, tl) ->
                  Some (hd, tl))
              
      interface IEnumerable<'T> with
          member this.GetEnumerator () =
  
negative.code:         checkNonNull "list" list
  
          let rec loop acc (list : LazyList<'T>) =
              match list.Value with
              | Empty ->
                  List.rev acc
              | Cons (hd, tl) ->
                  loop (hd :: acc) tl
          loop [] list
  
      let rec private copyFrom index (array : 'T[]) =
          lzy <| fun () ->
  