anchor.diff:          checkNonNull "list" list
   
           lzy <| fun () ->
  -            match getCell list with
  +            match list.Value with
               | Empty ->
                   Empty
               | Cons (hd, tl) ->
  
positive.code:     /// 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 () ->
              appendc list1 list2
  
      and private appendc l1 l2 =
          match getCell l1 with
          | Empty ->
              getCell l2
          | Cons (hd, tl) ->
              consc hd (append tl l2)
  
      /// Return a list that is -- in effect -- the list returned by the given computation.
      /// The given computation is not executed until the first element on the list is consumed.
      [<CompiledName("Delayed")>]
      let delayed creator : LazyList<'T> =
          lzy <| fun () ->
              creator ()
              |> getCell
  
      /// Return the list which on consumption will consist of an
      /// infinite sequence of the given item.
  
negative.code:             if count = 0 then
                  Empty
              else
                  match list.Value with
                  | Cons (hd, tl) ->
                      consc hd (take (count - 1) tl)
                  | Empty ->
                      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 list.Value with
              | Cons (_, tl) ->
                  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 skip count (list : LazyList<'T>) =
          // Preconditions
          checkNonNull "list" list
          if count < 0 then
              argOutOfRange "count" "Cannot skip a negative number of elements."
  
          lzy <| fun () ->
              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).
  