anchor.diff:      /// <param name="reducer">The reducer function.</param>
       /// <param name="source">The input flow.</param>
       /// <returns>A flow of key - reduced value pairs.</returns>
  -    let inline reduceBy (projection : 'T -> 'Key) (reducer : 'T -> 'T -> 'T) (source : CloudFlow<'T>) : CloudFlow<'Key * 'T> =
  +    let reduceBy (projection : 'T -> 'Key) (reducer : 'T -> 'T -> 'T) (source : CloudFlow<'T>) : CloudFlow<'Key * 'T> =
           foldBy (fun v -> projection v)
                  (fun state x -> match state with Some y -> y := reducer !y x; state | None -> Some (ref x))
                  (fun left right ->
  
positive.code:     /// <param name="state">A function that produces the initial state.</param>
      /// <param name="flow">The input CloudFlow.</param>
      /// <returns>The final result.</returns>
      let inline fold (folder : 'State -> 'T -> 'State) (combiner : 'State -> 'State -> 'State)
                      (state : unit -> 'State) (flow : CloudFlow<'T>) : Cloud<'State> =
          foldGen (fun _ x y -> folder x y) (fun _ x y -> combiner x y) (fun _ -> state ()) flow
  
      let inline private foldByGen (projection : ExecutionContext -> 'T -> 'Key)
                                   (folder : ExecutionContext -> 'State -> 'T -> 'State)
                                   (combiner : ExecutionContext -> 'State -> 'State -> 'State)
                                   (state : ExecutionContext -> 'State) (flow : CloudFlow<'T>) : CloudFlow<'Key * 'State> =
  
negative.code:     /// <param name="f">A function to transform items from the input CloudFlow.</param>
      /// <param name="flow">The input CloudFlow.</param>
      /// <returns>The result CloudFlow.</returns>
      let collect (f : 'T -> #seq<'R>) (flow : CloudFlow<'T>) : CloudFlow<'R> =
          collectGen (fun _ x -> f x) flow
  
      /// <summary>Transforms each element of the input CloudFlow to a new sequence and flattens its elements using a locally executing cloud function.</summary>
      /// <param name="f">A locally executing cloud function to transform items from the input CloudFlow.</param>
      /// <param name="flow">The input CloudFlow.</param>
      /// <returns>The result CloudFlow.</returns>
      let collectLocal (f : 'T -> Local<#seq<'R>>) (flow : CloudFlow<'T>) : CloudFlow<'R> =
          collectGen (fun ctx x -> f x |> run ctx) flow
  
      let private filterGen (predicate : ExecutionContext -> 'T -> bool) (flow : CloudFlow<'T>) : CloudFlow<'T> =
          { new CloudFlow<'T> with
              member self.DegreeOfParallelism = flow.DegreeOfParallelism
              member self.WithEvaluators<'S, 'R> (collectorf : Local<Collector<'T, 'S>>) (projection : 'S -> Local<'R>) combiner =
  