warpo 3.1.3 → 3.2.1

package/assemblyscript/std/assembly/compat.ts

@@ -0,0 +1,2 @@
+export type ReturnType<T> = returnof<T>;
+export type NonNullable<T> = nonnull<T>;

package/assemblyscript/std/assembly/dataview.ts

@@ -0,0 +1,144 @@
+import { BLOCK_MAXSIZE } from "./rt/common";
+import { ArrayBuffer } from "./arraybuffer";
+import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from "./util/error";
+
+// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte
+
+export class DataView {
+  readonly buffer: ArrayBuffer;
+
+
+  @unsafe readonly dataStart: usize;
+  readonly byteLength: i32;
+
+  get byteOffset(): i32 {
+    return <i32>(this.dataStart - changetype<usize>(this.buffer));
+  }
+
+  constructor(buffer: ArrayBuffer, byteOffset: i32 = 0, byteLength: i32 = buffer.byteLength) {
+    if (i32(<u32>byteLength > <u32>BLOCK_MAXSIZE) | i32(<u32>byteOffset + byteLength > <u32>buffer.byteLength))
+      throw new RangeError(E_INVALIDLENGTH);
+    this.buffer = buffer; // links
+    let dataStart = changetype<usize>(buffer) + <usize>byteOffset;
+    this.dataStart = dataStart;
+    this.byteLength = byteLength;
+  }
+
+  getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    return littleEndian
+      ? load<f32>(this.dataStart + <usize>byteOffset)
+      : reinterpret<f32>(bswap<u32>(load<u32>(this.dataStart + <usize>byteOffset)));
+  }
+
+  getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    return littleEndian
+      ? load<f64>(this.dataStart + <usize>byteOffset)
+      : reinterpret<f64>(bswap<u64>(load<u64>(this.dataStart + <usize>byteOffset)));
+  }
+
+  getInt8(byteOffset: i32): i8 {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<i8>(this.dataStart + <usize>byteOffset);
+  }
+
+  getInt16(byteOffset: i32, littleEndian: bool = false): i16 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i16 = load<i16>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u16>(result);
+  }
+
+  getInt32(byteOffset: i32, littleEndian: bool = false): i32 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i32 = load<i32>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u32>(result);
+  }
+
+  getUint8(byteOffset: i32): u8 {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<u8>(this.dataStart + <usize>byteOffset);
+  }
+
+  getUint16(byteOffset: i32, littleEndian: bool = false): u16 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: u16 = load<u16>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u16>(result);
+  }
+
+  getUint32(byteOffset: i32, littleEndian: bool = false): u32 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: u32 = load<u32>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u32>(result);
+  }
+
+  setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    if (littleEndian) store<f32>(this.dataStart + <usize>byteOffset, value);
+    else store<u32>(this.dataStart + <usize>byteOffset, bswap<u32>(reinterpret<u32>(value)));
+  }
+
+  setFloat64(byteOffset: i32, value: f64, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    if (littleEndian) store<f64>(this.dataStart + <usize>byteOffset, value);
+    else store<u64>(this.dataStart + <usize>byteOffset, bswap<u64>(reinterpret<u64>(value)));
+  }
+
+  setInt8(byteOffset: i32, value: i8): void {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i8>(this.dataStart + <usize>byteOffset, value);
+  }
+
+  setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
+  }
+
+  setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u32>(value));
+  }
+
+  setUint8(byteOffset: i32, value: u8): void {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u8>(this.dataStart + <usize>byteOffset, value);
+  }
+
+  setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
+  }
+
+  setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u32>(value));
+  }
+
+  // Non-standard additions that make sense in WebAssembly, but won't work in JS:
+
+  getInt64(byteOffset: i32, littleEndian: bool = false): i64 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i64 = load<i64>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u64>(result);
+  }
+
+  getUint64(byteOffset: i32, littleEndian: bool = false): u64 {
+    if ((byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result = load<u64>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u64>(result);
+  }
+
+  setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
+  }
+
+  setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {
+    if ((byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
+  }
+
+  toString(): string {
+    return "[object DataView]";
+  }
+}

package/assemblyscript/std/assembly/date.ts

@@ -0,0 +1,383 @@
+import { E_INVALIDDATE } from "util/error";
+
+// @ts-ignore: decorator
+@inline const MILLIS_PER_DAY = 1000 * 60 * 60 * 24,
+  MILLIS_PER_HOUR = 1000 * 60 * 60,
+  MILLIS_PER_MINUTE = 1000 * 60,
+  MILLIS_PER_SECOND = 1000,
+  YEARS_PER_EPOCH = 400,
+  DAYS_PER_EPOCH = 146097,
+  EPOCH_OFFSET = 719468, // Jan 1, 1970
+  MILLIS_LIMIT = 8640000000000000;
+
+// ymdFromEpochDays returns values via globals to avoid allocations
+// @ts-ignore: decorator
+@lazy let _month: i32, _day: i32;
+
+export class Date {
+  private year: i32 = 0;
+  private month: i32 = 0;
+  private day: i32 = 0;
+
+
+  @inline static UTC(
+    year: i32,
+    month: i32 = 0,
+    day: i32 = 1,
+    hour: i32 = 0,
+    minute: i32 = 0,
+    second: i32 = 0,
+    millisecond: i32 = 0
+  ): i64 {
+    if (year >= 0 && year <= 99) year += 1900;
+    let ms = epochMillis(year, month + 1, day, hour, minute, second, millisecond);
+    if (invalidDate(ms)) throw new RangeError(E_INVALIDDATE);
+    return ms;
+  }
+
+  // It can parse only ISO 8601 inputs like YYYY-MM-DDTHH:MM:SS.000Z
+  @inline static parse(dateString: string): Date {
+    return this.fromString(dateString);
+  }
+
+  static fromString(dateTimeString: string): Date {
+    if (!dateTimeString.length) throw new RangeError(E_INVALIDDATE);
+    var hour: i32 = 0,
+      min: i32 = 0,
+      sec: i32 = 0,
+      ms: i32 = 0,
+      offsetMs: i32 = 0;
+
+    let dateString = dateTimeString;
+    let posT = dateTimeString.indexOf("T");
+    if (~posT) {
+      // includes a time component
+      let timeString: string;
+      dateString = dateTimeString.substring(0, posT);
+      timeString = dateTimeString.substring(posT + 1);
+
+      // might end with an offset ("Z", "+05:30", "-08:00", etc.)
+      for (let i = timeString.length - 1; i >= 0; i--) {
+        let c = timeString.charCodeAt(i);
+        if (c == 90) {
+          // Z
+          timeString = timeString.substring(0, i);
+          break;
+        } else if (c == 43 || c == 45) {
+          // + or -
+          if (i == timeString.length - 1) {
+            throw new RangeError(E_INVALIDDATE);
+          }
+
+          let posColon = timeString.indexOf(":", i + 1);
+          if (~posColon) {
+            let offsetHours = i32.parse(timeString.substring(i + 1, posColon));
+            let offsetMinutes = i32.parse(timeString.substring(posColon + 1));
+            offsetMs = (offsetHours * 60 + offsetMinutes) * MILLIS_PER_MINUTE;
+          } else {
+            let offsetHours = i32.parse(timeString.substring(i + 1));
+            offsetMs = offsetHours * MILLIS_PER_HOUR;
+          }
+
+          if (c == 45) offsetMs = -offsetMs; // negative offset
+          timeString = timeString.substring(0, i);
+          break;
+        }
+      }
+
+      // parse the HH:MM:SS component
+      let timeParts = timeString.split(":");
+      let len = timeParts.length;
+      if (len <= 1) throw new RangeError(E_INVALIDDATE);
+
+      hour = i32.parse(timeParts[0]);
+      min = i32.parse(timeParts[1]);
+      if (len >= 3) {
+        let secAndFrac = timeParts[2];
+        let posDot = secAndFrac.indexOf(".");
+        if (~posDot) {
+          // includes fractional seconds (truncate to milliseconds)
+          sec = i32.parse(secAndFrac.substring(0, posDot));
+          ms = i32.parse(secAndFrac.substr(posDot + 1, 3).padEnd(3, "0"));
+        } else {
+          sec = i32.parse(secAndFrac);
+        }
+      }
+    }
+
+    // parse the YYYY-MM-DD component
+    let parts = dateString.split("-");
+    let year = i32.parse(parts[0]);
+    let month = 1,
+      day = 1;
+    let len = parts.length;
+    if (len >= 2) {
+      month = i32.parse(parts[1]);
+      if (len >= 3) {
+        day = i32.parse(parts[2]);
+      }
+    }
+
+    return new Date(epochMillis(year, month, day, hour, min, sec, ms) - offsetMs);
+  }
+
+  constructor(private epochMillis: i64) {
+    // this differs from JavaScript which prefer return NaN or "Invalid Date" string
+    // instead throwing exception.
+    if (invalidDate(epochMillis)) throw new RangeError(E_INVALIDDATE);
+
+    this.year = dateFromEpoch(epochMillis);
+    this.month = _month;
+    this.day = _day;
+  }
+
+
+  @inline getTime(): i64 {
+    return this.epochMillis;
+  }
+
+  setTime(time: i64): i64 {
+    if (invalidDate(time)) throw new RangeError(E_INVALIDDATE);
+
+    this.epochMillis = time;
+    this.year = dateFromEpoch(time);
+    this.month = _month;
+    this.day = _day;
+
+    return time;
+  }
+
+
+  @inline getUTCFullYear(): i32 {
+    return this.year;
+  }
+
+
+  @inline getUTCMonth(): i32 {
+    return this.month - 1;
+  }
+
+
+  @inline getUTCDate(): i32 {
+    return this.day;
+  }
+
+
+  @inline getUTCDay(): i32 {
+    return dayOfWeek(this.year, this.month, this.day);
+  }
+
+  getUTCHours(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_DAY)) / MILLIS_PER_HOUR;
+  }
+
+  getUTCMinutes(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_HOUR)) / MILLIS_PER_MINUTE;
+  }
+
+  getUTCSeconds(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_MINUTE)) / MILLIS_PER_SECOND;
+  }
+
+  getUTCMilliseconds(): i32 {
+    return i32(euclidRem(this.epochMillis, MILLIS_PER_SECOND));
+  }
+
+  setUTCMilliseconds(millis: i32): void {
+    this.setTime(this.epochMillis + (millis - this.getUTCMilliseconds()));
+  }
+
+  setUTCSeconds(seconds: i32): void {
+    this.setTime(this.epochMillis + (seconds - this.getUTCSeconds()) * MILLIS_PER_SECOND);
+  }
+
+  setUTCMinutes(minutes: i32): void {
+    this.setTime(this.epochMillis + (minutes - this.getUTCMinutes()) * MILLIS_PER_MINUTE);
+  }
+
+  setUTCHours(hours: i32): void {
+    this.setTime(this.epochMillis + (hours - this.getUTCHours()) * MILLIS_PER_HOUR);
+  }
+
+  setUTCDate(day: i32): void {
+    if (this.day == day) return;
+    this.setTime(join(this.year, this.month, day, this.epochMillis));
+  }
+
+  setUTCMonth(month: i32, day: i32 = this.day): void {
+    if (this.month == month + 1) return;
+    this.setTime(join(this.year, month + 1, day, this.epochMillis));
+  }
+
+  setUTCFullYear(year: i32): void {
+    if (this.year == year) return;
+    this.setTime(join(year, this.month, this.day, this.epochMillis));
+  }
+
+  toISOString(): string {
+    // TODO: add more low-level helper which combine toString and padStart without extra allocation
+
+    let yr = this.year;
+    let isNeg = yr < 0;
+    let year = isNeg || yr >= 10000 ? (isNeg ? "-" : "+") + stringify(abs(yr), 6) : stringify(yr, 4);
+    let month = stringify(this.month, 2);
+    let day = stringify(this.day);
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+    let ms = stringify(this.getUTCMilliseconds(), 3);
+
+    return `${year}-${month}-${day}T${hours}:${mins}:${secs}.${ms}Z`;
+  }
+
+  toUTCString(): string {
+    const weeks: StaticArray<string> = ["Sun, ", "Mon, ", "Tue, ", "Wed, ", "Thu, ", "Fri, ", "Sat, "],
+      months: StaticArray<string> = [
+        " Jan ",
+        " Feb ",
+        " Mar ",
+        " Apr ",
+        " May ",
+        " Jun ",
+        " Jul ",
+        " Aug ",
+        " Sep ",
+        " Oct ",
+        " Nov ",
+        " Dec ",
+      ];
+
+    let mo = this.month;
+    let da = this.day;
+    let yr = this.year;
+    let wd = dayOfWeek(yr, mo, da);
+    let year = stringify(abs(yr), 4);
+    let month = unchecked(months[mo - 1]);
+    let week = unchecked(weeks[wd]);
+    let day = stringify(da);
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+
+    return `${week}${day}${month}${yr < 0 ? "-" : ""}${year} ${hours}:${mins}:${secs} GMT`;
+  }
+
+  toDateString(): string {
+    // TODO: use u64 static data instead 4 chars
+    // also use stream itoa variants.
+    const weeks: StaticArray<string> = ["Sun ", "Mon ", "Tue ", "Wed ", "Thu ", "Fri ", "Sat "],
+      months: StaticArray<string> = [
+        "Jan ",
+        "Feb ",
+        "Mar ",
+        "Apr ",
+        "May ",
+        "Jun ",
+        "Jul ",
+        "Aug ",
+        "Sep ",
+        "Oct ",
+        "Nov ",
+        "Dec ",
+      ];
+
+    let mo = this.month;
+    let da = this.day;
+    let yr = this.year;
+    let wd = dayOfWeek(yr, mo, da);
+    let year = stringify(abs(yr), 4);
+    let month = unchecked(months[mo - 1]);
+    let week = unchecked(weeks[wd]);
+    let day = stringify(da);
+
+    return `${week}${month}${day}${yr < 0 ? " -" : " "}${year}`;
+  }
+
+  // Note: it uses UTC time instead local time (without timezone offset)
+  toTimeString(): string {
+    let hours = stringify(this.getUTCHours());
+    let mins = stringify(this.getUTCMinutes());
+    let secs = stringify(this.getUTCSeconds());
+    // TODO: add timezone
+    return `${hours}:${mins}:${secs}`;
+  }
+
+  // Note: it uses UTC datetime instead local datetime (without timezone offset)
+  toString(): string {
+    return `${this.toDateString()} ${this.toTimeString()}`;
+  }
+}
+
+function epochMillis(year: i32, month: i32, day: i32, hour: i32, minute: i32, second: i32, milliseconds: i32): i64 {
+  return (
+    daysSinceEpoch(year, month, day) * MILLIS_PER_DAY +
+    hour * MILLIS_PER_HOUR +
+    minute * MILLIS_PER_MINUTE +
+    second * MILLIS_PER_SECOND +
+    milliseconds
+  );
+}
+
+// @ts-ignore: decorator
+@inline function floorDiv<T extends number>(a: T, b: T): T {
+  return ((a - (a < 0 ? b - 1 : 0)) / b) as T;
+}
+
+// @ts-ignore: decorator
+@inline function euclidRem<T extends number>(a: T, b: T): T {
+  let m = a % b;
+  return (m + (m < 0 ? b : 0)) as T;
+}
+
+function invalidDate(millis: i64): bool {
+  // @ts-ignore
+  return (millis < -MILLIS_LIMIT) | (millis > MILLIS_LIMIT);
+}
+
+// Based on "Euclidean Affine Functions and Applications to Calendar Algorithms"
+// Paper: https://arxiv.org/pdf/2102.06959.pdf
+function dateFromEpoch(ms: i64): i32 {
+  let da = (<i32>floorDiv(ms, MILLIS_PER_DAY) * 4 + EPOCH_OFFSET * 4) | 3;
+  let q0 = floorDiv(da, DAYS_PER_EPOCH); // [0, 146096]
+  let r1 = <u32>da - q0 * DAYS_PER_EPOCH;
+  let u1 = u64(r1 | 3) * 2939745;
+  let dm1 = <u32>u1 / 11758980;
+  let n1 = 2141 * dm1 + 197913;
+  let year = 100 * q0 + i32(u1 >>> 32);
+  let mo = n1 >>> 16;
+  _day = (n1 & 0xffff) / 2141 + 1; // [1, 31]
+  if (dm1 >= 306) {
+    mo -= 12;
+    ++year;
+  }
+  _month = mo; // [1, 12]
+  return year;
+}
+
+// http://howardhinnant.github.io/date_algorithms.html#days_from_civil
+function daysSinceEpoch(y: i32, m: i32, d: i32): i64 {
+  y -= i32(m <= 2);
+  let era = <u32>floorDiv(y, YEARS_PER_EPOCH);
+  let yoe = <u32>y - era * YEARS_PER_EPOCH; // [0, 399]
+  let doy = <u32>(153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1; // [0, 365]
+  let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; // [0, 146096]
+  return <i64>(<i32>(era * 146097 + doe - EPOCH_OFFSET));
+}
+
+// TomohikoSakamoto algorithm from https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week
+function dayOfWeek(year: i32, month: i32, day: i32): i32 {
+  const tab = memory.data<u8>([0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4]);
+
+  year -= i32(month < 3);
+  year += floorDiv(year, 4) - floorDiv(year, 100) + floorDiv(year, YEARS_PER_EPOCH);
+  month = <i32>load<u8>(tab + month - 1);
+  return euclidRem(year + month + day, 7);
+}
+
+function stringify(value: i32, padding: i32 = 2): string {
+  return value.toString().padStart(padding, "0");
+}
+
+function join(year: i32, month: i32, day: i32, ms: i64): i64 {
+  return daysSinceEpoch(year, month, day) * MILLIS_PER_DAY + euclidRem(ms, MILLIS_PER_DAY);
+}

package/assemblyscript/std/assembly/diagnostics.ts

@@ -0,0 +1,11 @@
+// @ts-ignore: decorator
+@builtin
+export declare function ERROR(message?: string): void;
+
+// @ts-ignore: decorator
+@builtin
+export declare function WARNING(message?: string): void;
+
+// @ts-ignore: decorator
+@builtin
+export declare function INFO(message?: string): void;

package/assemblyscript/std/assembly/error.ts

@@ -0,0 +1,39 @@
+export class Error {
+  name: string = "Error";
+  stack: string = ""; // TODO
+
+  constructor(public message: string = "") {}
+
+  toString(): string {
+    let message = this.message;
+    return message.length ? this.name + ": " + message : this.name;
+  }
+}
+
+export class RangeError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "RangeError";
+  }
+}
+
+export class TypeError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "TypeError";
+  }
+}
+
+export class SyntaxError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "SyntaxError";
+  }
+}
+
+export class URIError extends Error {
+  constructor(message: string = "") {
+    super(message);
+    this.name = "URIError";
+  }
+}

