anchor.diff:                  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.
  
positive.code:     let inline private lzy cellCreator : LazyList<'T> =
          LazyList<_>.CreateLazy cellCreator
  
      /// Apply the given function to successive elements of the list, returning the first
      /// result where function returns <c>Some(x)</c> for some x.
      /// If the function never returns true, 'None' is returned.
  
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")>]
  