anchor.diff:                      let! slice = (cached :> CloudArray<'T>).GetPartition(pid)
                       CloudArrayCache.Add(cached, pid, slice)
                   }
  +            let! workerCount = getWorkerCount()
               let taskId = Guid.NewGuid().ToString()
               let cached = new CachedCloudArray<'T>(source, taskId)
               if source.Length > 0L then
                   let partitions = [|0..source.PartitionCount-1|]
                   do! partitions 
                       |> Array.map (fun pid -> createTask pid cached) 
  -                    |> Cloud.Parallel
  +                    |> parallelInChunks workerCount
                       |> Cloud.Ignore
               return cached :> _
           }
  
positive.code:                                 let! results2 = restPartitions 
                                                  |> Set.toArray 
                                                  |> Array.map (fun pid -> cloud { let! r = createTask pid collectorf in return pid,r }) 
                                                  |> Cloud.Parallel
                                  let final = Seq.append results1 results2
                                              |> Seq.sortBy (fun (p,_) -> p)
                                              |> Seq.map (fun (_,r) -> r)
  
negative.code:         | Sequential  -> return failwith "Invalid CloudStream context : %A" ctx
          | ThreadParallel -> return 1
          | Distributed -> return! Cloud.GetWorkerCount()
      }
  
      /// Flat map/reduce with sequential execution on leafs.
      let inline private parallelInChunks (npar : int) (workflows : Cloud<'T> []) = cloud {
          let! partials = 
              workflows 
              |> Partitions.ofArray npar
              |> Array.map (fun wfs -> wfs |> Cloud.Parallel |> Cloud.ToSequential)
              |> Cloud.Parallel
          return Array.concat partials
      }
  
      /// <summary>Wraps array as a CloudStream.</summary>
  