anchor.diff:      let inline private getCell (list : LazyList<'T>) =
           list.Value
   
  -    /// Evaluates to the list that contains no items.
  +    /// The empty LazyList.
       [<GeneralizableValue>]
       [<CompiledName("Empty")>]
       let empty<'T> : LazyList<'T> =
  -        LazyList (Value Empty)
  +        LazyList<'T>.Empty
       
       /// Get the first cell of the list.
       [<CompiledName("TryGet")>]
  
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: exception UndefinedException
  
  //
  [<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>
  
  /// LazyLists are possibly-infinite, cached sequences.  See also IEnumerable/Seq for
  /// uncached sequences. LazyLists normally involve delayed computations without 
  