anchor.diff:  ///
   /// Lazy lists may be matched using the LazyList.Cons and LazyList.Nil active patterns. 
   /// These may force the computation of elements of the list.
  -and [<NoEquality; NoComparison>]
  +and [<NoEquality; NoComparison; Sealed>]
       LazyList<'T> internal (initialStatus) =
       //
  +    static let emptyList = LazyList (Value Empty)
  +
  +    //
       let mutable status : LazyCellStatus<'T> = initialStatus
  +
  +    /// The empty LazyList.
  +    static member Empty
  +        with get () = emptyList
       
       member internal this.Value =
           match status with
  
positive.code: exception UndefinedException
  
  //
  type
      [<NoEquality; NoComparison>]
      internal LazyCellStatus<'T> =
          | Delayed of (unit -> LazyListCell<'T>)
          | Value of LazyListCell<'T>
          | Exception of exn
  
  // OPTIMIZE : Would there be any benefit to applying [<UseNullAsTrueValue>] here
  // so CellEmpty would be represented as null?
  and [<NoEquality; NoComparison>]
      internal LazyListCell<'T> =
          | Empty
          | Cons of 'T * LazyList<'T>
  
  /// LazyLists are possibly-infinite, cached sequences.  See also IEnumerable/Seq for
  /// uncached sequences. LazyLists normally involve delayed computations without 
  
negative.code:     let inline private getCell (list : LazyList<'T>) =
          list.Value
  
      /// The empty LazyList.
      [<GeneralizableValue>]
      [<CompiledName("Empty")>]
      let empty<'T> : LazyList<'T> =
          LazyList<'T>.Empty
      
      /// Get the first cell of the list.
      [<CompiledName("TryGet")>]
  