@rust-js/runtime 0.0.1 → 0.0.3

package/index.js

@@ -1,4 +1,4 @@
-// @rust-js/runtime 0.0.1: the helpers the JS rust-js writes imports (ADR 0103).
+// @rust-js/runtime 0.0.3: the helpers the JS rust-js writes imports (ADR 0103).
 // Generated by `rust-js --runtime-module`. Do not edit.
 export function $traitImpl(cache, keys, make) {
   // Each key is a dictionary or a drop, held weakly: a drop made for one call
@@ -93,6 +93,172 @@ export function $displayF64(value) {
   throw new Error('No f64 round-trip decimal found');
 }
 
+// The shortest digits of the positive `f32` `x` that read back as `x`, the
+// nearest to it of those, as Rust's: `[digits, point]`, `x` being `0.digits`
+// times 10 to `point` (ADR 0122). A decimal reads back as `x` when it's in
+// `x`'s rounding interval, at an end of it only when `x`'s significand is
+// even, as a tie rounds to an even one. Tested exactly: through an `f64`,
+// `Math.fround(Number(text))` rounds twice, which can miss `x`.
+export function $f32Digits(x) {
+  const view = new DataView(new ArrayBuffer(4));
+  view.setFloat32(0, x);
+  const bits = view.getUint32(0);
+  const exponentBits = bits >>> 23;
+  const fraction = bits & 0x7fffff;
+  const significand = BigInt(exponentBits === 0 ? fraction : fraction | 0x800000);
+  const exponent2 = exponentBits === 0 ? -149 : exponentBits - 150;
+  // In quarters of the last place: `x` is 4m of them, and its interval's ends
+  // 2 either side, or 1 below a power of two, where the gap below is half.
+  const quarters = 4n * significand;
+  const below = fraction === 0 && exponentBits > 1 ? 1n : 2n;
+  const even = (significand & 1n) === 0n;
+  const quarterNum = exponent2 >= 2 ? 1n << BigInt(exponent2 - 2) : 1n;
+  const quarterDen = exponent2 < 2 ? 1n << BigInt(2 - exponent2) : 1n;
+  // `c` times 10 to `p`, against `k` quarters.
+  const compare = (c, p, k) => {
+    const left = p >= 0 ? c * 10n ** BigInt(p) * quarterDen : c * quarterDen;
+    const right = p >= 0 ? k * quarterNum : k * quarterNum * 10n ** BigInt(-p);
+    return left < right ? -1 : left > right ? 1 : 0;
+  };
+  const readsBack = (c, p) => {
+    const low = compare(c, p, quarters - below);
+    const high = compare(c, p, quarters + 2n);
+    return (low > 0 || (low === 0 && even)) && (high < 0 || (high === 0 && even));
+  };
+
+  // The first digit's power of ten, estimated, then made exact.
+  let exponent = Math.floor(Math.log10(x));
+  while (compare(1n, exponent, quarters) > 0) exponent--;
+  while (compare(1n, exponent + 1, quarters) <= 0) exponent++;
+
+  for (let precision = 1; precision <= 9; precision++) {
+    const power = exponent - precision + 1;
+    // `x` over 10 to `power`, as `n / d`, and the integer nearest it.
+    const n = power >= 0 ? quarters * quarterNum : quarters * quarterNum * 10n ** BigInt(-power);
+    const d = power >= 0 ? quarterDen * 10n ** BigInt(power) : quarterDen;
+    const rounded = n / d + (2n * (n % d) >= d ? 1n : 0n);
+    let best;
+    let bestDistance;
+    for (const candidate of [rounded, rounded - 1n, rounded + 1n]) {
+      if (candidate > 0n && readsBack(candidate, power)) {
+        const delta = candidate * d - n;
+        const distance = delta < 0n ? -delta : delta;
+        if (best === undefined || distance < bestDistance || (distance === bestDistance && candidate > best)) {
+          best = candidate;
+          bestDistance = distance;
+        }
+      }
+    }
+    if (best !== undefined) {
+      let digits = best.toString();
+      let decimalPower = power;
+      while (digits.endsWith("0")) {
+        digits = digits.slice(0, -1);
+        decimalPower++;
+      }
+      return [digits, digits.length + decimalPower];
+    }
+  }
+  throw new Error("No f32 round-trip decimal found");
+}
+
+export function $displayF32(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Infinity) return "inf";
+  if (value === -Infinity) return "-inf";
+  const sign = value < 0 || Object.is(value, -0) ? "-" : "";
+  if (value === 0) return sign + "0";
+  const [digits, point] = $f32Digits(Math.abs(value));
+  const body =
+    point <= 0
+      ? "0." + "0".repeat(-point) + digits
+      : point >= digits.length
+        ? digits + "0".repeat(point - digits.length)
+        : digits.slice(0, point) + "." + digits.slice(point);
+  return sign + body;
+}
+
+export function $debugF32(value) {
+  const size = Math.abs(value);
+  if (Number.isFinite(value) && size !== 0 && (size < Math.fround(1e-4) || size >= Math.fround(1e16))) {
+    const [digits, point] = $f32Digits(size);
+    const mantissa = digits.length > 1 ? digits[0] + "." + digits.slice(1) : digits;
+    return (value < 0 ? "-" : "") + mantissa + "e" + (point - 1);
+  }
+  const text = $displayF32(value);
+  return Number.isFinite(value) && !text.includes(".") ? text + ".0" : text;
+}
+
+export function $bigToF32(n) {
+  const negative = n < 0n;
+  let size = negative ? -n : n;
+  const length = size.toString(2).length;
+  if (length > 24) {
+    const shift = BigInt(length - 24);
+    const rest = size & ((1n << shift) - 1n);
+    const half = 1n << (shift - 1n);
+    size >>= shift;
+    if (rest > half || (rest === half && (size & 1n) === 1n)) size++;
+    size <<= shift;
+  }
+  const x = Number(size);
+  return negative ? -x : x;
+}
+
+export function $powiF32(x, n) {
+  const reciprocal = n < 0;
+  let result = 1;
+  while (true) {
+    if (n & 1) {
+      result = Math.fround(result * x);
+    }
+    n = (n / 2) | 0;
+    if (n === 0) {
+      break;
+    }
+    x = Math.fround(x * x);
+  }
+  return reciprocal ? Math.fround(1 / result) : result;
+}
+
+export function $parseF32(s) {
+  const read = $parseF64(s);
+  const d = read._0;
+  if (read.TAG === "Err" || !Number.isFinite(d) || Math.fround(d) === d) {
+    return read.TAG === "Err" ? read : { TAG: "Ok", _0: Math.fround(d) };
+  }
+  const rounded = Math.fround(d);
+  // The `f32` this side of `d`: the largest where it rounds to infinity.
+  const near = Number.isFinite(rounded) ? rounded : Math.sign(d) * 3.4028234663852886e38;
+  const size = Math.abs(near);
+  // The `f32` on `d`'s other side, and the tie between them: past the
+  // largest, where infinity is, it's as far above as the one below is.
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat32(0, size);
+  const bits = view.getUint32(0);
+  view.setUint32(0, Math.abs(d) > size ? bits + 1 : bits - 1);
+  const other = view.getFloat32(0);
+  view.setUint32(0, bits - 1);
+  const tie = other === Infinity ? size + (size - view.getFloat32(0)) / 2 : (size + other) / 2;
+  if (Math.abs(d) !== tie) return { TAG: "Ok", _0: rounded };
+  // The digits, `digits` times 10 to `exponent`, against the tie, `m`
+  // times 2 to `k`, in integers.
+  const [mantissa, power = "0"] = s.toLowerCase().replace(/^[+-]/, "").split("e");
+  const [whole, fraction = ""] = mantissa.split(".");
+  const digits = BigInt(whole + fraction || "0");
+  const exponent = Number(power) - fraction.length;
+  view.setFloat64(0, tie);
+  const tieBits = view.getBigUint64(0);
+  const m = (tieBits & ((1n << 52n) - 1n)) | (1n << 52n);
+  const k = Number(tieBits >> 52n) - 1075;
+  const left = digits * 10n ** BigInt(Math.max(exponent, 0)) * 2n ** BigInt(Math.max(-k, 0));
+  const right = m * 2n ** BigInt(Math.max(k, 0)) * 10n ** BigInt(Math.max(-exponent, 0));
+  // The tie itself goes to the even one, as `Math.fround` takes it.
+  if (left === right) return { TAG: "Ok", _0: rounded };
+  const chosen = left > right ? Math.max(size, other) : Math.min(size, other);
+  return { TAG: "Ok", _0: d < 0 ? -chosen : chosen };
+}
+
 export function $f64Max(a, b) {
   return Number.isNaN(a) ? b : Number.isNaN(b) ? a : Math.max(a, b);
 }
