anchor.diff:          for x = 0 to System.Math.Floor(float(array.Length) / float(chunkSize)) |> int do
               let start = x * chunkSize;
               let end' = start + chunkSize;
  -            let slice = slice array start end'
  -            push result slice |> ignore
  +            let slice = sliceImpl array start end'
  +            pushImpl result slice |> ignore
   
           result
   
  
positive.code: 
  let foldIndexed folder state array =
      let mutable acc = state
      for i = 0 to length array - 1 do
          acc <- folder i acc array.[i]
      acc
  
  let fold<'T,'State> folder (state: 'State) (array: 'T[]) = 
      let mutable acc = state
      for i = 0 to length array - 1 do
          acc <- folder acc array.[i]
      acc
  
  // TODO: CompiledName: iterate
  let iter action array =
      for i = 0 to length array - 1 do
          action array.[i]
  
  // TODO: CompiledName: iterate2
  let iter2 action (array1: 'T[]) (array2: 'T[]) =
      if array1.Length <> array2.Length then failwith "Arrays had different lengths"
      for i = 0 to array1.Length - 1 do
          action array1.[i] array2.[i]
  
  // TODO: CompiledName: iterateIndexed
  let iteri action array =
      for i = 0 to length array - 1 do
          action i array.[i]
  
  // TODO: CompiledName: iterateIndexed2
  let iteri2 action (array1: 'T[]) (array2: 'T[]) =
      if array1.Length <> array2.Length then failwith "Arrays had different lengths"
      for i = 0 to array1.Length - 1 do
          action i array1.[i] array2.[i]
  
negative.code:    foldBackIndexed2 (fun _ x y acc -> f x y acc) array1 array2 state 
  
  let reduce reduction array =
     if lengthImpl array = 0 then invalidOp LanguagePrimitives.ErrorStrings.InputArrayEmptyString
     else foldIndexed (fun i acc x -> if i = 0 then x else reduction acc x) Unchecked.defaultof<_> array
  
  let reduceBack reduction array =
     if lengthImpl array = 0 then invalidOp LanguagePrimitives.ErrorStrings.InputArrayEmptyString
     else foldBackIndexed (fun i x acc -> if i = 0 then x else reduction acc x) array Unchecked.defaultof<_>
  
  let forAll2 predicate array1 array2 =
     fold2 (fun acc x y -> acc && predicate x y) true array1 array2
  
  let rec existsOffset predicate array index =
     if index = lengthImpl array then false
     else predicate array.[index] || existsOffset predicate array (index+1)
  
  let exists predicate array = 
     existsOffset predicate array 0
  
  let rec existsOffset2 predicate array1 (array2:_ []) index =
     if index = lengthImpl array1 then false
     else predicate array1.[index] array2.[index] || existsOffset2 predicate array1 array2 (index+1)
  
  let rec exists2 predicate array1 array2 =
     if lengthImpl array1 <> lengthImpl array2 then failwith "Arrays had different lengths"
     existsOffset2 predicate array1 array2 0
  
  let sum (array: 'T[]) : 'T =
      let mutable acc = nativeZero<'T>()
      for i = 0 to array.Length - 1 do
          acc <- nativeAddition acc array.[i]
      acc
  
  let sumBy (projection: 'T -> 'U) (array: 'T []) : 'U =
      let mutable acc = nativeZero<'U>()
      for i = 0 to array.Length - 1 do
          acc <- array.[i] |> projection |> nativeAddition acc 
      acc
  
  let maxBy projection array =
      reduce (fun x y -> if projection y > projection x then y else x) array
  
  let max array =
      reduce max array
  
  let minBy projection array =
      reduce (fun x y -> if projection y > projection x then x else y) array
  
  let min array =
      reduce min array
  
  let average (array: 'T []) : 'T =
      if array.Length = 0 then invalidArg "array" LanguagePrimitives.ErrorStrings.InputArrayEmptyString
      let total = sum array
      nativeDivision total array.Length
  
  let averageBy (projection: 'T -> 'U) (array: 'T []) : 'U =
      if array.Length = 0 then invalidArg "array" LanguagePrimitives.ErrorStrings.InputArrayEmptyString
      let total = sumBy projection array
      nativeDivision total array.Length
  
  