anchor.diff:                          let partitions = Partitions.ofLongRange workerCount (int64 source.Length)
                           let! results = 
                               partitions 
  -                            |> Array.map (fun (s, e) -> createTask [| for i in s..(e - 1L) do yield source.[int i] |] collectorf) 
  +                            |> Array.mapi (fun i (s, e) -> 
  +                                                let cloudBlock = createTask [| for i in s..(e - 1L) do yield source.[int i] |] collectorf
  +                                                (cloudBlock, workers.[i % workers.Length])) 
                               |> Cloud.Parallel
                           return! combiner results 
                       else
  
positive.code:     /// gets all partition indices found in cloud vector
      let inline private getPartitionIndices (v : CloudVector<'T>) = [| 0 .. v.PartitionCount - 1 |]
  
      /// Flat map/reduce with sequential execution on leafs.
      let inline private parallelInChunks (npar : int) (workflows : Local<'T> []) = cloud {
          let! partials = 
              workflows 
              |> Partitions.ofArray npar
              |> Array.map (fun wfs -> wfs |> Local.Parallel)
              |> Cloud.Parallel
          return Array.concat partials
      }
  
      /// Converts MBrace.Flow.Collector to Nessos.Streams.Collector
      let inline private toParStreamCollector (collector : Collector<'T, 'S>) =
  
negative.code:                         match collector.DegreeOfParallelism with
                          | Some n -> local { return n }
                          | _ -> Cloud.GetWorkerCount()
                      let! workers = Cloud.GetAvailableWorkers()
  
                      let rangeBasedReadLines (s : int64) (e : int64) (stream : System.IO.Stream) = 
                          seq {
  