@@ -265,6 +431,129 @@ export function $orInsertWith(map, key, make) {
   return map.get(key);
 }
 
+export function $key(value) {
+  if (value == null) {
+    return "~";
+  }
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "bigint":
+      return value + "n";
+    case "object":
+      if (Array.isArray(value)) {
+        return "[" + value.map($key).join(",") + "]";
+      }
+      return "{" + Object.keys(value).sort().map((k) => JSON.stringify(k) + ":" + $key(value[k])).join(",") + "}";
+    default:
+      return String(value);
+  }
+}
+
+export class $KeyMap extends Map {
+  constructor(entries) {
+    super();
+    if (entries) {
+      for (const [key, value] of entries) {
+        this.set(key, value);
+      }
+    }
+  }
+  get(key) {
+    const entry = super.get($key(key));
+    return entry === undefined ? undefined : entry[1];
+  }
+  set(key, value) {
+    const found = $key(key);
+    const entry = super.get(found);
+    if (entry === undefined) {
+      super.set(found, [key, value]);
+    } else {
+      entry[1] = value;
+    }
+    return this;
+  }
+  has(key) {
+    return super.has($key(key));
+  }
+  delete(key) {
+    return super.delete($key(key));
+  }
+  *entries() {
+    for (const [key, value] of super.values()) {
+      yield [key, value];
+    }
+  }
+  *keys() {
+    for (const [key] of super.values()) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const [, value] of super.values()) {
+      yield value;
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(f, that) {
+    for (const [key, value] of this.entries()) {
+      f.call(that, value, key, this);
+    }
+  }
+}
+
+export class $KeySet extends Set {
+  #items = new Map();
+  constructor(items) {
+    super();
+    if (items) {
+      for (const item of items) {
+        this.add(item);
+      }
+    }
+  }
+  get size() {
+    return this.#items.size;
+  }
+  add(item) {
+    const found = $key(item);
+    if (!this.#items.has(found)) {
+      this.#items.set(found, item);
+    }
+    return this;
+  }
+  has(item) {
+    return this.#items.has($key(item));
+  }
+  delete(item) {
+    return this.#items.delete($key(item));
+  }
+  clear() {
+    this.#items.clear();
+  }
+  values() {
+    return this.#items.values();
+  }
+  keys() {
+    return this.#items.values();
+  }
+  *entries() {
+    for (const item of this.#items.values()) {
+      yield [item, item];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.#items.values();
+  }
+  forEach(f, that) {
+    for (const item of this.#items.values()) {
+      f.call(that, item, item, this);
+    }
+  }
+}
+
 export function $sortedEntries(map, cmp) {
   return Array.from(map).sort((a, b) => cmp(a[0], b[0]));
 }
@@ -571,6 +860,56 @@ export function $bigRange(start, end) {
   return items;
 }
 
+export function* $rangeFrom(start) {
+  for (let i = start; ; i++) {
+    yield i;
+  }
+}
+
+export function $rangeNext(range) {
+  return range.start < range.end ? range.start++ : undefined;
+}
+
+export function $rangeNextBack(range) {
+  return range.start < range.end ? --range.end : undefined;
+}
+
+export function $rangeFromNext(range) {
+  return range.start++;
+}
+
+export function $asciiCase(text, upper = false) {
+  return upper
+    ? text.replace(/[a-z]+/g, (letters) => letters.toUpperCase())
+    : text.replace(/[A-Z]+/g, (letters) => letters.toLowerCase());
+}
+
+export function $append(items, other) {
+  for (const item of other) {
+    items.push(item);
+  }
+  other.length = 0;
+}
+
+export function $pretty(open, items, close, rest = false) {
+  if (items.length === 0) {
+    return open + (rest ? ".." : "") + close;
+  }
+  const lines = items.map((item) => "    " + item.replaceAll("\n", "\n    ") + ",\n").join("");
+  return open + "\n" + lines + (rest ? "    ..\n" : "") + close;
+}
+
+export function $charRange(start, end, inclusive = false) {
+  const items = [];
+  const last = end.codePointAt(0) - (inclusive ? 0 : 1);
+  for (let c = start.codePointAt(0); c <= last; c++) {
+    if (c < 0xd800 || c > 0xdfff) {
+      items.push(String.fromCodePoint(c));
+    }
+  }
+  return items;
+}
+
 export function $tryFromInt(x, lo, hi) {
   if (x < lo) return { TAG: "Err", _0: "NegOverflow" };
   if (x > hi) return { TAG: "Err", _0: "PosOverflow" };
@@ -634,7 +973,8 @@ export function $jsonWriter(pretty) {
     null() { this.text += "null"; },
     bool(b) { this.text += String(b); },
     int(n) { this.text += String(n); },
-    number(x) { this.text += $jsonNumber(x); },
+    // An `f32`'s, `single`, with its own digits, as serde_json writes it (ADR 0122).
+    number(x, single) { this.text += single ? $jsonF32(x) : $jsonNumber(x); },
     char(c) { this.text += JSON.stringify(c); },
     string(s) { this.text += JSON.stringify(s); },
     // An externally tagged unit variant: its name.
@@ -666,7 +1006,7 @@ export function $jsonFlat(into) {
     null() { if (depth > 0) into.null(); },
     bool(b) { top("a boolean"); into.bool(b); },
     int(n) { top("an integer"); into.int(n); },
-    number(x) { top("a float"); into.number(x); },
+    number(x, single) { top("a float"); into.number(x, single); },
     char(c) { top("a char"); into.char(c); },
     string(s) { top("a string"); into.string(s); },
     variant(name) {
@@ -696,6 +1036,22 @@ export function $toJson(value, write, pretty) {
   }
   return { TAG: "Ok", _0: json.text };
 }
+// An `f32` as serde_json writes one: its shortest digits, zmij's, fixed from
+// 1e-6 to 1e12, else `1.5e+16` (ADR 0122).
+export function $jsonF32(x) {
+  if (!Number.isFinite(x)) return "null";
+  if (x === 0) return Object.is(x, -0) ? "-0.0" : "0.0";
+  const [digits, point] = $f32Digits(Math.abs(x));
+  const sign = x < 0 ? "-" : "";
+  const e = point - 1;
+  if (e < -6 || e > 12) {
+    const mantissa = digits.length > 1 ? `${digits[0]}.${digits.slice(1)}` : digits;
+    return `${sign}${mantissa}e${e < 0 ? "-" : "+"}${Math.abs(e)}`;
+  }
+  if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+  if (point >= digits.length) return `${sign}${digits}${"0".repeat(point - digits.length)}.0`;
+  return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
 
 // What serde's impls and derives read, the same whatever they read from:
 // the text (`$JsonReader`), or a value already read (`$JsonContent`), which
@@ -717,6 +1073,12 @@ export class $JsonDecoder {
     return this.deserializeNumber("f64", (n) => Number(n.value));
   }
 
+  // serde's `f32` takes any number, `as f32`: an integer rounded once, by
+  // `$bigToF32`, and a float, serde_json's `f64`, rounded (ADR 0122).
+  f32() {
+    return this.deserializeNumber("f32", (n) => (n.kind === "f" ? Math.fround(n.value) : $bigToF32(BigInt(n.value))));
+  }
+
   string() {
     return this.deserializeStr("a string", (s) => s);
   }
@@ -2513,7 +2875,7 @@ export class $JsonMissing {
   }
 }
 for (const method of [
-  "bool", "int", "f64", "string", "char", "borrowedStr", "unit", "unitStruct", "vec", "tuple", "array", "map",
+  "bool", "int", "f64", "f32", "string", "char", "borrowedStr", "unit", "unitStruct", "vec", "tuple", "array", "map",
   "struct", "untaggedStruct", "tupleStruct", "enum", "taggedUnit", "internallyTagged",
   "adjacentlyTagged", "untagged",
 ]) {
@@ -2615,6 +2977,7 @@ export const $json = {
   u64: (json) => json.int("u64", 0n, 18446744073709551615n),
   i64: (json) => json.int("i64", -9223372036854775808n, 9223372036854775807n),
   f64: (json) => json.f64(),
+  f32: (json) => json.f32(),
   string: (json) => json.string(),
   str: (json) => json.borrowedStr(),
   // serde_json's `Value` (ADR 0083), from whatever's there, and its `Number`.
@@ -2768,16 +3131,22 @@ export function $jsonNumberText(n) {
 }
 
 // serde_json's `Debug`: `Null`, `Bool(true)`, `Number(1)`, `String("a")`,
-// `Array [..]` and `Object {..}`.
-export function $debugJsonValue(value) {
+// `Array [..]` and `Object {..}`, whose parts `{:#?}` puts on lines of their
+// own, as a `Vec`'s and a map's.
+export function $debugJsonValue(value, alternate = false) {
   if (value === "Null") return "Null";
   const { TAG: tag, _0: inner } = value;
   if (tag === "Bool") return `Bool(${inner})`;
   if (tag === "Number") return $debugJsonNumber(inner);
   if (tag === "String") return `String(${$debugStr(inner)})`;
-  if (tag === "Array") return `Array [${inner.map($debugJsonValue).join(", ")}]`;
-  const entries = $sortedEntries(inner, $cmp).map(([key, item]) => `${$debugStr(key)}: ${$debugJsonValue(item)}`);
-  return `Object {${entries.join(", ")}}`;
+  if (tag === "Array") {
+    const items = inner.map((item) => $debugJsonValue(item, alternate));
+    return alternate ? "Array " + $pretty("[", items, "]") : `Array [${items.join(", ")}]`;
+  }
+  const entries = $sortedEntries(inner, $cmp).map(
+    ([key, item]) => `${$debugStr(key)}: ${$debugJsonValue(item, alternate)}`,
+  );
+  return alternate ? "Object " + $pretty("{", entries, "}") : `Object {${entries.join(", ")}}`;
 }
 export function $debugJsonNumber(n) {
   return `Number(${$jsonNumberText(n)})`;
@@ -2831,6 +3200,7 @@ export function $jsonValueEq(value, other, kind) {
   if (value.TAG !== "Number") return false;
   const n = value._0;
   if (kind === "f64") return Number(n.value) === other;
+  if (kind === "f32") return (n.kind === "f" ? Math.fround(n.value) : $bigToF32(BigInt(n.value))) === other;
   if (kind === "i64") return $jsonNumberIsI64(n) && n.value == other;
   return n.kind === "u" && n.value == other;
 }
@@ -2886,6 +3256,57 @@ export function $debugJsonError(e) {
   return `Error(${$debugStr(e.message)}, line: ${e.line}, column: ${e.column})`;
 }
 
+// std's error of a message, which `Box<dyn Error>::from("..")` makes: a
+// `dyn Error`'s dictionary, whose `value` is the message (ADR 0141).
+export function $stringError() {
+  return {
+    Debug: () => ({ fmt: (message) => $debugStr(message) }),
+    Display: () => ({ fmt: (message) => message }),
+    source: () => undefined,
+  };
+}
+
+// A channel on one thread is a queue (ADR 0142), shared by its ends: both
+// are the one object, which counts its senders and knows if its receiver
+// is still there.
+export function $channel() {
+  const channel = { queue: [], senders: 1, receiving: true };
+  return [channel, channel];
+}
+
+export function $send(channel, item) {
+  if (!channel.receiving) return { TAG: "Err", _0: [item] };
+  channel.queue.push(item);
+  return { TAG: "Ok", _0: undefined };
+}
+
+// Rust's `recv` waits for another thread to send; on one, none can, so an
+// empty channel whose senders are all there would wait forever.
+export function $recv(channel) {
+  if (channel.queue.length > 0) return { TAG: "Ok", _0: channel.queue.shift() };
+  if (channel.senders === 0) return { TAG: "Err", _0: undefined };
+  throw new Error("`recv` of an empty channel would wait forever: no other thread can send");
+}
+
+export function $tryRecv(channel) {
+  if (channel.queue.length > 0) return { TAG: "Ok", _0: channel.queue.shift() };
+  return { TAG: "Err", _0: channel.senders === 0 ? "Disconnected" : "Empty" };
+}
+
+export function $cloneSender(channel) {
+  channel.senders += 1;
+  return channel;
+}
+
+export function $dropSender(channel) {
+  channel.senders -= 1;
+}
+
+export function $dropReceiver(channel) {
+  channel.receiving = false;
+  channel.queue.length = 0;
+}
+
 export function $lowerExp(x) {
   if (Number.isNaN(x)) return "NaN";
   if (!Number.isFinite(x)) return x > 0 ? "inf" : "-inf";
@@ -3100,6 +3521,64 @@ export function $sliceEnd(items, start, end = items.length) {
   return end;
 }
 
+export function $byteLen(s) {
+  let bytes = 0;
+  for (let i = 0; i < s.length; i++) {
+    const unit = s.charCodeAt(i);
+    if (unit < 0x80) bytes += 1;
+    else if (unit < 0x800) bytes += 2;
+    else if (unit >= 0xd800 && unit < 0xdc00) {
+      bytes += 4;
+      i++;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+
+export function $strSlice(s, start, end) {
+  const length = $byteLen(s);
+  end ??= length;
+  if (start > length) throw new Error(`start byte index ${start} is out of bounds for string of length ${length}`);
+  if (end > length) throw new Error(`end byte index ${end} is out of bounds for string of length ${length}`);
+  if (start > end) throw new Error(`byte range starts at ${start} but ends at ${end}`);
+  return s.slice($unitAt(s, start, "start"), $unitAt(s, end, "end"));
+}
+
+export function $unitAt(s, at, which) {
+  let bytes = 0;
+  let unit = 0;
+  for (const c of s) {
+    if (bytes === at) return unit;
+    const next = bytes + $byteLen(c);
+    if (next > at) {
+      throw new Error(`${which} byte index ${at} is not a char boundary; it is inside ${$debugStr(c, "'")} (bytes ${bytes}..${next} of string)`);
+    }
+    bytes = next;
+    unit += c.length;
+  }
+  return unit;
+}
+
+export function $find(s, pattern) {
+  const at = s.indexOf(pattern);
+  return at === -1 ? undefined : $byteLen(s.slice(0, at));
+}
+
+export function $rfind(s, pattern) {
+  const at = s.lastIndexOf(pattern);
+  return at === -1 ? undefined : $byteLen(s.slice(0, at));
+}
+
+export function $charIndices(s) {
+  const indices = [];
+  let at = 0;
+  for (const c of s) {
+    indices.push([at, c]);
+    at += $byteLen(c);
+  }
+  return indices;
+}
+
 export function $extend(v, items) {
   for (const item of items) {
     v.push(item);
@@ -3171,6 +3650,78 @@ export function $skipWhile(items, skip) {
   return start < 0 ? [] : items.slice(start);
 }
 
+export function* $lazyChain(a, b) {
+  yield* a;
+  yield* b;
+}
+
+export function* $lazyZip(a, b) {
+  const right = b[Symbol.iterator]();
+  for (const item of a) {
+    const other = right.next();
+    if (other.done) {
+      return;
+    }
+    yield [item, other.value];
+  }
+}
+
+export function* $lazyTakeWhile(items, keep) {
+  for (const item of items) {
+    if (!keep(item)) {
+      return;
+    }
+    yield item;
+  }
+}
+
+export function* $lazySkipWhile(items, skip) {
+  let skipping = true;
+  for (const item of items) {
+    if (skipping && skip(item)) {
+      continue;
+    }
+    skipping = false;
+    yield item;
+  }
+}
+
+export function* $repeating(value, clone = (value) => value) {
+  while (true) {
+    yield clone(value);
+  }
+}
+
+export function* $repeatingWith(f) {
+  while (true) {
+    yield f();
+  }
+}
+
+export function* $successors(next, successor, boxed = false) {
+  while (next != null) {
+    const item = boxed ? $someValue(next) : next;
+    next = successor(item);
+    yield item;
+  }
+}
+
+export function $fromFn(f, boxed = false) {
+  return Iterator.from({
+    next() {
+      const item = f();
+      if (item == null) {
+        return { done: true, value: undefined };
+      }
+      return { done: false, value: boxed ? $someValue(item) : item };
+    }
+  });
+}
+
+export function $unzip(pairs) {
+  return [pairs.map(([a]) => a), pairs.map(([, b]) => b)];
+}
+
 export function $partition(items, keep) {
   const yes = [];
   const no = [];
@@ -3281,8 +3832,9 @@ export function $debugStr(s, quote = '"') {
   return out + quote;
 }
 
-export function $debugFields(name, fields, values) {
-  return name + " { " + fields.map((field, i) => field + ": " + values[i]).join(", ") + " }";
+export function $debugFields(name, fields, values, alternate = false) {
+  const shown = fields.map((field, i) => field + ": " + values[i]);
+  return alternate ? $pretty(name + " {", shown, "}") : name + " { " + shown.join(", ") + " }";
 }
 
 export function $plus(text) {
@@ -3301,6 +3853,56 @@ export function $pad(text, width, align, fill = " ") {
   return fill.repeat(before) + text + fill.repeat(room - before);
 }
 
+// A `Formatter`'s options, applied to the text a number, a `bool` or a
+// string shows as std's `fmt`s apply them (ADR 0058): a number takes a
+// sign and zeros, a string is cut to its precision, and either is padded.
+export function $formatted(text, options, numeric = false) {
+  if (options === undefined) return text;
+  const { width, precision } = options;
+  if (numeric && options.plus) text = $plus(text);
+  if (!numeric && precision !== undefined) text = [...text].slice(0, precision).join("");
+  if (width === undefined) return text;
+  if (numeric && options.zero) return $zeroPad(text, width);
+  const align = { Left: "<", Right: ">", Center: "^" }[options.align] ?? (numeric ? ">" : "<");
+  return $pad(text, width, align, options.fill);
+}
+
+// A float's precision is its digits; the rest is `$formatted`'s.
+export function $formatFloat(value, options, show) {
+  const precision = options?.precision;
+  return $formatted(precision === undefined ? show(value) : $toFixed(value, precision), options, true);
+}
+
+// A JS iterator lent as a `&mut` (ADR 0071): it steps `it`, and what takes
+// from it and stops early, as `take` or a loop that breaks does, closes
+// this, not `it`, which its lender goes on stepping.
+export function $lent(it) {
+  return Iterator.from({ next: () => it.next() });
+}
+
+// `collect()` into a `Result`: the first `Err`, where it stops, as Rust's
+// does, or `Ok` of all the values.
+export function $collectResults(items) {
+  const values = [];
+  for (const item of items) {
+    if (item.TAG === "Err") return item;
+    values.push(item._0);
+  }
+  return { TAG: "Ok", _0: values };
+}
+
+// `collect()` into an `Option`: `None` at the first `None`, where it stops,
+// as Rust's does, or all the values, each out of its box where it has one
+// (ADR 0051).
+export function $collectOptions(items, boxed = false) {
+  const values = [];
+  for (const item of items) {
+    if (item == null) return undefined;
+    values.push(boxed ? $someValue(item) : item);
+  }
+  return values;
+}
+
 export function $cmpIn(names, a, b) {
   return $cmp(names.indexOf(a), names.indexOf(b));
 }
@@ -3349,6 +3951,10 @@ export function $min(items) {
 }
 
 export function $position(items, found) {
-  const i = items.findIndex(found);
-  return i < 0 ? undefined : i;
+  let i = 0;
+  for (const item of items) {
+    if (found(item)) return i;
+    i++;
+  }
+  return undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rust-js/runtime",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "The helpers the JS rust-js writes imports, released with the compiler, as @rescript/runtime is with ReScript. See docs/decisions/0103-runtime-package.md.",
   "license": "MIT",
   "repository": {