anchor.diff:                              {   Index = iterator.Index; 
                                   Func = 
                                       (fun value -> 
  -                                        let (Stream streamf) = f value
  +                                        let (Stream streamf) = f ctx value
                                           let cts = CancellationTokenSource.CreateLinkedTokenSource(iterator.Cts.Token)
                                           let { Bulk = bulk; Iterator = _ } = streamf { Complete = (fun () -> ()); Cont = iter; Cts = cts } in bulk ());
                                   Cts = iterator.Cts }
  
positive.code:                                     let mutable grouping = Unchecked.defaultof<_>
                                      if dict.TryGetValue(key, &grouping) then
                                          let acc = grouping
                                          lock grouping (fun () -> acc := combiner !acc value) 
                                      else
                                          grouping <- ref <| state ()
                                          if not <| dict.TryAdd(key, grouping) then
                                              dict.TryGetValue(key, &grouping) |> ignore
                                          let acc = grouping
                                          lock grouping (fun () -> acc := combiner !acc value) 
                                  ());
                          Cts = new CancellationTokenSource() }
                  member self.Result =
  
negative.code:             when ^T : (static member ( + ) : ^T * ^T -> ^T) 
              and  ^T : (static member Zero : ^T) = 
          fold (+) (+) (fun () -> LanguagePrimitives.GenericZero) stream
  
  
      /// <summary>Applies a key-generating function to each element of a CloudStream and return the sum of the keys.</summary>
      /// <param name="stream">The input CloudStream.</param>
      /// <returns>The sum of the keys.</returns>
      let inline sumBy projection (stream : CloudStream< ^T >) : Cloud< ^T > 
              when ^T : (static member ( + ) : ^T * ^T -> ^T) 
              and  ^T : (static member Zero : ^T) = 
          fold (fun s x -> s + projection x) (+) (fun () -> LanguagePrimitives.GenericZero) stream
  
      /// <summary>Returns the total number of elements of the CloudStream.</summary>
      /// <param name="stream">The input CloudStream.</param>
  