Add Array#join and Array#toString + dtoa

std/assembly/array.ts

@@ -13,6 +13,9 @@ import {
   weakHeapSort
 } from "./internal/array";
 
+import { itoa } from "./internal/itoa";
+import { dtoa } from "./internal/dtoa";
+
 export class Array<T> {
 
   /* @internal */ buffer_: ArrayBuffer;
@@ -356,6 +359,66 @@ export class Array<T> {
     }
   }
 
+  join(separator: string = ","): string {
+    var lastIndex = this.length_ - 1;
+    if (lastIndex < 0) return "";
+    var result = "";
+    var value: T;
+    var buffer = this.buffer_;
+    var hasSeparator = separator.length != 0;
+    if (value instanceof bool) {
+      for (let i = 0; i < lastIndex; ++i) {
+        result += loadUnsafe<T,T>(buffer, i) ? "true" : "false";
+        if (hasSeparator) result += separator;
+      }
+      result += loadUnsafe<T,T>(buffer, lastIndex) ? "true" : "false";
+    } else if (isInteger<T>()) {
+      for (let i = 0; i < lastIndex; ++i) {
+        result += itoa<T>(loadUnsafe<T,T>(buffer, i));
+        if (hasSeparator) result += separator;
+      }
+      result += itoa<T>(loadUnsafe<T,T>(buffer, lastIndex));
+    } else if (isFloat<T>()) {
+      for (let i = 0; i < lastIndex; ++i) {
+        result += dtoa(loadUnsafe<T,f64>(buffer, i));
+        if (hasSeparator) result += separator;
+      }
+      result += dtoa(loadUnsafe<T,f64>(buffer, lastIndex));
+    } else if (isString<T>()) {
+      for (let i = 0; i < lastIndex; ++i) {
+        value = loadUnsafe<T,T>(buffer, i);
+        if (value) result += value;
+        if (hasSeparator) result += separator;
+      }
+      value = loadUnsafe<T,T>(buffer, lastIndex);
+      if (value) result += value;
+    } else if (isArray<T>()) {
+      for (let i = 0; i < lastIndex; ++i) {
+        value = loadUnsafe<T,T>(buffer, i);
+        if (value) result += value.join(separator); // tslint:disable-line:no-unsafe-any
+        if (hasSeparator) result += separator;
+      }
+      value = loadUnsafe<T,T>(buffer, lastIndex);
+      if (value) result += value.join(separator); // tslint:disable-line:no-unsafe-any
+    } else if (isReference<T>()) { // References
+      for (let i = 0; i < lastIndex; ++i) {
+        value = loadUnsafe<T,T>(buffer, i);
+        if (value) result += "[object Object]";
+        if (hasSeparator) result += separator;
+      }
+      value = loadUnsafe<T,T>(buffer, lastIndex);
+      if (value) result += "[object Object]";
+    } else {
+      assert(false); // Unsupported generic typename
+    }
+    return result;
+  }
+
+  @inline
+  toString(): string {
+    return this.join();
+  }
+
   private __gc(): void {
     var buffer = this.buffer_;
     __gc_mark(changetype<usize>(buffer)); // tslint:disable-line

std/assembly/index.d.ts

@@ -454,8 +454,10 @@ declare class Array<T> {
   unshift(element: T): i32;
   slice(from: i32, to?: i32): T[];
   splice(start: i32, deleteCount?: i32): void;
-  reverse(): T[];
   sort(comparator?: (a: T, b: T) => i32): this;
+  join(separator?: string): string;
+  reverse(): T[];
+  toString(): string;
 }
 
 /** Class representing a sequence of characters. */