anchor.diff:      let inline private lzy cellCreator : LazyList<'T> =
           LazyList<_>.CreateLazy cellCreator
   
  +    /// Return the length of the list.
  +    [<CompiledName("Length")>]
  +    let length (list : LazyList<'T>) =
  +        // Preconditions
  +        checkNonNull "list" list
  +
  +        let rec lengthAux acc (list : LazyList<'T>) =
  +            match list.Value with
  +            | Empty ->
  +                int acc
  +            | Cons (_, tl) ->
  +                lengthAux (acc + 1u) tl
  +
  +        lengthAux 0u list
  +
  +    /// 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
  +
  +    /// 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)
  +
       /// 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.
  
positive.code: 
          copyFrom 0 array
  
      /// Build an array from the given collection.
      [<CompiledName("ToArray")>]
      let toArray (list : LazyList<'T>) =
  
negative.code:                 Empty
              | Some (value, state) ->
                  Cons (value, unfold generator state)
  
      /// Build a new collection whose elements are the results of applying
      /// the given function to each of the elements of the collection.
  