anchor.diff:      /// <param name="stream">The input stream.</param>
       /// <returns>true if all of the elements satisfies the predicate. Otherwise, returns false.</returns>
       let inline forall (predicate : 'T -> bool) (stream : Stream<'T>) : bool = 
  -        not <| exists (fun value -> not <| predicate value) stream+        not <| exists (fun value -> not <| predicate value) stream
  
positive.code: /// Provides basic operations on Streams.
  [<RequireQualifiedAccessAttribute>]
  module Stream =
             
      /// <summary>Wraps array as a stream.</summary>
      /// <param name="source">The input array.</param>
  
negative.code:             streamf (fun value -> 
                  incr counter
                  if !counter > n then iterf value else true)
          Stream iter
  
  
      /// <summary>Concatenates a collection of streams.</summary>
      /// <param name="streams">The sequence of streams to concatenate.</param>
      /// <returns>The concatenated stream.</returns>
      let inline concat (streams: #seq<Stream<'T>>): Stream<'T> =
          let iter iterf =
              let current = ref Unchecked.defaultof<'T>
              let bulk =
                  fun () ->                    
                      for stream in streams do
                          let (Stream streamF) = stream
                          let (_, nextF) = streamF (fun v -> current := v; true)
                          let mutable flag = false
                          let mutable next = true
                          while not flag && next do
                              flag <- nextF()
                              if flag then next <- iterf !current
  
              let next =
                  let flag = ref true
                  if Seq.length streams = 0 then fun () -> false
                  else
                      fun () ->
                          if not !flag then false
                          else
                              let stream = Seq.head streams
                              let (Stream streamF) = stream
                              let (_, nextF) = streamF (fun v -> current := v; true)
  
                              let hasNext = nextF()
                              if hasNext then flag := iterf !current
                              hasNext
  
              (bulk, next)
  
          Stream iter
  
  
  