anchor.diff:                      None
                   | CellCons (hd, tl) ->
                       Some (hd, tl))
  -        (toSeq s).GetEnumerator ()
  +        (toSeq this).GetEnumerator ()
               
       interface IEnumerable<'T> with
  -        member s.GetEnumerator () =
  -            s.GetEnumeratorImpl ()
  +        member this.GetEnumerator () =
  +            this.GetEnumeratorImpl ()
   
       interface System.Collections.IEnumerable with
  -        override s.GetEnumerator () =
  -            s.GetEnumeratorImpl () :> System.Collections.IEnumerator
  -
  -
  -and
  -    [<NoEquality; NoComparison>]
  -    LazyCellStatus<'T> =
  -        | Delayed of (unit -> LazyListCell<'T>)
  -        | Value of LazyListCell<'T> 
  -        | Exception of System.Exception
  -
  -    // OPTIMIZE : Would there be any benefit to applying [<UseNullAsTrueValue>] here
  -    // so CellEmpty would be represented as null?
  -and
  -    [<NoEquality; NoComparison>]
  -    LazyListCell<'T> =
  -        | CellEmpty
  -        | CellCons of 'T * LazyList<'T> 
  -
  +        override this.GetEnumerator () =
  +            this.GetEnumeratorImpl ()
  +            :> System.Collections.IEnumerator
  +
  +//
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module LazyList =
       /// Curried form of the CellCons constructor.
  
positive.code: 
  //
  exception UndefinedException
  
  /// LazyLists are possibly-infinite, cached sequences.  See also IEnumerable/Seq for
  /// uncached sequences. LazyLists normally involve delayed computations without 
  
negative.code: 
      //
      let inline private lzy cellCreator : LazyList<'T> =
          LazyList (Delayed cellCreator)
  
      //
      let inline private getCell (list : LazyList<'T>) =
  