anchor.diff:      /// 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")>]
  -    let foldi (folder : int -> 'State -> 'T -> 'State) (state : 'State) (arr : 'T[]) =
  -        checkNonNull "arr" arr
  +    let foldi (folder : int -> 'State -> 'T -> 'State) (state : 'State) (array : 'T[]) =
  +        // Preconditions
  +        checkNonNull "array" array
  +
           let folder = FSharpFunc<_,_,_,_>.Adapt folder
           let mutable state = state
  -        let len = arr.Length
  +        let len = array.Length
           for i = 0 to len - 1 do
  -            state <- folder.Invoke (i, state, arr.[i])
  +            state <- folder.Invoke (i, state, array.[i])
           state
   
       /// Applies a function to each element of the array, returning a new array whose elements are
       /// tuples of the original element and the function result for that element.
       [<CompiledName("ProjectValues")>]
       let projectValues (projection : 'Key -> 'U) (array : 'Key[]) =
  +        // Preconditions
  +        checkNonNull "array" array
  +
           array |> Array.map (fun x -> x, projection x)
   
       //
       [<CompiledName("ProjectKeys")>]
       let projectKeys (projection : 'T -> 'Key) (array : 'T[]) =
  +        // Preconditions
  +        checkNonNull "array" array
  +
           array |> Array.map (fun x -> projection x, x)
   
       /// Returns the first element in the array.
  -    let [<NoDynamicInvocation>] inline first (arr : 'T[]) =
  -        if Array.isEmpty arr then
  +    let [<NoDynamicInvocation>] inline first (array : 'T[]) =
  +        if Array.isEmpty array then
               invalidOp "Cannot retrieve the first element of an empty array."
  -        else arr.[0]
  +        else array.[0]
   
       /// Returns the index of the last element in the array.
  -    let [<NoDynamicInvocation>] inline lastIndex (arr : 'T[]) =
  -        if Array.isEmpty arr then
  +    let [<NoDynamicInvocation>] inline lastIndex (array : 'T[]) =
  +        if Array.isEmpty array then
               invalidOp "The array is empty."
  -        else arr.Length - 1
  +        else array.Length - 1
   
       /// Returns the last element in the array.
  -    let [<NoDynamicInvocation>] inline last (arr : 'T[]) =
  -        if Array.isEmpty arr then
  +    let [<NoDynamicInvocation>] inline last (array : 'T[]) =
  +        if Array.isEmpty array then
               invalidOp "Cannot retrieve the last element of an empty array."
  -        else arr.[arr.Length - 1]
  +        else array.[array.Length - 1]
   
       /// Splits an array into one or more arrays; the specified predicate is applied
       /// to each element in the array, and whenever it returns true, that element will
       /// be the first element in one of the "subarrays".
       [<CompiledName("Split")>]
       let split (predicate : 'T -> bool) (array : 'T[]) =
  +        // Preconditions
           checkNonNull "array" array
   
           let segments = ResizeArray<_> ()
  
positive.code:     /// the predicate returns true.
      [<CompiledName("Segment")>]
      let segment (predicate : 'T -> bool) (array : 'T[]) =
          checkNonNull "array" array
          
          let segments = ResizeArray<_> ()
  
negative.code:     //
      [<CompiledName("FoldIndexed")>]
      let foldi (folder : int -> 'State -> 'T -> 'State) (state : 'State) (set : Set<'T>) =
          // Preconditions
          checkNonNull "set" set
  
          let folder = FSharpFunc<_,_,_,_>.Adapt folder
          let mutable state = state
          let mutable idx = 0
  