anchor.diff:                              !resultRef }
               }
           cloud {
  -            return! stream.Apply collectorf (fun v -> local { return v }) (fun result -> local { return Array.tryPick id result })
  +            return! flow.Apply collectorf (fun v -> local { return v }) (fun result -> local { return Array.tryPick id result })
           }
   
   
       /// <summary>Returns the first element for which the given function returns true. Returns None if no such element exists.</summary>
       /// <param name="predicate">A function to test each source element for a condition.</param>
  -    /// <param name="stream">The input cloud stream.</param>
  +    /// <param name="flow">The input cloud flow.</param>
       /// <returns>The first element for which the predicate returns true, or None if every element evaluates to false.</returns>
  -    let inline tryFind (predicate : 'T -> bool) (stream : CloudFlow<'T>) : Cloud<'T option> =
  -        tryFindGen (fun _ctx x -> predicate x) stream 
  +    let inline tryFind (predicate : 'T -> bool) (flow : CloudFlow<'T>) : Cloud<'T option> =
  +        tryFindGen (fun _ctx x -> predicate x) flow 
   
       /// <summary>Returns the first element for which the given locally executing cloud function returns true. Returns None if no such element exists.</summary>
       /// <param name="predicate">A function to test each source element for a condition.</param>
  -    /// <param name="stream">The input cloud stream.</param>
  +    /// <param name="flow">The input cloud flow.</param>
       /// <returns>The first element for which the predicate returns true, or None if every element evaluates to false.</returns>
  -    let inline tryFindLocal (predicate : 'T -> Local<bool>) (stream : CloudFlow<'T>) : Cloud<'T option> =
  -        tryFindGen (fun ctx x -> predicate x |> run ctx) stream 
  +    let inline tryFindLocal (predicate : 'T -> Local<bool>) (flow : CloudFlow<'T>) : Cloud<'T option> =
  +        tryFindGen (fun ctx x -> predicate x |> run ctx) flow 
   
       /// <summary>Returns the first element for which the given function returns true. Raises KeyNotFoundException if no such element exists.</summary>
       /// <param name="predicate">A function to test each source element for a condition.</param>
  -    /// <param name="stream">The input cloud stream.</param>
  +    /// <param name="flow">The input cloud flow.</param>
       /// <returns>The first element for which the predicate returns true.</returns>
  -    /// <exception cref="System.KeyNotFoundException">Thrown if the predicate evaluates to false for all the elements of the cloud stream.</exception>
  -    let inline find (predicate : 'T -> bool) (stream : CloudFlow<'T>) : Cloud<'T> = 
  -        cloud {
  -            let! result = tryFind predicate stream 
  +    /// <exception cref="System.KeyNotFoundException">Thrown if the predicate evaluates to false for all the elements of the cloud flow.</exception>
  +    let inline find (predicate : 'T -> bool) (flow : CloudFlow<'T>) : Cloud<'T> = 
  +        cloud {
  +            let! result = tryFind predicate flow 
               return
                   match result with
                   | Some value -> value 
  
positive.code:                             !resultRef }
              }
          cloud {
              return! stream.Apply collectorf (fun v -> local { return v }) (fun result -> local { return Array.tryPick id result })
          }
  
  
      /// <summary>Applies the given function to successive elements, returning the first result where the function returns a Some value.</summary>
      /// <param name="chooser">A function that transforms items into options.</param>
      /// <param name="stream">The input cloud stream.</param>
      /// <returns>The first element for which the chooser returns Some, or None if every element evaluates to None.</returns>
      let inline tryPick (chooser : 'T -> 'R option) (stream : CloudFlow<'T>) : Cloud<'R option> = 
          tryPickGen (fun _ctx x -> chooser x) stream 
  
      /// <summary>Applies the given locally executing cloud function to successive elements, returning the first result where the function returns a Some value.</summary>
      /// <param name="chooser">A locally executing cloud function that transforms items into options.</param>
      /// <param name="stream">The input cloud stream.</param>
      /// <returns>The first element for which the chooser returns Some, or None if every element evaluates to None.</returns>
      let inline tryPickLocal (chooser : 'T -> Local<'R option>) (stream : CloudFlow<'T>) : Cloud<'R option> = 
          tryPickGen (fun ctx x -> chooser x |> run ctx) stream 
  
      /// <summary>Applies the given function to successive elements, returning the first result where the function returns a Some value.
      /// Raises KeyNotFoundException when every item of the cloud stream evaluates to None when the given function is applied.</summary>
      /// <param name="chooser">A function that transforms items into options.</param>
      /// <param name="stream">The input cloud stream.</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 stream evaluates to None when the given function is applied.</exception>
      let inline pick (chooser : 'T -> 'R option) (stream : CloudFlow<'T>) : Cloud<'R> = 
          cloud {
              let! result = tryPick chooser stream 
              return 
                  match result with
                  | Some value -> value 
  
negative.code:                         /// use sequential computation; should probably allow some degree of parallelization
                          let! results = Sequential.map computePartition partitions
  
                          // do not allow cache state updating in flow execution under local runtimes
                          if useCache then
                              let! worker = Cloud.CurrentWorker
                              do! source.UpdateCacheState(worker, partitions)
  