anchor.diff:          LazyList.singleton value
       member __.YieldFrom (list : LazyList<'T>) =
           list
  -    member __.For (lazyList : LazyList<'T>, binding) =
  +    member __.For (lazyList : LazyList<'T>, binding) : LazyList<'U> =
           LazyList.collect binding lazyList
  -    member __.For (sequence, f) =
  +    member __.For (sequence : seq<'T>, binding) : LazyList<'U> =
           // TODO :   Right now, we're evaluating the entire sequence, then wrapping the results in a LazyList.
           //          It would be more efficient to evaluate the sequence on-demand, though we need to decide if it's safe enough.
           //          Or, we could use type tests on 'sequence' so if it's an array, list, etc., we can use a more-efficient conversion to LazyList.
           // LazyList.collect f (LazyList.ofSeq sequence)
  -        LazyList.collect f (LazyList.ofList (List.ofSeq sequence))
  +        LazyList.collect binding (LazyList.ofList (List.ofSeq sequence))
       member __.Bind (lazyValue : Lazy<'T>, binding : 'T -> LazyList<'U>) =
           LazyList.Delayed (fun () ->
               lazyValue.Force ()
  
positive.code:         | Cons (hd, tl) ->
              Some (hd, tl)
  
      /// <summary>Creates a sequence which enumerates the values in the <see cref="LazyList`1"/>.</summary>
      member this.ToSeq () =
          this
          |> Seq.unfold (fun list ->
  
negative.code: 
  
  type LazyList<'T> with
      /// <summary>Appends the second <see cref="LazyList`1{T}"/> to the end of the first.</summary>
      /// <param name="list1"></param>
      /// <param name="list2"></param>
      /// <returns></returns>
  