package/assemblyscript/std/assembly/function.ts

@@ -0,0 +1,44 @@
+type auto = i32;
+
+
+@final export abstract class Function<T> {
+  private _index: u32;
+  private _env: usize;
+
+  // @ts-ignore: this on getter
+  get index(this: T): u32 {
+    return load<u32>(changetype<usize>(this), offsetof<Function<T>>("_index"));
+  }
+
+  // @ts-ignore: this on getter
+  get env(this: T): usize {
+    return load<usize>(changetype<usize>(this), offsetof<Function<T>>("_env"));
+  }
+
+  // @ts-ignore: this on getter
+  get name(this: T): string {
+    return "";
+  }
+
+  // @ts-ignore: this on getter
+  get length(this: T): i32 {
+    // @ts-ignore: T is function
+    return lengthof<T>();
+  }
+
+  // @ts-ignore: T is function
+  @builtin call(thisArg: thisof<T> | null, ...args: auto[]): returnof<T> {
+    return unreachable();
+  }
+
+  toString(this: T): string {
+    return "function() { [native code] }";
+  }
+
+  // RT integration
+
+  @unsafe private __visit(cookie: u32): void {
+    // Env is either `null` (nop) or compiler-generated
+    __visit(this._env, cookie);
+  }
+}

package/assemblyscript/std/assembly/iterator.ts

@@ -0,0 +1,24 @@
+
+@final export class IteratorResult<T> {
+  constructor(public value: T) {}
+
+
+  @inline
+  get done(): boolean {
+    return 0 == changetype<usize>(this);
+  }
+  static done<T>(): IteratorResult<T> {
+    return changetype<IteratorResult<T>>(0);
+  }
+  static fromValue<T>(value: T): IteratorResult<T> {
+    return new IteratorResult<T>(value);
+  }
+}
+
+export interface Iterator<T> {
+  next(): IteratorResult<T>;
+}
+
+export interface Iterable<T> {
+  [Symbol.iterator](): Iterator<T>;
+}