anchor.diff:  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?
  +[<NoEquality; NoComparison>]
  +type internal LazyCellStatus<'T> =
  +    //
  +    | Delayed of (unit -> LazyListCell<'T>)
  +    //
  +    | Value of LazyListCell<'T>
  +    //
  +    | Exception of exn
  +
  +//
   and [<NoEquality; NoComparison>]
  +    [<CompilationRepresentation(CompilationRepresentationFlags.UseNullAsTrueValue)>]
       internal LazyListCell<'T> =
  -        | Empty
  -        | Cons of 'T * LazyList<'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 
  
positive.code: ///
  /// 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>]
      LazyList<'T> internal (initialStatus) =
      //
      let mutable status : LazyCellStatus<'T> = initialStatus
      
      member internal this.Value =
          match status with
  
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")>]
  