anchor.diff:  
       //
       let inline private lzy cellCreator : LazyList<'T> =
  -        { status = Delayed cellCreator; }
  +        LazyList (Delayed cellCreator)
   
       //
       let inline private getCell (list : LazyList<'T>) =
  
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:     [<GeneralizableValue>]
      [<CompiledName("Empty")>]
      let empty<'T> : LazyList<'T> =
          LazyList (Value CellEmpty)
      
      /// Get the first cell of the list.
      [<CompiledName("TryGet")>]
  