anchor.diff:      /// The integer index passed to the function indicates the array index of the element being transformed.
       /// The index values are tagged with a unit-of-measure type before applying them to the folder function.
       [<CompiledName("FoldIndexed")>]
  -    let foldi (folder : int<'Tag> -> 'State -> 'T -> 'State) (state : 'State) (arr : 'T[]) =
  -        // Preconditions
  -        checkNonNull "arr" arr
  +    let foldi (folder : int<'Tag> -> 'State -> 'T -> 'State) (state : 'State) (array : 'T[]) =
  +        // Preconditions
  +        checkNonNull "array" array
           
           let folder = OptimizedClosures.FSharpFunc<_,_,_,_>.Adapt folder
           let mutable state = state
  -        let len = arr.Length
  +        let len = Array.length array
           for i = 0 to len - 1 do
  -            state <- folder.Invoke (Int32WithMeasure<'Tag> i, state, arr.[i])
  +            state <- folder.Invoke (Int32WithMeasure<'Tag> i, state, array.[i])
  +        state
  +
  +    /// Applies a function to each element of the collection, threading an accumulator argument through the computation.
  +    /// The integer index passed to the function indicates the array index of the element being transformed.
  +    /// The index values are tagged with a unit-of-measure type before applying them to the folder function.
  +    [<CompiledName("FoldBackIndexed")>]
  +    let foldiBack (folder : int<'Tag> -> 'T -> 'State -> 'State) (array : 'T[]) (state : 'State) : 'State =
  +        // Preconditions
  +        checkNonNull "array" array
  +
  +        let folder = FSharpFunc<_,_,_,_>.Adapt folder
  +        
  +        let mutable state = state
  +        for i = Array.length array - 1 downto 0 do
  +            state <- folder.Invoke (Int32WithMeasure<'Tag> i, array.[i], state)
           state
   
   
  
positive.code:     let [<NoDynamicInvocation>] inline toSet (array : 'T[]) : Set<'T> =
          Set.ofArray array
  
      /// Applies a function to each element of the collection, threading an accumulator argument through the computation.
      /// The integer index passed to the function indicates the array index of the element being transformed.
      [<CompiledName("FoldIndexed")>]
  
negative.code:         state
  
      // TODO :
      // foldPairs, foldBackPairs
      // derive    // takes a 'T -> 'T -> 'T like reduce, but only performs one step; used to perform 'divided differences'
          // Other possible names: reduceOnce, reduceStep
  
  
  //
  