anchor.diff:                                      let! partial = projection collectorResult
                                       result.Add(partial)
                                   if result.Count = 0 then
  -                                    return! projection (collectorf ()).Result
  +                                    let! collector = collectorf
  +                                    return! projection collector.Result
                                   else
                                       return Array.reduce combiner (result.ToArray())
                               }
  
positive.code:         let degreeOfParallelism = ref None
          { new CloudStream<'T> with
              member self.DegreeOfParallelism = degreeOfParallelism
              member self.Apply<'S, 'R> (collectorf : unit -> Collector<'T, 'S>) (projection : 'S -> Cloud<'R>) (combiner : 'R -> 'R -> 'R) =
                  cloud { 
                      if Seq.isEmpty sources then 
                          return! projection (collectorf ()).Result
                      else
                          let! workerCount = 
                              match !self.DegreeOfParallelism with
                              | Some n -> cloud { return n }
                              | None -> Cloud.GetWorkerCount()
  
                          let createTask (files : CloudFile []) (collectorf : unit -> Collector<'T, 'S>) : Cloud<'R> = 
                              cloud {
                                  let rec partitionByLength (files : CloudFile []) index (currLength : int64) (currAcc : CloudFile list) (acc : CloudFile list list)=
                                      cloud {
  
negative.code:                 member self.Result =
                      dict
                      |> Seq.map (fun keyValue -> (keyValue.Key, !keyValue.Value)) }
          }
          // Phase 2
          let reducer (stream : CloudStream<int * CloudArray<'Key * 'State>>) : Cloud<CloudArray<'Key * 'State>> = 
              cloud {
  