anchor.diff:  
           Array.map async.Return array
   
  +    /// Async implementation of Array.fold.
  +    let rec private foldImpl (folder : FSharpFunc<_,_,_>, array : 'T[], state : 'State, currentIndex) =
  +        async {
  +        if currentIndex >= array.Length then
  +            // We've reached the end of the array so return the final state value.
  +            return state
  +        else
  +            // Invoke the folder with the current array element and state value.
  +            let! state = folder.Invoke (state, array.[currentIndex])
  +
  +            // Continue folding over the remaining array elements.
  +            return! foldImpl (folder, array, state, currentIndex + 1)
  +        }
  +
  +    /// Async implementation of Array.fold.
  +    [<CompiledName("Fold")>]
  +    let fold (folder : 'State -> 'T -> Async<'State>) (state : 'State) (array : 'T[]) : Async<'State> =
  +        // Preconditions
  +        checkNonNull "array" array
  +
  +        // Call the recursive implementation.
  +        let folder = FSharpFunc<_,_,_>.Adapt folder
  +        foldImpl (folder, array, state, 0)
  +
  +    /// Async implementation of Array.foldBack.
  +    let rec private foldBackImpl (folder : FSharpFunc<_,_,_>, array : 'T[], state : 'State, currentIndex) =
  +        async {
  +        if currentIndex < 0 then
  +            // We've reached the beginning of the array so return the final state value.
  +            return state
  +        else
  +            // Invoke the folder with the current array element and state value.
  +            let! state = folder.Invoke (array.[currentIndex], state)
  +
  +            // Continue folding over the remaining array elements.
  +            return! foldBackImpl (folder, array, state, currentIndex - 1)
  +        }
  +
  +    /// Async implementation of Array.foldBack.
  +    [<CompiledName("FoldBack")>]
  +    let foldBack (folder : 'T -> 'State -> Async<'State>) (array : 'T[]) (state : 'State) : Async<'State> =
  +        // Preconditions
  +        checkNonNull "array" array
  +
  +        // Call the recursive implementation.
  +        let folder = FSharpFunc<_,_,_>.Adapt folder
  +        foldBackImpl (folder, array, state, array.Length - 1)
  +
  +    /// Async implementation of Array.foldi.
  +    let rec private foldiImpl (folder : FSharpFunc<_,_,_,_>, array : 'T[], state : 'State, currentIndex) =
  +        async {
  +        if currentIndex >= array.Length then
  +            // We've reached the end of the array so return the final state value.
  +            return state
  +        else
  +            // Invoke the folder with the current array element and state value.
  +            let! state = folder.Invoke (state, currentIndex, array.[currentIndex])
  +
  +            // Continue folding over the remaining array elements.
  +            return! foldiImpl (folder, array, state, currentIndex + 1)
  +        }
  +
  +    /// Async implementation of Array.foldi.
  +    [<CompiledName("FoldIndexed")>]
  +    let foldi (folder : 'State -> int -> 'T -> Async<'State>) (state : 'State) (array : 'T[]) : Async<'State> =
  +        // Preconditions
  +        checkNonNull "array" array
  +
  +        // Call the recursive implementation.
  +        let folder = FSharpFunc<_,_,_,_>.Adapt folder
  +        foldiImpl (folder, array, state, 0)
  +
  +    /// Async implementation of Array.foldiBack.
  +    let rec private foldiBackImpl (folder : FSharpFunc<_,_,_,_>, array : 'T[], state : 'State, currentIndex) =
  +        async {
  +        if currentIndex < 0 then
  +            // We've reached the beginning of the array so return the final state value.
  +            return state
  +        else
  +            // Invoke the folder with the current array element and state value.
  +            let! state = folder.Invoke (currentIndex, array.[currentIndex], state)
  +
  +            // Continue folding over the remaining array elements.
  +            return! foldiBackImpl (folder, array, state, currentIndex - 1)
  +        }
  +
  +    /// Async implementation of Array.foldiBack.
  +    [<CompiledName("FoldIndexedBack")>]
  +    let foldiBack (folder : int -> 'T -> 'State -> Async<'State>) (array : 'T[]) (state : 'State) : Async<'State> =
  +        // Preconditions
  +        checkNonNull "array" array
  +
  +        // Call the recursive implementation.
  +        let folder = FSharpFunc<_,_,_,_>.Adapt folder
  +        foldiBackImpl (folder, array, state, array.Length - 1)
  +
       /// Async implementation of Array.init.
       [<CompiledName("Init")>]
       let init (count : int) (initializer : int -> Async<'T>) : Async<'T[]> =
  
positive.code:             return keyNotFound "The array does not contain any elements which match the given predicate."
          }
  
  
  
  /// Functions for manipulating lists within 'async' workflows.
  
negative.code:         return result1, result2
          }
  
      /// Async implementation of Array.reduce.
      [<CompiledName("Reduce")>]
      let reduce (reduction : 'T -> 'T -> Async<'T>) (array : 'T[]) : Async<'T> =
  