anchor.diff:  module Distributed =
   
       /// <summary>
  -    ///     Distributed mapCombine combinator. Input data is partitioned according to cluster size
  +    ///     Distributed reduceCombine combinator. Input data is partitioned according to cluster size
       ///     and distributed to worker nodes accordingly. It is then further partitioned
       ///     according to the processor count of each worker.
       /// </summary>
  -    /// <param name="mapper">Map function that performs a local computation on a set of inputs.</param>
  -    /// <param name="combiner">Combiner function that composes two results.</param>
  +    /// <param name="reducer">Sequential reducer workflow.</param>
  +    /// <param name="combiner">Combiner function that sequentially composes a collection of results.</param>
       /// <param name="init">Initial state and identity element of result space.</param>
       /// <param name="source">Input data.</param>
  -    let mapCombine (mapper : 'T [] -> Cloud<'State>) 
  -                    (combiner : 'State [] -> Cloud<'State>)
  -                    (init : 'State) (source : seq<'T>) : Cloud<'State> =
  +    let reduceCombine (reducer : 'T [] -> Cloud<'State>) 
  +                        (combiner : 'State [] -> Cloud<'State>)
  +                        (init : 'State) (source : seq<'T>) : Cloud<'State> =
   
           let rec aux (inputs : 'T []) = cloud {
               if inputs.Length = 0 then return init else
               let! ctx = Cloud.GetSchedulingContext()
               match ctx with
  -            | Sequential -> return! mapper inputs
  +            | Sequential -> return! reducer inputs
               | ThreadParallel ->
                   let cores = System.Environment.ProcessorCount
                   let chunks = Array.splitByPartitionCount cores inputs
  
positive.code:     /// <param name="predicate">Predicate function.</param>
      /// <param name="source">Input data.</param>
      let filter (predicate : 'T -> Cloud<bool>) (source : seq<'T>) : Cloud<'T []> =
          mapCombine (Sequential.filter predicate) (Cloud.lift Array.concat) [||] source
  
      /// <summary>
      ///     Distributed choose combinator. Input data is partitioned according to cluster size
  
negative.code:     /// <param name="mapper">Mapper function.</param>
      /// <param name="source">Input data.</param>
      let map (mapper : 'T -> Cloud<'S>) (source : seq<'T>) : Cloud<'S []> = 
          reduceCombine (Sequential.map mapper) (Cloud.lift Array.concat) [||] source
  
      /// <summary>
      ///     Distributed filter combinator. Input data is partitioned according to cluster size
  