anchor.diff:              | hd :: tl ->
                   consc hd (ofList tl)
   
  -    /// Build a non-lazy list from the given collection. This function will eagerly
  -    /// evaluate the entire list (and thus may not terminate).
  -    [<CompiledName("ToList")>]
  -    let toList (list : LazyList<'T>) =
  -        // Preconditions
  -        checkNonNull "list" list
  -
  -        let rec loop acc (list : LazyList<'T>) =
  -            match list.Value with
  -            | Empty ->
  -                List.rev acc
  -            | Cons (hd, tl) ->
  -                loop (hd :: acc) tl
  -        loop [] list
  -
       let rec private copyFrom index (array : 'T[]) =
           lzy <| fun () ->
               if index >= Array.length array then
  
positive.code:                 Empty
              | Some (value, state) ->
                  Cons (value, unfold generator state)
  
      /// Return the list which contains on demand the elements of the
      /// first list followed by the elements of the second list.
      [<CompiledName("Append")>]
      let rec append (list1 : LazyList<'T>) (list2 : LazyList<'T>) =
          // Preconditions
          checkNonNull "list1" list1
          checkNonNull "list2" list2
  
          lzy <| fun () ->
              appendCell list1 list2
  
      and private appendCell list1 list2 =
          match list1.Value with
          | Empty ->
              list2.Value
          | Cons (hd, tl) ->
              consc hd (append tl list2)
  
      /// Return the list which contains on demand the list of elements of the list of lazy lists.
      [<CompiledName("Concat")>]
      let rec concat (lists : LazyList<LazyList<'T>>) =
          // Preconditions
          checkNonNull "lists" lists
  
          lzy <| fun () ->
              match lists.Value with
              | Empty ->
                  Empty
              | Cons (hd, tl) ->
                  appendCell hd (concat tl)
  
      /// Return the list which on consumption will consist of an
      /// infinite sequence of the given item.
      [<CompiledName("Repeat")>]
      let repeat value : LazyList<'T> =
          let rec s = cons value (delayed (fun () -> s))
          s
  
      /// Build a new collection whose elements are the results of applying
      /// the given function to each of the elements of the collection.
  
negative.code:             action hd
              iter action tl
  
      // NOTE : This function doesn't dispose the IEnumerator until it reaches
      // the end of the enumeration; this function can therefore cause memory leaks
      // if not used carefully.
      let rec private ofFreshIEnumerator (e : IEnumerator<'T>) =
          lzy <| fun () ->
              if e.MoveNext () then
                  consc e.Current (ofFreshIEnumerator e)
              else
                 e.Dispose ()
                 Empty
  
      /// Build a new collection from the given enumerable object.
      [<CompiledName("OfSeq")>]
      let ofSeq (sequence : seq<'T>) =
          // Preconditions
          checkNonNull "sequence" sequence
  
          sequence.GetEnumerator ()
          |> ofFreshIEnumerator
  
      /// Build a collection from the given list. This function will eagerly
      /// evaluate the entire list (and thus may not terminate).
      [<CompiledName("OfList")>]
  