anchor.diff:  
   
   
  -    let inline private sortByGen comparer (projection : ExecutionContext -> 'T -> 'Key) (takeCount : int) (stream : CloudFlow<'T>) : CloudFlow<'T> = 
  +    let inline private sortByGen comparer (projection : ExecutionContext -> 'T -> 'Key) (takeCount : int) (flow : CloudFlow<'T>) : CloudFlow<'T> = 
           let collectorf = local {  
               let results = new List<List<'T>>()
               let! ctx = Cloud.GetExecutionContext()
               return 
                 { new Collector<'T, List<'Key[] * 'T []>> with
  -                member self.DegreeOfParallelism = stream.DegreeOfParallelism 
  +                member self.DegreeOfParallelism = flow.DegreeOfParallelism 
                   member self.Iterator() = 
                       let list = new List<'T>()
                       results.Add(list)
  
positive.code:                         /// use sequential computation; should probably allow some degree of parallelization
                          let! results = Sequential.map computePartition partitions
  
                          // do not allow cache state updating in stream execution under local runtimes
                          if useCache then
                              let! worker = Cloud.CurrentWorker
                              do! source.UpdateCacheState(worker, partitions)
  
negative.code:         }
  
      /// <summary>Applies the given locally executing cloud function to successive elements, returning the first result where the function returns a Some value.
      /// Raises KeyNotFoundException when every item of the cloud flow evaluates to None when the given function is applied.</summary>
      /// <param name="chooser">A locally executing cloud function that transforms items into options.</param>
      /// <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 
                  match result with
                  | Some value -> value 
                  | None -> raise <| new KeyNotFoundException()
          }
  
      /// <summary>Tests if any element of the flow satisfies the given predicate.</summary>
      /// <param name="predicate">A function to test each source element for a condition.</param>
      /// <param name="flow">The input cloud flow.</param>
      /// <returns>true if any element satisfies the predicate. Otherwise, returns false.</returns>
      let inline exists (predicate : 'T -> bool) (flow : CloudFlow<'T>) : Cloud<bool> = 
          cloud {
              let! result = tryFind predicate flow 
              return 
                  match result with
                  | Some value -> true
                  | None -> false
          }
  
      /// <summary>Tests if any element of the flow satisfies the given locally executing cloud predicate.</summary>
      /// <param name="predicate">A locally executing cloud function to test each source element for a condition.</param>
      /// <param name="flow">The input cloud flow.</param>
      /// <returns>true if any element satisfies the predicate. Otherwise, returns false.</returns>
      let inline existsLocal (predicate : 'T -> Local<bool>) (flow : CloudFlow<'T>) : Cloud<bool> = 
          cloud {
              let! result = tryFindLocal predicate flow 
              return 
                  match result with
                  | Some value -> true
  