Implement TypedArray#map (AssemblyScript#365)

* Also cleans up TypedArray#reduce/reduceRight test cases
* Also fixes the (what needs to be) overloads on Uint8ClampedArray

Author: jtenner

std/assembly/internal/typedarray.ts

@@ -177,3 +177,18 @@ export function REDUCE_RIGHT<TArray extends TypedArray<T>, T, TRet>(
   }
   return initialValue;
 }
+
+@inline
+export function MAP<TArray extends TypedArray<T>, T>(
+  array: TArray,
+  callbackfn: (value: T, index: i32, self: TArray) => T,
+): TArray {
+  var length: i32 = array.length;
+  var result = instantiate<TArray>(length);
+  var i: i32 = 0;
+  while (i < length) {
+    unchecked(result[i] = callbackfn(array[i], i, <TArray>array));
+    ++i;
+  }
+  return result;
+}

std/assembly/typedarray.ts

@@ -4,7 +4,8 @@ import {
   SORT,
   SUBARRAY,
   REDUCE,
-  REDUCE_RIGHT
+  REDUCE_RIGHT,
+  MAP,
 } from "./internal/typedarray";
 
 import {
@@ -39,6 +40,10 @@ export class Int8Array extends TypedArray<i8> {
   ): T {
     return REDUCE_RIGHT<Int8Array, i8, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: i8, index: i32, self: Int8Array) => i8): Int8Array {
+    return MAP<Int8Array, i8>(this, callbackfn);
+  }
 }
 
 export class Uint8Array extends TypedArray<u8> {
@@ -69,6 +74,10 @@ export class Uint8Array extends TypedArray<u8> {
   ): T {
     return REDUCE_RIGHT<Uint8Array, u8, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: u8, index: i32, self: Uint8Array) => u8): Uint8Array {
+    return MAP<Uint8Array, u8>(this, callbackfn);
+  }
 }
 
 export class Uint8ClampedArray extends Uint8Array {
@@ -83,6 +92,22 @@ export class Uint8ClampedArray extends Uint8Array {
   protected __unchecked_set(index: i32, value: i32): void {
     super.__unchecked_set(index, max(min(value, 255), 0));
   }
+
+  fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {
+    return changetype<Uint8ClampedArray>(super.fill(value, start, end)); // safe because '.fill' reuses 'this'
+  }
+
+  sort(comparator: (a: u8, b: u8) => i32 = defaultComparator<u8>()): Uint8ClampedArray {
+    return changetype<Uint8ClampedArray>(super.sort(comparator)); // safe because '.sort' reuses 'this'
+  }
+
+  subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Uint8ClampedArray {
+    return SUBARRAY<Uint8ClampedArray, u8>(this, begin, end);
+  }
+
+  map(callbackfn: (value: u8, index: i32, self: Uint8ClampedArray) => u8): Uint8ClampedArray {
+    return MAP<Uint8ClampedArray, u8>(this, callbackfn);
+  }
 }
 
 export class Int16Array extends TypedArray<i16> {
@@ -113,6 +138,10 @@ export class Int16Array extends TypedArray<i16> {
   ): T {
     return REDUCE_RIGHT<Int16Array, i16, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: i16, index: i32, self: Int16Array) => i16): Int16Array {
+    return MAP<Int16Array, i16>(this, callbackfn);
+  }
 }
 
 export class Uint16Array extends TypedArray<u16> {
@@ -143,6 +172,10 @@ export class Uint16Array extends TypedArray<u16> {
   ): T {
     return REDUCE_RIGHT<Uint16Array, u16, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: u16, index: i32, self: Uint16Array) => u16): Uint16Array {
+    return MAP<Uint16Array, u16>(this, callbackfn);
+  }
 }
 
 export class Int32Array extends TypedArray<i32> {
@@ -173,6 +206,10 @@ export class Int32Array extends TypedArray<i32> {
   ): T {
     return REDUCE_RIGHT<Int32Array, i32, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: i32, index: i32, self: Int32Array) => i32): Int32Array {
+    return MAP<Int32Array, i32>(this, callbackfn);
+  }
 }
 
 export class Uint32Array extends TypedArray<u32> {
@@ -203,6 +240,10 @@ export class Uint32Array extends TypedArray<u32> {
   ): T {
     return REDUCE_RIGHT<Uint32Array, u32, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: u32, index: i32, self: Uint32Array) => u32): Uint32Array {
+    return MAP<Uint32Array, u32>(this, callbackfn);
+  }
 }
 
 export class Int64Array extends TypedArray<i64> {
@@ -233,6 +274,10 @@ export class Int64Array extends TypedArray<i64> {
   ): T {
     return REDUCE_RIGHT<Int64Array, i64, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: i64, index: i32, self: Int64Array) => i64): Int64Array {
+    return MAP<Int64Array, i64>(this, callbackfn);
+  }
 }
 
 export class Uint64Array extends TypedArray<u64> {
@@ -263,6 +308,10 @@ export class Uint64Array extends TypedArray<u64> {
   ): T {
     return REDUCE_RIGHT<Uint64Array, u64, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: u64, index: i32, self: Uint64Array) => u64): Uint64Array {
+    return MAP<Uint64Array, u64>(this, callbackfn);
+  }
 }
 
 export class Float32Array extends TypedArray<f32> {
@@ -293,6 +342,10 @@ export class Float32Array extends TypedArray<f32> {
   ): T {
     return REDUCE_RIGHT<Float32Array, f32, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: f32, index: i32, self: Float32Array) => f32): Float32Array {
+    return MAP<Float32Array, f32>(this, callbackfn);
+  }
 }
 
 export class Float64Array extends TypedArray<f64> {
@@ -323,4 +376,8 @@ export class Float64Array extends TypedArray<f64> {
   ): T {
     return REDUCE_RIGHT<Float64Array, f64, T>(this, callbackfn, initialValue);
   }
+
+  map(callbackfn: (value: f64, index: i32, self: Float64Array) => f64): Float64Array {
+    return MAP<Float64Array, f64>(this, callbackfn);
+  }
 }