anchor.diff:              member self.SourceType = SourceType.Array
               member self.PreserveOrdering = false
               member self.Stream () = Stream.ofArray source
  -            member self.Apply<'R> (collector : Collector<'T, 'R>) =
  +            member self.Apply<'R> (collector : ParCollector<'T, 'R>) =
                   if not (source.Length = 0) then 
                       let partitions = getPartitions collector.DegreeOfParallelism source.Length
                       let nextRef = ref true
  
positive.code:             member self.SourceType = stream.SourceType
              member self.PreserveOrdering = stream.PreserveOrdering
              member self.Stream() = stream.Stream() |> Stream.skip n
              member self.Apply<'S> (collector : Collector<'T, 'S>) =
                  let collector = 
                      let count = ref 0
                      { new Collector<'T, 'S> with
                          member self.DegreeOfParallelism = collector.DegreeOfParallelism
                          member self.Iterator() = 
                              let { Func = iter } as iterator = collector.Iterator()
  
negative.code:         if stream.PreserveOrdering then
              stream.Stream() |> Stream.toArray
          else
              let arrayParCollector = 
                  Internals.foldInlined
                      (fun (acc : ArrayCollector<'T>) value -> acc.Add(value); acc)
                      (fun left right -> left.AddRange(right); left) 
                      (fun () -> new ArrayCollector<'T>()) stream 
              arrayParCollector.ToArray()
  
      /// <summary>Creates an ResizeArray from the given parallel stream.</summary>
      /// <param name="stream">The input parallel stream.</param>
  