anchor.diff:  
           copyFrom 0 array
   
  +    /// Return a view of the collection as an enumerable object.
  +    [<CompiledName("ToSeq")>]
  +    let inline toSeq (list : LazyList<'T>) =
  +        // Preconditions
  +        checkNonNull "list" list
  +
  +        list.ToSeq ()
  +
  +    /// 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
  +
       /// Build an array from the given collection.
       [<CompiledName("ToArray")>]
       let toArray (list : LazyList<'T>) =
  
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:         let elements = ResizeArray ()
          iter elements.Add list
          ResizeArray.toArray elements
  
  
  /// Active patterns for deconstructing lazy lists.
  