anchor.diff:                                  let! results2 = restPartitions 
                                                   |> Set.toArray 
                                                   |> Array.map (fun pid -> cloud { let! r = createTask pid collectorf in return pid,r }) 
  -                                                |> Cloud.Parallel
  +                                                |> parallelInChunks workerCount
                                   let final = Seq.append results1 results2
                                               |> Seq.sortBy (fun (p,_) -> p)
                                               |> Seq.map (fun (_,r) -> r)
  
positive.code:         | Sequential  -> return failwith "Invalid CloudStream context : %A" ctx
          | ThreadParallel -> return 1
          | Distributed -> return! Cloud.GetWorkerCount()
      }
  
      /// <summary>Wraps array as a CloudStream.</summary>
  
negative.code:                     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) 
                      |> parallelInChunks workerCount
                      |> Cloud.Ignore
              return cached :> _
          }
  