From d3ed577d2498bdd5e2b30f16329bb3541f23ca9d Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 17:23:50 -0700 Subject: [PATCH 1/2] chore(quest): claim quest/m3/ts-iter-debug.md Quest-Claim: 46472d86c834193c From f2fa302b7fb8979ead0e1e8d34c2874782b4a00a Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 17:55:56 -0700 Subject: [PATCH 2/2] feat(ts): translate Debug of std's iterators Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 2 +- quest/m3/ts-deque-slices.md | 34 + quest/m3/ts-iter-debug.md | 23 - ts/README.md | 5 +- ts/fixtures/lang/expected/chunks.ts | 10 +- ts/fixtures/lang/expected/collections.ts | 54 +- ts/fixtures/lang/expected/fmt.ts | 869 +++++++++++++++++++++++ ts/fixtures/lang/expected/harness.ts | 10 +- ts/fixtures/lang/expected/hints.ts | 2 +- ts/fixtures/lang/expected/holds.ts | 2 +- ts/fixtures/lang/expected/iters.ts | 6 +- ts/fixtures/lang/expected/keys.ts | 66 +- ts/fixtures/lang/expected/orders.ts | 10 +- ts/fixtures/lang/src/fmt.rs | 139 +++- ts/fixtures/lang/src/harness.rs | 1 + ts/runtime/rt.ts | 30 +- ts/runtime/rt/collections.ts | 44 +- ts/runtime/rt/iter.ts | 25 + ts/runtime/rt/str.ts | 4 + ts/src/lower/collections.rs | 2 +- ts/src/lower/fmt.rs | 86 +++ ts/src/lower/iter.rs | 2 +- 22 files changed, 1312 insertions(+), 114 deletions(-) create mode 100644 quest/m3/ts-deque-slices.md delete mode 100644 quest/m3/ts-iter-debug.md diff --git a/quest/m3/README.md b/quest/m3/README.md index a9edc11be..c0487d0dc 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -30,7 +30,7 @@ generic std gap is planned here even when moq never calls it. - [Waiting: a slice object for a mutable part of other values](/quest/m3/ts-slice-object.md) - waits on a moq profile showing the `Proxy` view's traps matter, then decides on an `rt.ByteSlice`-like form - [Port the workflow guard to kixelated/quest](/quest/m3/quest-workflow-guard.md) - quest's environment guard parses YAML as this repository's does - [Equality through a held type's own ne](/quest/m3/ts-eq-own-ne.md) - `==` of slices of a type whose `ne` the crate overrides, and `!=` of a tuple or `Arc` of one, translate -- [std iterators' Debug](/quest/m3/ts-iter-debug.md) - `{:?}` of std's iterators translates, writing std's text, a deque's two slices included +- [A deque's two slices](/quest/m3/ts-deque-slices.md) - `VecDeque::as_slices` and `{:?}` of a deque's `Iter`, `IterMut`, and `Drain` translate, split where std's are - [LinkedList](/quest/m3/ts-linked-list.md) - `LinkedList` and its methods translate - [A parameter read only where lowering leaves nothing](/quest/m3/ts-unread-params.md) - an instance whose lowering drops every read of a parameter marks it unused, so `tsc` accepts it - [Array keys a collection holds](/quest/m3/ts-array-keys.md) - collections of `[T; N]` keys type-check diff --git a/quest/m3/ts-deque-slices.md b/quest/m3/ts-deque-slices.md new file mode 100644 index 000000000..ee7659ca0 --- /dev/null +++ b/quest/m3/ts-deque-slices.md @@ -0,0 +1,34 @@ +# [M] A deque's two slices + +## Goal + +[rust2-ts](/ts/README.md) translates `VecDeque::as_slices` and `as_mut_slices`, and `{:?}` +of `vec_deque::Iter`, `IterMut`, and `Drain`, writing the same text as std, proven by +differential tests against native Rust on wrapped deques. + +## Plan + +Left by [moq-dev/rust2#317](https://github.com/moq-dev/rust2/pull/317), which translated +the rest of std's iterators' `Debug`. + +- `Iter` and `IterMut` write the two slices of the ring buffer as `as_slices` splits it: + `Iter([3], [1, 2])`, each half as consumed so far, the second taking the first's place + once it empties (`vec_deque/iter.rs`). The split depends on the buffer's capacity and + where its head sits. +- The runtime's deque does not split where std's does: it grows to a power of two of at + least 4 and moves its head to 0, ignores `with_capacity`, and shifts items one at a time + in `insert` and `remove`. std keeps `RawVec`'s capacity, moves the shorter segment as it + grows (`handle_capacity_increase`), and moves the shorter side in `insert`, `remove`, and + the rest. Every function that places items must place them where std's does. +- `Drain` writes its counts, `Drain(drain_len, idx, tail_len, remaining)`, which the + runtime's drain does not keep. + +Public API: the translator's output. + +## Required + +- [The rest of std the model reaches](/quest/m2/ts-model/std-rest.md) - `VecDeque` carries std's capacity, which the split depends on + +## Related + +- [LinkedList](/quest/m3/ts-linked-list.md) - the other std collection whose `Debug` is still refused diff --git a/quest/m3/ts-iter-debug.md b/quest/m3/ts-iter-debug.md deleted file mode 100644 index 5b20ea10d..000000000 --- a/quest/m3/ts-iter-debug.md +++ /dev/null @@ -1,23 +0,0 @@ -# [S] std iterators' Debug - -## Goal - -[rust2-ts](/ts/README.md) translates `{:?}` of std's iterators, writing the same text as -std, proven by differential tests against native Rust. - -## Plan - -Found auditing std collections' `Debug`: each of these refuses with `unsupported call to -<... as Debug>::fmt`, while the collections themselves translate. - -- `slice::Iter`, `vec::IntoIter`, and `binary_heap::Iter` write their remaining items as a - tuple of one slice: `Iter([1, 2])`. -- `str::Chars` writes `Chars(['a', 'b'])`, and `str::Bytes` its adaptor chain: - `Bytes(Copied { it: Iter([97]) })`. -- `btree_map`'s `Iter`, `Keys`, and `Values`, `btree_set::Iter`, and `hash_map`'s and - `hash_set`'s write their remaining entries as a list or map, without a name. -- `vec_deque::Iter` writes the two slices of its ring buffer, `Iter([3], [1, 2])`, as - `VecDeque::as_slices` returns them. Both need the runtime's buffer to split where - std's does, by the same growth and head; `as_slices` is refused too. - -Public API: the translator's output. diff --git a/ts/README.md b/ts/README.md index 8fbb177e7..dea2b5e6d 100644 --- a/ts/README.md +++ b/ts/README.md @@ -208,7 +208,10 @@ an `rt.ParseCharError`, `{ kind }`, its private `CharErrorKind`'s name. `==` of and of std's errors is their derived `PartialEq`, from core's MIR, so two errors are equal where their kinds are, private or not. `Debug` of a string or `char` escapes by std's Unicode tables, which the runtime carries, not the engine's. `Debug` of std's -collections writes their items in the order each iterates, a hash map's or set's included. A caller prints a +collections writes their items in the order each iterates, a hash map's or set's included, +and of their iterators and `Chars` the items each has left, in std's wrapper; a deque's +`Iter` and `IterMut`, which write its buffer's two halves, and its `Drain`, which writes its +counts, are refused. A caller prints a `printable` type as `to_string()` and `format!("{err:?}")` would: `rt.fmtToString((f) => DecodeError.fmt$Display(err, f))` and `rt.fmtFormat([(f) => DecodeError.fmt$Debug(err, f)])`, after diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index 0fb4486f1..3aaf75385 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -154,7 +154,7 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pairs[rt.idx(pairs, 0)])); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pairs[rt.idx(pairs, 1)])); } - const iter2: rt.Iter = rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom); + const iter2: rt.Iter = rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom); while (true) { const _219: rt.ByteSlice | rt.Done = iter2.next(); if (_219 === rt.DONE) { @@ -162,7 +162,7 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _219.data[_219.start] ^ _219.data[_219.start + 1]); } - const iter3: rt.Iter = rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom); + const iter3: rt.Iter = rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom); while (true) { const _234: rt.ByteSlice | rt.Done = iter3.next(); if (_234 === rt.DONE) { @@ -170,10 +170,10 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } _234.data[_234.start] = _234.data[_234.start + 1]; } - const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); - rt.iterExtendBytes(out, rt.iterChain(rt.iterMap(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), (p: rt.ByteSlice): rt.u8 => { + const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); + rt.iterExtendBytes(out, rt.iterChain(rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), (p: rt.ByteSlice): rt.u8 => { return p.data[p.start]; - }), rt.iterMap(rt.iterMap(rt.iterSlice(copies), rt.byteSliceFrom), (p2: rt.ByteSlice): rt.u8 => { + }), rt.iterMap(rt.iterLend(rt.iterSlice(copies), rt.byteSliceFrom), (p2: rt.ByteSlice): rt.u8 => { return p2.data[p2.start + 1]; })), undefined, true); } else { diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index 68d76c85a..16c751b03 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -2136,18 +2136,18 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: if (_25 === rt.DONE) { break; } - putAll$u8s_Union_u8s(rt.iterMap(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putAll$u8s_Intersection_u8s(rt.iterMap(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putAll$u8s_Difference_u8s(rt.iterMap(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putAll$u8s_SymmetricDifference_u8s(rt.iterMap(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putHints$u8s_Union_u8s(rt.iterMap(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - putHints$u8s_Intersection_u8s(rt.iterMap(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - putHints$u8s_Difference_u8s(rt.iterMap(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - putHints$u8s_SymmetricDifference_u8s(rt.iterMap(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); + putAll$u8s_Union_u8s(rt.iterLend(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom), put, out); + putAll$u8s_Intersection_u8s(rt.iterLend(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom), put, out); + putAll$u8s_Difference_u8s(rt.iterLend(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom), put, out); + putAll$u8s_SymmetricDifference_u8s(rt.iterLend(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom), put, out); + putHints$u8s_Union_u8s(rt.iterLend(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom), 1, out); + putHints$u8s_Intersection_u8s(rt.iterLend(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom), 1, out); + putHints$u8s_Difference_u8s(rt.iterLend(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom), 1, out); + putHints$u8s_SymmetricDifference_u8s(rt.iterLend(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom), 1, out); + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); const iter2: rt.Iter> = rt.iterSlice([rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeUnion(_25[0], _25[1]), copy$u8s)), rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeIntersection(_25[0], _25[1]), copy$u8s)), rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeDifference(_25[0], _25[1]), copy$u8s)), rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeSymmetricDifference(_25[0], _25[1]), copy$u8s))]); while (true) { @@ -2156,8 +2156,8 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: break; } const built: rt.BTreeSet = _81; - putAll$u8s_Iter_u8s(rt.iterMap(rt.btreeKeys(built), rt.byteSliceFrom), put, out); - putAll$u8s_Rev_Iter_u8s(rt.iterRev(rt.iterMap(rt.btreeKeys(built), rt.byteSliceFrom)), put, out); + putAll$u8s_Iter_u8s(rt.iterLend(rt.btreeKeys(built), rt.byteSliceFrom), put, out); + putAll$u8s_Rev_Iter_u8s(rt.iterRev(rt.iterLend(rt.btreeKeys(built), rt.byteSliceFrom)), put, out); } } const _93: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_23: rt.u8): Uint8Array => { @@ -2174,15 +2174,15 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: if (_111 === rt.DONE) { break; } - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putHints$u8s_Union_u8s_RandomState(rt.iterMap(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - putHints$u8s_Intersection_u8s_RandomState(rt.iterMap(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - putHints$u8s_Difference_u8s_RandomState(rt.iterMap(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - putHints$u8s_SymmetricDifference_u8s_RandomState(rt.iterMap(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v: rt.ByteSlice): rt.u8 => { + putSorted$u8s(rt.iterToArray(rt.iterLend(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterLend(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterLend(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterLend(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); + putHints$u8s_Union_u8s_RandomState(rt.iterLend(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), 0, out); + putHints$u8s_Intersection_u8s_RandomState(rt.iterLend(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), 0, out); + putHints$u8s_Difference_u8s_RandomState(rt.iterLend(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), 0, out); + putHints$u8s_SymmetricDifference_u8s_RandomState(rt.iterLend(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), 0, out); + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v: rt.ByteSlice): rt.u8 => { let _3!: boolean; if (!rt.hashContains(_111[0], rt.byteSliceView(v))) { _3 = rt.hashContains(_111[1], rt.byteSliceView(v)); @@ -2191,7 +2191,7 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: } return _3 ? 1 : 0; })); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v2: rt.ByteSlice): rt.u8 => { + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v2: rt.ByteSlice): rt.u8 => { let _32!: boolean; if (!rt.hashContains(_111[0], rt.byteSliceView(v2))) { _32 = false; @@ -2200,10 +2200,10 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: } return _32 ? 1 : 0; })); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v3: rt.ByteSlice): rt.u8 => { + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v3: rt.ByteSlice): rt.u8 => { return !rt.hashContains(_111[1], rt.byteSliceView(v3)) ? 1 : 0; })); - rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterMap(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v4: rt.ByteSlice): rt.u8 => { + rt.byteVecPush(out, mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v4: rt.ByteSlice): rt.u8 => { return rt.hashContains(_111[0], rt.byteSliceView(v4)) !== rt.hashContains(_111[1], rt.byteSliceView(v4)) ? 1 : 0; })); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rt.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rt.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); @@ -2213,7 +2213,7 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: if (_175 === rt.DONE) { break; } - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashKeys(_175), rt.byteSliceFrom), "next", 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterLend(rt.hashKeys(_175), rt.byteSliceFrom), "next", 4), put, out); } } } diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index b295b8789..f3eed79b5 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -1,6 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; +import { copy$u8s } from "./lib.ts"; import { thenSome$0d5am30 } from "./core/bool.ts"; import { unwrapOr$0k15iai, unwrapOr$0r2bmpr } from "./core/option.ts"; import * as Bare from "./fmt.Bare.ts"; @@ -807,6 +808,874 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args16[0], "|", rt.fmtSpec({ alternate: true }, args16[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args16[0]), "|", args16[1], "|", rt.fmtSpec({ alternate: true }, args16[1]), "|", rt.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args16[1])])); } +/** + * std's iterators' `Debug`, each the items it has left in its own wrapper, through each + * element's `Debug` with the formatter's options: consumed from either end, empty, and + * pretty. A hash iterator holds at most one entry, since std leaves their order unspecified. + */ +export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const _6: [rt.usize, rt.usize] = [rt.u8Rem(at(0), 3) as rt.usize, rt.u8Rem(at(1), 3) as rt.usize]; + const front: rt.usize = _6[0]; + const back: rt.usize = _6[1]; + const part = ends$Iter_u8$3(rt.iterSlice(rt.byteSliceView(data)), front, back); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part, f, rt.u8Debug, ["Iter"])]; + put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args2[0])])); + const part2 = ends$IterMut_u8(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), undefined, true)))), front, back); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part2, f, rt.u8Debug, ["IterMut"])]; + put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0])])); + const part3 = ends$IntoIter_Pair(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_2: rt.u8): Pair.Pair => { + const b2: rt.u8 = _2; + return { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }; + }), undefined, 16, true)), front, back); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part3, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$Debug(value, f), ["IntoIter"])]; + put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); + const part4 = ends$IntoIter_u8$3(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), front, back); + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part4, f, rt.u8Debug, ["IntoIter"])]; + put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args8[0])])); + const it4: rt.Iter = ends$Drain_Hex(rt.vecDrain(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_23: rt.u8): Hex.Hex => { + return { _0: rt.u32Mul(_23 as rt.u32, 257) }; + }), undefined, 4, true), { start: 1 }), front, back); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it4, f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$Debug(value, f), ["Drain"])]; + put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true, debugHex: "x" }, args10[0])])); + rt.drop(it4); + const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); + const _111: { end: rt.usize } = { end: rt.usizeDiv(data.length, 2) }; + const it5: rt.Iter = ends$Drain_u8$2(rt.byteVecDrain(bytes, _111), front, back); + const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it5, f, rt.u8Debug, ["Drain"])]; + put(out, rt.fmtFormat([args12[0], "|", rt.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args12[0])])); + rt.drop(it5); + const arrays: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c: rt.ByteSlice): Uint8Array => { + rt.idx(c, 0); + const _32: rt.u8 = c.data[c.start]; + rt.idx(c, 1); + return Uint8Array.of(_32, c.data[c.start + 1]); + }), undefined, 2, true); + const part5 = ends$Iter_u8s(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), front, back); + const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part5, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug), ["Iter"])]; + put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ alternate: true }, args14[0])])); + const part6 = ends$IterMut_u8s(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), back, front); + const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part6, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug), ["IterMut"])]; + put(out, rt.fmtFormat([args16[0]])); + const _165: Array = []; + const _174: rt.Iter = rt.iterSlice(_165); + const _176: rt.Iter = rt.iterSlice(rt.byteVecView(new rt.ByteVec())); + const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_174, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["Iter"]), (f: rt.Formatter) => rt.fmtIter(_176, f, rt.u8Debug, ["IntoIter"])]; + put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); + const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); + const part7 = ends$Iter_u8(rt.heapIter(heap), front, back); + const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part7, f, rt.u8Debug, ["Iter"])]; + put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ alternate: true }, args20[0])])); + const part8 = ends$IntoIter_u8(rt.heapIter(rt.heapClone(heap)), front, back); + const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part8, f, rt.u8Debug, ["IntoIter"])]; + put(out, rt.fmtFormat([args22[0]])); + const it8: rt.Iter = ends$Drain_u8(rt.heapDrain(rt.heapClone(heap)), front, back); + const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it8, f, rt.u8Debug, [["Drain", "iter"], "Drain"])]; + put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0])])); + rt.drop(it8); + const _236: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined => { + const b4: rt.u8 = _27; + return thenSome$0d5am30(rt.u8Rem(b4, 3) !== 0, b4); + }); + const part9 = ends$IntoIter_Option_u8(rt.dequeIter(rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _236, undefined, 2, true)), front, back); + const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part9, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["IntoIter"])]; + put(out, rt.fmtFormat([args26[0], "|", rt.fmtSpec({ alternate: true }, args26[0])])); + const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.char => { + const _59: rt.usize = rt.u8Rem(_28, 6) as rt.usize; + if (!(_59 < 6)) { + rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _59); + } + return [97, 233, 20013, 129408, 10, 39][_59]; + })); + const part10 = ends$Chars(rt.strChars(text), front, back); + const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChars(part10, f)]; + put(out, rt.fmtFormat([args28[0], "|", rt.fmtSpec({ alternate: true }, args28[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args28[0])])); + const part11 = ends$Bytes(rt.strBytes(text), front, back); + const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part11, f, rt.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; + put(out, rt.fmtFormat([args30[0], "|", rt.fmtSpec({ alternate: true }, args30[0]), "|", rt.fmtSpec({ debugHex: "x" }, args30[0])])); + const _295: rt.Iter = rt.strChars(""); + const _298: rt.Iter = rt.strChars(""); + const _301: rt.Iter = rt.strBytes(""); + const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChars(_295, f), (f: rt.Formatter) => rt.fmtChars(_298, f), (f: rt.Formatter) => rt.fmtIter(_301, f, rt.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; + put(out, rt.fmtFormat([args32[0], "|", rt.fmtSpec({ alternate: true }, args32[1]), "|", args32[2]])); + const _310: rt.Iter<[rt.u8, rt.u8 | undefined]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): [rt.u8, rt.u8 | undefined] => { + const b6: rt.u8 = _29; + return [rt.u8Rem(b6, 16), thenSome$0d5am30(rt.u8Rem(b6, 3) !== 0, b6)] as [rt.u8, rt.u8 | undefined]; + }); + const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _310, true, undefined, undefined, undefined, 3, true); + const part12 = ends$Iter_u8_Option_u8(rt.btreeIter(map), front, back); + const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part12, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + put(out, rt.fmtFormat([args34[0], "|", rt.fmtSpec({ alternate: true }, args34[0]), "|", rt.fmtSpec({ debugHex: "x" }, args34[0])])); + const _335: rt.Iter = ends$Keys_u8_Option_u8(rt.btreeKeys(map), front, back); + const _339: rt.Iter = ends$Values_u8_Option_u8(rt.btreeValues(map), front, back); + const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_335, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtIter(_339, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args36[0], "|", args36[1]])); + const lo: rt.u8 = rt.u8Rem(at(2), 16); + const _360: rt.Iter<[rt.u8, rt.u8 | undefined]> = ends$Range_u8_Option_u8(rt.btreeRange(map, { start: lo }), front, back); + const _365: rt.Iter<[rt.u8, rt.u8 | undefined]> = ends$Range_u8_Option_u8(rt.btreeRange(map, { end: lo, inclusive: true }), front, back); + const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_360, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f)), (f: rt.Formatter) => rt.fmtIter(_365, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + put(out, rt.fmtFormat([args38[0], "|", args38[1]])); + const part13 = ends$IterMut_u8_Option_u8(rt.btreeIterMut(map), front, back); + const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part13, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + put(out, rt.fmtFormat([args40[0]])); + const part14 = ends$ValuesMut_u8_Option_u8(rt.btreeValuesMut(map), front, back); + const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part14, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args42[0]])); + const part15 = ends$RangeMut_u8_Option_u8(rt.btreeRangeMut(map, { start: lo }), front, back); + const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part15, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + put(out, rt.fmtFormat([args44[0]])); + const part16 = ends$IntoIter_u8_Option_u8(rt.btreeIter(rt.btreeClone(map, undefined, undefined)), front, back); + const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part16, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; + put(out, rt.fmtFormat([args46[0]])); + const part17 = ends$IntoKeys_u8_Option_u8(rt.btreeKeys(rt.btreeClone(map, undefined, undefined)), front, back); + const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part17, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args48[0]])); + const part18 = ends$IntoValues_u8_Option_u8(rt.btreeValues(map), front, back); + const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part18, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args50[0]])); + const _468: rt.Iter<[Uint8Array, Hex.Hex]> = rt.iterMap(rt.byteSliceChunksExact(data, 2), (c2: rt.ByteSlice): [Uint8Array, Hex.Hex] => { + rt.idx(c2, 0); + const _411: rt.u8 = c2.data[c2.start]; + rt.idx(c2, 1); + const _33: Uint8Array = Uint8Array.of(_411, c2.data[c2.start + 1]); + rt.idx(c2, 0); + return [_33, { _0: c2.data[c2.start] as rt.u32 }] as [Uint8Array, Hex.Hex]; + }); + const keyed: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmpBytes) as rt.BTreeMap, _468, true, undefined, undefined, undefined, 8, true); + const it13: rt.Iter<[rt.ByteSlice, Hex.Hex]> = ends$Iter_u8s_Hex(rt.iterLend(rt.btreeIter(keyed), (held): [rt.ByteSlice, Hex.Hex] => { + return [rt.byteSliceFrom(held[0]), held[1]]; + }), front, back); + const _481: rt.Iter = ends$Keys_u8s_Hex(rt.iterLend(rt.btreeKeys(keyed), rt.byteSliceFrom), back, front); + const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it13, f, (value: [Uint8Array, Hex.Hex], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.u8Debug), (f: rt.Formatter) => Hex.fmt$Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtIter(_481, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args52[0], "|", rt.fmtSpec({ alternate: true, debugHex: "x" }, args52[0]), "|", args52[1]])); + const _491: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): rt.u8 => { + return rt.u8Rem(_212, 16); + }); + const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _491, true, undefined, undefined, 1, true); + const part19 = ends$Iter_u8$2(rt.btreeKeys(set), front, back); + const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part19, f, rt.u8Debug, ["Iter"])]; + put(out, rt.fmtFormat([args54[0], "|", rt.fmtSpec({ alternate: true }, args54[0])])); + const part20 = ends$Range_u8(rt.btreeRangeKeys(set, { start: lo }), front, back); + const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part20, f, rt.fmtSetVal(rt.u8Debug), [["Range", "iter"]])]; + put(out, rt.fmtFormat([args56[0], "|", rt.fmtSpec({ alternate: true }, args56[0]), "|", rt.fmtSpec({ debugHex: "x" }, args56[0])])); + const part21 = ends$IntoIter_u8$2(rt.btreeKeys(set), front, back); + const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part21, f, rt.fmtSetVal(rt.u8Debug), [["IntoIter", "iter"]])]; + put(out, rt.fmtFormat([args58[0], "|", rt.fmtSpec({ alternate: true }, args58[0])])); + const empty2: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; + const _547: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(empty2); + const _550: rt.Iter = rt.btreeKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet); + const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_547, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtIter(_550, f, rt.u8Debug, ["Iter"])]; + put(out, rt.fmtFormat([args60[0], "|", rt.fmtSpec({ alternate: true }, args60[1])])); + const part22 = rt.btreeKeys(empty2); + const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part22, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args62[0]])); + const _573: [rt.HashMap, rt.HashSet] = [rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashMap, rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet]; + const one: rt.HashMap = _573[0]; + const keys: rt.HashSet = _573[1]; + const _576: rt.u8 | undefined = rt.byteSliceFirst(data); + if (_576 !== undefined) { + const b: rt.u8 = _576; + const _581: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); + rt.hashInsert(one, _581, rt.u16Mul(b as rt.u16, 257)); + const _590: Uint8Array = Uint8Array.of(b, at(1)); + rt.hashAdd(keys, _590); + } + const n: rt.usize = rt.u8Rem(at(1), 2) as rt.usize; + const _608: rt.Iter<[rt.u8 | undefined, rt.u16]> = rt.hashIter(one); + const _611: rt.Iter<[rt.u8 | undefined, rt.u16]> = skip$Iter_Option_u8_u16(rt.hashIter(one), n); + const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_608, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtIter(_611, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; + put(out, rt.fmtFormat([args64[0], "|", rt.fmtSpec({ alternate: true }, args64[1])])); + const _627: rt.Iter = skip$Keys_Option_u8_u16(rt.hashKeys(one), n); + const _631: rt.Iter = skip$Values_Option_u8_u16(rt.hashValues(one), n); + const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_627, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtIter(_631, f, rt.u16Debug)]; + put(out, rt.fmtFormat([args66[0], "|", args66[1]])); + const part23 = skip$IterMut_Option_u8_u16(rt.hashIterMut(one), n); + const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part23, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; + put(out, rt.fmtFormat([args68[0]])); + const part24 = skip$ValuesMut_Option_u8_u16(rt.hashValuesMut(one), rt.usizeSub(1, n)); + const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part24, f, rt.u16Debug)]; + put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args70[0])])); + const part25 = skip$IntoIter_Option_u8_u16(rt.hashIter(rt.hashClone(one, undefined, undefined)), n); + const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part25, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; + put(out, rt.fmtFormat([args72[0]])); + const _695: rt.Iter = rt.hashKeys(rt.hashClone(one, undefined, undefined)); + const _699: rt.Iter = skip$IntoValues_Option_u8_u16(rt.hashValues(rt.hashClone(one, undefined, undefined)), n); + const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_695, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtIter(_699, f, rt.u16Debug)]; + put(out, rt.fmtFormat([args74[0], "|", args74[1]])); + const it17: rt.Iter<[rt.u8 | undefined, rt.u16]> = skip$Drain_Option_u8_u16(rt.hashDrain(one), n); + const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it17, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; + put(out, rt.fmtFormat([args76[0], "|", rt.fmtSpec({ alternate: true }, args76[0])])); + const _732: rt.Iter = skip$Iter_u8s(rt.iterLend(rt.hashKeys(keys), rt.byteSliceFrom), n); + const _736: rt.Iter = rt.hashKeys(rt.hashClone(keys, copy$u8s, undefined)); + const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_732, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtIter(_736, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args78[0], "|", rt.fmtSpec({ alternate: true }, args78[1])])); + const part26 = skip$Drain_u8s(rt.hashDrainKeys(keys), rt.usizeSub(1, n)); + const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part26, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args80[0]])); +} + +export function skip$Bytes(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Chars(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Drain_Hex(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Drain_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.u16]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.u16]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Drain_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Drain_u8$2(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Drain_u8s(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoIter_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + return it; + } + return it; +} + +export function skip$IntoIter_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.u16]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.u16]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoIter_Pair(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoIter_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoIter_u8$2(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoIter_u8$3(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoIter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, n: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoKeys_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoValues_Option_u8_u16(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IntoValues_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + return it; + } + return it; +} + +export function skip$IterMut_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.Place]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.Place]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IterMut_u8(it: rt.Iter>, n: rt.usize): rt.Iter> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IterMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, n: rt.usize): rt.Iter<[rt.u8, rt.Place]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$IterMut_u8s(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.u16]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.u16]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_u8$2(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_u8$3(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, n: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_u8s(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_u8s$2(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Iter_u8s_Hex(it: rt.Iter<[rt.ByteSlice, Hex.Hex]>, n: rt.usize): rt.Iter<[rt.ByteSlice, Hex.Hex]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Keys_Option_u8_u16(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + return it; + } + return it; +} + +export function skip$Keys_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Keys_u8s_Hex(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$RangeMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, n: rt.usize): rt.Iter<[rt.u8, rt.Place]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Range_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Range_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, n: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$ValuesMut_Option_u8_u16(it: rt.Iter>, n: rt.usize): rt.Iter> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$ValuesMut_u8_Option_u8(it: rt.Iter>, n: rt.usize): rt.Iter> { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Values_Option_u8_u16(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1)); + return it; + } + return it; +} + +export function skip$Values_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { + if (n > 0) { + rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + return it; + } + return it; +} + +export function ends$Bytes(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Bytes(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Chars(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Chars(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Drain_Hex(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Drain_Hex(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Drain_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Drain_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Drain_u8$2(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Drain_u8$2(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IntoIter_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IntoIter_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack(), rt.None); + } +} + +export function ends$IntoIter_Pair(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IntoIter_Pair(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IntoIter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IntoIter_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IntoIter_u8$2(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IntoIter_u8$2(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IntoIter_u8$3(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IntoIter_u8$3(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IntoIter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { + const it2: rt.Iter<[rt.u8, rt.u8 | undefined]> = skip$IntoIter_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IntoKeys_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IntoKeys_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IntoValues_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IntoValues_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack(), rt.None); + } +} + +export function ends$IterMut_u8(it: rt.Iter>, front: rt.usize, back: rt.usize): rt.Iter> { + const it2: rt.Iter> = skip$IterMut_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IterMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.Place]> { + const it2: rt.Iter<[rt.u8, rt.Place]> = skip$IterMut_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$IterMut_u8s(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$IterMut_u8s(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Iter_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Iter_u8$2(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Iter_u8$2(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Iter_u8$3(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Iter_u8$3(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Iter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { + const it2: rt.Iter<[rt.u8, rt.u8 | undefined]> = skip$Iter_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Iter_u8s(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Iter_u8s$2(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Iter_u8s_Hex(it: rt.Iter<[rt.ByteSlice, Hex.Hex]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.ByteSlice, Hex.Hex]> { + const it2: rt.Iter<[rt.ByteSlice, Hex.Hex]> = skip$Iter_u8s_Hex(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Keys_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Keys_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Keys_u8s_Hex(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Keys_u8s_Hex(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$RangeMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.Place]> { + const it2: rt.Iter<[rt.u8, rt.Place]> = skip$RangeMut_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Range_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Range_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Range_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { + const it2: rt.Iter<[rt.u8, rt.u8 | undefined]> = skip$Range_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$ValuesMut_u8_Option_u8(it: rt.Iter>, front: rt.usize, back: rt.usize): rt.Iter> { + const it2: rt.Iter> = skip$ValuesMut_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack()); + } +} + +export function ends$Values_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + const it2: rt.Iter = skip$Values_u8_Option_u8(it, front); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = back; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it2; + } + rt.iterToOption(it2.nextBack(), rt.None); + } +} + /** * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 826724e63..bf1ee256c 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -19,7 +19,7 @@ import { dyns, shared, anys, fns } from "./dyns.ts"; import { edits, bytes } from "./edits.ts"; import { eqs } from "./errors.ts"; import { floats, mulAdds, formats, parses } from "./floats.ts"; -import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, writes } from "./fmt.ts"; +import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, iters, writes } from "./fmt.ts"; import { folds } from "./folds.ts"; import { methods } from "./generics.ts"; import { values, random, bytes as hashes_bytes } from "./hashes.ts"; @@ -40,7 +40,7 @@ import { singles, mulAdds as singles_mulAdds, formats as singles_formats, parses import { parts, chunked, subslices, drains, ranges as slices_ranges, edits as slices_edits } from "./slices.ts"; import { splits } from "./splits.ts"; import { statics, cells as statics_cells, onces } from "./statics.ts"; -import { strs, slices, edits as strs_edits, parses as strs_parses, iters, drains as strs_drains, hinted } from "./strs.ts"; +import { strs, slices, edits as strs_edits, parses as strs_parses, iters as strs_iters, drains as strs_drains, hinted } from "./strs.ts"; import { decodes } from "./utf8.ts"; import { wrappers } from "./wrappers.ts"; import { zeros, impls, keys as zeros_keys } from "./zeros.ts"; @@ -180,7 +180,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) reducers(data63, out64); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::writers", (_2164: rt.u8, data64: rt.ByteSlice, out65: rt.ByteVec): undefined => { writers(data64, out65); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", strs_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", slices_edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", strs_iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", strs_drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_2165: rt.u8, data65: rt.ByteSlice, out66: rt.ByteVec): undefined => { made(data65, out66); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::as_slices", (_2166: rt.u8, data66: rt.ByteSlice, out67: rt.ByteVec): undefined => { asSlices(data66, out67); @@ -194,7 +194,9 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) lent(data70, out71); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", singles_mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_2171: rt.u8, data71: rt.ByteSlice, out72: rt.ByteVec): undefined => { collections(data71, out72); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", zeros_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", zeros_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { + iters(data72, out73); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index 2a3d6a76f..4babbf02e 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -1952,7 +1952,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return Uint8Array.of(_245); }), (value: Uint8Array) => rt.iterSlice(value), false, 1, true), steps, out); } else { - walk$Flatten_Iter_u8s(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_244: rt.u8): Uint8Array => { + walk$Flatten_Iter_u8s(rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_244: rt.u8): Uint8Array => { const b5: rt.u8 = _244; return Uint8Array.of(b5, b5); }), undefined, 2, true)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), steps, out); diff --git a/ts/fixtures/lang/expected/holds.ts b/ts/fixtures/lang/expected/holds.ts index 6c0124b4c..3c9d1c43d 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -69,7 +69,7 @@ export function places(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): set(rt.place(() => grid[_30][_32], (value) => grid[_30][_32] = value), k); set(rt.place(() => rows[_35].cells[_39], (value2) => rows[_35].cells[_39] = value2), k ^ 1); } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 4), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 4), undefined, true); for (const _61 of rows) { rt.iterExtendBytes(out, rt.iterSlice(_61.cells), undefined, true); } diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index df73ed19c..50851676e 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -129,12 +129,12 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const b3: rt.u8 = _2; return Uint8Array.of(b3, ~b3 & 0xff); }), undefined, 2, true); - const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); + const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); if (!((copies.length === 0))) { const _174: rt.ByteSlice = rt.byteSliceFrom(copies[rt.idx(copies, 0)]); _174.data[_174.start] = 85; } - const iter4: rt.Iter = rt.iterChain(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), rt.iterMap(rt.iterSlice(copies), rt.byteSliceFrom)); + const iter4: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(copies), rt.byteSliceFrom)); while (true) { const _187: rt.ByteSlice | rt.Done = iter4.next(); if (_187 === rt.DONE) { @@ -996,7 +996,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _28[0] ^ _28[1]; })); rt.byteVecPush(out, rest14.len() & 0xff); - const rest15: rt.Iter = rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Uint8Array => { + const rest15: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Uint8Array => { const b5: rt.u8 = _29; return Uint8Array.of(b5, ~b5 & 0xff); }), undefined, 2, true)), rt.byteSliceFrom); diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 34aa07614..1ede4f8ca 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -920,7 +920,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const boxed: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpBytes) as rt.BTreeSet; - const _151: rt.Iter = rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), (w: rt.ByteSlice): Uint8Array => { + const _151: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), (w: rt.ByteSlice): Uint8Array => { rt.idx(w, 0); const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); rt.idx(w, 1); @@ -1078,7 +1078,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const tree: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpBytes) as rt.BTreeSet; - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom)); + const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom)); while (true) { const _24: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1093,7 +1093,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void key[0] = key[0] ^ 16; rt.byteVecPush(out, rt.hashContains(map, rt.byteSliceView(rt.byteSliceFrom(key))) ? 1 : 0); } - const lent: rt.ByteSlice[] = rt.iterToArray(rt.iterMap(rt.hashKeys(map), rt.byteSliceFrom), "next", 4); + const lent: rt.ByteSlice[] = rt.iterToArray(rt.iterLend(rt.hashKeys(map), rt.byteSliceFrom), "next", 4); rt.sliceSort(lent, rt.cmpLt(rt.cmpBytes)); for (const k of lent) { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(k.data[k.start], k.data[k.start + 1], rt.hashIndex(map, rt.byteSliceView(k)), rt.hashContains(map, rt.byteSliceView(k)) ? 1 : 0, rt.eqBytes(k, rt.byteSliceFrom(probe)) ? 1 : 0, rt.cmpBytes(k, rt.byteSliceFrom(probe)) === -1 ? 1 : 0)), undefined, true); @@ -1109,7 +1109,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return rt.hashContains(map, rt.byteSliceView(k3)); }) ? 1 : 0); const entries: [Uint8Array, rt.u8][] = []; - const iter3: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterMap(rt.hashIter(map), (held): [rt.ByteSlice, rt.u8] => { + const iter3: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.hashIter(map), (held): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held[0]), held[1]]; }); while (true) { @@ -1125,7 +1125,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, _136[1]); } let sum: rt.u8 = 0; - const iter5: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterMap(rt.hashIterMut(map), (held2): [rt.ByteSlice, rt.Place] => { + const iter5: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.hashIterMut(map), (held2): [rt.ByteSlice, rt.Place] => { return [rt.byteSliceFrom(held2[0]), held2[1]]; }); while (true) { @@ -1136,7 +1136,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void _149[1].v = rt.u8WrappingAdd(_149[1].v, _149[0].data[_149[0].start]); sum = rt.u8WrappingAdd(rt.u8WrappingAdd(sum, _149[0].data[_149[0].start + 1]), _149[1].v); } - const iter6: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterMap(rt.hashIterMut(map), (held3): [rt.ByteSlice, rt.Place] => { + const iter6: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.hashIterMut(map), (held3): [rt.ByteSlice, rt.Place] => { return [rt.byteSliceFrom(held3[0]), held3[1]]; }); while (true) { @@ -1146,7 +1146,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } _170[1].v = _170[1].v ^ _170[0].data[_170[0].start + 1]; } - const iter7: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterMap(rt.hashIter(map), (held4): [rt.ByteSlice, rt.u8] => { + const iter7: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.hashIter(map), (held4): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held4[0]), held4[1]]; }); while (true) { @@ -1215,9 +1215,9 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_294 !== undefined) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.entryKey(_294))); } - const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); + const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterLend(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); rt.sliceSort(members, rt.cmpLt(rt.cmpBytes)); - const iter8: rt.Iter = rt.iterMap(rt.iterSlice(members), rt.byteSliceFrom); + const iter8: rt.Iter = rt.iterLend(rt.iterSlice(members), rt.byteSliceFrom); while (true) { const _312: rt.ByteSlice | rt.Done = iter8.next(); if (_312 === rt.DONE) { @@ -1225,7 +1225,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.byteVecExtendFromSlice(out, _312); } - const iter9: rt.Iter = rt.iterMap(rt.hashKeys(set), rt.byteSliceFrom); + const iter9: rt.Iter = rt.iterLend(rt.hashKeys(set), rt.byteSliceFrom); while (true) { const _321: rt.ByteSlice | rt.Done = iter9.next(); if (_321 === rt.DONE) { @@ -1250,7 +1250,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, mapOr$1w1gbwl(rt.optionMap(rt.btreeKey(ordered, rt.byteSliceView(_358)), rt.byteSliceFrom), 221, (k9: rt.ByteSlice): rt.u8 => { return k9.data[k9.start] ^ ((k9.data[k9.start + 1] << 2) & 0xff); })); - const iter10: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterRev(rt.iterMap(rt.btreeIter(tree), (held9): [rt.ByteSlice, rt.u8] => { + const iter10: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterRev(rt.iterLend(rt.btreeIter(tree), (held9): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held9[0]), held9[1]]; })); while (true) { @@ -1260,7 +1260,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_365[0].data[_365[0].start], _365[0].data[_365[0].start + 1], _365[1])), undefined, true); } - const iter11: rt.Iter = rt.iterMap(rt.btreeKeys(tree), rt.byteSliceFrom); + const iter11: rt.Iter = rt.iterLend(rt.btreeKeys(tree), rt.byteSliceFrom); while (true) { const _383: rt.ByteSlice | rt.Done = iter11.next(); if (_383 === rt.DONE) { @@ -1268,7 +1268,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.byteVecExtendFromSlice(out, _383); } - const iter12: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterMap(rt.btreeRange(tree, new rt.Range(Uint8Array.of(1, 0), Uint8Array.of(3, 0))), (held10): [rt.ByteSlice, rt.u8] => { + const iter12: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.btreeRange(tree, new rt.Range(Uint8Array.of(1, 0), Uint8Array.of(3, 0))), (held10): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held10[0]), held10[1]]; }); while (true) { @@ -1278,7 +1278,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_396[0].data[_396[0].start], _396[0].data[_396[0].start + 1], _396[1])), undefined, true); } - const iter13: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterMap(rt.btreeRangeMut(tree, { start: copy$u8s(probe) }), (held11): [rt.ByteSlice, rt.Place] => { + const iter13: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.btreeRangeMut(tree, { start: copy$u8s(probe) }), (held11): [rt.ByteSlice, rt.Place] => { return [rt.byteSliceFrom(held11[0]), held11[1]]; }); while (true) { @@ -1288,7 +1288,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } _415[1].v = rt.u8WrappingAdd(_415[1].v, _415[0].data[_415[0].start]); } - const iter14: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterMap(rt.btreeIter(tree), (held12): [rt.ByteSlice, rt.u8] => { + const iter14: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.btreeIter(tree), (held12): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held12[0]), held12[1]]; }); while (true) { @@ -1298,7 +1298,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_428[0].data[_428[0].start + 1], _428[1])), undefined, true); } - const iter15: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterMap(rt.btreeIterMut(tree), (held13): [rt.ByteSlice, rt.Place] => { + const iter15: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.btreeIterMut(tree), (held13): [rt.ByteSlice, rt.Place] => { return [rt.byteSliceFrom(held13[0]), held13[1]]; }); while (true) { @@ -1318,7 +1318,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void }), 221, (_25: [rt.ByteSlice, rt.u8]): rt.u8 => { return _25[0].data[_25[0].start + 1] ^ _25[1]; })); - const iter16: rt.Iter = rt.iterRev(rt.iterMap(rt.btreeKeys(ordered), rt.byteSliceFrom)); + const iter16: rt.Iter = rt.iterRev(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom)); while (true) { const _463: rt.ByteSlice | rt.Done = iter16.next(); if (_463 === rt.DONE) { @@ -1326,7 +1326,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.byteVecExtendFromSlice(out, _463); } - const iter17: rt.Iter = rt.iterMap(rt.btreeRangeKeys(ordered, { end: copy$u8s(probe), inclusive: true }), rt.byteSliceFrom); + const iter17: rt.Iter = rt.iterLend(rt.btreeRangeKeys(ordered, { end: copy$u8s(probe), inclusive: true }), rt.byteSliceFrom); while (true) { const _474: rt.ByteSlice | rt.Done = iter17.next(); if (_474 === rt.DONE) { @@ -1334,7 +1334,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.byteVecExtendFromSlice(out, _474); } - const iter18: rt.Iter = rt.iterMap(rt.btreeKeys(ordered), rt.byteSliceFrom); + const iter18: rt.Iter = rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom); while (true) { const _483: rt.ByteSlice | rt.Done = iter18.next(); if (_483 === rt.DONE) { @@ -1375,7 +1375,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void copy2[0] = 255; rt.byteVecPush(out, rt.btreeContains(ordered, rt.byteSliceView(rt.byteSliceFrom(copy2))) ? 1 : 0); } - rt.byteVecPush(out, rt.iterAll(rt.iterMap(rt.btreeKeys(ordered), rt.byteSliceFrom), (k16: rt.ByteSlice): boolean => { + rt.byteVecPush(out, rt.iterAll(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (k16: rt.ByteSlice): boolean => { return k16.data[k16.start] < 2; }) ? 1 : 0); const _548: rt.Iter<[rt.ByteVec, rt.u8]> = rt.iterMap(rt.byteSliceChunks(data, 3), (c: rt.ByteSlice): [rt.ByteVec, rt.u8] => { @@ -1408,11 +1408,11 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void })); const empty: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; const none: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterMap(rt.btreeKeys(empty), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.btreeFirst(empty), (held22): [rt.ByteSlice, rt.u8] => { + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterLend(rt.btreeKeys(empty), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.btreeFirst(empty), (held22): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held22[0]), held22[1]]; - }) === undefined ? 1 : 0, rt.iterCount(rt.iterMap(rt.btreeRange(empty, { start: copy$u8s(probe) }), (held23): [rt.ByteSlice, rt.u8] => { + }) === undefined ? 1 : 0, rt.iterCount(rt.iterLend(rt.btreeRange(empty, { start: copy$u8s(probe) }), (held23): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held23[0]), held23[1]]; - })) & 0xff, rt.iterCount(rt.iterMap(rt.hashKeys(none), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.hashKey(none, rt.byteSliceView(rt.byteSliceFrom(probe))), rt.byteSliceFrom) === undefined ? 1 : 0)), undefined, true); + })) & 0xff, rt.iterCount(rt.iterLend(rt.hashKeys(none), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.hashKey(none, rt.byteSliceView(rt.byteSliceFrom(probe))), rt.byteSliceFrom) === undefined ? 1 : 0)), undefined, true); } /** @@ -1474,7 +1474,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return Uint8Array.of(at, 0); })); _99.data[_99.start] = _99.data[_99.start] ^ 2; - const iter2: rt.Iter = rt.iterMap(rt.hashValues(map), rt.byteSliceFrom); + const iter2: rt.Iter = rt.iterLend(rt.hashValues(map), rt.byteSliceFrom); while (true) { const _110: rt.ByteSlice | rt.Done = iter2.next(); if (_110 === rt.DONE) { @@ -1483,7 +1483,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const _114: rt.u8 = rt.u8WrappingMul(_110.data[_110.start + 1], 3); _110.data[_110.start + 1] = _114; } - const iter3: rt.Iter<[rt.u8, rt.ByteSlice]> = rt.iterMap(rt.btreeIter(tree), (held2): [rt.u8, rt.ByteSlice] => { + const iter3: rt.Iter<[rt.u8, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(tree), (held2): [rt.u8, rt.ByteSlice] => { return [held2[0], rt.byteSliceFrom(held2[1])]; }); while (true) { @@ -1494,9 +1494,9 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const _128: rt.u8 = rt.u8WrappingAdd(_124[1].data[_124[1].start], _124[1].data[_124[1].start + 1]); _124[1].data[_124[1].start] = _128; } - const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashValues(map), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); + const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterLend(rt.hashValues(map), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); rt.sliceSort(values, rt.cmpLt(rt.cmpBytes)); - const iter4: rt.Iter = rt.iterMap(rt.iterSlice(values), rt.byteSliceFrom); + const iter4: rt.Iter = rt.iterLend(rt.iterSlice(values), rt.byteSliceFrom); while (true) { const _147: rt.ByteSlice | rt.Done = iter4.next(); if (_147 === rt.DONE) { @@ -1504,7 +1504,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo } rt.byteVecExtendFromSlice(out, _147); } - const iter5: rt.Iter<[rt.u8, rt.ByteSlice]> = rt.iterMap(rt.btreeIter(tree), (held3): [rt.u8, rt.ByteSlice] => { + const iter5: rt.Iter<[rt.u8, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(tree), (held3): [rt.u8, rt.ByteSlice] => { return [held3[0], rt.byteSliceFrom(held3[1])]; }); while (true) { @@ -1533,7 +1533,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo _201.data[_201.start] = _201.data[_201.start] ^ 1; rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.dequeIndex(deque, 0)))), undefined, true); } - const iter6: rt.Iter = rt.iterMap(rt.dequeIter(deque), rt.byteSliceFrom); + const iter6: rt.Iter = rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom); while (true) { const _213: rt.ByteSlice | rt.Done = iter6.next(); if (_213 === rt.DONE) { @@ -1546,7 +1546,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.u8Rem(v7.data[v7.start], 3) !== 0; }; rt.dequeRetain(deque, (held4) => f2(rt.byteSliceFrom(held4))); - const iter7: rt.Iter = rt.iterMap(rt.dequeIter(deque), rt.byteSliceFrom); + const iter7: rt.Iter = rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom); while (true) { const _228: rt.ByteSlice | rt.Done = iter7.next(); if (_228 === rt.DONE) { @@ -1554,7 +1554,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo } rt.byteVecExtendFromSlice(out, _228); } - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.dequeIter(deque), rt.byteSliceFrom), (v8: rt.ByteSlice): boolean => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (v8: rt.ByteSlice): boolean => { const _63: rt.ByteSlice = v8; return _63.data[_63.start + 1] > 4; })) & 0xff); @@ -1565,7 +1565,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return v10.data[v10.start + 1] !== rt.u8Rem(kind, 8); }; rt.heapRetain(heap, (held5) => _247(rt.byteSliceFrom(held5)), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)); - const iter8: rt.Iter = rt.iterMap(rt.heapIter(heap), rt.byteSliceFrom); + const iter8: rt.Iter = rt.iterLend(rt.heapIter(heap), rt.byteSliceFrom); while (true) { const _253: rt.ByteSlice | rt.Done = iter8.next(); if (_253 === rt.DONE) { @@ -1573,7 +1573,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo } rt.byteVecExtendFromSlice(out, _253); } - const iter9: rt.Iter = rt.iterMap(rt.heapIter(heap), rt.byteSliceFrom); + const iter9: rt.Iter = rt.iterLend(rt.heapIter(heap), rt.byteSliceFrom); while (true) { const _262: rt.ByteSlice | rt.Done = iter9.next(); if (_262 === rt.DONE) { diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index e81b6eb54..117dd7d55 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -510,13 +510,13 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(b2, 4); })); }), undefined, 2, true); - rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.iterMax(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a4: rt.ByteSlice): Uint8Array => { + rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.iterMax(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a4: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(a4); })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.iterMin(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a5: rt.ByteSlice): Uint8Array => { + rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.iterMin(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a5: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(a5); })), undefined, true); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)); + const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterCopied(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)); while (true) { const _179: Uint8Array | undefined = rt.heapPop(heap, rt.cmpLe(rt.cmpBytes)); if (_179 !== undefined) { @@ -525,7 +525,7 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - const _185: rt.Iter<[Uint8Array, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterCopied(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.byteSliceToArray)), (_2: [rt.usize, Uint8Array]): [Uint8Array, rt.usize] => { + const _185: rt.Iter<[Uint8Array, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterCopied(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), rt.byteSliceToArray)), (_2: [rt.usize, Uint8Array]): [Uint8Array, rt.usize] => { return [_2[1], _2[0]] as [Uint8Array, rt.usize]; }); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpBytes) as rt.BTreeMap, _185, true, undefined, undefined, undefined, 8, true)), (_22: [Uint8Array, rt.usize]): Uint8Array => { @@ -533,7 +533,7 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { return Uint8Array.of(k[0], k[1], _22[1] & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 3), undefined, true); rt.sliceSort(arrays, rt.cmpLt(rt.cmpBytes)); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); const slices: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(data, 3), undefined, 8, true); rt.sliceSortBy(slices, (a7: rt.ByteSlice, b3: rt.ByteSlice): rt.Ordering => { return rt.cmpBytes(b3, a7); diff --git a/ts/fixtures/lang/src/fmt.rs b/ts/fixtures/lang/src/fmt.rs index 01c243b78..fe0e29277 100644 --- a/ts/fixtures/lang/src/fmt.rs +++ b/ts/fixtures/lang/src/fmt.rs @@ -3,7 +3,7 @@ #![allow(dead_code, reason = "fields only `Debug` reads")] -use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet, VecDeque}; +use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque}; use std::fmt; use std::ops::{Range, RangeToInclusive}; use std::rc::Rc; @@ -724,6 +724,143 @@ pub fn collections(data: &[u8], out: &mut Vec) { put(out, &format!("{one:?}|{one:#?}|{one:>3?}|{set:?}|{set:#?}|{set:#04x?}")); } +/// std's iterators' `Debug`, each the items it has left in its own wrapper, through each +/// element's `Debug` with the formatter's options: consumed from either end, empty, and +/// pretty. A hash iterator holds at most one entry, since std leaves their order unspecified. +pub fn iters(data: &[u8], out: &mut Vec) { + let at = |i: usize| data.get(i).copied().unwrap_or(0); + let (front, back) = (usize::from(at(0) % 3), usize::from(at(1) % 3)); + // Taken from the front by `nth`, and from the back by `next_back`. + fn skip(mut it: I, n: usize) -> I { + if n > 0 { + it.nth(n - 1); + } + it + } + fn ends(it: I, front: usize, back: usize) -> I { + let mut it = skip(it, front); + for _ in 0..back { + it.next_back(); + } + it + } + + let it = ends(data.iter(), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:x?}|{it:>3?}")); + let mut v: Vec = data.iter().take(5).copied().collect(); + let it = ends(v.iter_mut(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let pairs: Vec = data.iter().take(4).map(|&b| Pair(b, -i64::from(b))).collect(); + let it = ends(pairs.into_iter(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + put(out, &format!("{:x?}", ends(data.to_vec().into_iter(), front, back))); + let mut hexes: Vec = data.iter().take(5).map(|&b| Hex(u32::from(b) * 0x101)).collect(); + let it = ends(hexes.drain(1..), front, back); + put(out, &format!("{it:?}|{it:#x?}")); + drop(it); + let mut bytes = data.to_vec(); + let it = ends(bytes.drain(..data.len() / 2), front, back); + put(out, &format!("{it:?}|{it:02X?}")); + drop(it); + // Arrays of bytes, which a borrow lends as slices of them. + let arrays: Vec<[u8; 2]> = data.chunks_exact(2).map(|c| [c[0], c[1]]).collect(); + let it = ends(arrays.iter(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let mut arrays = arrays; + put(out, &format!("{:?}", ends(arrays.iter_mut(), back, front))); + let empty: &[Option] = &[]; + put(out, &format!("{:?}|{:#?}", empty.iter(), Vec::::new().into_iter())); + + let heap: BinaryHeap = data.iter().copied().collect(); + let it = ends(heap.iter(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + put(out, &format!("{:?}", ends(heap.clone().into_iter(), front, back))); + let mut drained = heap.clone(); + let it = ends(drained.drain(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + drop(it); + let q: VecDeque> = data.iter().map(|&b| (b % 3 != 0).then_some(b)).collect(); + let it = ends(q.into_iter(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + + // Text of one-, two-, three-, and four-byte chars, and chars `Debug` escapes. + let text: String = data + .iter() + .map(|&b| ['a', 'é', '中', '🦀', '\n', '\''][usize::from(b % 6)]) + .collect(); + let it = ends(text.chars(), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:>3?}")); + let it = ends(text.bytes(), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:x?}")); + put(out, &format!("{:?}|{:#?}|{:?}", "".chars(), "".chars(), "".bytes())); + + let mut map: BTreeMap> = data.iter().map(|&b| (b % 16, (b % 3 != 0).then_some(b))).collect(); + let it = ends(map.iter(), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:x?}")); + put( + out, + &format!( + "{:?}|{:?}", + ends(map.keys(), front, back), + ends(map.values(), front, back) + ), + ); + let lo = at(2) % 16; + put( + out, + &format!( + "{:?}|{:?}", + ends(map.range(lo..), front, back), + ends(map.range(..=lo), front, back) + ), + ); + put(out, &format!("{:?}", ends(map.iter_mut(), front, back))); + put(out, &format!("{:?}", ends(map.values_mut(), front, back))); + put(out, &format!("{:?}", ends(map.range_mut(lo..), front, back))); + put(out, &format!("{:?}", ends(map.clone().into_iter(), front, back))); + put(out, &format!("{:?}", ends(map.clone().into_keys(), front, back))); + put(out, &format!("{:?}", ends(map.into_values(), front, back))); + let keyed: BTreeMap<[u8; 2], Hex> = data.chunks_exact(2).map(|c| ([c[0], c[1]], Hex(c[0].into()))).collect(); + let it = ends(keyed.iter(), front, back); + put(out, &format!("{it:?}|{it:#x?}|{:?}", ends(keyed.keys(), back, front))); + let set: BTreeSet = data.iter().map(|&b| b % 16).collect(); + let it = ends(set.iter(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let it = ends(set.range(lo..), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:x?}")); + let it = ends(set.into_iter(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let empty = BTreeMap::::new(); + put(out, &format!("{:?}|{:#?}", empty.iter(), BTreeSet::::new().iter())); + put(out, &format!("{:?}", empty.into_keys())); + + let (mut one, mut keys) = (HashMap::new(), HashSet::new()); + if let Some(&b) = data.first() { + one.insert((b % 2 == 0).then_some(b), u16::from(b) * 0x101); + keys.insert([b, at(1)]); + } + // Past its one entry, or not. + let n = usize::from(at(1) % 2); + put(out, &format!("{:?}|{:#?}", one.iter(), skip(one.iter(), n))); + put(out, &format!("{:?}|{:?}", skip(one.keys(), n), skip(one.values(), n))); + put(out, &format!("{:?}", skip(one.iter_mut(), n))); + put(out, &format!("{:x?}", skip(one.values_mut(), 1 - n))); + put(out, &format!("{:?}", skip(one.clone().into_iter(), n))); + put( + out, + &format!("{:?}|{:?}", one.clone().into_keys(), skip(one.clone().into_values(), n)), + ); + let it = skip(one.drain(), n); + put(out, &format!("{it:?}|{it:#?}")); + drop(it); + put( + out, + &format!("{:?}|{:#?}", skip(keys.iter(), n), keys.clone().into_iter()), + ); + let it = skip(keys.drain(), 1 - n); + put(out, &format!("{it:?}")); +} + /// An error only a TypeScript caller prints, as moq's callers print its errors: nothing /// translated formats it, so its `Display` and `Debug` come along as `printable`. #[derive(Debug)] diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 4736ff853..54736c8c5 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -175,6 +175,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("collections::unlike_eqs", collections::unlike_eqs), ("zeros::impls", zeros::impls), ("zeros::keys", zeros::keys), + ("fmt::iters", |_, data, out| fmt::iters(data, out)), ] } diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index ad3c3caa5..41f1c332b 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -8,7 +8,7 @@ import type { Ordering } from "./rt/collections.ts"; import type { ParseFloatError } from "./rt/float.ts"; import { type char, type ParseCharError, type ParseIntError, type TryFromIntError, type u32, type usize, u8Debug, usizeDebug, usizeDisplay } from "./rt/int.ts"; -import type { Range, RangeInclusive } from "./rt/iter.ts"; +import type { Iter, Range, RangeInclusive } from "./rt/iter.ts"; import { drop as dispose, dropAll, type Pending } from "./rt/task.ts"; import { AtIndex } from "./rt/collections.ts"; @@ -1737,6 +1737,34 @@ export function fmtMap(entries: Iterable<[K, V]>, f: Formatter, key: Debug }); } +/** What one of std's iterators writes around its list: a tuple struct's name, or a struct's name and its one field's. */ +export type IterWrap = string | readonly [name: string, field: string]; + +/** `Debug` of one of std's iterators: the items `it` has left, as a list inside `wraps`, outermost first. */ +export function fmtIter(it: Iter, f: Formatter, debug: Debug, wraps: readonly IterWrap[] = []): FmtResult { + return wrapIn(f, wraps, (f) => fmtList(it.remaining() as Iterable, f, debug)); +} + +function wrapIn(f: Formatter, wraps: readonly IterWrap[], inner: Fmt): FmtResult { + if (wraps.length === 0) return inner(f); + const [wrap, ...rest] = wraps; + const field: Fmt = (f) => wrapIn(f, rest, inner); + if (typeof wrap === "string") return fmtDebugTupleFields(f, wrap, [field]); + return fmtDebugStructFields(f, wrap[0], [wrap[1]], [field]); +} + +/** `Debug` of `str::Chars`: its name around the list of chars it has left, which a field's indent would not be. */ +export function fmtChars(it: Iter, f: Formatter): FmtResult { + let r = f.out.writeStr("Chars("); + if (r.ok) r = fmtList(it.remaining() as Iterable, f, fmtCharDebug); + return r.ok ? f.out.writeStr(")") : r; +} + +/** `Debug` of a key as a `BTreeSet`'s `range` and `into_iter` list it: its map's entry, the key and a `SetValZST`. */ +export function fmtSetVal(debug: Debug): Debug { + return (key, f) => fmtTuple([(f) => debug(key, f), (f) => f.out.writeStr("SetValZST")], f); +} + /** `Debug` of a range: each bound present, written with the formatter's options, around `dots`, which none pads. */ function fmtBounds(f: Formatter, start: Fmt | undefined, dots: string, end: Fmt | undefined): FmtResult { if (start !== undefined) { diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index b78a580fd..493af766d 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -25,7 +25,6 @@ import { iterChain, iterEmpty, iterFilter, - iterMap, iterOnce, iterSlice, type RangeInclusive, @@ -663,14 +662,20 @@ function retainHash(m: HashMap, f: (key: K, value: V | Place) => } /** - * What a collection's iterator yields: its entries as `[key, value]`, keys, values, or - * `[key, place]`, the place of a value JS copies. + * What a collection's iterator yields: its entries as `[key, value]`, keys, values, + * `[key, place]`, the place of a value JS copies, or that place alone. */ -type Pick = 0 | 1 | 2 | 3; +type Pick = 0 | 1 | 2 | 3 | 4; const ENTRIES = 0; const KEYS = 1; const VALUES = 2; const PLACES = 3; +const VALUE_PLACES = 4; + +/** What `pick` yields by value: each place its value. */ +function byValue(pick: Pick): Pick { + return pick === PLACES ? ENTRIES : pick === VALUE_PLACES ? VALUES : pick; +} /** * An iterator of a hash collection: `iter`, `keys`, `values`, `drain`, and the rest. @@ -678,6 +683,7 @@ const PLACES = 3; * and drops each entry it still holds as it drops. */ export class HashIter extends Iter implements Disposable { + private readonly h: HashMap; private readonly m: Map; private readonly p: Iterator<[K, V]>; private readonly o: Iterator> | undefined; @@ -691,6 +697,7 @@ export class HashIter extends Iter implements Disposable { constructor(m: HashMap, pick: Pick, k?: (key: K) => void, v?: (value: V) => void, drain = false) { super(); + this.h = m; this.m = m.p; this.p = m.p.entries(); this.o = m.o?.values(); @@ -733,6 +740,7 @@ export class HashIter extends Iter implements Disposable { if (this.left === 0) return DONE; this.left--; if (this.pick === PLACES) return this.place() as T; + if (this.pick === VALUE_PLACES) return this.place()[1] as T; const entry = this.entry(); if (this.pick === ENTRIES) return entry as T; if (this.pick === KEYS) { @@ -762,6 +770,13 @@ export class HashIter extends Iter implements Disposable { return acc; } + /** A fresh iterator of the same map, past what this one took: the map is unchanged while it is held. */ + override remaining(): Iterable { + const it = new HashIter(this.h, byValue(this.pick)); + while (it.left > this.left) it.next(); + return it; + } + override len(): number { return this.left; } @@ -806,7 +821,7 @@ export function hashIterMut(m: HashMap): Iter<[K, Place]> { /** `values_mut` of values JS copies: the place of each. */ export function hashValuesMut(m: HashMap): Iter> { - return iterMap(hashIterMut(m), (entry) => entry[1]); + return new HashIter>(m, VALUE_PLACES); } /** `drain` of a map: every entry, taken out at once, which drops as `hashIter`'s. */ @@ -1539,6 +1554,7 @@ export class BTreeIter extends Iter implements Disposable { private picked(l: Leaf, i: number): T { if (this.pick === ENTRIES) return [l.k[i], l.v[i]] as T; if (this.pick === PLACES) return [l.k[i], new AtIndex(l.v, i)] as T; + if (this.pick === VALUE_PLACES) return new AtIndex(l.v, i) as T; if (this.pick === KEYS) { this.v?.(l.v[i]); return l.k[i] as unknown as T; @@ -1547,6 +1563,10 @@ export class BTreeIter extends Iter implements Disposable { return l.v[i] as unknown as T; } + override remaining(): Iterable { + return new BTreeIter(byValue(this.pick), this.fl, this.fi, this.bl, this.bi); + } + override len(): number { return this.n; } @@ -1608,7 +1628,7 @@ export function btreeIterMut(m: BTreeMap): Iter<[K, Place]> { /** `values_mut` of values JS copies: the place of each. */ export function btreeValuesMut(m: BTreeMap): Iter> { - return iterMap(btreeIterMut(m), (entry) => entry[1]); + return whole(m, VALUE_PLACES); } /** `values` and `values_mut`, and with droppers as `btreeIter`'s, `into_values`. */ @@ -2439,6 +2459,10 @@ class DequeIter extends Iter implements Disposable { return this.front < this.back ? (this.q.b[at(this.q, this.front++)] as T) : DONE; } + override remaining(): Iterable { + return new DequeIter(this.q, this.front, this.back); + } + override nextBack(): T | Done { return this.front < this.back ? (this.q.b[at(this.q, --this.back)] as T) : DONE; } @@ -2611,6 +2635,10 @@ class VecDrain extends Iter implements Disposable { return this.front < this.back ? this.rest[this.front++] : DONE; } + override remaining(): Iterable { + return this.rest.slice(this.front, this.back); + } + override nextBack(): T | Done { return this.front < this.back ? this.rest[--this.back] : DONE; } @@ -2664,6 +2692,10 @@ class ByteVecDrain extends Iter implements Disposable { return this.front < this.back ? this.v.data[this.front++] : DONE; } + override remaining(): Iterable { + return this.v.data.slice(this.front, this.back); + } + override nextBack(): number | Done { return this.front < this.back ? this.v.data[--this.back] : DONE; } diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 50b9955f8..ef06ec21f 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -71,6 +71,8 @@ export interface Iter { nextBack(): T | Done; /** `ExactSizeIterator::len`. */ len(): number; + /** The items it has left, by value, without taking them: what std's `Debug` of it lists. */ + remaining(): Iterable; } /** `Iterator`: `next`, and the methods std's iterators each do their own way. */ @@ -518,6 +520,14 @@ export function iterMap(it: Iter, f: (item: T) => U): Iter { return new MapIter(it, f); } +/** + * `it` with each item lent by `f` as translated code reads it, as a `&[u8; N]` of a + * `Uint8Array` is lent as an `rt.ByteSlice`. + */ +export function iterLend(it: Iter, f: (item: T) => U): Iter { + return new LendIter(it, f); +} + /** `Iterator::filter`, dropping what `f` rejects by `drop`. */ export function iterFilter(it: Iter, f: (item: T) => boolean, drop?: Drop): Iter { return new FilterIter(it, f, drop); @@ -1227,6 +1237,10 @@ class SliceIter extends Iter implements Disposable { return exactHint(this.len()); } + override remaining(): Iterable { + return Array.prototype.slice.call(this.s, this.front, this.back); + } + [Symbol.dispose](): void { if (this.drop === undefined) return; const from = this.front; @@ -1280,6 +1294,10 @@ class SliceMutIter extends Iter> { return exactHint(this.len()); } + override remaining(): Iterable { + return Array.prototype.slice.call(this.s, this.front, this.back); + } + override advanceBy(n: number): number { const step = Math.min(n, this.back - this.front); this.front += step; @@ -1558,6 +1576,13 @@ class MapIter extends Calling U> { } } +/** What `iterLend` makes, which has left the items `inner` has, as it holds them. */ +class LendIter extends MapIter { + override remaining(): Iterable { + return this.inner.remaining(); + } +} + /** std's `map_fold`: `g` of what `f` makes of each item. */ function mapFold(f: (item: T) => U, g: (acc: A, item: U) => A): (acc: A, item: T) => A { return (acc, item) => g(acc, f(item)); diff --git a/ts/runtime/rt/str.ts b/ts/runtime/rt/str.ts index fc1371771..0f4e53a0c 100644 --- a/ts/runtime/rt/str.ts +++ b/ts/runtime/rt/str.ts @@ -131,6 +131,10 @@ class Chars extends Iter { rest(): string { return this.#s.slice(this.#front, this.#back); } + + override remaining(): Iterable { + return new Chars(this.rest()); + } } /** diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index bc679ac23..621788242 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -360,7 +360,7 @@ fn lend<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) && let Some(item) = b.t.iter_item(ty) { let f = lend_fn(b, item, span); - return Expr::rt("iterMap", vec![value, f]); + return Expr::rt("iterLend", vec![value, f]); } if let ty::Tuple(parts) = ty.kind() && value.is_path() diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 10203be75..9b668d56a 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -286,6 +286,12 @@ pub fn std_impl<'tcx>( { rt("writeStr", vec![f, Expr::Str(tcx.item_name(adt.did()).to_string())]) } + ty::Adt(adt, args) + if tr == Trait::Debug + && let Some(e) = iter_debug(b, adt.did(), args, &value, &f, span) => + { + e + } ty::Adt(adt, args) => match (Std::of(tcx, adt.did())?, tr) { (Std::String | Std::Cow, Trait::Display) if library::string(tcx, ty) => Expr::rt("fmtPad", vec![f, value]), (Std::String | Std::Cow, Trait::Debug) if library::string(tcx, ty) => rt("str", vec![value, f]), @@ -375,6 +381,86 @@ pub fn std_impl<'tcx>( }) } +/// `Debug` of one of std's iterators that lists the items it has left, as std writes +/// them, or `None` for another type. A deque's `Iter` and `IterMut` write the two halves of +/// its ring buffer, which the runtime's deque splits elsewhere than std's, and its `Drain` +/// its indices, so they stay refused. +fn iter_debug<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + did: DefId, + args: ty::GenericArgsRef<'tcx>, + value: &Expr, + f: &Expr, + span: Span, +) -> Option { + /// What std writes around the list: a tuple struct's name, or a struct's and its field's. + enum Wrap { + Tuple(&'static str), + Struct(&'static str, &'static str), + } + /// What it lists: a type argument, the map entry of the first two, or a `BTreeSet`'s + /// entry of its key and `SetValZST`. + enum Item { + Arg(usize), + Entry, + SetVal, + Byte, + } + use {Item::*, Wrap::*}; + let tcx = b.t.tcx; + let path = library::std_path(tcx, did); + let path: Vec<&str> = path.iter().map(String::as_str).collect(); + let (item, wraps): (Item, &[Wrap]) = match path.as_slice() { + ["str", "iter", "Chars"] => return Some(Expr::rt("fmtChars", vec![value.clone(), f.clone()])), + ["str", "iter", "Bytes"] => (Byte, &[Tuple("Bytes"), Struct("Copied", "it"), Tuple("Iter")]), + ["slice", "iter", "Iter"] + | ["collections", "binary_heap", "Iter"] + | ["collections", "btree", "set", "Iter"] => (Arg(0), &[Tuple("Iter")]), + ["slice", "iter", "IterMut"] => (Arg(0), &[Tuple("IterMut")]), + ["vec", "into_iter", "IntoIter"] + | ["collections", "binary_heap", "IntoIter"] + | ["collections", "vec_deque", "into_iter", "IntoIter"] => (Arg(0), &[Tuple("IntoIter")]), + ["vec", "drain", "Drain"] => (Arg(0), &[Tuple("Drain")]), + ["collections", "binary_heap", "Drain"] => (Arg(0), &[Struct("Drain", "iter"), Tuple("Drain")]), + ["collections", "btree", "set", "Range"] => (SetVal, &[Struct("Range", "iter")]), + ["collections", "btree", "set", "IntoIter"] => (SetVal, &[Struct("IntoIter", "iter")]), + [ + "collections", + "btree", + "map", + "Iter" | "IterMut" | "Range" | "RangeMut" | "IntoIter", + ] + | ["collections", "hash", "map", "Iter" | "IterMut" | "IntoIter" | "Drain"] => (Entry, &[]), + ["collections", "btree" | "hash", "map", "Keys" | "IntoKeys"] + | ["collections", "hash", "set", "Iter" | "IntoIter" | "Drain"] => (Arg(0), &[]), + [ + "collections", + "btree" | "hash", + "map", + "Values" | "ValuesMut" | "IntoValues", + ] => (Arg(1), &[]), + _ => return None, + }; + let arg = |n: usize| args.types().nth(n); + let debug = match item { + Arg(n) => b.fmt_fn(Trait::Debug, arg(n)?, span), + Entry => b.fmt_fn(Trait::Debug, Ty::new_tup(tcx, &[arg(0)?, arg(1)?]), span), + SetVal => Expr::rt("fmtSetVal", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + Byte => b.fmt_fn(Trait::Debug, tcx.types.u8, span), + }; + let wraps: Vec = (wraps.iter()) + .map(|wrap| match *wrap { + Tuple(name) => Expr::Str(name.into()), + Struct(name, field) => Expr::Array(vec![Expr::Str(name.into()), Expr::Str(field.into())]), + }) + .collect(); + let mut call = vec![value.clone(), f.clone(), debug]; + if !wraps.is_empty() { + call.push(Expr::Array(wraps)); + } + Some(Expr::rt("fmtIter", call)) +} + /// One part of a `format_args!` template. pub enum Piece { Lit(String), diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 8afe5b202..e7747307b 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -199,7 +199,7 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp /// a slice of each array of bytes. pub(super) fn by_ref(iter: Expr, elem: Ty<'_>) -> Expr { match super::byte_array(elem) { - true => Expr::rt("iterMap", vec![iter, Expr::Rt("byteSliceFrom".into())]), + true => Expr::rt("iterLend", vec![iter, Expr::Rt("byteSliceFrom".into())]), false => iter, } }