anchor.diff:              if count = 0 then
                   Empty
               else
  -                match getCell list with
  +                match list.Value with
                   | Cons (hd, tl) ->
                       consc hd (take (count - 1) tl)
                   | Empty ->
  -                    invalidArg "count" "not enough items in the list"
  -
  -    let rec private skipc n (list : LazyList<'T>) =
  -        if n = 0 then
  +                    let msg = sprintf "There are not enough items in the list. (Count = %i)" count
  +                    invalidArg "count" msg
  +
  +    let rec private skipCell count (list : LazyList<'T>) =
  +        if count = 0 then
               getCell list
           else
  -            match getCell list with
  +            match list.Value with
               | Cons (_, tl) ->
  -                skipc (n - 1) tl
  -            | Empty ->
  -                invalidArg "n" "not enough items in the list"
  +                skipCell (count - 1) tl
  +            | Empty ->
  +                let msg = sprintf "There are not enough items in the list. (Count = %i)" count
  +                invalidArg "count" msg
   
       /// Return the list which on consumption will skip the first 'count' elements of the input list.
       [<CompiledName("Skip")>]
  -    let rec skip count (list : LazyList<'T>) =
  +    let skip count (list : LazyList<'T>) =
           // Preconditions
           checkNonNull "list" list
           if count < 0 then
               argOutOfRange "count" "Cannot skip a negative number of elements."
   
           lzy <| fun () ->
  -            skipc count list
  +            skipCell count list
  +
  +    /// Apply the given function to each element of the collection.
  +    [<CompiledName("Iterate")>]
  +    let rec iter (action : 'T -> unit) (list : LazyList<'T>) =
  +        // Preconditions
  +        checkNonNull "list" list
  +
  +        match list.Value with
  +        | Empty -> ()
  +        | Cons (hd, tl) ->
  +            action hd
  +            iter action tl
   
       /// Build a collection from the given list. This function will eagerly
       /// evaluate the entire list (and thus may not terminate).
  
positive.code:         checkNonNull "list" list
  
          lzy <| fun () ->
              match getCell list with
              | Empty ->
                  consc state empty
              | Cons (hd, tl) ->
  
negative.code:             this.ToSeq().GetEnumerator ()
              :> System.Collections.IEnumerator
  
  /// Functional operators on LazyLists.
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module LazyList =
      /// The empty LazyList.
      [<GeneralizableValue>]
      [<CompiledName("Empty")>]
  