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?
  +and [<NoEquality; NoComparison>]
  +    internal LazyListCell<'T> =
  +        | CellEmpty
  +        | CellCons 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.
  [<NoEquality; NoComparison>]
  type LazyList<'T> = {
      //
      mutable status : LazyCellStatus<'T>;
  } with
      
      member x.Value =
          match x.status with
          | LazyCellStatus.Value value ->
              value
          | _ ->
              lock x <| fun () ->
                  match x.status with
                  | LazyCellStatus.Delayed f ->
                      x.status <- Exception UndefinedException
                      try
                          let res = f ()
                          x.status <- LazyCellStatus.Value res
                          res
                      with ex ->
                          x.status <- LazyCellStatus.Exception ex
                          reraise ()
                  | LazyCellStatus.Value value ->
                      value
                  | LazyCellStatus.Exception ex ->
                      raise ex
      
      member s.GetEnumeratorImpl() =
          let getCell (x : LazyList<'T>) = x.Value
          let toSeq s =
              s |> Seq.unfold (fun list ->
                  match getCell list with
  
negative.code: 
      //
      let inline private lzy cellCreator : LazyList<'T> =
          LazyList (Delayed cellCreator)
  
      //
      let inline private getCell (list : LazyList<'T>) =
  