anchor.diff:          | 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>
  
positive.code:                     let! slice = (cached :> CloudArray<'T>).GetPartition(pid)
                      CloudArrayCache.Add(cached, pid, slice)
                  }
              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
                      |> Cloud.Ignore
              return cached :> _
          }
  
negative.code:                             let! results = 
                                  partitions 
                                  |> Array.map (fun partitionId -> createTask partitionId collectorf) 
                                  |> parallelInChunks workerCount
                              return Array.reduce combiner results
                              
                  } }
  
  