anchor.diff:              and  ^U : (static member Zero : ^U) =
           cloud {
               let! (y, c) =
  -                foldGen (fun _ ((y, c) as state) v ->
  -                             y := Checked.(+) !y (projection v)
  -                             incr c
  -                             state)
  -                        (fun _ ((y, c) as state) (y', c') ->
  -                             y := Checked.(+) !y !y'
  -                             c := !c + !c'
  -                             state)
  -                        (fun _ -> ref LanguagePrimitives.GenericZero, ref 0)
  -                        source
  +                fold (fun ((y, c) as state) v ->
  +                          y := Checked.(+) !y (projection v)
  +                          incr c
  +                          state)
  +                     (fun ((y, c) as state) (y', c') ->
  +                          y := Checked.(+) !y !y'
  +                          c := !c + !c'
  +                          state)
  +                     (fun () -> ref LanguagePrimitives.GenericZero, ref 0)
  +                     source
   
               if !c = 0 then return! Cloud.Raise (new System.ArgumentException("The input flow was empty.", "source"))
               else return LanguagePrimitives.DivideByInt !y !c
  
positive.code:     /// <param name="flow">The input cloud flow.</param>
      /// <returns>The first element for which the chooser returns Some, or raises KeyNotFoundException if every element evaluates to None.</returns>
      /// <exception cref="System.KeyNotFoundException">Thrown if every item of the cloud flow evaluates to None when the given function is applied.</exception>
      let inline pickLocal (chooser : 'T -> Local<'R option>) (flow : CloudFlow<'T>) : Cloud<'R> =
          cloud {
              let! result = tryPickLocal chooser flow
              return
  
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 map  (f : 'T -> 'R) (flow : CloudFlow<'T>) : CloudFlow<'R> =
          mapGen (fun _ x -> f x) flow
  
      /// <summary>Transforms each element of the input CloudFlow 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 mapLocal (f : 'T -> Local<'R>) (flow : CloudFlow<'T>) : CloudFlow<'R> =
          mapGen (fun ctx x -> f x |> run ctx) flow
  
      let private collectGen (f : ExecutionContext -> 'T -> #seq<'R>) (flow : CloudFlow<'T>) : CloudFlow<'R> =
          { new CloudFlow<'R> with
              member self.DegreeOfParallelism = flow.DegreeOfParallelism
              member self.WithEvaluators<'S, 'Result> (collectorf : Local<Collector<'R, 'S>>) (projection : 'S -> Local<'Result>) combiner =
  