From 066ea1fbd2c0180729328cda5f0375aac5d194b9 Mon Sep 17 00:00:00 2001
From: dcode <dcode@dcode.io>
Date: Sat, 1 Jun 2019 05:12:30 +0200
Subject: [PATCH] consistent naming

---
 std/assembly/array.ts      |  48 +++---
 std/assembly/set.ts        |  70 ++++----
 std/assembly/typedarray.ts | 336 ++++++++++++++++++-------------------
 3 files changed, 227 insertions(+), 227 deletions(-)

diff --git a/std/assembly/array.ts b/std/assembly/array.ts
index c2b84fe4..095efb2b 100644
--- a/std/assembly/array.ts
+++ b/std/assembly/array.ts
@@ -77,14 +77,14 @@ export class Array<T> extends ArrayBufferView {
     this.length_ = length;
   }
 
-  every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
+  every(fn: (value: T, index: i32, array: Array<T>) => bool): bool {
     for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
-      if (!callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;
+      if (!fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;
     }
     return true;
   }
 
-  findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
+  findIndex(predicate: (value: T, index: i32, array: Array<T>) => bool): i32 {
     for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
       if (predicate(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return index;
     }
@@ -151,30 +151,30 @@ export class Array<T> extends ArrayBufferView {
     return this;
   }
 
-  includes(searchElement: T, fromIndex: i32 = 0): bool {
-    return this.indexOf(searchElement, fromIndex) >= 0;
+  includes(value: T, fromIndex: i32 = 0): bool {
+    return this.indexOf(value, fromIndex) >= 0;
   }
 
-  indexOf(searchElement: T, fromIndex: i32 = 0): i32 {
+  indexOf(value: T, fromIndex: i32 = 0): i32 {
     var length = this.length_;
     if (length == 0 || fromIndex >= length) return -1;
     if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
     var dataStart = this.dataStart;
     while (fromIndex < length) {
-      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == searchElement) return fromIndex;
+      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;
       ++fromIndex;
     }
     return -1;
   }
 
-  lastIndexOf(searchElement: T, fromIndex: i32 = this.length_): i32 {
+  lastIndexOf(value: T, fromIndex: i32 = this.length_): i32 {
     var length = this.length_;
     if (length == 0) return -1;
     if (fromIndex < 0) fromIndex = length + fromIndex;
     else if (fromIndex >= length) fromIndex = length - 1;
     var dataStart = this.dataStart;
     while (fromIndex >= 0) {
-      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == searchElement) return fromIndex;
+      if (load<T>(dataStart + (<usize>fromIndex << alignof<T>())) == value) return fromIndex;
       --fromIndex;
     }
     return -1;
@@ -261,18 +261,18 @@ export class Array<T> extends ArrayBufferView {
     return element;
   }
 
-  forEach(callbackfn: (value: T, index: i32, array: Array<T>) => void): void {
+  forEach(fn: (value: T, index: i32, array: Array<T>) => void): void {
     for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
-      callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
+      fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
     }
   }
 
-  map<U>(callbackfn: (value: T, index: i32, array: Array<T>) => U): Array<U> {
+  map<U>(fn: (value: T, index: i32, array: Array<T>) => U): Array<U> {
     var length = this.length_;
     var out = changetype<Array<U>>(__allocArray(length, alignof<U>(), idof<Array<U>>())); // retains
     var outStart = out.dataStart;
     for (let index = 0; index < min(length, this.length_); ++index) {
-      let result = callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this); // retains
+      let result = fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this); // retains
       if (isManaged<U>()) {
         store<usize>(outStart + (<usize>index << alignof<U>()), __retain(changetype<usize>(result)));
       } else {
@@ -283,33 +283,33 @@ export class Array<T> extends ArrayBufferView {
     return out;
   }
 
-  filter(callbackfn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {
+  filter(fn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {
     var result = changetype<Array<T>>(__allocArray(0, alignof<T>(), idof<Array<T>>())); // retains
     for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
       let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));
-      if (callbackfn(value, index, this)) result.push(value);
+      if (fn(value, index, this)) result.push(value);
     }
     return result;
   }
 
   reduce<U>(
-    callbackfn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
+    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
     initialValue: U
   ): U {
     var accum = initialValue;
     for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
-      accum = callbackfn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
+      accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
     }
     return accum;
   }
 
   reduceRight<U>(
-    callbackfn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
+    fn: (previousValue: U, currentValue: T, currentIndex: i32, array: Array<T>) => U,
     initialValue: U
   ): U {
     var accum = initialValue;
     for (let index = this.length_ - 1; index >= 0; --index) {
-      accum = callbackfn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
+      accum = fn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
     }
     return accum;
   }
@@ -333,14 +333,14 @@ export class Array<T> extends ArrayBufferView {
     return element;
   }
 
-  some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
+  some(fn: (value: T, index: i32, array: Array<T>) => bool): bool {
     for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
-      if (callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return true;
+      if (fn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return true;
     }
     return false;
   }
 
-  unshift(element: T): i32 {
+  unshift(value: T): i32 {
     var newLength = this.length_ + 1;
     ensureSize(changetype<usize>(this), newLength, alignof<T>());
     var dataStart = this.dataStart;
@@ -350,9 +350,9 @@ export class Array<T> extends ArrayBufferView {
       <usize>(newLength - 1) << alignof<T>()
     );
     if (isManaged<T>()) {
-      store<usize>(dataStart, __retain(changetype<usize>(element)));
+      store<usize>(dataStart, __retain(changetype<usize>(value)));
     } else {
-      store<T>(dataStart, element);
+      store<T>(dataStart, value);
     }
     this.length_ = newLength;
     return newLength;
diff --git a/std/assembly/set.ts b/std/assembly/set.ts
index 3fe0e03f..a2354105 100644
--- a/std/assembly/set.ts
+++ b/std/assembly/set.ts
@@ -35,22 +35,22 @@ const BUCKET_SIZE = sizeof<usize>();
 /** Computes the alignment of an entry. */
 // @ts-ignore: decorator
 @inline
-function ENTRY_ALIGN<K>(): usize {
+function ENTRY_ALIGN<T>(): usize {
   // can align to 4 instead of 8 if 32-bit and K is <= 32-bits
-  const align = (sizeof<K>() > sizeof<usize>() ? sizeof<K>() : sizeof<usize>()) - 1;
+  const align = (sizeof<T>() > sizeof<usize>() ? sizeof<T>() : sizeof<usize>()) - 1;
   return align;
 }
 
 /** Computes the aligned size of an entry. */
 // @ts-ignore: decorator
 @inline
-function ENTRY_SIZE<K>(): usize {
-  const align = ENTRY_ALIGN<K>();
-  const size = (offsetof<SetEntry<K>>() + align) & ~align;
+function ENTRY_SIZE<T>(): usize {
+  const align = ENTRY_ALIGN<T>();
+  const size = (offsetof<SetEntry<T>>() + align) & ~align;
   return size;
 }
 
-export class Set<K> {
+export class Set<T> {
 
   // buckets holding references to the respective first entry within
   private buckets: ArrayBuffer; // usize[bucketsMask + 1]
@@ -70,30 +70,30 @@ export class Set<K> {
     const bucketsSize = INITIAL_CAPACITY * <i32>BUCKET_SIZE;
     this.buckets = new ArrayBuffer(bucketsSize);
     this.bucketsMask = INITIAL_CAPACITY - 1;
-    const entriesSize = INITIAL_CAPACITY * <i32>ENTRY_SIZE<K>();
+    const entriesSize = INITIAL_CAPACITY * <i32>ENTRY_SIZE<T>();
     this.entries = new ArrayBuffer(entriesSize);
     this.entriesCapacity = INITIAL_CAPACITY;
     this.entriesOffset = 0;
     this.entriesCount = 0;
   }
 
-  private find(key: K, hashCode: u32): SetEntry<K> | null {
-    var entry = load<SetEntry<K>>( // unmanaged!
+  private find(key: T, hashCode: u32): SetEntry<T> | null {
+    var entry = load<SetEntry<T>>( // unmanaged!
       changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE
     );
     while (entry) {
       if (!(entry.taggedNext & EMPTY) && entry.key == key) return entry;
-      entry = changetype<SetEntry<K>>(entry.taggedNext & ~EMPTY);
+      entry = changetype<SetEntry<T>>(entry.taggedNext & ~EMPTY);
     }
     return null;
   }
 
-  has(key: K): bool {
-    return this.find(key, HASH<K>(key)) !== null;
+  has(key: T): bool {
+    return this.find(key, HASH<T>(key)) !== null;
   }
 
-  add(key: K): void {
-    var hashCode = HASH<K>(key);
+  add(key: T): void {
+    var hashCode = HASH<T>(key);
     var entry = this.find(key, hashCode); // unmanaged!
     if (!entry) {
       // check if rehashing is necessary
@@ -105,9 +105,9 @@ export class Set<K> {
         );
       }
       // append new entry
-      entry = changetype<SetEntry<K>>(changetype<usize>(this.entries) + this.entriesOffset++ * ENTRY_SIZE<K>());
-      entry.key = isManaged<K>()
-        ? changetype<K>(__retain(changetype<usize>(key)))
+      entry = changetype<SetEntry<T>>(changetype<usize>(this.entries) + this.entriesOffset++ * ENTRY_SIZE<T>());
+      entry.key = isManaged<T>()
+        ? changetype<T>(__retain(changetype<usize>(key)))
         : key;
       ++this.entriesCount;
       // link with previous entry in bucket
@@ -117,10 +117,10 @@ export class Set<K> {
     }
   }
 
-  delete(key: K): bool {
-    var entry = this.find(key, HASH<K>(key)); // unmanaged!
+  delete(key: T): bool {
+    var entry = this.find(key, HASH<T>(key)); // unmanaged!
     if (!entry) return false;
-    if (isManaged<K>()) __release(changetype<usize>(entry.key)); // exact 'key'
+    if (isManaged<T>()) __release(changetype<usize>(entry.key)); // exact 'key'
     entry.taggedNext |= EMPTY;
     --this.entriesCount;
     // check if rehashing is appropriate
@@ -136,24 +136,24 @@ export class Set<K> {
     var newBucketsCapacity = <i32>(newBucketsMask + 1);
     var newBuckets = new ArrayBuffer(newBucketsCapacity * <i32>BUCKET_SIZE);
     var newEntriesCapacity = <i32>(newBucketsCapacity * FILL_FACTOR);
-    var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<K>());
+    var newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<T>());
 
     // copy old entries to new entries
     var oldPtr = changetype<usize>(this.entries);
-    var oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<K>();
+    var oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<T>();
     var newPtr = changetype<usize>(newEntries);
     while (oldPtr != oldEnd) {
-      let oldEntry = changetype<SetEntry<K>>(oldPtr); // unmanaged!
+      let oldEntry = changetype<SetEntry<T>>(oldPtr); // unmanaged!
       if (!(oldEntry.taggedNext & EMPTY)) {
-        let newEntry = changetype<SetEntry<K>>(newPtr); // unmanaged!
+        let newEntry = changetype<SetEntry<T>>(newPtr); // unmanaged!
         newEntry.key = oldEntry.key;
-        let newBucketIndex = HASH<K>(oldEntry.key) & newBucketsMask;
+        let newBucketIndex = HASH<T>(oldEntry.key) & newBucketsMask;
         let newBucketPtrBase = changetype<usize>(newBuckets) + <usize>newBucketIndex * BUCKET_SIZE;
         newEntry.taggedNext = load<usize>(newBucketPtrBase);
         store<usize>(newBucketPtrBase, newPtr);
-        newPtr += ENTRY_SIZE<K>();
+        newPtr += ENTRY_SIZE<T>();
       }
-      oldPtr += ENTRY_SIZE<K>();
+      oldPtr += ENTRY_SIZE<T>();
     }
 
     this.buckets = newBuckets;
@@ -163,13 +163,13 @@ export class Set<K> {
     this.entriesOffset = this.entriesCount;
   }
 
-  values(): K[] {
+  values(): T[] {
     // FIXME: this is preliminary, needs iterators/closures
     var start = changetype<usize>(this.entries);
     var size = this.entriesOffset;
-    var values = Array.create<K>(size);
+    var values = Array.create<T>(size);
     for (let i = 0; i < size; ++i) {
-      let entry = changetype<SetEntry<K>>(start + <usize>i * ENTRY_SIZE<K>());
+      let entry = changetype<SetEntry<T>>(start + <usize>i * ENTRY_SIZE<T>());
       if (!(entry.taggedNext & EMPTY)) {
         values.push(entry.key);
       }
@@ -186,18 +186,18 @@ export class Set<K> {
   @unsafe private __visit_impl(cookie: u32): void {
     __visit(changetype<usize>(this.buckets), cookie);
     var entries = changetype<usize>(this.entries);
-    if (isManaged<K>()) {
+    if (isManaged<T>()) {
       let cur = entries;
-      let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<K>();
+      let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<T>();
       while (cur < end) {
-        let entry = changetype<SetEntry<K>>(cur);
+        let entry = changetype<SetEntry<T>>(cur);
         if (!(entry.taggedNext & EMPTY)) {
           let val = changetype<usize>(entry.key);
-          if (isNullable<K>()) {
+          if (isNullable<T>()) {
             if (val) __visit(val, cookie);
           } else __visit(val, cookie);
         }
-        cur += ENTRY_SIZE<K>();
+        cur += ENTRY_SIZE<T>();
       }
     }
     __visit(entries, cookie);
diff --git a/std/assembly/typedarray.ts b/std/assembly/typedarray.ts
index d878a9f2..60a60db8 100644
--- a/std/assembly/typedarray.ts
+++ b/std/assembly/typedarray.ts
@@ -47,37 +47,37 @@ export class Int8Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
+    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Int8Array, i8, T>(this, callbackfn, initialValue);
+    return REDUCE<Int8Array, i8, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
+    fn: (accumulator: T, value: i8, index: i32, array: Int8Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Int8Array, i8, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Int8Array, i8, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {
-    return MAP<Int8Array, i8>(this, callbackfn);
+  map(fn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {
+    return MAP<Int8Array, i8>(this, fn);
   }
 
-  findIndex(callbackfn: (value: i8, index: i32, self: Int8Array) => bool): i32 {
-    return FIND_INDEX<Int8Array, i8>(this, callbackfn);
+  findIndex(fn: (value: i8, index: i32, self: Int8Array) => bool): i32 {
+    return FIND_INDEX<Int8Array, i8>(this, fn);
   }
 
-  some(callbackfn: (value: i8, index: i32, self: Int8Array) => bool): bool {
-    return SOME<Int8Array, i8>(this, callbackfn);
+  some(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {
+    return SOME<Int8Array, i8>(this, fn);
   }
 
-  every(callbackfn: (value: i8, index: i32, self: Int8Array) => bool): bool {
-    return EVERY<Int8Array, i8>(this, callbackfn);
+  every(fn: (value: i8, index: i32, self: Int8Array) => bool): bool {
+    return EVERY<Int8Array, i8>(this, fn);
   }
 
-  forEach(callbackfn: (value: i8, index: i32, self: Int8Array) => void): void {
-    FOREACH<Int8Array, i8>(this, callbackfn);
+  forEach(fn: (value: i8, index: i32, self: Int8Array) => void): void {
+    FOREACH<Int8Array, i8>(this, fn);
   }
 
   reverse(): this {
@@ -129,37 +129,37 @@ export class Uint8Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
+    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Uint8Array, u8, T>(this, callbackfn, initialValue);
+    return REDUCE<Uint8Array, u8, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
+    fn: (accumulator: T, value: u8, index: i32, array: Uint8Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Uint8Array, u8, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Uint8Array, u8, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {
-    return MAP<Uint8Array, u8>(this, callbackfn);
+  map(fn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {
+    return MAP<Uint8Array, u8>(this, fn);
   }
 
-  findIndex(callbackfn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {
-    return FIND_INDEX<Uint8Array, u8>(this, callbackfn);
+  findIndex(fn: (value: u8, index: i32, self: Uint8Array) => bool): i32 {
+    return FIND_INDEX<Uint8Array, u8>(this, fn);
   }
 
-  some(callbackfn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
-    return SOME<Uint8Array, u8>(this, callbackfn);
+  some(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
+    return SOME<Uint8Array, u8>(this, fn);
   }
 
-  every(callbackfn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
-    return EVERY<Uint8Array, u8>(this, callbackfn);
+  every(fn: (value: u8, index: i32, self: Uint8Array) => bool): bool {
+    return EVERY<Uint8Array, u8>(this, fn);
   }
 
-  forEach(callbackfn: (value: u8, index: i32, self: Uint8Array) => void): void {
-    FOREACH<Uint8Array, u8>(this, callbackfn);
+  forEach(fn: (value: u8, index: i32, self: Uint8Array) => void): void {
+    FOREACH<Uint8Array, u8>(this, fn);
   }
 
   reverse(): this {
@@ -211,37 +211,37 @@ export class Uint8ClampedArray extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
+    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Uint8ClampedArray, u8, T>(this, callbackfn, initialValue);
+    return REDUCE<Uint8ClampedArray, u8, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
+    fn: (accumulator: T, value: u8, index: i32, array: Uint8ClampedArray) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Uint8ClampedArray, u8, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {
-    return MAP<Uint8ClampedArray, u8>(this, callbackfn);
+  map(fn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {
+    return MAP<Uint8ClampedArray, u8>(this, fn);
   }
 
-  findIndex(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {
-    return FIND_INDEX<Uint8ClampedArray, u8>(this, callbackfn);
+  findIndex(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): i32 {
+    return FIND_INDEX<Uint8ClampedArray, u8>(this, fn);
   }
 
-  some(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
-    return SOME<Uint8ClampedArray, u8>(this, callbackfn);
+  some(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
+    return SOME<Uint8ClampedArray, u8>(this, fn);
   }
 
-  every(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
-    return EVERY<Uint8ClampedArray, u8>(this, callbackfn);
+  every(fn: (value: u8, index: i32, self: Uint8ClampedArray) => bool): bool {
+    return EVERY<Uint8ClampedArray, u8>(this, fn);
   }
 
-  forEach(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {
-    FOREACH<Uint8ClampedArray, u8>(this, callbackfn);
+  forEach(fn: (value: u8, index: i32, self: Uint8ClampedArray) => void): void {
+    FOREACH<Uint8ClampedArray, u8>(this, fn);
   }
 
   reverse(): this {
@@ -293,37 +293,37 @@ export class Int16Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
+    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Int16Array, i16, T>(this, callbackfn, initialValue);
+    return REDUCE<Int16Array, i16, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
+    fn: (accumulator: T, value: i16, index: i32, array: Int16Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Int16Array, i16, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Int16Array, i16, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {
-    return MAP<Int16Array, i16>(this, callbackfn);
+  map(fn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {
+    return MAP<Int16Array, i16>(this, fn);
   }
 
-  findIndex(callbackfn: (value: i16, index: i32, self: Int16Array) => bool): i32 {
-    return FIND_INDEX<Int16Array, i16>(this, callbackfn);
+  findIndex(fn: (value: i16, index: i32, self: Int16Array) => bool): i32 {
+    return FIND_INDEX<Int16Array, i16>(this, fn);
   }
 
-  some(callbackfn: (value: i16, index: i32, self: Int16Array) => bool): bool {
-    return SOME<Int16Array, i16>(this, callbackfn);
+  some(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {
+    return SOME<Int16Array, i16>(this, fn);
   }
 
-  every(callbackfn: (value: i16, index: i32, self: Int16Array) => bool): bool {
-    return EVERY<Int16Array, i16>(this, callbackfn);
+  every(fn: (value: i16, index: i32, self: Int16Array) => bool): bool {
+    return EVERY<Int16Array, i16>(this, fn);
   }
 
-  forEach(callbackfn: (value: i16, index: i32, self: Int16Array) => void): void {
-    FOREACH<Int16Array, i16>(this, callbackfn);
+  forEach(fn: (value: i16, index: i32, self: Int16Array) => void): void {
+    FOREACH<Int16Array, i16>(this, fn);
   }
 
   reverse(): this {
@@ -375,37 +375,37 @@ export class Uint16Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
+    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Uint16Array, u16, T>(this, callbackfn, initialValue);
+    return REDUCE<Uint16Array, u16, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
+    fn: (accumulator: T, value: u16, index: i32, array: Uint16Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Uint16Array, u16, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Uint16Array, u16, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {
-    return MAP<Uint16Array, u16>(this, callbackfn);
+  map(fn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {
+    return MAP<Uint16Array, u16>(this, fn);
   }
 
-  findIndex(callbackfn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {
-    return FIND_INDEX<Uint16Array, u16>(this, callbackfn);
+  findIndex(fn: (value: u16, index: i32, self: Uint16Array) => bool): i32 {
+    return FIND_INDEX<Uint16Array, u16>(this, fn);
   }
 
-  some(callbackfn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
-    return SOME<Uint16Array, u16>(this, callbackfn);
+  some(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
+    return SOME<Uint16Array, u16>(this, fn);
   }
 
-  every(callbackfn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
-    return EVERY<Uint16Array, u16>(this, callbackfn);
+  every(fn: (value: u16, index: i32, self: Uint16Array) => bool): bool {
+    return EVERY<Uint16Array, u16>(this, fn);
   }
 
-  forEach(callbackfn: (value: u16, index: i32, self: Uint16Array) => void): void {
-    FOREACH<Uint16Array, u16>(this, callbackfn);
+  forEach(fn: (value: u16, index: i32, self: Uint16Array) => void): void {
+    FOREACH<Uint16Array, u16>(this, fn);
   }
 
   reverse(): this {
@@ -457,37 +457,37 @@ export class Int32Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
+    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Int32Array, i32, T>(this, callbackfn, initialValue);
+    return REDUCE<Int32Array, i32, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
+    fn: (accumulator: T, value: i32, index: i32, array: Int32Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Int32Array, i32, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Int32Array, i32, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {
-    return MAP<Int32Array, i32>(this, callbackfn);
+  map(fn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {
+    return MAP<Int32Array, i32>(this, fn);
   }
 
-  findIndex(callbackfn: (value: i32, index: i32, self: Int32Array) => bool): i32 {
-    return FIND_INDEX<Int32Array, i32>(this, callbackfn);
+  findIndex(fn: (value: i32, index: i32, self: Int32Array) => bool): i32 {
+    return FIND_INDEX<Int32Array, i32>(this, fn);
   }
 
-  some(callbackfn: (value: i32, index: i32, self: Int32Array) => bool): bool {
-    return SOME<Int32Array, i32>(this, callbackfn);
+  some(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {
+    return SOME<Int32Array, i32>(this, fn);
   }
 
-  every(callbackfn: (value: i32, index: i32, self: Int32Array) => bool): bool {
-    return EVERY<Int32Array, i32>(this, callbackfn);
+  every(fn: (value: i32, index: i32, self: Int32Array) => bool): bool {
+    return EVERY<Int32Array, i32>(this, fn);
   }
 
-  forEach(callbackfn: (value: i32, index: i32, self: Int32Array) => void): void {
-    FOREACH<Int32Array, i32>(this, callbackfn);
+  forEach(fn: (value: i32, index: i32, self: Int32Array) => void): void {
+    FOREACH<Int32Array, i32>(this, fn);
   }
 
   reverse(): this {
@@ -539,37 +539,37 @@ export class Uint32Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
+    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Uint32Array, u32, T>(this, callbackfn, initialValue);
+    return REDUCE<Uint32Array, u32, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
+    fn: (accumulator: T, value: u32, index: i32, array: Uint32Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Uint32Array, u32, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Uint32Array, u32, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {
-    return MAP<Uint32Array, u32>(this, callbackfn);
+  map(fn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {
+    return MAP<Uint32Array, u32>(this, fn);
   }
 
-  findIndex(callbackfn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {
-    return FIND_INDEX<Uint32Array, u32>(this, callbackfn);
+  findIndex(fn: (value: u32, index: i32, self: Uint32Array) => bool): i32 {
+    return FIND_INDEX<Uint32Array, u32>(this, fn);
   }
 
-  some(callbackfn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
-    return SOME<Uint32Array, u32>(this, callbackfn);
+  some(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
+    return SOME<Uint32Array, u32>(this, fn);
   }
 
-  every(callbackfn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
-    return EVERY<Uint32Array, u32>(this, callbackfn);
+  every(fn: (value: u32, index: i32, self: Uint32Array) => bool): bool {
+    return EVERY<Uint32Array, u32>(this, fn);
   }
 
-  forEach(callbackfn: (value: u32, index: i32, self: Uint32Array) => void): void {
-    FOREACH<Uint32Array, u32>(this, callbackfn);
+  forEach(fn: (value: u32, index: i32, self: Uint32Array) => void): void {
+    FOREACH<Uint32Array, u32>(this, fn);
   }
 
   reverse(): this {
@@ -621,37 +621,37 @@ export class Int64Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
+    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Int64Array, i64, T>(this, callbackfn, initialValue);
+    return REDUCE<Int64Array, i64, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
+    fn: (accumulator: T, value: i64, index: i32, array: Int64Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Int64Array, i64, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Int64Array, i64, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {
-    return MAP<Int64Array, i64>(this, callbackfn);
+  map(fn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {
+    return MAP<Int64Array, i64>(this, fn);
   }
 
-  findIndex(callbackfn: (value: i64, index: i32, self: Int64Array) => bool): i32 {
-    return FIND_INDEX<Int64Array, i64>(this, callbackfn);
+  findIndex(fn: (value: i64, index: i32, self: Int64Array) => bool): i32 {
+    return FIND_INDEX<Int64Array, i64>(this, fn);
   }
 
-  some(callbackfn: (value: i64, index: i32, self: Int64Array) => bool): bool {
-    return SOME<Int64Array, i64>(this, callbackfn);
+  some(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {
+    return SOME<Int64Array, i64>(this, fn);
   }
 
-  every(callbackfn: (value: i64, index: i32, self: Int64Array) => bool): bool {
-    return EVERY<Int64Array, i64>(this, callbackfn);
+  every(fn: (value: i64, index: i32, self: Int64Array) => bool): bool {
+    return EVERY<Int64Array, i64>(this, fn);
   }
 
-  forEach(callbackfn: (value: i64, index: i32, self: Int64Array) => void): void {
-    FOREACH<Int64Array, i64>(this, callbackfn);
+  forEach(fn: (value: i64, index: i32, self: Int64Array) => void): void {
+    FOREACH<Int64Array, i64>(this, fn);
   }
 
   reverse(): this {
@@ -703,37 +703,37 @@ export class Uint64Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
+    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Uint64Array, u64, T>(this, callbackfn, initialValue);
+    return REDUCE<Uint64Array, u64, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
+    fn: (accumulator: T, value: u64, index: i32, array: Uint64Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Uint64Array, u64, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Uint64Array, u64, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {
-    return MAP<Uint64Array, u64>(this, callbackfn);
+  map(fn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {
+    return MAP<Uint64Array, u64>(this, fn);
   }
 
-  findIndex(callbackfn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {
-    return FIND_INDEX<Uint64Array, u64>(this, callbackfn);
+  findIndex(fn: (value: u64, index: i32, self: Uint64Array) => bool): i32 {
+    return FIND_INDEX<Uint64Array, u64>(this, fn);
   }
 
-  some(callbackfn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
-    return SOME<Uint64Array, u64>(this, callbackfn);
+  some(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
+    return SOME<Uint64Array, u64>(this, fn);
   }
 
-  every(callbackfn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
-    return EVERY<Uint64Array, u64>(this, callbackfn);
+  every(fn: (value: u64, index: i32, self: Uint64Array) => bool): bool {
+    return EVERY<Uint64Array, u64>(this, fn);
   }
 
-  forEach(callbackfn: (value: u64, index: i32, self: Uint64Array) => void): void {
-    FOREACH<Uint64Array, u64>(this, callbackfn);
+  forEach(fn: (value: u64, index: i32, self: Uint64Array) => void): void {
+    FOREACH<Uint64Array, u64>(this, fn);
   }
 
   reverse(): this {
@@ -785,37 +785,37 @@ export class Float32Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
+    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Float32Array, f32, T>(this, callbackfn, initialValue);
+    return REDUCE<Float32Array, f32, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
+    fn: (accumulator: T, value: f32, index: i32, array: Float32Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Float32Array, f32, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Float32Array, f32, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {
-    return MAP<Float32Array, f32>(this, callbackfn);
+  map(fn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {
+    return MAP<Float32Array, f32>(this, fn);
   }
 
-  findIndex(callbackfn: (value: f32, index: i32, self: Float32Array) => bool): i32 {
-    return FIND_INDEX<Float32Array, f32>(this, callbackfn);
+  findIndex(fn: (value: f32, index: i32, self: Float32Array) => bool): i32 {
+    return FIND_INDEX<Float32Array, f32>(this, fn);
   }
 
-  some(callbackfn: (value: f32, index: i32, self: Float32Array) => bool): bool {
-    return SOME<Float32Array, f32>(this, callbackfn);
+  some(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {
+    return SOME<Float32Array, f32>(this, fn);
   }
 
-  every(callbackfn: (value: f32, index: i32, self: Float32Array) => bool): bool {
-    return EVERY<Float32Array, f32>(this, callbackfn);
+  every(fn: (value: f32, index: i32, self: Float32Array) => bool): bool {
+    return EVERY<Float32Array, f32>(this, fn);
   }
 
-  forEach(callbackfn: (value: f32, index: i32, self: Float32Array) => void): void {
-    FOREACH<Float32Array, f32>(this, callbackfn);
+  forEach(fn: (value: f32, index: i32, self: Float32Array) => void): void {
+    FOREACH<Float32Array, f32>(this, fn);
   }
 
   reverse(): this {
@@ -867,37 +867,37 @@ export class Float64Array extends ArrayBufferView {
   }
 
   reduce<T>(
-    callbackfn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
+    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE<Float64Array, f64, T>(this, callbackfn, initialValue);
+    return REDUCE<Float64Array, f64, T>(this, fn, initialValue);
   }
 
   reduceRight<T>(
-    callbackfn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
+    fn: (accumulator: T, value: f64, index: i32, array: Float64Array) => T,
     initialValue: T,
   ): T {
-    return REDUCE_RIGHT<Float64Array, f64, T>(this, callbackfn, initialValue);
+    return REDUCE_RIGHT<Float64Array, f64, T>(this, fn, initialValue);
   }
 
-  map(callbackfn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {
-    return MAP<Float64Array, f64>(this, callbackfn);
+  map(fn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {
+    return MAP<Float64Array, f64>(this, fn);
   }
 
-  findIndex(callbackfn: (value: f64, index: i32, self: Float64Array) => bool): i32 {
-    return FIND_INDEX<Float64Array, f64>(this, callbackfn);
+  findIndex(fn: (value: f64, index: i32, self: Float64Array) => bool): i32 {
+    return FIND_INDEX<Float64Array, f64>(this, fn);
   }
 
-  some(callbackfn: (value: f64, index: i32, self: Float64Array) => bool): bool {
-    return SOME<Float64Array, f64>(this, callbackfn);
+  some(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {
+    return SOME<Float64Array, f64>(this, fn);
   }
 
-  every(callbackfn: (value: f64, index: i32, self: Float64Array) => bool): bool {
-    return EVERY<Float64Array, f64>(this, callbackfn);
+  every(fn: (value: f64, index: i32, self: Float64Array) => bool): bool {
+    return EVERY<Float64Array, f64>(this, fn);
   }
 
-  forEach(callbackfn: (value: f64, index: i32, self: Float64Array) => void): void {
-    FOREACH<Float64Array, f64>(this, callbackfn);
+  forEach(fn: (value: f64, index: i32, self: Float64Array) => void): void {
+    FOREACH<Float64Array, f64>(this, fn);
   }
 
   reverse(): this {
@@ -971,12 +971,12 @@ function SUBARRAY<TArray extends ArrayBufferView, T>(
 @inline
 function REDUCE<TArray extends ArrayBufferView, T, TRet>(
   array: TArray,
-  callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
+  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
   initialValue: TRet
 ): TRet {
   var dataStart = array.dataStart;
   for (let i = 0, k = array.length; i < k; i++) {
-    initialValue = callbackfn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
+    initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
   }
   return initialValue;
 }
@@ -985,12 +985,12 @@ function REDUCE<TArray extends ArrayBufferView, T, TRet>(
 @inline
 function REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(
   array: TArray,
-  callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
+  fn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
   initialValue: TRet
 ): TRet {
   var dataStart = array.dataStart;
   for (let i = array.length - 1; i >= 0; i--) {
-    initialValue = callbackfn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
+    initialValue = fn(initialValue, load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
   }
   return initialValue;
 }
@@ -999,7 +999,7 @@ function REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(
 @inline
 function MAP<TArray extends ArrayBufferView, T>(
   array: TArray,
-  callbackfn: (value: T, index: i32, self: TArray) => T,
+  fn: (value: T, index: i32, self: TArray) => T,
 ): TArray {
   var length = array.length;
   var dataStart = array.dataStart;
@@ -1008,7 +1008,7 @@ function MAP<TArray extends ArrayBufferView, T>(
   for (let i = 0; i < length; i++) {
     store<T>(
       outDataStart + (<usize>i << alignof<T>()),
-      callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)
+      fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)
     );
   }
   return out;
@@ -1018,11 +1018,11 @@ function MAP<TArray extends ArrayBufferView, T>(
 @inline
 function FIND_INDEX<TArray extends ArrayBufferView, T>(
   array: TArray,
-  callbackfn: (value: T, index: i32, array: TArray) => bool,
+  fn: (value: T, index: i32, array: TArray) => bool,
 ): i32 {
   var dataStart = array.dataStart;
   for (let i = 0, k = array.length; i < k; i++) {
-    if (callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return i;
+    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return i;
   }
   return -1;
 }
@@ -1031,11 +1031,11 @@ function FIND_INDEX<TArray extends ArrayBufferView, T>(
 @inline
 function SOME<TArray extends ArrayBufferView, T>(
   array: TArray,
-  callbackfn: (value: T, index: i32, array: TArray) => bool,
+  fn: (value: T, index: i32, array: TArray) => bool,
 ): bool {
   var dataStart = array.dataStart;
   for (let i = 0, k = array.length; i < k; i++) {
-    if (callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return true;
+    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) return true;
   }
   return false;
 }
@@ -1044,11 +1044,11 @@ function SOME<TArray extends ArrayBufferView, T>(
 @inline
 function EVERY<TArray extends ArrayBufferView, T>(
   array: TArray,
-  callbackfn: (value: T, index: i32, array: TArray) => bool,
+  fn: (value: T, index: i32, array: TArray) => bool,
 ): bool {
   var dataStart = array.dataStart;
   for (let i = 0, k = array.length; i < k; i++) {
-    if (callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) continue;
+    if (fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array)) continue;
     return false;
   }
   return true;
@@ -1058,11 +1058,11 @@ function EVERY<TArray extends ArrayBufferView, T>(
 @inline
 function FOREACH<TArray extends ArrayBufferView, T>(
   array: TArray,
-  callbackfn: (value: T, index: i32, array: TArray) => void,
+  fn: (value: T, index: i32, array: TArray) => void,
 ): void {
   var dataStart = array.dataStart;
   for (let i = 0, k = array.length; i < k; i++) {
-    callbackfn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
+    fn(load<T>(dataStart + (<usize>i << alignof<T>())), i, array);
   }
 }