From 26e415742783d74fed7338701c9528b7437579f0 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:01:48 -0800 Subject: [PATCH 01/11] chore(quest): claim quest/m3/ts-iter-adaptor-debug.md Quest-Claim: afbc67f337eeed14 From c49160d5de9e21027c200f92ab5e304710ff14e5 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:20:13 -0800 Subject: [PATCH 02/11] feat(ts): translate Debug of std's iterator adaptors Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 2 +- quest/m3/ts-iter-adaptor-debug.md | 25 - quest/m3/ts-iter-source-debug.md | 18 + ts/README.md | 6 +- ts/fixtures/lang/arrays/expected/arrays.ts | 114 +-- ts/fixtures/lang/boxes/expected/boxes.ts | 8 +- ts/fixtures/lang/cells/expected/cells.ts | 24 +- ts/fixtures/lang/chars/expected/chars.ts | 6 +- ts/fixtures/lang/clones/expected/clones.ts | 10 +- .../lang/collections/expected/collections.ts | 16 +- ts/fixtures/lang/cycles/expected/cycles.ts | 2 +- .../lang/elements/expected/elements.ts | 8 +- ts/fixtures/lang/folds/expected/folds.ts | 28 +- ts/fixtures/lang/heap/expected/heap.ts | 6 +- ts/fixtures/lang/hints/expected/hints.ts | 64 +- ts/fixtures/lang/holds/expected/holds.ts | 2 +- ts/fixtures/lang/iters/expected/iters.ts | 28 +- ts/fixtures/lang/keys/expected/keys.ts | 72 +- ts/fixtures/lang/lengths/expected/lengths.ts | 24 +- ts/fixtures/lang/orders/expected/orders.ts | 18 +- ts/fixtures/lang/refs/expected/refs.ts | 2 +- ts/fixtures/lang/results/expected/results.ts | 56 +- .../lang/searches/expected/searches.ts | 110 +-- ts/fixtures/lang/shapes/expected/core/bool.ts | 7 + ts/fixtures/lang/shapes/expected/fmt.ts | 763 +++++++++++++++++- ts/fixtures/lang/shapes/expected/lib.ts | 8 +- ts/fixtures/lang/shapes/src/fmt.rs | 189 +++++ ts/fixtures/lang/shapes/src/lib.rs | 1 + ts/fixtures/lang/sorts/expected/sorts.ts | 14 +- ts/fixtures/lang/strs/expected/strs.ts | 6 +- ts/fixtures/lang/tuples/expected/tuples.ts | 30 +- ts/fixtures/lang/zeros/expected/zeros.ts | 4 +- ts/fixtures/share/expected/harness.ts | 2 +- ts/fixtures/task/expected/drops.ts | 6 +- ts/fixtures/task/expected/drops/indexed.ts | 2 +- ts/runtime/rt/char.ts | 34 +- ts/runtime/rt/iter.ts | 163 +++- ts/src/lower/fmt.rs | 104 +++ ts/src/lower/iter.rs | 49 +- 39 files changed, 1631 insertions(+), 400 deletions(-) delete mode 100644 quest/m3/ts-iter-adaptor-debug.md create mode 100644 quest/m3/ts-iter-source-debug.md diff --git a/quest/m3/README.md b/quest/m3/README.md index 9f60bee8a..0735d2e68 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -25,9 +25,9 @@ generic std gap is planned here even when moq never calls it. - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library - [A slice of one byte behind any &mut](/quest/m3/ts-slice-of-one.md) - `slice::from_mut` and `array::from_mut` of a `&mut u8` translate - [str's case maps and Unicode escapes](/quest/m3/ts-str-unicode.md) - `str::to_lowercase`, `to_uppercase`, the escapes, and `encode_utf16` translate by std's Unicode tables, final sigma included -- [Debug of std's iterator adaptors](/quest/m3/ts-iter-adaptor-debug.md) - `Debug` of `Map`, `Zip`, `Peekable`, `DecodeUtf16`, and the other adaptors writes what std's does - [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 +- [Debug of std's other iterators](/quest/m3/ts-iter-source-debug.md) - `Debug` of `Once`, `Repeat`, `FromFn`, an array's `IntoIter`, and std's other iterators writes what std's does - [A crate's own collect, eq, partial_cmp, and by_ref](/quest/m3/ts-iter-own-calls.md) - a crate's iterator that overrides `collect`, `eq`, `partial_cmp`, or `by_ref` translates, each called where std calls it - [A vector's exact capacity as it shrinks](/quest/m3/ts-vec-exact-capacity.md) - a deque made from a `Vec` splits its slices where std's does - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number diff --git a/quest/m3/ts-iter-adaptor-debug.md b/quest/m3/ts-iter-adaptor-debug.md deleted file mode 100644 index 445065eb8..000000000 --- a/quest/m3/ts-iter-adaptor-debug.md +++ /dev/null @@ -1,25 +0,0 @@ -# [M] Debug of std's iterator adaptors - -## Goal - -[rust2-ts](/ts/README.md) translates `Debug` of std's iterator adaptors, such as `Map`, -`Filter`, `Enumerate`, `Zip`, `Chain`, `Peekable`, `Rev`, `Take`, `Skip`, and -`char::DecodeUtf16`, writing what std's derived or hand-written impl writes, pretty forms -included, over whatever iterator each wraps. Proven by differential tests against -native Rust. - -## Plan - -Found in [#507](https://github.com/moq-dev/rust2/pull/507): `Debug` of `DecodeUtf16` -fails as "unsupported call", and so does every adaptor's today, since -`iter_debug` in `src/lower/fmt.rs` covers only collections' iterators and `Chars`. - -Each adaptor's `Debug` writes its fields in std's order, the wrapped iterator's own -`Debug` among them, and leaves out a closure as std does (`Map { iter: .. }`); some write -state as they go, as `Peekable` writes what it peeked and `DecodeUtf16` its buffered -unit. Read std's impls rather than guess them, and survey which adaptors share a shape -before choosing how the runtime writes them. - -An adaptor over an iterator whose `Debug` has no mapping stays refused, at its span. - -Public API: the translator's output, and the runtime functions each needs. diff --git a/quest/m3/ts-iter-source-debug.md b/quest/m3/ts-iter-source-debug.md new file mode 100644 index 000000000..645e725b3 --- /dev/null +++ b/quest/m3/ts-iter-source-debug.md @@ -0,0 +1,18 @@ +# [S] Debug of std's other iterators + +## Goal + +[rust2-ts](/ts/README.md) translates `Debug` of std's iterators that still have no +mapping, so an adaptor over one writes what std's does instead of being refused: +iterator sources such as `Once`, `Repeat`, `RepeatN`, `FromFn`, `Successors`, +`OnceWith`, and `RepeatWith`, an array's and an `Option`'s or `Result`'s iterators, and +`str`'s iterators other than `Chars` and `Bytes`. Proven by differential tests against +native Rust. + +## Plan + +Found while translating `Debug` of the adaptors: `char::decode_utf16([..])` refuses at +its span, as `Debug` of `array::IntoIter` has no mapping. Read each of std's impls, which +write private fields of their own (`Once { inner: IntoIter { inner: Item { opt } } }`), +and survey which share a shape before choosing how the runtime writes them, as +`iter_debug` and `adaptor_debug` in `src/lower/fmt.rs` do. diff --git a/ts/README.md b/ts/README.md index 458745c81..7603f810b 100644 --- a/ts/README.md +++ b/ts/README.md @@ -267,7 +267,11 @@ collections writes their items in the order each iterates, a hash map's or set's and of their iterators and `Chars` the items each has left, in std's wrapper; a deque's `Iter` and `IterMut` write the two slices of its buffer they have left, swapped as std's swap them, and its `Drain` its counts; a list's `Iter` and `IterMut` write what is left and -its length, as std's do. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is +its length, as std's do. `Debug` of std's iterator adaptors, `Map` through `Flatten` +and `DecodeUtf16`, writes their fields as std's does, each iterator it wraps by its own +`Debug`, no closure, and the state each keeps, such as what a `Peekable` peeked, what a +`Skip` has left to skip, and the countdown std's `StepBy` of a small unsigned range keeps +in its end. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is their derived one, whichever way each is held, and a guard of a cell or a lock, mapped or not, writes what it lends by its own `Debug` and `Display`. `Debug` of a `Cell`, a `RefCell`, a `Mutex`, and an `RwLock` writes what each holds, or `` and diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index 65bbd0832..bb8c7f212 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -1210,7 +1210,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { return bytesAt$0(data, rt.usizeMul(k, 0)); }); }), undefined, 1, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _13: rt.ByteSlice | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -1218,7 +1218,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _26: rt.ByteSlice | rt.Done = iter2.next(); if (_26 === rt.DONE) { @@ -1226,7 +1226,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _26); } - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _36: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; if (_36[0] !== undefined) { @@ -1237,7 +1237,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true); + const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _56: rt.ByteSlice | rt.Done = iter3.next(); if (_56 === rt.DONE) { @@ -1252,7 +1252,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { putOptions$0(out, options); const iter4: rt.Iter = rt.iterFlatMap(rt.iterSlice(options), (o: Uint8Array | undefined): Uint8Array | undefined => { return o; - }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _75: rt.ByteSlice | rt.Done = iter4.next(); if (_75 === rt.DONE) { @@ -1262,7 +1262,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter5: rt.Iter = rt.iterRev(rt.iterFlatMap(rt.iterSlice(options), (o2: Uint8Array | undefined): rt.Iter => { return rt.iterLend(rt.iterOption(o2), rt.byteSliceFrom); - }, undefined, false, undefined, true)); + }, undefined, true, undefined, true)); while (true) { const _88: rt.ByteSlice | rt.Done = iter5.next(); if (_88 === rt.DONE) { @@ -1272,7 +1272,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter6: rt.Iter = rt.iterFlatMap(rt.iterSlice(options), (o3: Uint8Array | undefined): rt.ByteSlice | undefined => { return rt.optionMap(o3, rt.byteSliceFrom); - }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), false, undefined, true); + }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _100: rt.ByteSlice | rt.Done = iter6.next(); if (_100 === rt.DONE) { @@ -1282,7 +1282,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter7: rt.Iter = rt.iterFlatMap(rt.iterSliceMut(options), (o4: rt.Place): rt.Place => { return o4; - }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true); + }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _112: rt.ByteSlice | rt.Done = iter7.next(); if (_112 === rt.DONE) { @@ -1296,7 +1296,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { putOptions$0(out, options); const one: Uint8Array | undefined = copy$Option_array0_u8(options[rt.idx(options, 0)]); const other: Uint8Array | undefined = copy$Option_array0_u8(options[rt.idx(options, 1)]); - const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _142: rt.ByteSlice | rt.Done = iter8.next(); if (_142 === rt.DONE) { @@ -1304,7 +1304,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _142); } - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); while (true) { const _156: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); if (_156 === rt.DONE) { @@ -1313,10 +1313,10 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, _156[0]); rt.byteVecExtendFromSlice(out, _156[1]); } - const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); while (iter10.next() !== rt.DONE) { } - const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), _182); while (true) { const _187: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); @@ -1355,7 +1355,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(sums), (x: rt.u16): Uint8Array => { return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const iter14: rt.Iter = rt.iterChain(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterLend(rt.iterOption(options[rt.idx(options, 3)]), rt.byteSliceFrom)); while (true) { const _249: rt.ByteSlice | rt.Done = iter14.next(); @@ -1384,11 +1384,11 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { putSome$0(out, other); const copied: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterSlice(rt.iterToArray(rt.iterLend(rt.iterOption(options[rt.idx(options, 0)]), rt.byteSliceFrom), undefined, 4, true)), rt.byteSliceToArray), undefined, 0, true); rt.iterExtend(copied, rt.iterMap(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 0, true); - const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); rt.iterExtend(copied, rt.iterMap(_289, rt.byteSliceToArray), "next", 0); put$0(out, copied); const nested: Array = copy$array_Option_Option_array0_u8([undefined, rt.None, copy$Option_array0_u8(options[rt.idx(options, 0)]), bytesAt$0(data, 3), undefined]).map(copy$Option_Option_array0_u8); - const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), false, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _317: rt.ByteSlice | rt.Done = iter17.next(); if (_317 === rt.DONE) { @@ -1396,7 +1396,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _317); } - const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), false, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _331: rt.ByteSlice | rt.Done = iter18.next(); if (_331 === rt.DONE) { @@ -1406,7 +1406,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } const _339: Uint8Array[] = []; const vecs: Uint8Array[][] = [_339, copy$array_array0_u8([bytesAt$0(data, 4), bytesAt$0(data, 5)]).map(copy$array_u8)]; - const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom))); + const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true)); while (true) { const _351: rt.ByteSlice | rt.Done = iter19.next(); if (_351 === rt.DONE) { @@ -1416,7 +1416,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter20: rt.Iter = rt.iterFlatten(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(vecs), (v: Uint8Array[]): Uint8Array[] => { return v; - }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom)); + }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true); while (true) { const _366: rt.ByteSlice | rt.Done = iter20.next(); if (_366 === rt.DONE) { @@ -1430,7 +1430,7 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { }); const iter21: rt.Iter = rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array0_u8(_373); - })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), false, 2); + })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true, 2); while (true) { const _381: rt.ByteSlice | rt.Done = iter21.next(); if (_381 === rt.DONE) { @@ -1453,7 +1453,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { return bytesAt$1(data, rt.usizeMul(k, 1)); }); }), undefined, 2, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _13: rt.ByteSlice | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -1461,7 +1461,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _26: rt.ByteSlice | rt.Done = iter2.next(); if (_26 === rt.DONE) { @@ -1469,7 +1469,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _26); } - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _36: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; if (_36[0] !== undefined) { @@ -1480,7 +1480,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true); + const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _56: rt.ByteSlice | rt.Done = iter3.next(); if (_56 === rt.DONE) { @@ -1495,7 +1495,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { putOptions$1(out, options); const iter4: rt.Iter = rt.iterFlatMap(rt.iterSlice(options), (o: Uint8Array | undefined): Uint8Array | undefined => { return o; - }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _75: rt.ByteSlice | rt.Done = iter4.next(); if (_75 === rt.DONE) { @@ -1505,7 +1505,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter5: rt.Iter = rt.iterRev(rt.iterFlatMap(rt.iterSlice(options), (o2: Uint8Array | undefined): rt.Iter => { return rt.iterLend(rt.iterOption(o2), rt.byteSliceFrom); - }, undefined, false, undefined, true)); + }, undefined, true, undefined, true)); while (true) { const _88: rt.ByteSlice | rt.Done = iter5.next(); if (_88 === rt.DONE) { @@ -1515,7 +1515,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter6: rt.Iter = rt.iterFlatMap(rt.iterSlice(options), (o3: Uint8Array | undefined): rt.ByteSlice | undefined => { return rt.optionMap(o3, rt.byteSliceFrom); - }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), false, undefined, true); + }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _100: rt.ByteSlice | rt.Done = iter6.next(); if (_100 === rt.DONE) { @@ -1525,7 +1525,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter7: rt.Iter = rt.iterFlatMap(rt.iterSliceMut(options), (o4: rt.Place): rt.Place => { return o4; - }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true); + }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _112: rt.ByteSlice | rt.Done = iter7.next(); if (_112 === rt.DONE) { @@ -1539,7 +1539,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { putOptions$1(out, options); const one: Uint8Array | undefined = copy$Option_array1_u8(options[rt.idx(options, 0)]); const other: Uint8Array | undefined = copy$Option_array1_u8(options[rt.idx(options, 1)]); - const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _142: rt.ByteSlice | rt.Done = iter8.next(); if (_142 === rt.DONE) { @@ -1547,7 +1547,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _142); } - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); while (true) { const _156: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); if (_156 === rt.DONE) { @@ -1556,7 +1556,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, _156[0]); rt.byteVecExtendFromSlice(out, _156[1]); } - const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); while (true) { const _173: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter10.next(); if (_173 === rt.DONE) { @@ -1566,7 +1566,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { _173[0].data.set(rt.byteSliceToArray(_173[1]), _173[0].start); _173[1].data.set(swapped, _173[1].start); } - const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), _182); while (true) { const _187: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); @@ -1605,7 +1605,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(sums), (x: rt.u16): Uint8Array => { return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const iter14: rt.Iter = rt.iterChain(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterLend(rt.iterOption(options[rt.idx(options, 3)]), rt.byteSliceFrom)); while (true) { const _249: rt.ByteSlice | rt.Done = iter14.next(); @@ -1634,11 +1634,11 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { putSome$1(out, other); const copied: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterSlice(rt.iterToArray(rt.iterLend(rt.iterOption(options[rt.idx(options, 0)]), rt.byteSliceFrom), undefined, 4, true)), rt.byteSliceToArray), undefined, 1, true); rt.iterExtend(copied, rt.iterMap(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 1, true); - const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); rt.iterExtend(copied, rt.iterMap(_289, rt.byteSliceToArray), "next", 1); put$1(out, copied); const nested: Array = copy$array_Option_Option_array1_u8([undefined, rt.None, copy$Option_array1_u8(options[rt.idx(options, 0)]), bytesAt$1(data, 3), undefined]).map(copy$Option_Option_array1_u8); - const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), false, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _317: rt.ByteSlice | rt.Done = iter17.next(); if (_317 === rt.DONE) { @@ -1646,7 +1646,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _317); } - const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), false, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _331: rt.ByteSlice | rt.Done = iter18.next(); if (_331 === rt.DONE) { @@ -1656,7 +1656,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } const _339: Uint8Array[] = []; const vecs: Uint8Array[][] = [_339, copy$array_array1_u8([bytesAt$1(data, 4), bytesAt$1(data, 5)]).map(copy$array_u8)]; - const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom))); + const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true)); while (true) { const _351: rt.ByteSlice | rt.Done = iter19.next(); if (_351 === rt.DONE) { @@ -1666,7 +1666,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter20: rt.Iter = rt.iterFlatten(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(vecs), (v: Uint8Array[]): Uint8Array[] => { return v; - }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom)); + }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true); while (true) { const _366: rt.ByteSlice | rt.Done = iter20.next(); if (_366 === rt.DONE) { @@ -1680,7 +1680,7 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { }); const iter21: rt.Iter = rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array1_u8(_373); - })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), false, 2); + })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true, 2); while (true) { const _381: rt.ByteSlice | rt.Done = iter21.next(); if (_381 === rt.DONE) { @@ -1703,7 +1703,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { return bytesAt$5(data, rt.usizeMul(k, 5)); }); }), undefined, 6, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _13: rt.ByteSlice | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -1711,7 +1711,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _26: rt.ByteSlice | rt.Done = iter2.next(); if (_26 === rt.DONE) { @@ -1719,7 +1719,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _26); } - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _36: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; if (_36[0] !== undefined) { @@ -1730,7 +1730,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true); + const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _56: rt.ByteSlice | rt.Done = iter3.next(); if (_56 === rt.DONE) { @@ -1745,7 +1745,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { putOptions$5(out, options); const iter4: rt.Iter = rt.iterFlatMap(rt.iterSlice(options), (o: Uint8Array | undefined): Uint8Array | undefined => { return o; - }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _75: rt.ByteSlice | rt.Done = iter4.next(); if (_75 === rt.DONE) { @@ -1755,7 +1755,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter5: rt.Iter = rt.iterRev(rt.iterFlatMap(rt.iterSlice(options), (o2: Uint8Array | undefined): rt.Iter => { return rt.iterLend(rt.iterOption(o2), rt.byteSliceFrom); - }, undefined, false, undefined, true)); + }, undefined, true, undefined, true)); while (true) { const _88: rt.ByteSlice | rt.Done = iter5.next(); if (_88 === rt.DONE) { @@ -1765,7 +1765,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter6: rt.Iter = rt.iterFlatMap(rt.iterSlice(options), (o3: Uint8Array | undefined): rt.ByteSlice | undefined => { return rt.optionMap(o3, rt.byteSliceFrom); - }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), false, undefined, true); + }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _100: rt.ByteSlice | rt.Done = iter6.next(); if (_100 === rt.DONE) { @@ -1775,7 +1775,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter7: rt.Iter = rt.iterFlatMap(rt.iterSliceMut(options), (o4: rt.Place): rt.Place => { return o4; - }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true); + }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _112: rt.ByteSlice | rt.Done = iter7.next(); if (_112 === rt.DONE) { @@ -1789,7 +1789,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { putOptions$5(out, options); const one: Uint8Array | undefined = copy$Option_array5_u8(options[rt.idx(options, 0)]); const other: Uint8Array | undefined = copy$Option_array5_u8(options[rt.idx(options, 1)]); - const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _142: rt.ByteSlice | rt.Done = iter8.next(); if (_142 === rt.DONE) { @@ -1797,7 +1797,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _142); } - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); while (true) { const _156: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); if (_156 === rt.DONE) { @@ -1806,7 +1806,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, _156[0]); rt.byteVecExtendFromSlice(out, _156[1]); } - const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), false, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); while (true) { const _173: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter10.next(); if (_173 === rt.DONE) { @@ -1816,7 +1816,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { _173[0].data.set(rt.byteSliceToArray(_173[1]), _173[0].start); _173[1].data.set(swapped, _173[1].start); } - const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), _182); while (true) { const _187: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); @@ -1855,7 +1855,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(sums), (x: rt.u16): Uint8Array => { return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const iter14: rt.Iter = rt.iterChain(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterLend(rt.iterOption(options[rt.idx(options, 3)]), rt.byteSliceFrom)); while (true) { const _249: rt.ByteSlice | rt.Done = iter14.next(); @@ -1884,11 +1884,11 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { putSome$5(out, other); const copied: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterSlice(rt.iterToArray(rt.iterLend(rt.iterOption(options[rt.idx(options, 0)]), rt.byteSliceFrom), undefined, 4, true)), rt.byteSliceToArray), undefined, 5, true); rt.iterExtend(copied, rt.iterMap(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 5, true); - const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); rt.iterExtend(copied, rt.iterMap(_289, rt.byteSliceToArray), "next", 5); put$5(out, copied); const nested: Array = copy$array_Option_Option_array5_u8([undefined, rt.None, copy$Option_array5_u8(options[rt.idx(options, 0)]), bytesAt$5(data, 3), undefined]).map(copy$Option_Option_array5_u8); - const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), false, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true); + const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _317: rt.ByteSlice | rt.Done = iter17.next(); if (_317 === rt.DONE) { @@ -1896,7 +1896,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _317); } - const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), false, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), false, undefined, true)); + const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _331: rt.ByteSlice | rt.Done = iter18.next(); if (_331 === rt.DONE) { @@ -1906,7 +1906,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } const _339: Uint8Array[] = []; const vecs: Uint8Array[][] = [_339, copy$array_array5_u8([bytesAt$5(data, 4), bytesAt$5(data, 5)]).map(copy$array_u8)]; - const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom))); + const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true)); while (true) { const _351: rt.ByteSlice | rt.Done = iter19.next(); if (_351 === rt.DONE) { @@ -1916,7 +1916,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter20: rt.Iter = rt.iterFlatten(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(vecs), (v: Uint8Array[]): Uint8Array[] => { return v; - }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom)); + }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true); while (true) { const _366: rt.ByteSlice | rt.Done = iter20.next(); if (_366 === rt.DONE) { @@ -1930,7 +1930,7 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { }); const iter21: rt.Iter = rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array5_u8(_373); - })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), false, 2); + })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true, 2); while (true) { const _381: rt.ByteSlice | rt.Done = iter21.next(); if (_381 === rt.DONE) { diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index 5b8181c72..753ddcd37 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -688,7 +688,7 @@ export function places(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(held.nested).reverse()), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (b: rt.u32): Uint8Array => { return rt.u32ToBeBytes(b).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 4), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(option_unwrapOr$11c0we2(option_asDeref$0avuzwv(o), 238)).reverse()), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(result_unwrapOr$0e4foht(copied$0bbq7yi(result_asDeref$04i8i5u(res)), 238)).reverse()), undefined, true); const _298: rt.Result = said; @@ -699,10 +699,10 @@ export function places(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(words), (w: rt.u32): Uint8Array => { return rt.u32ToBeBytes(w).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 4), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterFlatten(rt.iterOption(someWords), (value: rt.u32[]) => rt.iterSlice(value)), (w2: rt.u32): Uint8Array => { + }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterFlatten(rt.iterOption(someWords), (value: rt.u32[]) => rt.iterSlice(value), true), (w2: rt.u32): Uint8Array => { return rt.u32ToBeBytes(w2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 4), "next"); + }, (value: Uint8Array) => rt.iterSlice(value), true, 4), "next"); put(out, option_unwrapOr$1iemzn8(option_asDeref$0w8at8i(named), "-")); rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(leaked.v).reverse()), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(option_unwrapOr$11c0we2(option_flatten$08boupk(option_asDeref$0w2m0zn(deep)), 238)).reverse()), undefined, true); diff --git a/ts/fixtures/lang/cells/expected/cells.ts b/ts/fixtures/lang/cells/expected/cells.ts index f6bd1a136..a49931942 100644 --- a/ts/fixtures/lang/cells/expected/cells.ts +++ b/ts/fixtures/lang/cells/expected/cells.ts @@ -109,7 +109,7 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num }, undefined, rt.None); put(out, t5); rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceCell | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -297,7 +297,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceCell | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -479,7 +479,7 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceCell | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -667,7 +667,7 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceCell | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -853,7 +853,7 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe }, undefined, rt.None); put(out, t3); rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceCell | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -1039,7 +1039,7 @@ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceCell | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -1249,7 +1249,7 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num }, undefined, rt.None); put(out, t5); rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceLock | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -1437,7 +1437,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceLock | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -1619,7 +1619,7 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceLock | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -1807,7 +1807,7 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceLock | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -1993,7 +1993,7 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe }, undefined, rt.None); put(out, t3); rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceLock | rt.Done = iter.next(); if (_112 === rt.DONE) { @@ -2179,7 +2179,7 @@ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t5); rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), false, undefined, true); + const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); while (true) { const _112: rt.OnceLock | rt.Done = iter.next(); if (_112 === rt.DONE) { diff --git a/ts/fixtures/lang/chars/expected/chars.ts b/ts/fixtures/lang/chars/expected/chars.ts index 6cd7f5bf7..680e7bfd7 100644 --- a/ts/fixtures/lang/chars/expected/chars.ts +++ b/ts/fixtures/lang/chars/expected/chars.ts @@ -570,16 +570,16 @@ export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), rt.usizeAdd, 0); const upper: string = rt.stringExtendChars("", rt.iterFlatMap(rt.strChars(s2), (a09: rt.char): rt.Iter => { return rt.charToUppercase(a09); - })); + }, undefined, true)); const lower: string = rt.stringExtendChars("", rt.iterFlatMap(rt.strChars(s2), (a010: rt.char): rt.Iter => { return rt.charToLowercase(a010); - })); + }, undefined, true)); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(lens, f), (f: rt.Formatter) => rt.usizeDisplay(units, f), (f: rt.Formatter) => rt.fmtPad(f, upper), (f: rt.Formatter) => rt.fmtPad(f, lower)]; put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); } else { const escaped: string = rt.stringExtendChars("", rt.iterFlatMap(rt.strChars(s2), (a0: rt.char): rt.Iter => { return rt.charEscapeDefault(a0); - })); + }, undefined, true)); const debug: string = rt.stringFromStrings(rt.iterMap(rt.iterMap(rt.strChars(s2), (a02: rt.char): rt.Iter => { return rt.charEscapeDebug(a02); }), (e: rt.Iter): string => { diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index 0fdd4d22e..66c86d3d6 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -6836,7 +6836,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x42: rt.u8): rt.u8 => { return x42; }, out); - turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iters_closure0(rt.iterFuse(rt.iterSlice(rt.byteSliceView(data))), (it39: rt.Iter): rt.u8 | undefined => { + turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iters_closure0(rt.iterFuse(rt.iterSlice(rt.byteSliceView(data)), true), (it39: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it39.nextBack()); }, plan, (x43: rt.u8): rt.u8 => { return x43; @@ -6853,19 +6853,19 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, out); turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_closure87_clones_iters_closure88_clones_iters_closure0(rt.iterFlatMap(rt.byteSliceChunks(data, n), (c2: rt.ByteSlice): rt.Iter => { return rt.iterSlice(rt.byteSliceView(c2)); - }), (it42: rt.Iter): rt.u8 | undefined => { + }, undefined, true), (it42: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it42.nextBack()); }, plan, (x46: rt.u8): rt.u8 => { return x46; }, out); turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(c3); - }), (value: rt.ByteVec) => rt.byteVecIntoIter(value)), (it43: rt.Iter): rt.u8 | undefined => { + }), (value: rt.ByteVec) => rt.byteVecIntoIter(value), true), (it43: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it43.nextBack()); }, plan, (x47: rt.u8): rt.u8 => { return x47; }, out); - turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones_iters_closure0(rt.iterFlatten(rt.byteSliceChunks(data, n), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), (it44: rt.Iter): rt.u8 | undefined => { + turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones_iters_closure0(rt.iterFlatten(rt.byteSliceChunks(data, n), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true), (it44: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it44.nextBack()); }, plan, (x48: rt.u8): rt.u8 => { return x48; @@ -7230,7 +7230,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); }, () => make4(captured4)); }; - turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones_iters_closure153_closure0_clones_iters_closure153_clones_iters_closure154_clones_iters_closure155(rt.iterFlatMap(_599, make4(0)), (it6: rt.Iter): rt.u8 | undefined => { + turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones_iters_closure153_closure0_clones_iters_closure153_clones_iters_closure154_clones_iters_closure155(rt.iterFlatMap(_599, make4(0), undefined, true), (it6: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it6.nextBack()); }, plan, (x9: rt.u8): rt.u8 => { return x9; diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index f92d23246..63b108f26 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -73,7 +73,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { const map: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2); + const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2, undefined, 4294967295); while (true) { const _13: rt.usize | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -643,7 +643,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi const _4: rt.u8 = rt.u8Rem(kind, 4); if (_4 === 0) { const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2); + const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2, undefined, 4294967295); while (true) { const _13: rt.usize | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -1284,7 +1284,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { v[at8][1] = v[at8][1] ^ 16; rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (p: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(p[0], p[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); const tally: Tally.Tally = { n: a as rt.u16 }; const q: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; @@ -1316,7 +1316,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { return option_mapOr$1nlkf9b(rt.hashGet(hash, k), rt.bytes(2).fill(255), (p2: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(p2[0], p2[1]); }); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; rt.btreeInsert(tree, 0, copy$tuple2_u8_u8(pair)); rt.btreeInsert(tree, 1, copy$tuple2_u8_u8(pair)); @@ -1326,7 +1326,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeValues(tree), (p3: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(p3[0], p3[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const boxed: [rt.u8, rt.u8] = copy$tuple2_u8_u8(pair); boxed[0] = boxed[0] ^ 1; const holders: Holder.Holder[] = [{ pair: copy$tuple2_u8_u8(pair) }]; @@ -5337,7 +5337,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo }), undefined, true); rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.btreeIter(map), (_214: [[ByRef.ByRef], rt.usize]): Uint8Array => { return Uint8Array.of(_214[0][0]._0 & 0xff, _214[1] & 0xff); - }), (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.iterOption(option_map$0ltgf8p(rt.btreeKey(set, xs[rt.idx(xs, 0)]), (x6: ByRef.ByRef): rt.u8 => { return x6._0 & 0xff; })), undefined, true); @@ -5386,7 +5386,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo }), undefined, true); rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.btreeIter(map2), (_222: [[ByVal.ByVal], rt.usize]): Uint8Array => { return Uint8Array.of(_222[0][0]._0 & 0xff, _222[1] & 0xff); - }), (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.iterOption(option_map$1ajptuf(rt.btreeKey(set2, xs2[rt.idx(xs2, 0)]), (x12: ByVal.ByVal): rt.u8 => { return x12._0 & 0xff; })), undefined, true); @@ -5435,7 +5435,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo }), undefined, true); rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.btreeIter(map3), (_233: [[Mixed.Mixed], rt.usize]): Uint8Array => { return Uint8Array.of(_233[0][0]._0 & 0xff, _233[1] & 0xff); - }), (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.iterOption(option_map$0i8kclf(rt.btreeKey(set3, xs3[rt.idx(xs3, 0)]), (x18: Mixed.Mixed): rt.u8 => { return x18._0 & 0xff; })), undefined, true); diff --git a/ts/fixtures/lang/cycles/expected/cycles.ts b/ts/fixtures/lang/cycles/expected/cycles.ts index 96b78df64..85b630dcb 100644 --- a/ts/fixtures/lang/cycles/expected/cycles.ts +++ b/ts/fixtures/lang/cycles/expected/cycles.ts @@ -961,7 +961,7 @@ export function cycles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(peeked, steps, (x16: rt.u8): rt.u8 => { return x16; }, out); - read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(rt.iterFlatten(rt.byteSliceChunks(data, rt.usizeAdd(n, 1)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), steps, (x17: rt.u8): rt.u8 => { + read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(rt.iterFlatten(rt.byteSliceChunks(data, rt.usizeAdd(n, 1)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true), steps, (x17: rt.u8): rt.u8 => { return x17; }, out); } else if (_12 === 2) { diff --git a/ts/fixtures/lang/elements/expected/elements.ts b/ts/fixtures/lang/elements/expected/elements.ts index 1f2e8767b..60d674032 100644 --- a/ts/fixtures/lang/elements/expected/elements.ts +++ b/ts/fixtures/lang/elements/expected/elements.ts @@ -83,7 +83,7 @@ export function arrays(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, unit === unit ? 1 : 0); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(a), (x: rt.u16): Uint8Array => { return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } @@ -174,7 +174,7 @@ export function inline(data: rt.ByteSlice, out: rt.ByteVec): void { return option_mapOr$1nlkf9b(p, Uint8Array.of(0, 0), (_2: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); }); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } drop$elements_Inline_sync_Arc_u8(held); rt.byteVecPush(out, shared.strong & 0xff); @@ -195,7 +195,7 @@ export function inline(data: rt.ByteSlice, out: rt.ByteVec): void { return option_mapOr$1nlkf9b(p2, Uint8Array.of(0, 0), (_25: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_25[0], _25[1]); }); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); drop$elements_Inline_Option_tuple2_u8_u8(pairs); shared[Symbol.dispose](); } @@ -515,7 +515,7 @@ export function emptyParts(data: rt.ByteSlice, out: rt.ByteVec): void { export function emit(values: rt.u32[], out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(values), (x: rt.u32): Uint8Array => { return rt.u32ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 4), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); } //# sourceMappingURL=elements.ts.map diff --git a/ts/fixtures/lang/folds/expected/folds.ts b/ts/fixtures/lang/folds/expected/folds.ts index d3b54b94f..c5cf8e478 100644 --- a/ts/fixtures/lang/folds/expected/folds.ts +++ b/ts/fixtures/lang/folds/expected/folds.ts @@ -428,9 +428,9 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x64; }), "next").length, r53); const r54: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r54))), r54); + state$u8_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r54), true)), r54); const r55: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r55))), (x65: rt.u8): boolean => { + state$u8_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r55), true)), (x65: rt.u8): boolean => { return isK(x65); }), r55); const r56: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); @@ -462,29 +462,29 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const r61: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); state$u8_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r61), (x67: rt.u8): rt.u8 | undefined => { return x67; - }, (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true)), r61); + }, (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true)), r61); const r62: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); state$u8_Option_u8(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r62), (x68: rt.u8): rt.u8 | undefined => { return x68; - }, (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true).next()), r62); + }, (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true).next()), r62); const r63: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); const _594: rt.RangeInclusive = r63; const _596: (a0: rt.u8) => rt.RangeInclusive = (x69: rt.u8): rt.RangeInclusive => { return new rt.RangeInclusive(lo2, x69, rt.u8Step); }; - state$u8_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_594), _596))), r63); + state$u8_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_594), _596), undefined, true)), r63); const r64: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); const _604: rt.RangeInclusive = r64; const _606: (a0: rt.u8) => rt.RangeInclusive = (x70: rt.u8): rt.RangeInclusive => { return new rt.RangeInclusive(x70, hi2, rt.u8Step); }; - state$u8_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_604), _606), (x71: rt.u8): boolean => { + state$u8_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_604), _606, undefined, true), (x71: rt.u8): boolean => { return isK(x71); }), r64); const r65: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r65), (x72: rt.u8): Uint8Array => { return Uint8Array.of(x72, x72); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2))), r65); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2))), r65); const r66: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); const _623: rt.RangeInclusive = r66; const _625: rt.usize = rt.usizeAdd(n2, 1); @@ -783,9 +783,9 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x28; }), "next", 8).length, r136); const r137: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r137))), r137); + state$i64_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r137), true)), r137); const r138: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r138))), (x29: rt.i64): boolean => { + state$i64_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r138), true)), (x29: rt.i64): boolean => { return isK3(x29); }), r138); const r139: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); @@ -817,29 +817,29 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const r144: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); state$i64_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r144), (x31: rt.i64): rt.i64 | undefined => { return x31; - }, (value: rt.i64 | undefined) => rt.iterOption(value), false, undefined, true)), r144); + }, (value: rt.i64 | undefined) => rt.iterOption(value), true, undefined, true)), r144); const r145: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); state$i64_Option_i64(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r145), (x32: rt.i64): rt.i64 | undefined => { return x32; - }, (value: rt.i64 | undefined) => rt.iterOption(value), false, undefined, true).next()), r145); + }, (value: rt.i64 | undefined) => rt.iterOption(value), true, undefined, true).next()), r145); const r146: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); const _1374: rt.RangeInclusive = r146; const _1376: (a0: rt.i64) => rt.RangeInclusive = (x33: rt.i64): rt.RangeInclusive => { return new rt.RangeInclusive(lo5, x33, rt.i64Step); }; - state$i64_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_1374), _1376))), r146); + state$i64_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_1374), _1376), undefined, true)), r146); const r147: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); const _1384: rt.RangeInclusive = r147; const _1386: (a0: rt.i64) => rt.RangeInclusive = (x34: rt.i64): rt.RangeInclusive => { return new rt.RangeInclusive(x34, hi5, rt.i64Step); }; - state$i64_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_1384), _1386), (x35: rt.i64): boolean => { + state$i64_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_1384), _1386, undefined, true), (x35: rt.i64): boolean => { return isK3(x35); }), r147); const r148: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r148), (x36: rt.i64): rt.i64[] => { return [x36, x36]; - }, (value: rt.i64[]) => rt.iterSlice(value), false, 2))), r148); + }, (value: rt.i64[]) => rt.iterSlice(value), true, 2))), r148); const r149: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); const _1403: rt.RangeInclusive = r149; const _1405: rt.usize = rt.usizeAdd(n4, 1); diff --git a/ts/fixtures/lang/heap/expected/heap.ts b/ts/fixtures/lang/heap/expected/heap.ts index c3475dd45..b3f814940 100644 --- a/ts/fixtures/lang/heap/expected/heap.ts +++ b/ts/fixtures/lang/heap/expected/heap.ts @@ -81,7 +81,7 @@ export function spills(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(Spill.asSlice$u32(ints)), (x: rt.u32): Uint8Array => { return rt.u32ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 4), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); rt.byteVecPush(out, ints.cap & 0xff); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(Spill.asSlice$Option_tuple2_u8_u16(pairs)), (p: [rt.u8, rt.u16] | undefined): rt.u8 => { return option_mapOr$0hi5qhf(p, 0, (_2: [rt.u8, rt.u16]): rt.u8 => { @@ -116,7 +116,7 @@ export function remnants(data: rt.ByteSlice, out: rt.ByteVec): void { const words: rt.Place = slots; rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(rt.ptrSlice(words, data.length)), (x: rt.u32): Uint8Array => { return rt.u32ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 4), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); rt.dealloc(rt.allocBytes(words, 4, "u32")); const pointer2 = rt.alloc(rt.resultUnwrap(rt.layoutFromSizeAlign(9, 4), rt.fmtLayoutErrorDebug)); const pair: rt.Place = rt.allocAs(rt.optionUnwrap(pointer2 === rt.NULL ? undefined : pointer2), 4, "u32"); @@ -129,7 +129,7 @@ export function remnants(data: rt.ByteSlice, out: rt.ByteVec): void { const grown2: rt.Place = rt.allocAs(rt.optionUnwrap(pointer3 === rt.NULL ? undefined : pointer3), 4, "u32"); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice([grown2.v, rt.ptrAdd(grown2, 1).v]), (x2: rt.u32): Uint8Array => { return rt.u32ToBeBytes(x2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 4), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); rt.dealloc(rt.allocBytes(grown2, 4, "u32")); const one: rt.Layout = { size: 1, align: 1 }; const pointer4 = rt.alloc(one); diff --git a/ts/fixtures/lang/hints/expected/hints.ts b/ts/fixtures/lang/hints/expected/hints.ts index 39e6c015d..725cb368e 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -1809,9 +1809,9 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const step: rt.usize = rt.usizeAdd(rt.usizeRem(at(1) as rt.usize, 7), 1); const _178: rt.u8 = rt.u8Rem(arm, 4); if (_178 === 0) { - walk$iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step), steps, out); + walk$iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step, undefined, 4294967295), steps, out); } else if (_178 === 1) { - walkFront$iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step), steps, out); + walkFront$iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step, undefined, 4294967295), steps, out); } else if (_178 === 2) { walkFront$iter_StepBy_ops_Range_u64(rt.iterStepBy(new rt.Range(0, n, rt.u64Step), step), steps, out); } else { @@ -1868,7 +1868,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_219 === 1) { walkFront$iter_Fuse_iter_Take_hints_Endless(rt.iterFuse(rt.iterTake(rt.iterFrom({ _0: n }, Endless.next$iter_Iterator), 2)), steps, out); } else if (_219 === 2) { - walk$iter_Fuse_ops_Range_u64(rt.iterFuse(new rt.Range(0, n, rt.u64Step)), steps, out); + walk$iter_Fuse_ops_Range_u64(rt.iterFuse(new rt.Range(0, n, rt.u64Step), true), steps, out); } else { walkFront$iter_Fuse_hints_Countdown(rt.iterFuse(rt.iterFrom({ _0: rt.u64Low(n) & 0xff }, Countdown.next$iter_Iterator)), steps, out); } @@ -1896,25 +1896,25 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return Array.from({ length: 3 }, (): rt.u64 => { return i15; }); - }), (value: rt.u64[]) => rt.iterSlice(value), false, 3), steps, out); + }), (value: rt.u64[]) => rt.iterSlice(value), true, 3), steps, out); } else if (_267 === 1) { walk$iter_FlatMap_ops_Range_u64_array1_u64_hints_hints_closure10(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i14: rt.u64): rt.u64[] => { return [i14]; - }, (value: rt.u64[]) => rt.iterSlice(value), false, 1, true), steps, out); + }, (value: rt.u64[]) => rt.iterSlice(value), true, 1, true), steps, out); } else if (_267 === 2) { - walk$iter_Flatten_slice_Chunks_u8(rt.iterFlatten(rt.byteSliceChunks(bytes, 2), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), steps, out); + walk$iter_Flatten_slice_Chunks_u8(rt.iterFlatten(rt.byteSliceChunks(bytes, 2), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true), steps, out); } else if (_267 === 3) { walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure11(rt.iterFlatten(rt.iterMap(new rt.Range(0, rt.u64Min(n, 9), rt.u64Step), (i13: rt.u64): rt.Range => { return new rt.Range(0, i13, rt.u64Step); - })), steps, out); + }), undefined, true), steps, out); } else if (_267 === 5) { walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure12(rt.iterFlatten(rt.iterMap(new rt.Range(0, rt.u64Min(n, 9), rt.u64Step), (_247: rt.u64): Uint8Array => { return Uint8Array.of(); - }), (value: Uint8Array) => rt.iterSlice(value), false, 0, true), steps, out); + }), (value: Uint8Array) => rt.iterSlice(value), true, 0, true), steps, out); } else if (_267 === 6) { put(out, rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (_i12: rt.u64): rt.u64[] => { return []; - }, (value: rt.u64[]) => rt.iterSlice(value), false, 0, true).sizeHint()); + }, (value: rt.u64[]) => rt.iterSlice(value), true, 0, true).sizeHint()); } else { walk$iter_FlatMap_ops_Range_u64_iter_Flatten_array_IntoIter_array2_u64_2_hints_hints_closure14(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i11: rt.u64): rt.Iter => { const _514: rt.u64[] = Array.from({ length: 2 }, (): rt.u64 => { @@ -1922,38 +1922,38 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); return rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): rt.u64[] => { return _514; - })), (value: rt.u64[]) => rt.iterSlice(value), false, 2); - }), steps, out); + })), (value: rt.u64[]) => rt.iterSlice(value), true, 2); + }, undefined, true), steps, out); } } else if (_37 === 13) { const _290: rt.u8 = rt.u8Rem(arm, 6); if (_290 === 0) { walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure15(rt.iterFlatten(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i10: rt.u64): rt.u64 | undefined => { return rt.u64CheckedSub(i10, 2); - }), (value: rt.u64 | undefined) => rt.iterOption(value), false, undefined, true), steps, out); + }), (value: rt.u64 | undefined) => rt.iterOption(value), true, undefined, true), steps, out); } else if (_290 === 1) { walk$iter_FlatMap_ops_Range_u64_Option_u64_hints_hints_closure16(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i9: rt.u64): rt.u64 | undefined => { return thenSome$1ugl8af(rt.u64Rem(i9, 2) === 0, i9); - }, (value: rt.u64 | undefined) => rt.iterOption(value), false, undefined, true), steps, out); + }, (value: rt.u64 | undefined) => rt.iterOption(value), true, undefined, true), steps, out); } else if (_290 === 2) { walk$iter_FlatMap_ops_Range_u64_iter_Once_u64_iter_once_u64(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (a0: rt.u64): rt.Iter => { return rt.iterOnce(a0); - }, undefined, false, undefined, true), steps, out); + }, undefined, true, undefined, true), steps, out); } else if (_290 === 3) { walk$iter_FlatMap_ops_Range_u64_iter_Filter_option_IntoIter_u64_hints_hints_closure17_closure0_hints_hints_closure17(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i7: rt.u64): rt.Iter => { return rt.iterFilter(rt.iterOption(i7), (i8: rt.u64): boolean => { return rt.u64Rem(i8, 2) === 0; }); - }, undefined, false, undefined, true), steps, out); + }, undefined, true, undefined, true), steps, out); } else if (_290 === 4) { walk$iter_Flatten_iter_Map_slice_Iter_u8_hints_hints_closure18(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_245: rt.u8): Uint8Array => { return Uint8Array.of(_245); - }), (value: Uint8Array) => rt.iterSlice(value), false, 1, true), steps, out); + }), (value: Uint8Array) => rt.iterSlice(value), true, 1, true), steps, out); } else { walk$iter_Flatten_slice_Iter_array2_u8(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); + }), undefined, 2, true)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), steps, out); } } else if (_37 === 14) { const _312: rt.u8 = rt.u8Rem(arm, 6); @@ -2105,7 +2105,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return Array.from({ length: 2 }, (): rt.u64 => { return i4; }); - }), (value: rt.u64[]) => rt.iterSlice(value), false, 2), new rt.Range(0, m, rt.u64Step)), steps, out); + }), (value: rt.u64[]) => rt.iterSlice(value), true, 2), new rt.Range(0, m, rt.u64Step)), steps, out); } else { walkFront$iter_Peekable_iter_Filter_ops_Range_u64_hints_hints_closure29(rt.iterPeekable(rt.iterFilter(new rt.Range(0, n, rt.u64Step), (_22: rt.u64): boolean => { return true; @@ -2126,11 +2126,11 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return Array.from({ length: 2 }, (): rt.u32 => { return i3; }); - }), (value: rt.u32[]) => rt.iterSlice(value), false, 2), rt.usizeRem(rt.u64Low(m), 9)), steps, out); + }), (value: rt.u32[]) => rt.iterSlice(value), true, 2), rt.usizeRem(rt.u64Low(m), 9)), steps, out); } else { walkFront$iter_Take_iter_FlatMap_ops_Range_u64_ops_Range_u64_hints_hints_closure32(rt.iterTake(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i2: rt.u64): rt.Range => { return new rt.Range(0, i2, rt.u64Step); - }), rt.u64Low(m)), steps, out); + }, undefined, true), rt.u64Low(m)), steps, out); } } } @@ -2240,9 +2240,9 @@ export function typed$array275_u32_hints_reserves_closure5(kind: rt.u8, data: rt return true; }), seed, out); } else if (shape === 3) { - fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } else { - fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } rt.byteVecPush(out, calls.v); } @@ -2312,9 +2312,9 @@ export function typed$hints_Unit_hints_reserves_closure4(kind: rt.u8, data: rt.B return true; }), seed, out); } else if (shape === 3) { - fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } else { - fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } rt.byteVecPush(out, calls.v); } @@ -2384,9 +2384,9 @@ export function typed$tuple2_u64_u8_hints_reserves_closure3(kind: rt.u8, data: r return true; }), seed, out); } else if (shape === 3) { - fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } else { - fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } rt.byteVecPush(out, calls.v); } @@ -2456,9 +2456,9 @@ export function typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind: rt.u8, data: return true; }), seed, out); } else if (shape === 3) { - fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } else { - fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } rt.byteVecPush(out, calls.v); } @@ -2528,9 +2528,9 @@ export function typed$u32_hints_reserves_closure1(kind: rt.u8, data: rt.ByteSlic return true; }), seed, out); } else if (shape === 3) { - fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } else { - fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } rt.byteVecPush(out, calls.v); } @@ -2600,9 +2600,9 @@ export function typed$u8_hints_reserves_closure0(kind: rt.u8, data: rt.ByteSlice return true; }), seed, out); } else if (shape === 3) { - fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } else { - fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)])), f), seed, out); + fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); } rt.byteVecPush(out, calls.v); } diff --git a/ts/fixtures/lang/holds/expected/holds.ts b/ts/fixtures/lang/holds/expected/holds.ts index 7b4590a02..be8e26bc7 100644 --- a/ts/fixtures/lang/holds/expected/holds.ts +++ b/ts/fixtures/lang/holds/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.iterLend(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)), true, 4), undefined, true); for (const _61 of rows) { rt.iterExtendBytes(out, rt.iterSlice(_61.cells), undefined, true); } diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index 0cc6e4d37..6479ecda1 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -85,12 +85,12 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const words: rt.ByteVec[] = chunksByZero$iters_ChunksByZero_slice_u8(data); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { return rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w)))); - }), "next"))); + }, undefined, true), "next"))); rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { return rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w2))), (_212: rt.u8): rt.u8 => { return rt.u8WrappingAdd(_212, 3); }); - }))), "next"); + }), undefined, true)), "next"); } else { if (_4 === 5) { const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); @@ -646,7 +646,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _10: rt.u8 = rt.u8Rem(rt.u8Div(kind, 2), 14); if (_10 === 0) { const rest: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it: rt.Iter = rt.iterFuse(rt.iterTake(rt.iterBorrow(rest), limit)); + const it: rt.Iter = rt.iterFuse(rt.iterTake(rt.iterBorrow(rest), limit), true); if (!back) { item = rt.iterNth(it, n); } else { @@ -659,7 +659,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.ByteVec = new rt.ByteVec(); const it2: rt.Iter = rt.iterFuse(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_267: rt.u8): undefined => { rt.byteVecPush(log, _267); - }), limit)); + }), limit), true); if (!back) { item2 = rt.iterNth(it2, n); } else { @@ -833,7 +833,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log7)); } else if (_10 === 7) { const rest8: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it17: rt.Iter = rt.iterFlatten(rt.iterOnce(rt.iterTake(rt.iterBorrow(rest8), limit))); + const it17: rt.Iter = rt.iterFlatten(rt.iterOnce(rt.iterTake(rt.iterBorrow(rest8), limit)), undefined, true); if (!back) { item15 = rt.iterNth(it17, n); } else { @@ -846,7 +846,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const log8: rt.ByteVec = new rt.ByteVec(); const it18: rt.Iter = rt.iterFlatten(rt.iterOnce(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_231: rt.u8): undefined => { rt.byteVecPush(log8, _231); - }), limit))); + }), limit)), undefined, true); if (!back) { item16 = rt.iterNth(it18, n); } else { @@ -959,7 +959,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_10 === 12) { const rest13: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); const src25: rt.Iter = rest13; - const it27: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterFuse(rt.iterTake(rt.iterBorrow(src25), limit))); + const it27: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterFuse(rt.iterTake(rt.iterBorrow(src25), limit), true)); if (!back) { item25 = rt.iterNth(it27, n); } else { @@ -973,7 +973,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const src26: rt.Iter = rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): undefined => { rt.byteVecPush(log13, _213); }); - const it28: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterFuse(rt.iterTake(src26, limit))); + const it28: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterFuse(rt.iterTake(src26, limit), true)); if (!back) { item26 = rt.iterNth(it28, n); } else { @@ -1230,7 +1230,7 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { return _24; }, rt.lt), 0)))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(option_unwrapOr$00uis1j(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Add(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Step), rt.lt), 0)))); - for (const _295 of rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8)), undefined, 4, true)) { + for (const _295 of rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8, undefined, 4294967295)), undefined, 4, true)) { rt.byteVecPush(out, _295 & 0xff); } updates(a, b, data, out); @@ -1325,7 +1325,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { return b6; } return undefined; - }), (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true), "next"))); + }), (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true), "next"))); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); @@ -6538,16 +6538,16 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _22: rt.Iter = rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), 3); rt.iterExtendBytes(v, _22, undefined, true); rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.iterSlice([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)])), 5), "next"); + rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.iterSlice([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)]), undefined, true), 5), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatMap(it(), (x: rt.u8): rt.RangeFrom => { return new rt.RangeFrom(rt.u8Div(x, 4), rt.u8Step); - }), rt.usizeMul(n, 2)), "next"); + }, undefined, true), rt.usizeMul(n, 2)), "next"); rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(it(), (x2: rt.u8): rt.Range => { return new rt.Range(rt.u8Div(x2, 32), rt.u8Div(x2, 16)); - })), "next"); + }), undefined, true), "next"); rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(it(), (x3: rt.u8): rt.RangeInclusive => { return new rt.RangeInclusive(rt.u8Div(x3, 64), rt.u8Div(x3, 32), rt.u8Step); - })), "next"); + }), undefined, true), "next"); const _54: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(it(), new rt.RangeFrom(0, rt.usizeStep), "len"); rt.iterExtendBytes(out, rt.iterMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rt.u8, rt.usize]): rt.u8 => { return _24[0] ^ (_24[1] & 0xff); diff --git a/ts/fixtures/lang/keys/expected/keys.ts b/ts/fixtures/lang/keys/expected/keys.ts index b93463b22..2f4822291 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -4043,14 +4043,14 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r _104.v = _104.v ^ 8; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterLend(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next", 0); rt.sliceSort(members, rt.cmpLt(rt.cmpBytes), 0, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(members), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(members), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const entries: [Uint8Array, Uint8Array][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held3): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held3[0]), rt.byteSliceFrom(held3[1])]; }), (_2: [rt.ByteSlice, rt.ByteSlice]): [Uint8Array, Uint8Array] => { @@ -4082,7 +4082,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r return rt.iterAny(rt.iterSlice(rt.byteSliceView(p3)), (_22: rt.u8): boolean => { return _22 < 2; }); - }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 0)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 0)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p4) === 64; }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); @@ -4097,7 +4097,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r _224.v = 170; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterToOption(rest.next())), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterToOption(rest.next())), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); let seen: rt.u8 = 0; const taken: Uint8Array[] = rt.iterToArray(rt.iterTakeWhile(rt.iterInspect(rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p5: rt.ByteSlice): undefined => { seen = rt.u8WrappingAdd(seen, p5.length & 0xff); @@ -4109,19 +4109,19 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const f10 = (a: rt.ByteSlice, b2: rt.ByteSlice): rt.Ordering => { return rt.cmpBytes(a, b2); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMaxBy(_255, (held10, held11) => f10(rt.byteSliceFrom(held10), rt.byteSliceFrom(held11)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMaxBy(_255, (held10, held11) => f10(rt.byteSliceFrom(held10), rt.byteSliceFrom(held11)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const _264: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray); const f11 = (p7: rt.ByteSlice): rt.u8 => { return rt.iterFold(rt.iterSlice(rt.byteSliceView(p7)), 0, (a2: rt.u8, b3: rt.u8): rt.u8 => { return a2 ^ b3; }); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMinByKey(_264, (held12) => f11(rt.byteSliceFrom(held12)), rt.lt)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMinByKey(_264, (held12) => f11(rt.byteSliceFrom(held12)), rt.lt)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const _274: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray); const f12 = (p8: rt.ByteSlice): boolean => { return rt.iterSum(rt.iterSlice(rt.byteSliceView(p8)), rt.u8Add, 0) > 18; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterFind(_274, (held13) => f12(rt.byteSliceFrom(held13)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterFind(_274, (held13) => f12(rt.byteSliceFrom(held13)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const _281: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray); const f13 = (a3: rt.ByteSlice, b4: rt.ByteSlice): boolean => { const order = rt.cmpBytes(a3, b4); @@ -4132,7 +4132,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const f14 = (p9: rt.ByteSlice): boolean => { return rt.cmpBytes(p9, rt.byteSliceFrom(Uint8Array.of())) === -1; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterRfind(_291, (held16) => f14(rt.byteSliceFrom(held16)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterRfind(_291, (held16) => f14(rt.byteSliceFrom(held16)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); const first: Dropped.Dropped = new Dropped.Dropped(1, log); const _299: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray); @@ -4221,9 +4221,9 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const probe: Uint8Array = option_mapOr$0z7fb2w(rt.optionMap(rt.sliceFirst(pairs), rt.byteSliceFrom), rt.bytes(0), (p13: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(p13); }); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.btreeGet(sorted2, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.btreeGet(sorted2, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const _429: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.optionMap(rt.hashGetKeyValue(refs, rt.byteSliceFrom(probe)), (held23): [rt.ByteSlice, rt.ByteSlice] => { return [held23[0], rt.byteSliceFrom(held23[1])]; }); @@ -4233,10 +4233,10 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(rt.entryOrInsert(rt.entry(refs, rt.byteSliceFrom(probe)), rt.bytes(0).fill(238))))), undefined, true); const keys: rt.ByteSlice[] = rt.iterToArray(rt.hashKeys(refs), "next", 4); rt.sliceSort(keys, rt.cmpLt(rt.cmpBytes), 4, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(keys), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(keys), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterLend(rt.hashValues(refs), rt.byteSliceFrom), rt.byteSliceToArray), "next", 0); rt.sliceSort(values, rt.cmpLt(rt.cmpBytes), 0, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(values), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(values), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(sorted2), (held24): [rt.ByteSlice, rt.ByteSlice] => { return [held24[0], rt.byteSliceFrom(held24[1])]; }); @@ -4256,7 +4256,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r }; rt.btreeRetain(sorted2, (held27, held28) => f18(held27, rt.byteSliceFrom(held28))); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(refs) & 0xff, rt.btreeLen(sorted2) & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.iterToOption(rt.btreeKeys(sorted2).next())), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.iterToOption(rt.btreeKeys(sorted2).next())), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.hashValues(refs), (v4: Uint8Array): rt.u8 => { return rt.byteSliceFrom(v4).length & 0xff; }), "next"); @@ -4344,14 +4344,14 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r _104.v = _104.v ^ 8; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); 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), 2, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(members), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(members), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const entries: [Uint8Array, Uint8Array][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held3): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held3[0]), rt.byteSliceFrom(held3[1])]; }), (_2: [rt.ByteSlice, rt.ByteSlice]): [Uint8Array, Uint8Array] => { @@ -4383,7 +4383,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r return rt.iterAny(rt.iterSlice(rt.byteSliceView(p3)), (_22: rt.u8): boolean => { return _22 < 2; }); - }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 2)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 2)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p4) === 64; }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); @@ -4398,7 +4398,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r _224.v = 170; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterToOption(rest.next())), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterToOption(rest.next())), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); let seen: rt.u8 = 0; const taken: Uint8Array[] = rt.iterToArray(rt.iterTakeWhile(rt.iterInspect(rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p5: rt.ByteSlice): undefined => { seen = rt.u8WrappingAdd(seen, p5.length & 0xff); @@ -4410,19 +4410,19 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const f10 = (a: rt.ByteSlice, b2: rt.ByteSlice): rt.Ordering => { return rt.cmpBytes(a, b2); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMaxBy(_255, (held10, held11) => f10(rt.byteSliceFrom(held10), rt.byteSliceFrom(held11)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMaxBy(_255, (held10, held11) => f10(rt.byteSliceFrom(held10), rt.byteSliceFrom(held11)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const _264: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray); const f11 = (p7: rt.ByteSlice): rt.u8 => { return rt.iterFold(rt.iterSlice(rt.byteSliceView(p7)), 0, (a2: rt.u8, b3: rt.u8): rt.u8 => { return a2 ^ b3; }); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMinByKey(_264, (held12) => f11(rt.byteSliceFrom(held12)), rt.lt)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMinByKey(_264, (held12) => f11(rt.byteSliceFrom(held12)), rt.lt)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const _274: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray); const f12 = (p8: rt.ByteSlice): boolean => { return rt.iterSum(rt.iterSlice(rt.byteSliceView(p8)), rt.u8Add, 0) > 18; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterFind(_274, (held13) => f12(rt.byteSliceFrom(held13)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterFind(_274, (held13) => f12(rt.byteSliceFrom(held13)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const _281: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray); const f13 = (a3: rt.ByteSlice, b4: rt.ByteSlice): boolean => { const order = rt.cmpBytes(a3, b4); @@ -4433,7 +4433,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const f14 = (p9: rt.ByteSlice): boolean => { return rt.cmpBytes(p9, rt.byteSliceFrom(Uint8Array.of(80, 80))) === -1; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterRfind(_291, (held16) => f14(rt.byteSliceFrom(held16)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterRfind(_291, (held16) => f14(rt.byteSliceFrom(held16)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); const first: Dropped.Dropped = new Dropped.Dropped(1, log); const _299: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec), rt.byteSliceFrom), rt.byteSliceToArray); @@ -4522,9 +4522,9 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const probe: Uint8Array = option_mapOr$0z7fb2w(rt.optionMap(rt.sliceFirst(pairs), rt.byteSliceFrom), rt.bytes(2), (p13: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(p13); }); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.btreeGet(sorted2, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.btreeGet(sorted2, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const _429: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.optionMap(rt.hashGetKeyValue(refs, rt.byteSliceFrom(probe)), (held23): [rt.ByteSlice, rt.ByteSlice] => { return [held23[0], rt.byteSliceFrom(held23[1])]; }); @@ -4534,10 +4534,10 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(rt.entryOrInsert(rt.entry(refs, rt.byteSliceFrom(probe)), rt.bytes(2).fill(238))))), undefined, true); const keys: rt.ByteSlice[] = rt.iterToArray(rt.hashKeys(refs), "next", 4); rt.sliceSort(keys, rt.cmpLt(rt.cmpBytes), 4, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(keys), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(keys), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterLend(rt.hashValues(refs), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); rt.sliceSort(values, rt.cmpLt(rt.cmpBytes), 2, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(values), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(values), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(sorted2), (held24): [rt.ByteSlice, rt.ByteSlice] => { return [held24[0], rt.byteSliceFrom(held24[1])]; }); @@ -4557,7 +4557,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r }; rt.btreeRetain(sorted2, (held27, held28) => f18(held27, rt.byteSliceFrom(held28))); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(refs) & 0xff, rt.btreeLen(sorted2) & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.iterToOption(rt.btreeKeys(sorted2).next())), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.iterToOption(rt.btreeKeys(sorted2).next())), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.hashValues(refs), (v4: Uint8Array): rt.u8 => { return rt.byteSliceFrom(v4).length & 0xff; }), "next"); diff --git a/ts/fixtures/lang/lengths/expected/lengths.ts b/ts/fixtures/lang/lengths/expected/lengths.ts index c09db3302..d71467562 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.ts @@ -161,22 +161,22 @@ export function each$3(data: rt.ByteSlice, out: rt.ByteVec): void { /** The bytes of `data` and then of each row, as one run. */ export function joined$0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0)), undefined, true); + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ export function joined$1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 1)), undefined, true); + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 1)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ export function joined$17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 17)), undefined, true); + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 17)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ export function joined$3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 3)), undefined, true); + rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 3)), undefined, true); } /** @@ -1406,7 +1406,7 @@ export function swapped$u32_0(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), false, 0)), (_2: rt.u32): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 0)), (_2: rt.u32): rt.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1457,7 +1457,7 @@ export function swapped$u32_1(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), false, 1)), (_2: rt.u32): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 1)), (_2: rt.u32): rt.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1508,7 +1508,7 @@ export function swapped$u32_17(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byt _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), false, 17)), (_2: rt.u32): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 17)), (_2: rt.u32): rt.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1559,7 +1559,7 @@ export function swapped$u32_3(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), false, 3)), (_2: rt.u32): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 3)), (_2: rt.u32): rt.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1612,7 +1612,7 @@ export function swapped$u8_0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0)), (_2: rt.u8): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0)), (_2: rt.u8): rt.u8 => { return ((_2 as rt.u32)) & 0xff; }), undefined, true); } @@ -1665,7 +1665,7 @@ export function swapped$u8_1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 1)), (_2: rt.u8): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 1)), (_2: rt.u8): rt.u8 => { return ((_2 as rt.u32)) & 0xff; }), undefined, true); } @@ -1718,7 +1718,7 @@ export function swapped$u8_17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.By _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 17)), (_2: rt.u8): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 17)), (_2: rt.u8): rt.u8 => { return ((_2 as rt.u32)) & 0xff; }), undefined, true); } @@ -1771,7 +1771,7 @@ export function swapped$u8_3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 3)), (_2: rt.u8): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 3)), (_2: rt.u8): rt.u8 => { return ((_2 as rt.u32)) & 0xff; }), undefined, true); } diff --git a/ts/fixtures/lang/orders/expected/orders.ts b/ts/fixtures/lang/orders/expected/orders.ts index f19e440d3..4a606f82e 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -416,7 +416,7 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { }, rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(copy.d), (s2: string): rt.Iter => { return rt.strBytes(s2); - }), "next"); + }, undefined, true), "next"); rt.iterExtendBytes(out, rt.iterMap(rt.heapIter(strings), (s3: string): rt.u8 => { return rt.stringLen(s3) & 0xff; }), "next"); @@ -445,7 +445,7 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(rt.heapIntoSortedVec(pairs, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])))), (_25: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_25[0], _25[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } /** @@ -540,9 +540,9 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { 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 => { const k: Uint8Array = _22[0]; return Uint8Array.of(k[0], k[1], _22[1] & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), false, 3), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 3), undefined, true); rt.sliceSort(arrays, rt.cmpLt(rt.cmpBytes), 2, 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); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); const slices: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(data, 3), undefined, 8, true); rt.sliceSort(slices, rt.cmpLt((a7: rt.ByteSlice, b3: rt.ByteSlice): rt.Ordering => { return rt.cmpBytes(b3, a7); @@ -690,7 +690,7 @@ export function tuples(data: rt.ByteSlice, out: rt.ByteVec): void { _510 = 9; } return Uint8Array.of(_510, n); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } const pairs: [rt.u8, Part.Part][] = rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (p4: Part.Part): [rt.u8, Part.Part] => { return [rt.u8Rem(p4.tag, 3), p4] as [rt.u8, Part.Part]; @@ -1144,7 +1144,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.btreeLen(map) & 0xff); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(map), (_26: [Torn.Torn, rt.u8]): Uint8Array => { return Uint8Array.of(_26[0].tag, _26[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const _57: Torn.Torn[] = keys2; if (_57.length >= 3) { const a: Torn.Torn = _57[0]; @@ -1159,7 +1159,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return !Torn.ne$cmp_PartialEq(a5, b6); })), (_28: [Torn.Torn, rt.u8]): Uint8Array => { return Uint8Array.of(_28[0].tag, _28[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToArray(rt.iterSlice([a]), undefined, 3, true), 3, true, Torn.lt$cmp_PartialOrd, (a6: Torn.Torn, b7: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a6, b7); })), (k4: Torn.Torn): rt.u8 => { @@ -1178,7 +1178,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.iterMap(rt.iterSlice(c2), (k5: Torn.Torn): rt.u8 => { return k5.tag; }); - }), "next"); + }, undefined, true), "next"); flush(out); const extended: rt.BTreeSet = rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet; const _103: rt.Iter = rt.iterSlice(keys2); @@ -1193,7 +1193,7 @@ export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.btreeExtend(entries, _114); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(entries), (_29: [Torn.Torn, rt.u8]): Uint8Array => { return Uint8Array.of(_29[0].tag, _29[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const _124: [rt.BTreeSet, rt.BTreeSet] = [rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet]; const left: rt.BTreeSet = _124[0]; const right: rt.BTreeSet = _124[1]; diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index d62c3f2c1..4d6379100 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -742,7 +742,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { for (const _168 of pairs) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_168[0], option_unwrapOr$0r2bmpr(_168[1], 238)))); } - const iter10: rt.Iter = rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), false, 2); + const iter10: rt.Iter = rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 2); while (true) { const _186: rt.u32 | rt.Done = iter10.next(); if (_186 === rt.DONE) { diff --git a/ts/fixtures/lang/results/expected/results.ts b/ts/fixtures/lang/results/expected/results.ts index 3fe967d2b..27741a18e 100644 --- a/ts/fixtures/lang/results/expected/results.ts +++ b/ts/fixtures/lang/results/expected/results.ts @@ -79,8 +79,8 @@ export function copied(data: rt.ByteSlice, out: rt.ByteVec): void { _56.v = _56.v ^ 16; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), "next"); - const iter6: rt.Iter> = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterOption(rt.resultAsMut(value)), false, undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), "next"); + const iter6: rt.Iter> = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterOption(rt.resultAsMut(value)), true, undefined, true); while (true) { const _71: rt.Place | rt.Done = iter6.next(); if (_71 === rt.DONE) { @@ -88,9 +88,9 @@ export function copied(data: rt.ByteSlice, out: rt.ByteVec): void { } _71.v = rt.u8WrappingMul(_71.v, 3); } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), "next"); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true)), "next"); - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), "next"); + rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true)), "next"); + const it: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true); while (true) { const _93: [rt.u8 | undefined, rt.u8 | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; if (_93[0] !== undefined) { @@ -194,7 +194,7 @@ export function owned(data: rt.ByteSlice, out: rt.ByteVec): void { _65.id = _65.id ^ 64; } } - const iter6: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterResult(value.v), false, undefined, true)); + const iter6: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterResult(value.v), true, undefined, true)); while (true) { const _76: Logged.Logged | rt.Done = iter6.next(); if (_76 === rt.DONE) { @@ -202,7 +202,7 @@ export function owned(data: rt.ByteSlice, out: rt.ByteVec): void { } _76.id = rt.u8WrappingAdd(_76.id, 1); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), (l4: Logged.Logged): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), (l4: Logged.Logged): rt.u8 => { return l4.id; }), "next"); flush(log.value, out); @@ -221,7 +221,7 @@ export function owned(data: rt.ByteSlice, out: rt.ByteVec): void { flush(log.value, out); const rest: Logged.Logged[] = rt.iterToArray(rt.iterFlatten(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_23: rt.u8): rt.Result => { return made(_23); - }), (value: rt.Result) => rt.iterResult(value, rt.drop, rt.drop), false, undefined, true), "next", 8); + }), (value: rt.Result) => rt.iterResult(value, rt.drop, rt.drop), true, undefined, true), "next", 8); flush(log.value, out); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rest), (l5: Logged.Logged): rt.u8 => { return l5.id; @@ -238,7 +238,7 @@ export function units(data: rt.ByteSlice, out: rt.ByteVec): void { const err: rt.u8 | undefined = part === undefined ? out$u8.err as rt.u8 : undefined; return result_map$03hz3l7((err !== undefined ? rt.Err(err as rt.u8) : rt.Ok(part as rt.u8)) as rt.Result, (_24: rt.u8): undefined => {}); }), undefined, 2, true); - rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true)) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true)) & 0xff); const iter: rt.Iter>> = rt.iterSliceMut(results); while (true) { const _16: rt.Place> | rt.Done = iter.next(); @@ -255,7 +255,7 @@ export function units(data: rt.ByteSlice, out: rt.ByteVec): void { })); rt.byteVecPush(out, rt.iterToOption(rt.iterResult(_36).nextBack(), rt.None) !== rt.None ? 1 : 0); } - rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true)) & 0xff); + rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true)) & 0xff); } /** Of an `Option`, which `flatten` reads into in turn. */ @@ -283,7 +283,7 @@ export function nested(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _14); } - const iter2: rt.Iter> = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterOption(rt.resultAsMut(value)), false, undefined, true); + const iter2: rt.Iter> = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterOption(rt.resultAsMut(value)), true, undefined, true); while (true) { const _27: rt.Place | rt.Done = iter2.next(); if (_27 === rt.DONE) { @@ -295,8 +295,8 @@ export function nested(data: rt.ByteSlice, out: rt.ByteVec): void { _27.v = rt.u8WrappingAdd(_27.v, 1); } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true), "next"); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true)), "next"); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true), "next"); + rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true)), "next"); } /** `N` bytes of `data` from `at`, past its end each its index. */ @@ -328,7 +328,7 @@ export function arrays$0(data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.Ok(bytesAt$0(data, rt.usizeMul(k, 0))); }), undefined, 2, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true); + const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _13: rt.ByteSlice | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -336,7 +336,7 @@ export function arrays$0(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true)); + const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _26: rt.ByteSlice | rt.Done = iter2.next(); if (_26 === rt.DONE) { @@ -344,7 +344,7 @@ export function arrays$0(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _26); } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), false, undefined, true); + const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _38: rt.ByteSlice | rt.Done = iter3.next(); if (_38 === rt.DONE) { @@ -376,7 +376,7 @@ export function arrays$0(data: rt.ByteSlice, out: rt.ByteVec): void { } const first: rt.Result = copy$Result_array0_u8_u8(results[rt.idx(results, 0)]); const other: rt.Result = copy$Result_array0_u8_u8(results[rt.idx(results, 1)]); - const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true)); + const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _85: rt.ByteSlice | rt.Done = iter6.next(); if (_85 === rt.DONE) { @@ -418,7 +418,7 @@ export function arrays$0(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, _131); } } - const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterChain(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), rt.iterResult(copy$Result_array0_u8_u8(first))), "next", 0)), rt.byteSliceFrom); + const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterChain(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), rt.iterResult(copy$Result_array0_u8_u8(first))), "next", 0)), rt.byteSliceFrom); while (true) { const _146: rt.ByteSlice | rt.Done = iter12.next(); if (_146 === rt.DONE) { @@ -436,7 +436,7 @@ export function arrays$1(data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.Ok(bytesAt$1(data, rt.usizeMul(k, 1))); }), undefined, 2, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true); + const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _13: rt.ByteSlice | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -444,7 +444,7 @@ export function arrays$1(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true)); + const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _26: rt.ByteSlice | rt.Done = iter2.next(); if (_26 === rt.DONE) { @@ -452,7 +452,7 @@ export function arrays$1(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _26); } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), false, undefined, true); + const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _38: rt.ByteSlice | rt.Done = iter3.next(); if (_38 === rt.DONE) { @@ -484,7 +484,7 @@ export function arrays$1(data: rt.ByteSlice, out: rt.ByteVec): void { } const first: rt.Result = copy$Result_array1_u8_u8(results[rt.idx(results, 0)]); const other: rt.Result = copy$Result_array1_u8_u8(results[rt.idx(results, 1)]); - const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true)); + const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _85: rt.ByteSlice | rt.Done = iter6.next(); if (_85 === rt.DONE) { @@ -526,7 +526,7 @@ export function arrays$1(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, _131); } } - const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterChain(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), rt.iterResult(copy$Result_array1_u8_u8(first))), "next", 1)), rt.byteSliceFrom); + const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterChain(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), rt.iterResult(copy$Result_array1_u8_u8(first))), "next", 1)), rt.byteSliceFrom); while (true) { const _146: rt.ByteSlice | rt.Done = iter12.next(); if (_146 === rt.DONE) { @@ -544,7 +544,7 @@ export function arrays$5(data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.Ok(bytesAt$5(data, rt.usizeMul(k, 5))); }), undefined, 6, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true); + const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true); while (true) { const _13: rt.ByteSlice | rt.Done = iter.next(); if (_13 === rt.DONE) { @@ -552,7 +552,7 @@ export function arrays$5(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true)); + const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _26: rt.ByteSlice | rt.Done = iter2.next(); if (_26 === rt.DONE) { @@ -560,7 +560,7 @@ export function arrays$5(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecExtendFromSlice(out, _26); } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), false, undefined, true); + const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), true, undefined, true); while (true) { const _38: rt.ByteSlice | rt.Done = iter3.next(); if (_38 === rt.DONE) { @@ -592,7 +592,7 @@ export function arrays$5(data: rt.ByteSlice, out: rt.ByteVec): void { } const first: rt.Result = copy$Result_array5_u8_u8(results[rt.idx(results, 0)]); const other: rt.Result = copy$Result_array5_u8_u8(results[rt.idx(results, 1)]); - const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), false, undefined, true)); + const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); while (true) { const _85: rt.ByteSlice | rt.Done = iter6.next(); if (_85 === rt.DONE) { @@ -634,7 +634,7 @@ export function arrays$5(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, _131); } } - const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterChain(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), false, undefined, true), rt.iterResult(copy$Result_array5_u8_u8(first))), "next", 5)), rt.byteSliceFrom); + const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterChain(rt.iterFlatten(rt.iterSlice(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), rt.iterResult(copy$Result_array5_u8_u8(first))), "next", 5)), rt.byteSliceFrom); while (true) { const _146: rt.ByteSlice | rt.Done = iter12.next(); if (_146 === rt.DONE) { diff --git a/ts/fixtures/lang/searches/expected/searches.ts b/ts/fixtures/lang/searches/expected/searches.ts index 588ba91c6..d492ec4cb 100644 --- a/ts/fixtures/lang/searches/expected/searches.ts +++ b/ts/fixtures/lang/searches/expected/searches.ts @@ -38,7 +38,7 @@ export function front$ref_str_str_Matches_array2_char(it: rt.Iter, out: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -68,7 +68,7 @@ export function front$ref_str_str_Matches_char(it: rt.Iter, out: rt.Byte } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -98,7 +98,7 @@ export function front$ref_str_str_Matches_ref_slice_char(it: rt.Iter, ou } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -128,7 +128,7 @@ export function front$ref_str_str_Matches_ref_str(it: rt.Iter, out: rt.B } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -158,7 +158,7 @@ export function front$ref_str_str_Matches_searches_searches_closure1(it: rt.Iter } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -188,7 +188,7 @@ export function front$ref_str_str_RMatches_array2_char(it: rt.Iter, out: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -218,7 +218,7 @@ export function front$ref_str_str_RMatches_char(it: rt.Iter, out: rt.Byt } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -248,7 +248,7 @@ export function front$ref_str_str_RMatches_ref_slice_char(it: rt.Iter, o } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -278,7 +278,7 @@ export function front$ref_str_str_RMatches_ref_str(it: rt.Iter, out: rt. } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -308,7 +308,7 @@ export function front$ref_str_str_RMatches_searches_searches_closure1(it: rt.Ite } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -338,7 +338,7 @@ export function front$ref_str_str_RSplitN_array2_char(it: rt.Iter, out: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -368,7 +368,7 @@ export function front$ref_str_str_RSplitN_char(it: rt.Iter, out: rt.Byte } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -398,7 +398,7 @@ export function front$ref_str_str_RSplitN_ref_slice_char(it: rt.Iter, ou } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -428,7 +428,7 @@ export function front$ref_str_str_RSplitN_ref_str(it: rt.Iter, out: rt.B } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -458,7 +458,7 @@ export function front$ref_str_str_RSplitN_searches_searches_closure1(it: rt.Iter } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -488,7 +488,7 @@ export function front$ref_str_str_RSplitTerminator_array2_char(it: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -518,7 +518,7 @@ export function front$ref_str_str_RSplitTerminator_char(it: rt.Iter, out } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -548,7 +548,7 @@ export function front$ref_str_str_RSplitTerminator_ref_slice_char(it: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -578,7 +578,7 @@ export function front$ref_str_str_RSplitTerminator_ref_str(it: rt.Iter, } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -608,7 +608,7 @@ export function front$ref_str_str_RSplitTerminator_searches_searches_closure1(it } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -638,7 +638,7 @@ export function front$ref_str_str_RSplit_array2_char(it: rt.Iter, out: r } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -668,7 +668,7 @@ export function front$ref_str_str_RSplit_char(it: rt.Iter, out: rt.ByteV } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -698,7 +698,7 @@ export function front$ref_str_str_RSplit_ref_slice_char(it: rt.Iter, out } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -728,7 +728,7 @@ export function front$ref_str_str_RSplit_ref_str(it: rt.Iter, out: rt.By } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -758,7 +758,7 @@ export function front$ref_str_str_RSplit_searches_searches_closure1(it: rt.Iter< } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -788,7 +788,7 @@ export function front$ref_str_str_SplitInclusive_array2_char(it: rt.Iter } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -818,7 +818,7 @@ export function front$ref_str_str_SplitInclusive_char(it: rt.Iter, out: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -848,7 +848,7 @@ export function front$ref_str_str_SplitInclusive_ref_slice_char(it: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -878,7 +878,7 @@ export function front$ref_str_str_SplitInclusive_ref_str(it: rt.Iter, ou } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -908,7 +908,7 @@ export function front$ref_str_str_SplitInclusive_searches_searches_closure1(it: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -938,7 +938,7 @@ export function front$ref_str_str_SplitN_array2_char(it: rt.Iter, out: r } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -968,7 +968,7 @@ export function front$ref_str_str_SplitN_char(it: rt.Iter, out: rt.ByteV } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -998,7 +998,7 @@ export function front$ref_str_str_SplitN_ref_slice_char(it: rt.Iter, out } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1028,7 +1028,7 @@ export function front$ref_str_str_SplitN_ref_str(it: rt.Iter, out: rt.By } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1058,7 +1058,7 @@ export function front$ref_str_str_SplitN_searches_searches_closure1(it: rt.Iter< } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1088,7 +1088,7 @@ export function front$ref_str_str_SplitTerminator_array2_char(it: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1118,7 +1118,7 @@ export function front$ref_str_str_SplitTerminator_char(it: rt.Iter, out: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1148,7 +1148,7 @@ export function front$ref_str_str_SplitTerminator_ref_slice_char(it: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1178,7 +1178,7 @@ export function front$ref_str_str_SplitTerminator_ref_str(it: rt.Iter, o } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1208,7 +1208,7 @@ export function front$ref_str_str_SplitTerminator_searches_searches_closure1(it: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1238,7 +1238,7 @@ export function front$ref_str_str_Split_array2_char(it: rt.Iter, out: rt } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1268,7 +1268,7 @@ export function front$ref_str_str_Split_char(it: rt.Iter, out: rt.ByteVe } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1298,7 +1298,7 @@ export function front$ref_str_str_Split_ref_slice_char(it: rt.Iter, out: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1328,7 +1328,7 @@ export function front$ref_str_str_Split_ref_str(it: rt.Iter, out: rt.Byt } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1358,7 +1358,7 @@ export function front$ref_str_str_Split_searches_searches_closure1(it: rt.Iter = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: string | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1388,7 +1388,7 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_array2_char(it: rt.I } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1418,7 +1418,7 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_char(it: rt.Iter<[rt } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1448,7 +1448,7 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: r } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1478,7 +1478,7 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_ref_str(it: rt.Iter< } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1508,7 +1508,7 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_searches_searches_cl } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1538,7 +1538,7 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rt. } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1568,7 +1568,7 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_char(it: rt.Iter<[r } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1598,7 +1598,7 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1628,7 +1628,7 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(it: rt.Iter } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { @@ -1658,7 +1658,7 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_c } } rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy)); + const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); while (true) { const _24: [rt.usize, string] | rt.Done = iter.next(); if (_24 === rt.DONE) { diff --git a/ts/fixtures/lang/shapes/expected/core/bool.ts b/ts/fixtures/lang/shapes/expected/core/bool.ts index 4a38187df..c95c295ec 100644 --- a/ts/fixtures/lang/shapes/expected/core/bool.ts +++ b/ts/fixtures/lang/shapes/expected/core/bool.ts @@ -38,4 +38,11 @@ export function then$1btzga3(self: boolean, f: () => rt.u8): rt.u8 | undefined { return f(); } +export function then$0uwf92a(self: boolean, f: () => rt.usize): rt.usize | undefined { + if (!self) { + return undefined; + } + return f(); +} + //# sourceMappingURL=bool.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index a7f3b5ba1..a657649dc 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { copy$array_u8 } from "./lib.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; +import { copy$array_tuple2_u8_u8, copy$array_u8, copy$tuple2_u8_u8 } from "./lib.ts"; +import { thenSome$0d5am30, then$0uwf92a } from "./core/bool.ts"; import { unwrapOr$0k15iai as option_unwrapOr$0k15iai, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; import * as Bare from "./fmt.Bare.ts"; import * as Braced from "./fmt.Braced.ts"; @@ -1849,6 +1849,765 @@ export function ends$iters_vec_IntoIter_u8(it: rt.Iter, front: rt.usize, } } +/** + * std's iterator adaptors' `Debug`, each its fields in std's order through what it wraps, + * with no closure: consumed from either end, so each writes the state it keeps, as a + * `Peekable` its peeked item and a `Skip` what it has left to skip, plain and pretty. + */ +export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const _6: [rt.usize, rt.usize] = [rt.u8Rem(at(0), 4) as rt.usize, rt.u8Rem(at(1), 3) as rt.usize]; + const front: rt.usize = _6[0]; + const back: rt.usize = _6[1]; + const bytes: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 6)); + const part2 = ends$adaptors_iter_Map_slice_Iter_u8_fmt_adaptors_closure1(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (b: rt.u8): rt.u8 => { + return rt.u8Add(b, 1); + }), front, back); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part2, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0])])); + const part3 = ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(rt.iterFilter(rt.iterSlice(rt.byteSliceView(bytes)), (_2: rt.u8): boolean => { + return rt.u8Rem(_2, 2) === 0; + }), front, back); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part3, f, "Filter", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0])])); + const part4 = ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_23: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedSub(_23, 9); + }), front, back); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part4, f, "FilterMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args6[0]])); + const part5 = ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(rt.iterInspect(rt.iterSlice(rt.byteSliceView(bytes)), (_26: rt.u8): undefined => {}), front, back); + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part5, f, "Inspect", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args8[0]])); + const part6 = fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_28: rt.u8): rt.u8 | undefined => { + return rt.u8CheckedSub(_28, 3); + }), front); + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part6, f, "MapWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args10[0]])); + const part7 = ends$adaptors_iter_Rev_slice_Iter_u8(rt.iterRev(rt.iterSlice(rt.byteSliceView(bytes))), front, back); + const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part7, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args12[0], "|", rt.fmtSpec({ alternate: true }, args12[0])])); + const part8 = ends$adaptors_iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), front, back); + const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(part8, f, rt.u8Debug, ["Iter"])])]; + put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ alternate: true }, args14[0]), "|", rt.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args14[0])])); + const part9 = ends$adaptors_iter_Cloned_slice_Iter_u8(rt.iterCloned(rt.iterSlice(rt.byteSliceView(bytes))), front, back); + const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part9, f, "Cloned", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), "it")]; + put(out, rt.fmtFormat([args16[0]])); + const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rt.iterCloned(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (b5: rt.u8): string => { + return rt.fmtToString((f: rt.Formatter) => rt.u8Display(b5, f)); + }), undefined, 12, true))), front, back); + const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part10, f, "Cloned", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.fmtStr, ["Iter"]), "it")]; + put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[0])])); + const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rt.iterCopied(rt.iterLend(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterTake(rt.byteSliceChunksExact(data, 2), 3), (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)), rt.byteSliceFrom), rt.byteSliceToArray), front, back); + const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part11, f, "Copied", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug), ["Iter"]), "it")]; + put(out, rt.fmtFormat([args20[0]])); + const part12 = ends$adaptors_iter_Enumerate_slice_Iter_u8(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(bytes))), front, back); + const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEnumerate(part12, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args22[0], "|", rt.fmtSpec({ alternate: true }, args22[0]), "|", rt.fmtSpec({ debugHex: "x" }, args22[0])])); + const it12: rt.Iter = rt.iterSkip(rt.iterSlice(rt.byteSliceView(bytes)), at(2) as rt.usize); + const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(it12, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0])])); + rt.iterToOption(it12.nextBack()); + const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(it12, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args26[0]])); + it12.next(); + const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(it12, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args28[0]])); + const part13 = ends$adaptors_iter_Take_slice_Iter_u8(rt.iterTake(rt.iterSlice(rt.byteSliceView(bytes)), rt.u8Rem(at(2), 8) as rt.usize), front, back); + const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part13, f, "Take", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args30[0], "|", rt.fmtSpec({ alternate: true }, args30[0])])); + const it14: rt.Iter = rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_211: rt.u8): boolean => { + return rt.u8Rem(_211, 3) !== 0; + }); + const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it14, f, "SkipWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args32[0]])); + it14.next(); + const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it14, f, "SkipWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args34[0], "|", rt.fmtSpec({ alternate: true }, args34[0])])); + const it15: rt.Iter = rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_212: rt.u8): boolean => { + return rt.u8Rem(_212, 5) !== 0; + }); + const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it15, f, "TakeWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args36[0]])); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + it15.next(); + } + const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it15, f, "TakeWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args38[0], "|", rt.fmtSpec({ alternate: true }, args38[0])])); + const part14 = fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(rt.iterScan(rt.iterSlice(rt.byteSliceView(bytes)), 0, (sum: rt.Place, _33: rt.u8): rt.u32 | undefined => { + sum.v = rt.u32Add(sum.v, _33 as rt.u32); + return sum.v; + }, true), front); + const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtScan(part14, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u32Debug)]; + put(out, rt.fmtFormat([args40[0], "|", rt.fmtSpec({ alternate: true }, args40[0]), "|", rt.fmtSpec({ debugHex: "x" }, args40[0])])); + const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rt.iterScan(rt.iterSlice(rt.byteSliceView(bytes)), "", (s: rt.Place, _34: rt.u8): rt.usize | undefined => { + const b9: rt.u8 = _34; + s.v = s.v + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(b9, 26)) as rt.char); + return then$0uwf92a(rt.u8Rem(b9, 7) !== 0, (): rt.usize => { + return rt.stringLen(s.v); + }); + }, true), front); + const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtScan(part15, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.fmtStr)]; + put(out, rt.fmtFormat([args42[0]])); + const it18: rt.Peekable = ends$adaptors_iter_Peekable_slice_Iter_u8(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))), front, back); + const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it18, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; + put(out, rt.fmtFormat([args44[0]])); + rt.peekablePeek(it18); + const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it18, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; + put(out, rt.fmtFormat([args46[0], "|", rt.fmtSpec({ alternate: true }, args46[0])])); + it18.next(); + const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it18, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; + put(out, rt.fmtFormat([args48[0]])); + const it19: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.min(bytes.length, 1))))); + it19.next(); + rt.peekablePeek(it19); + const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it19, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; + put(out, rt.fmtFormat([args50[0], "|", rt.fmtSpec({ alternate: true }, args50[0])])); + const part19 = ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.min(2, bytes.length)))), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, rt.min(2, bytes.length))))), front, back); + const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part19, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args52[0], "|", rt.fmtSpec({ alternate: true }, args52[0])])); + const it21: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.min(1, bytes.length)))), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(7, 8))))); + rt.iterToOption(it21.nextBack()); + rt.iterToOption(it21.nextBack()); + rt.iterToOption(it21.nextBack()); + const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(it21, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args54[0]])); + const part21 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(rt.iterZip(rt.iterSlice(rt.byteSliceView(bytes)), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b10: rt.u8): rt.u8 => { + return b10 ^ 1; + }), [false, true]), front, back); + const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part21, f)]; + put(out, rt.fmtFormat([args56[0], "|", rt.fmtSpec({ alternate: true }, args56[0])])); + const part22 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(rt.iterZip(rt.iterSlice(rt.byteSliceView(bytes)), rt.iterRev(rt.iterSlice(rt.byteSliceView(bytes))), "len"), front, back); + const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part22, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; + put(out, rt.fmtFormat([args58[0]])); + const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rt.iterZip(rt.strChars(rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_213: rt.u8): rt.char => { + const _511: rt.usize = rt.u8Rem(_213, 4) as rt.usize; + if (!(_511 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _511); + } + return [97, 233, 20013, 129408][_511]; + }))), rt.iterSlice(rt.byteSliceView(bytes))), front); + const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part23, f, rt.fmtChars, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args60[0], "|", rt.fmtSpec({ alternate: true }, args60[0])])); + const part24 = fronts$adaptors_iter_Cycle_slice_Iter_u8(rt.iterCycle(rt.iterSlice(rt.byteSliceView(bytes))), rt.usizeAdd(front, rt.u8Rem(at(2), 8) as rt.usize)); + const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCycle(part24, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args62[0], "|", rt.fmtSpec({ alternate: true }, args62[0])])); + const part25 = fronts$adaptors_iter_Fuse_slice_Iter_u8(rt.iterFuse(rt.iterSlice(rt.byteSliceView(bytes)), true), rt.usizeAdd(front, 6)); + const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part25, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args64[0], "|", rt.fmtSpec({ alternate: true }, args64[0])])); + const part26 = fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(rt.iterFuse(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(bytes)), 2), true), rt.usizeAdd(front, 2)); + const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part26, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtStepBy(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; + put(out, rt.fmtFormat([args66[0], "|", rt.fmtSpec({ alternate: true }, args66[0])])); + const part27 = fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(rt.iterFuse(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_216: rt.u8): rt.u8 | undefined => { + const b12: rt.u8 = _216; + return thenSome$0d5am30(rt.u8Rem(b12, 4) !== 0, b12); + })), rt.usizeMul(front, 2)); + const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part27, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "MapWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; + put(out, rt.fmtFormat([args68[0]])); + const step: rt.usize = rt.usizeAdd(rt.u8Rem(at(3), 4) as rt.usize, 1); + const part28 = ends$adaptors_iter_StepBy_slice_Iter_u8(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(bytes)), step), front, back); + const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part28, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args70[0], "|", rt.fmtSpec({ alternate: true }, args70[0])])); + const _630: [rt.u8, rt.u8] = [rt.u8Rem(at(4), 16), at(5)]; + const lo: rt.u8 = _630[0]; + const hi: rt.u8 = _630[1]; + const part29 = ends$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(lo, hi), step, undefined, 255), front, back); + const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part29, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args72[0], "|", rt.fmtSpec({ alternate: true }, args72[0])])); + const part30 = fronts$adaptors_iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(lo as rt.u32, hi as rt.u32), step, undefined, 4294967295), front); + const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part30, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u32Debug))]; + put(out, rt.fmtFormat([args74[0]])); + const part31 = ends$adaptors_iter_StepBy_ops_Range_usize(rt.iterStepBy(new rt.Range(lo as rt.usize, hi as rt.usize), step, undefined, 4294967295), front, back); + const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part31, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.usizeDebug))]; + put(out, rt.fmtFormat([args76[0], "|", rt.fmtSpec({ debugHex: "x" }, args76[0])])); + const part32 = ends$adaptors_iter_StepBy_ops_Range_u16(rt.iterStepBy(new rt.Range(lo as rt.u16, hi as rt.u16), step, undefined, 65535), front, back); + const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part32, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u16Debug))]; + put(out, rt.fmtFormat([args78[0]])); + const part33 = ends$adaptors_iter_StepBy_ops_Range_i32(rt.iterStepBy(new rt.Range(lo as rt.i32, hi as rt.i32), step), front, back); + const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part33, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.i32Debug))]; + put(out, rt.fmtFormat([args80[0]])); + const part34 = fronts$adaptors_iter_StepBy_ops_Range_u64(rt.iterStepBy(new rt.Range(lo as rt.u64, hi as rt.u64, rt.u64Step), step), front); + const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part34, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u64Debug))]; + put(out, rt.fmtFormat([args82[0]])); + const part35 = fronts$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(250, 255), 300, undefined, 255), front); + const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part35, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args84[0]])); + const part36 = fronts$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(250, 255), rt.usizeAdd(at(3) as rt.usize, 1), undefined, 255), front); + const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part36, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args86[0]])); + const part37 = fronts$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(hi, 255), rt.usizeAdd(step, 200), undefined, 255), front); + const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part37, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; + put(out, rt.fmtFormat([args88[0]])); + const lists: rt.ByteVec[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(bytes, 2), (a0: rt.ByteSlice): rt.ByteVec => { + return rt.byteSliceToByteVec(a0); + }), undefined, 12, true); + const part38 = ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(rt.iterFlatten(rt.iterSlice(lists), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), front, back); + const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlatten(part38, f, "Flatten", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args90[0], "|", rt.fmtSpec({ alternate: true }, args90[0])])); + const part39 = ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(rt.iterFlatMap(rt.iterSlice(lists), (v: rt.ByteVec): rt.Iter => { + return rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v))); + }, undefined, true), front, back); + const args92: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlatten(part39, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args92[0], "|", rt.fmtSpec({ alternate: true }, args92[0])])); + const part40 = fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(rt.iterFuse(rt.iterFlatten(rt.iterSlice(lists), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), true), rt.usizeAdd(front, 6)); + const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part40, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "Flatten", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; + put(out, rt.fmtFormat([args94[0]])); + const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_218: rt.u8): rt.u16 => { + const _517: rt.usize = rt.u8Rem(_218, 5) as rt.usize; + if (!(_517 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _517); + } + return [97, 55296, 56320, 233, 56319][_517]; + }), undefined, 2, true))), front); + const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part41, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])]))]; + put(out, rt.fmtFormat([args96[0], "|", rt.fmtSpec({ alternate: true }, args96[0]), "|", rt.fmtSpec({ debugHex: "x" }, args96[0])])); + const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rt.charDecodeUtf16(rt.iterSlice([55296, 97, 98])), rt.u8Rem(at(2), 3) as rt.usize); + const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part42, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["IntoIter"]))]; + put(out, rt.fmtFormat([args98[0]])); + const part43 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure17(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_219: rt.u8): Pair.Pair => { + return { _0: _219, _1: -1 }; + })), 1)), 3), front, back); + const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part43, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; + put(out, rt.fmtFormat([args100[0], "|", rt.fmtSpec({ alternate: true }, args100[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args100[0])])); + const it45: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); + rt.peekablePeek(it45); + const part44 = rt.iterChain(rt.iterFilter(rt.iterZip(it45, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { + return p[0] !== 0; + }), rt.iterSlice(copy$array_tuple2_u8_u8([[9, 9] as [rt.u8, rt.u8]]).map(copy$tuple2_u8_u8))); + const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part44, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])]), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; + put(out, rt.fmtFormat([args102[0], "|", rt.fmtSpec({ alternate: true }, args102[0])])); +} + +export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Cloned_slice_Iter_String(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Cloned_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Copied_slice_Iter_array2_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Copied_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Enumerate_slice_Iter_u8(it: rt.Iter<[rt.usize, rt.u8]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, rt.u8]> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Map_slice_Iter_u8_fmt_adaptors_closure1(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Peekable_slice_Iter_u8(it: rt.Peekable, front: rt.usize, back: rt.usize): rt.Peekable { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Rev_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_StepBy_ops_Range_i32(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_StepBy_ops_Range_u16(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_StepBy_ops_Range_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_StepBy_ops_Range_usize(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure17(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Take_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(it: rt.Iter<[rt.u8, rt.u8]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8]> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(it: rt.Iter<[rt.u8, rt.u8]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8]> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = back; + while (true) { + if (!(iterStart2++ < iterEnd2)) { + return it; + } + rt.iterToOption(it.nextBack()); + } +} + +export function fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(it: rt.Iter>, front: rt.usize): rt.Iter> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter>, front: rt.usize): rt.Iter> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Cycle_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Fuse_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_StepBy_ops_Range_u32(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_StepBy_ops_Range_u64(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_StepBy_ops_Range_u8(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(it: rt.Iter<[rt.char, rt.u8]>, front: rt.usize): rt.Iter<[rt.char, rt.u8]> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + /** * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. diff --git a/ts/fixtures/lang/shapes/expected/lib.ts b/ts/fixtures/lang/shapes/expected/lib.ts index 790e4e8fe..503436f75 100644 --- a/ts/fixtures/lang/shapes/expected/lib.ts +++ b/ts/fixtures/lang/shapes/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, enums, iters, writes, objects } from "./fmt.ts"; +import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, enums, iters, adaptors, writes, objects } from "./fmt.ts"; import { methods, runs } from "./generics.ts"; import type * as Either from "./generics.Either.ts"; import * as Fixed from "./generics.Fixed.ts"; @@ -41,6 +41,10 @@ export function copy$array_shapes_Point(v: Point.Point[]): Point.Point[] { return v.map(copy$shapes_Point); } +export function copy$array_tuple2_u8_u8(v: [rt.u8, rt.u8][]): [rt.u8, rt.u8][] { + return v.map(copy$tuple2_u8_u8); +} + export function copy$array_u16(v: rt.u16[]): rt.u16[] { return v.slice(); } @@ -194,6 +198,8 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) flows(data20, out21); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_231: rt.u8, data21: rt.ByteSlice, out22: rt.ByteVec): undefined => { uninhabited(data21, out22); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::adaptors", (_232: rt.u8, data22: rt.ByteSlice, out23: rt.ByteVec): undefined => { + adaptors(data22, out23); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } diff --git a/ts/fixtures/lang/shapes/src/fmt.rs b/ts/fixtures/lang/shapes/src/fmt.rs index 221a65b9e..eb4f8031d 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -944,6 +944,195 @@ pub fn iters(data: &[u8], out: &mut Vec) { put(out, &format!("{it:?}")); } +/// std's iterator adaptors' `Debug`, each its fields in std's order through what it wraps, +/// with no closure: consumed from either end, so each writes the state it keeps, as a +/// `Peekable` its peeked item and a `Skip` what it has left to skip, plain and pretty. +pub fn adaptors(data: &[u8], out: &mut Vec) { + let at = |i: usize| data.get(i).copied().unwrap_or(0); + let (front, back) = (usize::from(at(0) % 4), usize::from(at(1) % 3)); + fn ends(mut it: I, front: usize, back: usize) -> I { + for _ in 0..front { + it.next(); + } + for _ in 0..back { + it.next_back(); + } + it + } + fn fronts(mut it: I, front: usize) -> I { + for _ in 0..front { + it.next(); + } + it + } + let bytes = &data[..data.len().min(6)]; + + // Those that write only what they wrap. + let it = ends(bytes.iter().map(|b| b + 1), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:x?}")); + let it = ends(bytes.iter().filter(|&&b| b % 2 == 0), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let it = ends(bytes.iter().filter_map(|&b| b.checked_sub(9)), front, back); + put(out, &format!("{it:?}")); + let it = ends(bytes.iter().inspect(|_| {}), front, back); + put(out, &format!("{it:?}")); + let it = fronts(bytes.iter().map_while(|&b| b.checked_sub(3)), front); + put(out, &format!("{it:?}")); + let it = ends(bytes.iter().rev(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let it = ends(bytes.iter().copied(), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:02x?}")); + let it = ends(bytes.iter().cloned(), front, back); + put(out, &format!("{it:?}")); + let words: Vec = bytes.iter().map(|b| b.to_string()).collect(); + let it = ends(words.iter().cloned(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let pairs: Vec<[u8; 2]> = data.chunks_exact(2).take(3).map(|c| [c[0], c[1]]).collect(); + let it = ends(pairs.iter().copied(), front, back); + put(out, &format!("{it:?}")); + + // Those that write a count, a flag, or a state beside it. + let it = ends(bytes.iter().enumerate(), front, back); + put(out, &format!("{it:?}|{it:#?}|{it:x?}")); + let mut it = bytes.iter().skip(at(2).into()); + put(out, &format!("{it:?}|{it:#?}")); + it.next_back(); + put(out, &format!("{it:?}")); + it.next(); + put(out, &format!("{it:?}")); + let it = ends(bytes.iter().take(usize::from(at(2) % 8)), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let mut it = bytes.iter().skip_while(|&&b| b % 3 != 0); + put(out, &format!("{it:?}")); + it.next(); + put(out, &format!("{it:?}|{it:#?}")); + let mut it = bytes.iter().take_while(|&&b| b % 5 != 0); + put(out, &format!("{it:?}")); + for _ in 0..front { + it.next(); + } + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts( + bytes.iter().scan(0u32, |sum, &b| { + *sum += u32::from(b); + Some(*sum) + }), + front, + ); + put(out, &format!("{it:?}|{it:#?}|{it:x?}")); + let it = fronts( + bytes.iter().scan(String::new(), |s, &b| { + s.push(char::from(b'a' + b % 26)); + (b % 7 != 0).then(|| s.len()) + }), + front, + ); + put(out, &format!("{it:?}")); + + // A peeked item, `None` peeked, and none peeked. + let mut it = ends(bytes.iter().peekable(), front, back); + put(out, &format!("{it:?}")); + it.peek(); + put(out, &format!("{it:?}|{it:#?}")); + it.next(); + put(out, &format!("{it:?}")); + let mut it = bytes[..bytes.len().min(1)].iter().peekable(); + it.next(); + it.peek(); + put(out, &format!("{it:?}|{it:#?}")); + + // Both halves, until each runs out from its end. + let it = ends( + bytes[..2.min(bytes.len())].iter().chain(&bytes[2.min(bytes.len())..]), + front, + back, + ); + put(out, &format!("{it:?}|{it:#?}")); + let mut it = bytes[..1.min(bytes.len())].iter().chain([7u8, 8].iter()); + it.next_back(); + it.next_back(); + it.next_back(); + put(out, &format!("{it:?}")); + // A zip of two that read by index writes no field; another writes both. + let it = ends(bytes.iter().zip(data.iter().map(|b| b ^ 1)), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let it = ends(bytes.iter().zip(bytes.iter().rev()), front, back); + put(out, &format!("{it:?}")); + let text: String = bytes + .iter() + .map(|&b| ['a', 'é', '中', '🦀'][usize::from(b % 4)]) + .collect(); + let it = fronts(text.chars().zip(bytes.iter()), front); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts(bytes.iter().cycle(), front + usize::from(at(2) % 8)); + put(out, &format!("{it:?}|{it:#?}")); + + // What a `fuse` keeps of a `FusedIterator` past its end, and drops of another. + let it = fronts(bytes.iter().fuse(), front + 6); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts(bytes.iter().step_by(2).fuse(), front + 2); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts(bytes.iter().map_while(|&b| (b % 4 != 0).then_some(b)).fuse(), front * 2); + put(out, &format!("{it:?}")); + + // A step through a slice, and through ranges, std counting down the end of an unsigned + // one no wider than a `usize`. + let step = usize::from(at(3) % 4) + 1; + let it = ends(bytes.iter().step_by(step), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let (lo, hi) = (at(4) % 16, at(5)); + let it = ends((lo..hi).step_by(step), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts((u32::from(lo)..u32::from(hi)).step_by(step), front); + put(out, &format!("{it:?}")); + let it = ends((usize::from(lo)..usize::from(hi)).step_by(step), front, back); + put(out, &format!("{it:?}|{it:x?}")); + let it = ends((u16::from(lo)..u16::from(hi)).step_by(step), front, back); + put(out, &format!("{it:?}")); + let it = ends((i32::from(lo)..i32::from(hi)).step_by(step), front, back); + put(out, &format!("{it:?}")); + let it = fronts((u64::from(lo)..u64::from(hi)).step_by(step), front); + put(out, &format!("{it:?}")); + // A step past the type's greatest, and a start that wraps past it. + let it = fronts((250u8..255).step_by(300), front); + put(out, &format!("{it:?}")); + let it = fronts((250u8..255).step_by(usize::from(at(3)) + 1), front); + put(out, &format!("{it:?}")); + let it = fronts((hi..255).step_by(step + 200), front); + put(out, &format!("{it:?}")); + + // Each source item's iterator, from the front and the back. + let lists: Vec> = bytes.chunks(2).map(<[u8]>::to_vec).collect(); + let it = ends(lists.iter().flatten(), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let it = ends(lists.iter().flat_map(|v| v.iter()), front, back); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts(lists.iter().flatten().fuse(), front + 6); + put(out, &format!("{it:?}")); + + // What a unit after a leading surrogate leaves buffered. + let units: Vec = bytes + .iter() + .map(|&b| [0x61, 0xd800, 0xdc00, 0xe9, 0xdbff][usize::from(b % 5)]) + .collect(); + let it = fronts(char::decode_utf16(units.iter().copied()), front); + put(out, &format!("{it:?}|{it:#?}|{it:x?}")); + let it = fronts(char::decode_utf16(vec![0xd800, 0x61, 0x62]), usize::from(at(2) % 3)); + put(out, &format!("{it:?}")); + + // Adaptors of adaptors, with every option passed down. + let it = ends( + bytes.iter().map(|&b| Pair(b, -1)).enumerate().skip(1).rev().take(3), + front, + back, + ); + put(out, &format!("{it:?}|{it:#?}|{it:>4?}")); + let mut it = bytes.iter().copied().peekable(); + it.peek(); + let it = it.zip(1u8..).filter(|p| p.0 != 0).chain(vec![(9, 9)]); + put(out, &format!("{it:?}|{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/shapes/src/lib.rs b/ts/fixtures/lang/shapes/src/lib.rs index e8120ef3d..84efeeb25 100644 --- a/ts/fixtures/lang/shapes/src/lib.rs +++ b/ts/fixtures/lang/shapes/src/lib.rs @@ -49,5 +49,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("shapes::order", |_, data, out| shapes::order(data, out)), ("shapes::flows", |_, data, out| shapes::flows(data, out)), ("shapes::uninhabited", |_, data, out| shapes::uninhabited(data, out)), + ("fmt::adaptors", |_, data, out| fmt::adaptors(data, out)), ] } diff --git a/ts/fixtures/lang/sorts/expected/sorts.ts b/ts/fixtures/lang/sorts/expected/sorts.ts index b12bf7d97..fdeace44f 100644 --- a/ts/fixtures/lang/sorts/expected/sorts.ts +++ b/ts/fixtures/lang/sorts/expected/sorts.ts @@ -51,7 +51,7 @@ export function put$Cell_u32(v: Item.Item>[], out: rt.ByteVec): } else { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item>): Uint8Array => { return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } @@ -71,7 +71,7 @@ export function put$array10_u32(v: Item.Item[], out: rt.ByteVec): void } else { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } @@ -91,7 +91,7 @@ export function put$array1100_u32(v: Item.Item[], out: rt.ByteVec): vo } else { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } @@ -111,7 +111,7 @@ export function put$array22_u32(v: Item.Item[], out: rt.ByteVec): void } else { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } @@ -131,7 +131,7 @@ export function put$array30_u32(v: Item.Item[], out: rt.ByteVec): void } else { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } @@ -151,7 +151,7 @@ export function put$sorts_Held(v: Item.Item[], out: rt.ByteVec): void } else { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } @@ -171,7 +171,7 @@ export function put$unit(v: Item.Item[], out: rt.ByteVec): void { } else { rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } } diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 51075ffc1..468e78994 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -1503,7 +1503,7 @@ export function hinted(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { _70 = rt.usizeAdd(1, rt.usizeRem(m as rt.usize, 2)); } - const _67: rt.Iter = rt.iterMap(rt.iterStepBy(_69, _70), f); + const _67: rt.Iter = rt.iterMap(rt.iterStepBy(_69, _70, undefined, 4294967295), f); _66.v = rt.stringExtendChars(_66.v, _67); } else if (_38 === 5) { if (rt.u32Rem(m, 2) === 0) { @@ -1521,7 +1521,7 @@ export function hinted(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _91: rt.Place = rt.place(() => t, (value7) => t = value7); const _92: rt.Iter = rt.iterFlatMap(new rt.Range(0, n), (i2: rt.u32): rt.char[] => { return [f(i2), f(i2)]; - }, (value: rt.char[]) => rt.iterSlice(value), false, 2); + }, (value: rt.char[]) => rt.iterSlice(value), true, 2); _91.v = rt.stringExtendChars(_91.v, _92); } else if (_38 === 7) { const _96: rt.Place = rt.place(() => t, (value6) => t = value6); @@ -1551,7 +1551,7 @@ export function hinted(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const chars: rt.Peekable = rt.iterPeekable(rt.iterFuse(rt.iterRev(rt.iterMap(rt.iterEnumerate(rt.iterMap(new rt.Range(0, n), f)), (_23: [rt.usize, rt.char]): rt.char => { return _23[1]; - })))); + })), true)); putChar(out, rt.peekablePeek(chars)); const _172: rt.Place = rt.place(() => t, (value2) => t = value2); _172.v = rt.stringExtendChars(_172.v, chars); diff --git a/ts/fixtures/lang/tuples/expected/tuples.ts b/ts/fixtures/lang/tuples/expected/tuples.ts index 4a5214c0b..45d96dd23 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.ts @@ -32,7 +32,7 @@ export function entries(map: rt.HashMap, out: rt.ByteVec): void { }); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _5, true, undefined, undefined, "next", 2)), (_22: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_22[0], _22[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } /** Collected, unzipped, or extended as `kind` picks, from at most 24 bytes of `data`. */ @@ -75,7 +75,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { return [(((_2 as rt.u16)) << 4) & 0xffff] as [rt.u16]; }), (c, items) => rt.iterExtend(c, items, undefined, 2, true))[0]), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(rt.tupleExtendOne([""] as [string], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [rt.char] => { return [_24 as rt.char] as [rt.char]; }), (c2, items2) => rt.stringExtendChars(c2, items2))[0]), undefined, true); @@ -163,7 +163,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const _33: rt.Iter<[undefined, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): [undefined, rt.u8] => { return [undefined, _210] as [undefined, rt.u8]; }); @@ -179,7 +179,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const q2: rt.VecDeque = _38[1]; rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v4), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.dequeIntoIter(q2), undefined, true); } @@ -196,7 +196,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); const _22: rt.Iter<[[rt.u8, rt.u8], [rt.u8, rt.u16], rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [[rt.u8, rt.u8], [rt.u8, rt.u16], rt.u8] => { const b2: rt.u8 = _24; @@ -209,7 +209,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { entries(map, out); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_25: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_25[0], _25[1] & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); const _35: rt.Iter<[rt.u8, [rt.char, rt.u16]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8, [rt.char, rt.u16]] => { const b3: rt.u8 = _26; @@ -223,7 +223,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const _50: rt.Iter<[rt.u8, [rt.u8]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): [rt.u8, [rt.u8]] => { const b4: rt.u8 = _29; return [b4, [rt.u8Div(b4, 32)] as [rt.u8]] as [rt.u8, [rt.u8]]; @@ -270,7 +270,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(wide), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(chars), undefined, true); rt.iterExtendBytes(out, rt.strBytes(texts), undefined, true); rt.iterExtendBytes(out, rt.dequeIntoIter(q), undefined, true); @@ -282,7 +282,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { return rt.bytesMap(rt.u16ToBeBytes(_210[1]).reverse(), (x: rt.u8): rt.u8 => { return x ^ k; }); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(keys), undefined, true); rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); @@ -308,10 +308,10 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_22: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); sorted(set, out); const t2: [rt.BinaryHeap, rt.HashMap] = [rt.heapFrom(rt.iterToArray(rt.iterSlice(Uint8Array.of(7, 200, 30)), undefined, 1, true), rt.le, rt.ge, rt.lt), rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[1, 1] as [rt.u8, rt.u8]]), undefined, undefined, undefined, 469762048)]; const _45: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): [rt.u8, [rt.u8, rt.u8]] => { @@ -356,7 +356,7 @@ export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterChain(rt.iterSlice(copied), rt.iterSlice(ones[0])), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); entries(map, out); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(points), (p3: Spot.Spot): rt.u8 => { @@ -463,7 +463,7 @@ export function panicked(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); } /** @@ -543,7 +543,7 @@ export function shunted(data: rt.ByteSlice, out: rt.ByteVec): void { const tree: rt.BTreeSet = found[1]; rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v2), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree), undefined, true); } } @@ -634,7 +634,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, t3.sum); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); calls(out); const _63: rt.Iter<[rt.u8, rt.char, rt.u8]> = rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (b10: rt.u8): undefined => { made(b10); diff --git a/ts/fixtures/lang/zeros/expected/zeros.ts b/ts/fixtures/lang/zeros/expected/zeros.ts index c1f3ddf9b..e6dbe44f7 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.ts @@ -91,7 +91,7 @@ export function zeros(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 0, true).length & 0xff); rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): Unit.Unit[] => { return [{}, {}, {}]; - }), (value: Unit.Unit[]) => rt.iterSlice(value), false, 3)) & 0xff); + }), (value: Unit.Unit[]) => rt.iterSlice(value), true, 3)) & 0xff); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): Pair.Pair => { return pair(); }), (p: Pair.Pair): boolean => { @@ -451,7 +451,7 @@ export function flattened(_value: undefined, xs: rt.ByteVec[]): rt.u8 { if (false) { return 0; } - return rt.iterCount(rt.iterFlatten(rt.iterSlice(xs), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)))) & 0xff; + return rt.iterCount(rt.iterFlatten(rt.iterSlice(xs), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true)) & 0xff; } /** diff --git a/ts/fixtures/share/expected/harness.ts b/ts/fixtures/share/expected/harness.ts index c1d776e6b..52a0a6f1a 100644 --- a/ts/fixtures/share/expected/harness.ts +++ b/ts/fixtures/share/expected/harness.ts @@ -29,7 +29,7 @@ export function run(input: rt.ByteSlice): rt.ByteVec { rt.dequeExtend(deque, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, true); const _47: rt.Iter = rt.iterFlatMap(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (p: rt.ByteSlice): Uint8Array => { return Uint8Array.of(p.data[p.start], p.data[p.start + 1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2); rt.iterExtendBytes(out, _47, undefined, true); return out; } diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index b7bdcb61b..01a9cd661 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -438,7 +438,7 @@ export function ordered(log: Log.Log, id: rt.u32): void { return _06; })); }; - const iter3: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 3); + const iter3: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 3, undefined, 4294967295); while (true) { const _282: rt.u32 | rt.Done = iter3.next(); if (_282 === rt.DONE) { @@ -451,7 +451,7 @@ export function ordered(log: Log.Log, id: rt.u32): void { const _303: rt.usize = rt.btreeLen(many); const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_298, f), (f: rt.Formatter) => rt.usizeDisplay(_303, f)]; Log.note(log, rt.fmtFormat(["replaced ", args20[0], " ", args20[1]])); - const iter4: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 7); + const iter4: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 7, undefined, 4294967295); while (true) { const _314: rt.u32 | rt.Done = iter4.next(); if (_314 === rt.DONE) { @@ -465,7 +465,7 @@ export function ordered(log: Log.Log, id: rt.u32): void { const _336: rt.usize = rt.btreeLen(many); const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_331, f), (f: rt.Formatter) => rt.usizeDisplay(_336, f)]; Log.note(log, rt.fmtFormat(["taken ", args22[0], " ", args22[1]])); - const iter5: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 5); + const iter5: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 5, undefined, 4294967295); while (true) { const _347: rt.u32 | rt.Done = iter5.next(); if (_347 === rt.DONE) { diff --git a/ts/fixtures/task/expected/drops/indexed.ts b/ts/fixtures/task/expected/drops/indexed.ts index 323c16ad0..dbd413517 100644 --- a/ts/fixtures/task/expected/drops/indexed.ts +++ b/ts/fixtures/task/expected/drops/indexed.ts @@ -178,7 +178,7 @@ export function indexed(log: Log.Log, id: rt.u32, arg: rt.u8): void { _240[0][1][1][Symbol.dispose](); return _028; }); - f = rt.ownedCount(rt.iterZip(rt.iterFuse(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard)), new rt.Range(0, 1), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); + f = rt.ownedCount(rt.iterZip(rt.iterFuse(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), true), new rt.Range(0, 1), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n6, f), (f: rt.Formatter) => rt.fmtOption(e, f, (value: [rt.usize, rt.u32, rt.i32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.i32Debug(value[2], f)], f)), (f2: rt.Formatter) => rt.usizeDisplay(f, f2)]; Log.note(log, rt.fmtFormat(["adapted ", args32[0], " ", args32[1], " ", args32[2]])); } else if (_16 === 5) { diff --git a/ts/runtime/rt/char.ts b/ts/runtime/rt/char.ts index 3767de5b9..62427df29 100644 --- a/ts/runtime/rt/char.ts +++ b/ts/runtime/rt/char.ts @@ -4,7 +4,7 @@ // Each reads std's own Unicode tables, which `rt/unicode.ts` holds, rather than the // engine's, whose Unicode version may differ from std's. -import { type ByteSlice, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugTuple, fmtPad, fmtUnit, Ok, type Place, panic, type Result, sliceView } from "../rt.ts"; +import { type ByteSlice, type Debug, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugStructFields, fmtDebugTuple, fmtOption, fmtPad, fmtUnit, Ok, type Place, panic, type Result, sliceView } from "../rt.ts"; import { type char, type u8, type u16, u16Debug, type u32, type usize } from "./int.ts"; import { type Clones, DONE, type Done, Iter, type SizeHint } from "./iter.ts"; import { drop as dispose } from "./task.ts"; @@ -372,31 +372,37 @@ export function charDecodeUtf16(it: Iter): Iter(it: Iter, f: Formatter, inner: Debug): FmtResult { + const d = it as DecodeUtf16; + return fmtDebugStructFields(f, "DecodeUtf16", ["iter", "buf"], [(f) => inner(d.it as I, f), (f) => fmtOption(d.buf, f, u16Debug)]); +} + /** `char::DecodeUtf16`: `it`, and the unit after a leading surrogate that was no trailing one, which it reads next. */ class DecodeUtf16 extends Iter> implements Disposable { - readonly #it: Iter; - #buf: u16 | undefined; + readonly it: Iter; + buf: u16 | undefined; constructor(it: Iter, buf?: u16) { super(); - this.#it = it; - this.#buf = buf; + this.it = it; + this.buf = buf; } next(): Result | Done { - let u = this.#buf; - this.#buf = undefined; + let u = this.buf; + this.buf = undefined; if (u === undefined) { - const next = this.#it.next(); + const next = this.it.next(); if (next === DONE) return DONE; u = next; } if (u < 0xd800 || u > 0xdfff) return Ok(u as number as char); if (u >= 0xdc00) return Err(new DecodeUtf16Error(u)); - const u2 = this.#it.next(); + const u2 = this.it.next(); if (u2 === DONE) return Err(new DecodeUtf16Error(u)); if (u2 < 0xdc00 || u2 > 0xdfff) { - this.#buf = u2; + this.buf = u2; return Err(new DecodeUtf16Error(u)); } return Ok((((u & 0x3ff) << 10) + (u2 & 0x3ff) + 0x10000) as char); @@ -404,19 +410,19 @@ class DecodeUtf16 extends Iter> implements Dispos /** std's: half `it`'s lower bound, rounded up, and its upper bound, each with the unit it holds. */ override sizeHint(): SizeHint { - const [low, high] = this.#it.sizeHint(); - const u = this.#buf; + const [low, high] = this.it.sizeHint(); + const u = this.buf; const [lowBuf, highBuf] = u === undefined ? [0, 0] : u < 0xd800 || u > 0xdfff || high === 0 ? [1, 1] : [0, 1]; const upper = high === undefined || high + highBuf > 0xffffffff ? undefined : high + highBuf; return [Math.ceil(low / 2) + lowBuf, upper]; } override clone(h?: Clones): DecodeUtf16 { - return new DecodeUtf16(this.#it.clone(h?.i), this.#buf); + return new DecodeUtf16(this.it.clone(h?.i), this.buf); } [Symbol.dispose](): void { - dispose(this.#it); + dispose(this.it); } } diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index fd4d1d62c..066623587 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -22,10 +22,10 @@ // `owned` functions follow it, dispatching on the kind, so a bundle that never drops an // item carries none of it. -import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, type Capped, capHold, capOf, capReserve, capSet, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, slicePart, sliceView, vecCapacity, vecExtendFromSlice, vecMax, vecWithCapacity } from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, type Capped, capHold, capOf, capReserve, capSet, type Debug, Err, type Fmt, type FmtResult, type Formatter, fmtBool, fmtDebugStructFields, fmtDebugTupleFields, fmtOption, type None, Ok, type Place, panic, place, type RangeBound, type Result, slicePart, sliceView, vecCapacity, vecExtendFromSlice, vecMax, vecWithCapacity } from "../rt.ts"; import { AtIndex, BTreeIter, HashIter, type Ordering } from "./collections.ts"; import { type Hasher, hash8 } from "./hash.ts"; -import { charStep, intToBig, type Limbs, lt as wideLt, type Step } from "./int.ts"; +import { charStep, intToBig, type Limbs, type Step, usizeDebug, lt as wideLt } from "./int.ts"; import { closure, drop as dispose, dropRange } from "./task.ts"; /** What `next` returns once an iterator is exhausted, which no item is. */ @@ -871,9 +871,17 @@ export function iterScan(it: Iter, state: S, f: (state: never, item: return new ScanIter(it, state, f, copied, drop, none); } -/** `Iterator::step_by`, panicking on a step of 0, and dropping what it steps over by `drop`. */ -export function iterStepBy(it: Iter, step: number, drop?: Drop): Iter { - return new StepByIter(it, step, drop); +/** + * `Iterator::step_by`, panicking on a step of 0, and dropping what it steps over by `drop`. + * Of a `Range` of an unsigned integer no wider than a `usize`, whose greatest is `max`, it + * counts down the range's end, as std's specializes it to. + */ +export function iterStepBy(it: Iter, step: number, drop?: Drop, max?: number): Iter { + if (max === undefined) return new StepByIter(it, step, drop); + if (step === 0) panic("assertion failed: step != 0"); + const range = it as never as Range; + range.end = Math.ceil(range.sizeHint()[0] / step); + return new RangeStepBy(range, step - 1, max) as never as Iter; } /** @@ -920,7 +928,7 @@ export function iterPeekable(it: Iter, drop?: Drop): Peekable { * source drops once it ends unless it is `fused`, as `fuse` does. `size` and `oneShot` * are as `flatten`'s. */ -export function iterFlatMap(it: Iter, f: (item: T) => Iter): Iter; +export function iterFlatMap(it: Iter, f: (item: T) => Iter, into?: undefined, fused?: boolean, size?: number, oneShot?: boolean): Iter; export function iterFlatMap(it: Iter, f: (item: T) => U, into?: (value: U) => Iter, fused?: boolean, size?: number, oneShot?: boolean): Iter; export function iterFlatMap(it: Iter, f: (item: T) => U, into?: (value: U) => Iter, fused = false, size?: number, oneShot = false): Iter { return new FlattenIter(new MapIter(it, f), into ?? (itself as (value: U) => Iter), fused, size, oneShot); @@ -931,12 +939,100 @@ export function iterFlatMap(it: Iter, f: (item: T) => U, into?: (val * `flat_map`'s, `size` is each item's length if it is an array, and `oneShot` says each * item's iterator has at most one item, as std's size hint specializes on. */ -export function iterFlatten(it: Iter>): Iter; +export function iterFlatten(it: Iter>, into?: undefined, fused?: boolean, size?: number, oneShot?: boolean): Iter; export function iterFlatten(it: Iter, into?: (value: T) => Iter, fused?: boolean, size?: number, oneShot?: boolean): Iter; export function iterFlatten(it: Iter, into?: (value: T) => Iter, fused = false, size?: number, oneShot = false): Iter { return new FlattenIter(it, into ?? (itself as (value: T) => Iter), fused, size, oneShot); } +// Debug. Each writes what std's `Debug` of an adaptor writes: its fields in std's order, +// each iterator it wraps, an `I`, by the function given for its type, and no closure. + +/** `Debug` of an adaptor std writes as the iterator it wraps alone, under `field`. */ +export function fmtAdaptor(it: Iter, f: Formatter, name: string, inner: Debug, field = "iter"): FmtResult { + return fmtDebugStructFields(f, name, [field], [(f) => inner((it as Adaptor).inner as I, f)]); +} + +/** `Debug` of an `Enumerate`: its iterator and the index it yields next. */ +export function fmtEnumerate(it: Iter, f: Formatter, inner: Debug): FmtResult { + const e = it as EnumerateIter; + return fmtDebugStructFields(f, "Enumerate", ["iter", "count"], [(f) => inner(e.inner as I, f), (f) => usizeDebug(e.index, f)]); +} + +/** `Debug` of a `Skip` or a `Take`, `name`: its iterator and how many it has left to skip or take. */ +export function fmtCounted(it: Iter, f: Formatter, name: string, inner: Debug): FmtResult { + const c = it as SkipIter | TakeIter; + return fmtDebugStructFields(f, name, ["iter", "n"], [(f) => inner(c.inner as I, f), (f) => usizeDebug(c.n, f)]); +} + +/** `Debug` of a `SkipWhile` or a `TakeWhile`, `name`: its iterator and whether its closure has failed. */ +export function fmtFlagged(it: Iter, f: Formatter, name: string, inner: Debug): FmtResult { + const w = it as SkipWhileIter | TakeWhileIter; + return fmtDebugStructFields(f, name, ["iter", "flag"], [(f) => inner(w.inner as I, f), (f) => fmtBool(w.flag, f)]); +} + +/** `Debug` of a `Scan`: its iterator and its state, by `state`. */ +export function fmtScan(it: Iter, f: Formatter, inner: Debug, state: Debug): FmtResult { + const s = it as ScanIter; + return fmtDebugStructFields(f, "Scan", ["iter", "state"], [(f) => inner(s.inner as I, f), (f) => state(s.state, f)]); +} + +/** `Debug` of a `Peekable`: its iterator and what it peeked, `Some` of the item by `item` or of `None`. */ +export function fmtPeekable(it: Peekable, f: Formatter, inner: Debug, item: Debug): FmtResult { + const some = (f: Formatter, value: Fmt): FmtResult => fmtDebugTupleFields(f, "Some", [value]); + const peeked = (f: Formatter): FmtResult => { + if (!it.peeked) return f.out.writeStr("None"); + const held = it.item; + return some(f, (f) => (held === DONE ? f.out.writeStr("None") : some(f, (f) => item(held, f)))); + }; + return fmtDebugStructFields(f, "Peekable", ["iter", "peeked"], [(f) => inner(it.inner as I, f), peeked]); +} + +/** `Debug` of a `StepBy`: its iterator, its step less one, and whether it has yet to take its first item. */ +export function fmtStepBy(it: Iter, f: Formatter, inner: Debug): FmtResult { + const s = it as StepByIter | RangeStepBy; + const fields = [(f: Formatter) => inner(s.inner as I, f), (f: Formatter) => usizeDebug(s.step, f), (f: Formatter) => fmtBool(s.firstTake, f)]; + return fmtDebugStructFields(f, "StepBy", ["iter", "step_minus_one", "first_take"], fields); +} + +/** `Debug` of a `Chain`: each of its iterators, by `a` and `b`, until it has dropped it. */ +export function fmtChain(it: Iter, f: Formatter, a: Debug, b: Debug): FmtResult { + const c = it as ChainIter; + return fmtDebugStructFields(f, "Chain", ["a", "b"], [(f) => fmtOption(c.a as A | undefined, f, a), (f) => fmtOption(c.b as B | undefined, f, b)]); +} + +/** + * `Debug` of a `Zip`: each of its iterators, by `a` and `b`, or neither, as std's writes a + * zip of two `TrustedRandomAccessNoCoerce` ones, without them. + */ +export function fmtZip(it: Iter, f: Formatter, a?: Debug, b?: Debug): FmtResult { + const z = it as ZipIter; + if (a === undefined || b === undefined) return fmtDebugStructFields(f, "Zip", [], []); + return fmtDebugStructFields(f, "Zip", ["a", "b"], [(f) => a(z.a as A, f), (f) => b(z.b as B, f)]); +} + +/** `Debug` of a `Cycle`: the iterator as it was, and the one it reads. */ +export function fmtCycle(it: Iter, f: Formatter, inner: Debug): FmtResult { + const c = it as CycleIter; + return fmtDebugStructFields(f, "Cycle", ["orig", "iter"], [(f) => inner(c.orig as I, f), (f) => inner(c.iter as I, f)]); +} + +/** `Debug` of a `Fuse`: its iterator, until it has dropped it. */ +export function fmtFuse(it: Iter, f: Formatter, inner: Debug): FmtResult { + return fmtDebugStructFields(f, "Fuse", ["iter"], [(f) => fmtOption((it as FuseIter).inner as I | undefined, f, inner)]); +} + +/** + * `Debug` of a `Flatten` or a `FlatMap`, `name`: its `FlattenCompat`, of its source fused, + * by `source`, and the iterators it reads from the front and the back, by `inner`. + */ +export function fmtFlatten(it: Iter, f: Formatter, name: string, source: Debug, inner: Debug): FmtResult { + const flat = it as FlattenIter; + const fused = (f: Formatter): FmtResult => fmtDebugStructFields(f, "Fuse", ["iter"], [(f) => fmtOption(flat.outer as S | undefined, f, source)]); + const fields = [fused, (f: Formatter) => fmtOption(flat.front as I | undefined, f, inner), (f: Formatter) => fmtOption(flat.back as I | undefined, f, inner)]; + return fmtDebugStructFields(f, name, ["inner"], [(f) => fmtDebugStructFields(f, "FlattenCompat", ["iter", "frontiter", "backiter"], fields)]); +} + // Consumers. Each that takes an iterator by value that `drops` takes it as std's does: by // its own `fold` where std's folds, which drops what it holds as it goes, or as `take` // says, and else by `next`, dropping it once done. @@ -3494,7 +3590,7 @@ class TakeIter extends Adaptor { class SkipWhileIter extends Calling boolean> { private readonly drop: Drop | undefined; - private flag = false; + flag = false; constructor(inner: Iter, f: (item: T) => boolean, drop?: Drop) { super(inner, f); @@ -3551,7 +3647,7 @@ class SkipWhileIter extends Calling boolean> { class TakeWhileIter extends Calling boolean> { private readonly drop: Drop | undefined; - private flag = false; + flag = false; constructor(inner: Iter, f: (item: T) => boolean, drop?: Drop) { super(inner, f); @@ -3625,7 +3721,7 @@ class MapWhileIter extends Calling U | undefined | None * returns `None`: its `next` reads on after, but a fold, by `try_fold`, stops there. */ class ScanIter extends Calling U | undefined | None> { - private state: S; + state: S; private readonly at: S | Place; private readonly drop: Drop | undefined; /** The `Option`'s `None` that `f` returns. */ @@ -3801,6 +3897,53 @@ class StepByIter extends Adaptor { } } +/** + * std's `StepBy` of a `Range` of an unsigned integer no wider than a `usize`, whose + * greatest is `max`: its range's end counts the items it has left, and its start is the + * next from the front, which steps past `max` back to 0 only once it has none left. + */ +class RangeStepBy extends Adaptor { + declare readonly inner: Range; + readonly step: number; + readonly firstTake = true; + private readonly max: number; + + /** Of `inner`, whose end already counts its items, by a step of `step` and one. */ + constructor(inner: Range, step: number, max: number) { + super(inner); + this.step = step; + this.max = max; + } + + override clone(): Iter { + return new RangeStepBy(this.inner.clone(), this.step, this.max); + } + + next(): number | Done { + const r = this.inner; + if (r.end === 0) return DONE; + const item = r.start; + r.start = (item + Math.min(this.step + 1, this.max)) % (this.max + 1); + r.end--; + return item; + } + + override nextBack(): number | Done { + const r = this.inner; + if (r.end === 0) return DONE; + r.end--; + return r.start + (this.step + 1) * r.end; + } + + override len(): number { + return this.inner.end; + } + + override sizeHint(): SizeHint { + return exactHint(this.inner.end); + } +} + /** * std's `Cycle`: `iter`, read, and `orig`, the iterator as it was, which it clones by `h` * in place of `iter` each time that ends. It drops `orig` and then `iter`, as std's fields diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 69f65346d..ba1eb855f 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -339,6 +339,12 @@ pub fn std_impl<'tcx>( { e } + ty::Adt(adt, args) + if tr == Trait::Debug + && let Some(e) = adaptor_debug(b, adt.did(), args, &value, &f, span, out) => + { + 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]), @@ -626,6 +632,104 @@ fn iter_debug<'tcx>( Some(Expr::rt("fmtIter", call)) } +/// `Debug` of one of std's iterator adaptors, as std's derived or written impl writes it: +/// its fields in order, each iterator it wraps by that iterator's own `Debug`, and none of +/// its closures; or `None` for another type. +fn adaptor_debug<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + did: DefId, + args: ty::GenericArgsRef<'tcx>, + value: &Expr, + f: &Expr, + span: Span, + out: &mut Vec, +) -> Option { + let tcx = b.t.tcx; + let path = library::std_path(tcx, did); + let path: Vec<&str> = path.iter().map(String::as_str).collect(); + let arg = |n: usize| args.types().nth(n); + let call = |name: &str, rest: Vec| Expr::rt(name, [vec![value.clone(), f.clone()], rest].concat()); + let name = |name: &str| Expr::Str(name.into()); + Some(match path.as_slice() { + [ + "iter", + "adapters", + _, + adaptor @ ("Map" | "Filter" | "FilterMap" | "Inspect" | "MapWhile" | "Rev"), + ] => call("fmtAdaptor", vec![name(adaptor), b.fmt_fn(Trait::Debug, arg(0)?, span)]), + // A `copied` that JS reads its items as is is its iterator itself. + ["iter", "adapters", "copied", "Copied"] + if let ty::Ref(_, item, _) = b.t.iter_item(arg(0)?)?.kind() + && super::iter::copies_itself(b.t, *item) => + { + let it = b.fmt_value(Trait::Debug, arg(0)?, value.clone(), span, out); + let call = vec![ + f.clone(), + name("Copied"), + Expr::Array(vec![name("it")]), + Expr::Array(vec![it]), + ]; + Expr::rt_of("fmt", "debugStructFields").call(call) + } + ["iter", "adapters", _, adaptor @ ("Copied" | "Cloned")] => { + let inner = b.fmt_fn(Trait::Debug, arg(0)?, span); + call("fmtAdaptor", vec![name(adaptor), inner, name("it")]) + } + ["iter", "adapters", "enumerate", "Enumerate"] => { + call("fmtEnumerate", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]) + } + ["iter", "adapters", _, adaptor @ ("Skip" | "Take")] => { + call("fmtCounted", vec![name(adaptor), b.fmt_fn(Trait::Debug, arg(0)?, span)]) + } + ["iter", "adapters", _, adaptor @ ("SkipWhile" | "TakeWhile")] => { + call("fmtFlagged", vec![name(adaptor), b.fmt_fn(Trait::Debug, arg(0)?, span)]) + } + ["iter", "adapters", "scan", "Scan"] => { + let inner = b.fmt_fn(Trait::Debug, arg(0)?, span); + call("fmtScan", vec![inner, b.fmt_fn(Trait::Debug, arg(1)?, span)]) + } + ["iter", "adapters", "peekable", "Peekable"] => { + let inner = b.fmt_fn(Trait::Debug, arg(0)?, span); + let item = b.t.iter_item(arg(0)?)?; + call("fmtPeekable", vec![inner, b.fmt_fn(Trait::Debug, item, span)]) + } + ["iter", "adapters", "step_by", "StepBy"] => call("fmtStepBy", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + ["iter", "adapters", "chain", "Chain"] => { + let a = b.fmt_fn(Trait::Debug, arg(0)?, span); + call("fmtChain", vec![a, b.fmt_fn(Trait::Debug, arg(1)?, span)]) + } + // std's specializes it to write neither of two it reads by index. + ["iter", "adapters", "zip", "Zip"] => { + let (a, other) = (arg(0)?, arg(1)?); + match [a, other] + .iter() + .all(|&ty| super::iter::implements(b.t, ty, "TrustedRandomAccessNoCoerce")) + { + true => call("fmtZip", Vec::new()), + false => { + let a = b.fmt_fn(Trait::Debug, a, span); + call("fmtZip", vec![a, b.fmt_fn(Trait::Debug, other, span)]) + } + } + } + ["iter", "adapters", "cycle", "Cycle"] => call("fmtCycle", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + ["iter", "adapters", "fuse", "Fuse"] => call("fmtFuse", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + // Its `FlattenCompat`'s source and the iterator of each item, as its field's type + // names them. + ["iter", "adapters", "flatten", adaptor @ ("Flatten" | "FlatMap")] => { + let field = tcx.adt_def(did).non_enum_variant().fields.iter().next()?; + let ty::Adt(_, compat) = b.t.field_ty(field.did, args).kind() else { + return None; + }; + let source = b.fmt_fn(Trait::Debug, compat.type_at(0), span); + let inner = b.fmt_fn(Trait::Debug, compat.type_at(1), span); + call("fmtFlatten", vec![name(adaptor), source, inner]) + } + ["char", "decode", "DecodeUtf16"] => call("fmtDecodeUtf16", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + _ => return None, + }) +} + /// 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 b5172fe2f..6112de491 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -1039,7 +1039,24 @@ pub fn call<'tcx>( method(&camel, [rest, none.into_iter().collect()].concat()) } // What each drops: an item it skips or rejects, or one it peeked. - "filter" | "skip_while" | "take_while" | "peekable" | "skip" | "take" | "step_by" => { + // std's specializes a step through a `Range` of an unsigned integer no wider than a + // `usize`, which on wasm32 is a `u8`, a `u16`, a `u32`, or a `usize`, to count down + // the range's end: the runtime is given the integer's greatest. + "step_by" => { + let dropper = b.t.dropper(item, span); + let max = match self_ty.kind() { + ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Range) => match args.type_at(0).kind() { + ty::Uint(uint) => match uint.bit_width().unwrap_or(32) { + bits @ ..=32 => Expr::lit(((1u64 << bits) - 1).to_string()), + _ => Expr::undefined(), + }, + _ => Expr::undefined(), + }, + _ => Expr::undefined(), + }; + method("stepBy", tail(rest, vec![dropper, max])) + } + "filter" | "skip_while" | "take_while" | "peekable" | "skip" | "take" => { let dropper = b.t.dropper(item, span); // std's `take` folds a `TrustedRandomAccess` iterator by index, as `next` does // one that has no side effects. @@ -1049,7 +1066,7 @@ pub fn call<'tcx>( method(&camel, tail(rest, vec![dropper, Expr::lit(indexes.to_string())])) } "fuse" => { - let fused = fused(b, self_ty, None); + let fused = fused(b, self_ty); method(name, tail(rest, vec![fused])) } // What clones its iterator, as it is made and each time a clone of it ends. @@ -1272,7 +1289,7 @@ pub fn call<'tcx>( "flat_map" => { let inner = iter_of(b.t, targ(1)?)?; let into = into_fn(b, targ(1)?, span)?.unwrap_or_else(Expr::undefined); - let fused = fused(b, self_ty, Some(targ(2)?)); + let fused = fused(b, self_ty); let size = array_size(b, targ(1)?); let one_shot = Expr::lit(implements(b.t, inner, "OneShot").to_string()); method("flatMap", tail(rest, vec![into, fused, size, one_shot])) @@ -1280,7 +1297,7 @@ pub fn call<'tcx>( "flatten" => { let inner = iter_of(b.t, item)?; let into = into_fn(b, item, span)?.unwrap_or_else(Expr::undefined); - let fused = fused(b, self_ty, None); + let fused = fused(b, self_ty); let size = array_size(b, item); let one_shot = Expr::lit(implements(b.t, inner, "OneShot").to_string()); method("flatten", tail(Vec::new(), vec![into, fused, size, one_shot])) @@ -1293,6 +1310,9 @@ pub fn call<'tcx>( let clone = tcx.lang_items().clone_fn()?; Some(b.fn_value(clone, tcx.mk_args(&[(*inner).into()]), span)) }; + if name == "copied" && copies_itself(b.t, *inner) { + return Some(recv); + } // A `Clone` written by hand may do other than copy, even for a `Copy` type. A JS // string is a value already. let copies = name == "copied" @@ -1415,18 +1435,17 @@ pub(super) fn size_of<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span layout(b, ty, span).map_or_else(|e| e, |(size, _)| Expr::lit(size.to_string())) } +/// Whether `copied` of an iterator of `&inner`s is that iterator itself, as JS reads an +/// `inner` as its value already. +pub(super) fn copies_itself<'tcx>(t: &Translator<'_, 'tcx>, inner: Ty<'tcx>) -> bool { + !super::byte_array(inner) && !t.needs_copy(inner) +} + /// Whether an iterator of type `ty` is a `FusedIterator`, which std's `fuse` and `flatten` -/// keep once it ends rather than drop, and read on from: `true` or `false`. Only one that -/// drops, with `held` beside it, or holds an iterator of the crate's own, which may yield -/// again past its end, can tell. -fn fused<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, held: Option>) -> Expr { - let drops = b.t.drops(ty) || held.is_some_and(|held| b.t.drops(held)); - let own = (ty.walk().filter_map(|arg| arg.as_type())) - .any(|t| matches!(t.kind(), ty::Adt(adt, _) if b.t.own(adt.did())) && b.t.iter_item(t).is_some()); - Expr::lit(match (drops || own) && implements(b.t, ty, "FusedIterator") { - true => "true", - false => "false", - }) +/// keep once it ends rather than drop, as their `Debug` shows, and read on from: `true` or +/// `false`. +fn fused<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Expr { + Expr::lit(implements(b.t, ty, "FusedIterator").to_string()) } /// How many items `ty` has, if it is an array or a reference to one, which std's `flatten` From c0d41b0ac72cedee2713071ac5f756463a269642 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:25:25 -0800 Subject: [PATCH 03/11] fix(ts): write an adaptor's borrowed or own iterator as Rust holds it Co-Authored-By: Claude Opus 5.5 --- .../lang/shapes/expected/fmt.Countdown.ts | 28 ++++++ ts/fixtures/lang/shapes/expected/fmt.ts | 92 ++++++++++++++++--- ts/fixtures/lang/shapes/src/fmt.rs | 33 +++++++ ts/runtime/rt/char.ts | 4 +- ts/runtime/rt/iter.ts | 43 +++++---- 5 files changed, 171 insertions(+), 29 deletions(-) create mode 100644 ts/fixtures/lang/shapes/expected/fmt.Countdown.ts diff --git a/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts b/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts new file mode 100644 index 000000000..a067730b6 --- /dev/null +++ b/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts @@ -0,0 +1,28 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function fmt$fmt_Debug(self: Countdown, f: rt.Formatter): rt.Result { + const _3: string = "Countdown"; + const _4: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); + return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); +} + +/** + * An iterator of the crate's own, counting down from what it holds, which its derived + * `Debug` writes. + */ +export interface Countdown { + _0: rt.u8; +} + +export function next$iter_Iterator(self: Countdown): rt.u8 | rt.Done { + const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); + if (_2 !== undefined) { + self._0 = _2; + return self._0; + } + return rt.DONE; +} + +//# sourceMappingURL=fmt.Countdown.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index a657649dc..ad477c655 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -8,6 +8,7 @@ import * as Bare from "./fmt.Bare.ts"; import * as Braced from "./fmt.Braced.ts"; import * as Capped from "./fmt.Capped.ts"; import * as Clip from "./fmt.Clip.ts"; +import * as Countdown from "./fmt.Countdown.ts"; import * as Dropper from "./fmt.Dropper.ts"; import * as Fails from "./fmt.Fails.ts"; import * as fmt_Gauge from "./fmt.Gauge.ts"; @@ -2060,30 +2061,55 @@ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { const part40 = fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(rt.iterFuse(rt.iterFlatten(rt.iterSlice(lists), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), true), rt.usizeAdd(front, 6)); const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part40, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "Flatten", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; put(out, rt.fmtFormat([args94[0]])); - const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_218: rt.u8): rt.u16 => { + const units: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_218: rt.u8): rt.u16 => { const _517: rt.usize = rt.u8Rem(_218, 5) as rt.usize; if (!(_517 < 5)) { rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _517); } return [97, 55296, 56320, 233, 56319][_517]; - }), undefined, 2, true))), front); + }), undefined, 2, true); + const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterSlice(units)), front); const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part41, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])]))]; put(out, rt.fmtFormat([args96[0], "|", rt.fmtSpec({ alternate: true }, args96[0]), "|", rt.fmtSpec({ debugHex: "x" }, args96[0])])); const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rt.charDecodeUtf16(rt.iterSlice([55296, 97, 98])), rt.u8Rem(at(2), 3) as rt.usize); const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part42, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["IntoIter"]))]; put(out, rt.fmtFormat([args98[0]])); - const part43 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure17(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_219: rt.u8): Pair.Pair => { + const base: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + base.next(); + const part43 = rt.iterSkip(rt.iterMap(rt.iterBorrow(base), (b14: rt.u8): rt.u8 => { + return rt.u8Add(b14, 1); + }), 1); + const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part43, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; + put(out, rt.fmtFormat([args100[0], "|", rt.fmtSpec({ alternate: true }, args100[0])])); + const part44 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterBorrow(rt.iterSlice(units))), front); + const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part44, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])]))]; + put(out, rt.fmtFormat([args102[0]])); + const part45 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure18(rt.iterEnumerate(rt.iterMap(rt.iterFrom({ _0: rt.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rt.u8): rt.u8 => { + return rt.u8Mul(n, 2); + })), front); + const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEnumerate(part45, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; + put(out, rt.fmtFormat([args104[0], "|", rt.fmtSpec({ alternate: true }, args104[0])])); + const own: Countdown.Countdown = { _0: rt.u8Rem(at(3), 5) }; + const part46 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); + const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part46, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; + put(out, rt.fmtFormat([args106[0]])); + const part47 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure19_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { + return { _0: rt.u8Rem(v2.data[rt.idx(v2, 0)], 3) }; + }, (value: Countdown.Countdown) => rt.iterFrom(value, Countdown.next$iter_Iterator), true), rt.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); + const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part47, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args108[0]])); + const part48 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure20(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_219: rt.u8): Pair.Pair => { return { _0: _219, _1: -1 }; })), 1)), 3), front, back); - const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part43, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; - put(out, rt.fmtFormat([args100[0], "|", rt.fmtSpec({ alternate: true }, args100[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args100[0])])); - const it45: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); - rt.peekablePeek(it45); - const part44 = rt.iterChain(rt.iterFilter(rt.iterZip(it45, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { + const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part48, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; + put(out, rt.fmtFormat([args110[0], "|", rt.fmtSpec({ alternate: true }, args110[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args110[0])])); + const it50: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); + rt.peekablePeek(it50); + const part49 = rt.iterChain(rt.iterFilter(rt.iterZip(it50, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { return p[0] !== 0; }), rt.iterSlice(copy$array_tuple2_u8_u8([[9, 9] as [rt.u8, rt.u8]]).map(copy$tuple2_u8_u8))); - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part44, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])]), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; - put(out, rt.fmtFormat([args102[0], "|", rt.fmtSpec({ alternate: true }, args102[0])])); + const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part49, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])]), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; + put(out, rt.fmtFormat([args112[0], "|", rt.fmtSpec({ alternate: true }, args112[0])])); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { @@ -2390,7 +2416,7 @@ export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rt.Iter, fron } } -export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure17(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { +export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure20(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (iterStart++ < iterEnd) { @@ -2465,6 +2491,17 @@ export function fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(it: } } +export function fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(it: rt.Iter>, front: rt.usize): rt.Iter> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter>, front: rt.usize): rt.Iter> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; @@ -2476,6 +2513,17 @@ export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_iter_Cycle_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; @@ -2487,6 +2535,17 @@ export function fronts$adaptors_iter_Cycle_slice_Iter_u8(it: rt.Iter, fro } } +export function fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure18(it: rt.Iter<[rt.usize, rt.u8]>, front: rt.usize): rt.Iter<[rt.usize, rt.u8]> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; @@ -2542,6 +2601,17 @@ export function fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure } } +export function fronts$adaptors_iter_Peekable_mut_fmt_Countdown(it: rt.Peekable, front: rt.usize): rt.Peekable { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; diff --git a/ts/fixtures/lang/shapes/src/fmt.rs b/ts/fixtures/lang/shapes/src/fmt.rs index eb4f8031d..a5ce52290 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -944,6 +944,20 @@ pub fn iters(data: &[u8], out: &mut Vec) { put(out, &format!("{it:?}")); } +/// An iterator of the crate's own, counting down from what it holds, which its derived +/// `Debug` writes. +#[derive(Debug)] +struct Countdown(u8); + +impl Iterator for Countdown { + type Item = u8; + + fn next(&mut self) -> Option { + self.0 = self.0.checked_sub(1)?; + Some(self.0) + } +} + /// std's iterator adaptors' `Debug`, each its fields in std's order through what it wraps, /// with no closure: consumed from either end, so each writes the state it keeps, as a /// `Peekable` its peeked item and a `Skip` what it has left to skip, plain and pretty. @@ -1120,6 +1134,25 @@ pub fn adaptors(data: &[u8], out: &mut Vec) { let it = fronts(char::decode_utf16(vec![0xd800, 0x61, 0x62]), usize::from(at(2) % 3)); put(out, &format!("{it:?}")); + // An adaptor of a borrowed iterator, or of the crate's own, writes it as it is. + let mut base = bytes.iter(); + base.next(); + let it = base.by_ref().map(|b| b + 1).skip(1); + put(out, &format!("{it:?}|{it:#?}")); + let mut base = units.iter().copied(); + let it = fronts(char::decode_utf16(base.by_ref()), front); + put(out, &format!("{it:?}")); + let it = fronts(Countdown(at(2) % 5).map(|n| n * 2).enumerate(), front); + put(out, &format!("{it:?}|{it:#?}")); + let mut own = Countdown(at(3) % 5); + let it = fronts(own.by_ref().peekable(), front); + put(out, &format!("{it:?}")); + let it = fronts( + lists.iter().flat_map(|v| Countdown(v[0] % 3)).chain(Countdown(2)), + front, + ); + put(out, &format!("{it:?}")); + // Adaptors of adaptors, with every option passed down. let it = ends( bytes.iter().map(|&b| Pair(b, -1)).enumerate().skip(1).rev().take(3), diff --git a/ts/runtime/rt/char.ts b/ts/runtime/rt/char.ts index 62427df29..3ff65109d 100644 --- a/ts/runtime/rt/char.ts +++ b/ts/runtime/rt/char.ts @@ -6,7 +6,7 @@ import { type ByteSlice, type Debug, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugStructFields, fmtDebugTuple, fmtOption, fmtPad, fmtUnit, Ok, type Place, panic, type Result, sliceView } from "../rt.ts"; import { type char, type u8, type u16, u16Debug, type u32, type usize } from "./int.ts"; -import { type Clones, DONE, type Done, Iter, type SizeHint } from "./iter.ts"; +import { type Clones, DONE, type Done, Iter, iterHeld, type SizeHint } from "./iter.ts"; import { drop as dispose } from "./task.ts"; import { ALPHABETIC, LOWERCASE, NUMERIC, TO_LOWERCASE, TO_LOWERCASE_MULTI, TO_UPPERCASE, TO_UPPERCASE_MULTI, UNPRINTABLE, UPPERCASE } from "./unicode.ts"; @@ -375,7 +375,7 @@ export function charDecodeUtf16(it: Iter): Iter(it: Iter, f: Formatter, inner: Debug): FmtResult { const d = it as DecodeUtf16; - return fmtDebugStructFields(f, "DecodeUtf16", ["iter", "buf"], [(f) => inner(d.it as I, f), (f) => fmtOption(d.buf, f, u16Debug)]); + return fmtDebugStructFields(f, "DecodeUtf16", ["iter", "buf"], [(f) => inner(iterHeld(d.it), f), (f) => fmtOption(d.buf, f, u16Debug)]); } /** `char::DecodeUtf16`: `it`, and the unit after a leading surrogate that was no trailing one, which it reads next. */ diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 066623587..2b80a1c4b 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -948,33 +948,43 @@ export function iterFlatten(it: Iter, into?: (value: T) => Iter, fus // Debug. Each writes what std's `Debug` of an adaptor writes: its fields in std's order, // each iterator it wraps, an `I`, by the function given for its type, and no closure. +/** + * What an adaptor's field holds as Rust sees it, from the iterator the adaptor reads: one + * borrowed by `&mut`, or the crate's own, which `iterFrom` reads. + */ +export function iterHeld(it: Iter): I { + if (it instanceof Borrowed) return it.inner as I; + if (it instanceof FromNext) return it.source as I; + return it as I; +} + /** `Debug` of an adaptor std writes as the iterator it wraps alone, under `field`. */ export function fmtAdaptor(it: Iter, f: Formatter, name: string, inner: Debug, field = "iter"): FmtResult { - return fmtDebugStructFields(f, name, [field], [(f) => inner((it as Adaptor).inner as I, f)]); + return fmtDebugStructFields(f, name, [field], [(f) => inner(iterHeld((it as Adaptor).inner), f)]); } /** `Debug` of an `Enumerate`: its iterator and the index it yields next. */ export function fmtEnumerate(it: Iter, f: Formatter, inner: Debug): FmtResult { const e = it as EnumerateIter; - return fmtDebugStructFields(f, "Enumerate", ["iter", "count"], [(f) => inner(e.inner as I, f), (f) => usizeDebug(e.index, f)]); + return fmtDebugStructFields(f, "Enumerate", ["iter", "count"], [(f) => inner(iterHeld(e.inner), f), (f) => usizeDebug(e.index, f)]); } /** `Debug` of a `Skip` or a `Take`, `name`: its iterator and how many it has left to skip or take. */ export function fmtCounted(it: Iter, f: Formatter, name: string, inner: Debug): FmtResult { const c = it as SkipIter | TakeIter; - return fmtDebugStructFields(f, name, ["iter", "n"], [(f) => inner(c.inner as I, f), (f) => usizeDebug(c.n, f)]); + return fmtDebugStructFields(f, name, ["iter", "n"], [(f) => inner(iterHeld(c.inner), f), (f) => usizeDebug(c.n, f)]); } /** `Debug` of a `SkipWhile` or a `TakeWhile`, `name`: its iterator and whether its closure has failed. */ export function fmtFlagged(it: Iter, f: Formatter, name: string, inner: Debug): FmtResult { const w = it as SkipWhileIter | TakeWhileIter; - return fmtDebugStructFields(f, name, ["iter", "flag"], [(f) => inner(w.inner as I, f), (f) => fmtBool(w.flag, f)]); + return fmtDebugStructFields(f, name, ["iter", "flag"], [(f) => inner(iterHeld(w.inner), f), (f) => fmtBool(w.flag, f)]); } /** `Debug` of a `Scan`: its iterator and its state, by `state`. */ export function fmtScan(it: Iter, f: Formatter, inner: Debug, state: Debug): FmtResult { const s = it as ScanIter; - return fmtDebugStructFields(f, "Scan", ["iter", "state"], [(f) => inner(s.inner as I, f), (f) => state(s.state, f)]); + return fmtDebugStructFields(f, "Scan", ["iter", "state"], [(f) => inner(iterHeld(s.inner), f), (f) => state(s.state, f)]); } /** `Debug` of a `Peekable`: its iterator and what it peeked, `Some` of the item by `item` or of `None`. */ @@ -982,23 +992,23 @@ export function fmtPeekable(it: Peekable, f: Formatter, inner: Debug const some = (f: Formatter, value: Fmt): FmtResult => fmtDebugTupleFields(f, "Some", [value]); const peeked = (f: Formatter): FmtResult => { if (!it.peeked) return f.out.writeStr("None"); - const held = it.item; - return some(f, (f) => (held === DONE ? f.out.writeStr("None") : some(f, (f) => item(held, f)))); + const peek = it.item; + return some(f, (f) => (peek === DONE ? f.out.writeStr("None") : some(f, (f) => item(peek, f)))); }; - return fmtDebugStructFields(f, "Peekable", ["iter", "peeked"], [(f) => inner(it.inner as I, f), peeked]); + return fmtDebugStructFields(f, "Peekable", ["iter", "peeked"], [(f) => inner(iterHeld(it.inner), f), peeked]); } /** `Debug` of a `StepBy`: its iterator, its step less one, and whether it has yet to take its first item. */ export function fmtStepBy(it: Iter, f: Formatter, inner: Debug): FmtResult { const s = it as StepByIter | RangeStepBy; - const fields = [(f: Formatter) => inner(s.inner as I, f), (f: Formatter) => usizeDebug(s.step, f), (f: Formatter) => fmtBool(s.firstTake, f)]; + const fields = [(f: Formatter) => inner(iterHeld(s.inner), f), (f: Formatter) => usizeDebug(s.step, f), (f: Formatter) => fmtBool(s.firstTake, f)]; return fmtDebugStructFields(f, "StepBy", ["iter", "step_minus_one", "first_take"], fields); } /** `Debug` of a `Chain`: each of its iterators, by `a` and `b`, until it has dropped it. */ export function fmtChain(it: Iter, f: Formatter, a: Debug, b: Debug): FmtResult { const c = it as ChainIter; - return fmtDebugStructFields(f, "Chain", ["a", "b"], [(f) => fmtOption(c.a as A | undefined, f, a), (f) => fmtOption(c.b as B | undefined, f, b)]); + return fmtDebugStructFields(f, "Chain", ["a", "b"], [(f) => fmtOption(c.a && iterHeld(c.a), f, a), (f) => fmtOption(c.b && iterHeld(c.b), f, b)]); } /** @@ -1008,18 +1018,19 @@ export function fmtChain(it: Iter, f: Formatter, a: Debug, b: export function fmtZip(it: Iter, f: Formatter, a?: Debug, b?: Debug): FmtResult { const z = it as ZipIter; if (a === undefined || b === undefined) return fmtDebugStructFields(f, "Zip", [], []); - return fmtDebugStructFields(f, "Zip", ["a", "b"], [(f) => a(z.a as A, f), (f) => b(z.b as B, f)]); + return fmtDebugStructFields(f, "Zip", ["a", "b"], [(f) => a(iterHeld(z.a), f), (f) => b(iterHeld(z.b), f)]); } /** `Debug` of a `Cycle`: the iterator as it was, and the one it reads. */ export function fmtCycle(it: Iter, f: Formatter, inner: Debug): FmtResult { const c = it as CycleIter; - return fmtDebugStructFields(f, "Cycle", ["orig", "iter"], [(f) => inner(c.orig as I, f), (f) => inner(c.iter as I, f)]); + return fmtDebugStructFields(f, "Cycle", ["orig", "iter"], [(f) => inner(iterHeld(c.orig), f), (f) => inner(iterHeld(c.iter), f)]); } /** `Debug` of a `Fuse`: its iterator, until it has dropped it. */ export function fmtFuse(it: Iter, f: Formatter, inner: Debug): FmtResult { - return fmtDebugStructFields(f, "Fuse", ["iter"], [(f) => fmtOption((it as FuseIter).inner as I | undefined, f, inner)]); + const fused = (it as FuseIter).inner; + return fmtDebugStructFields(f, "Fuse", ["iter"], [(f) => fmtOption(fused && iterHeld(fused), f, inner)]); } /** @@ -1028,8 +1039,8 @@ export function fmtFuse(it: Iter, f: Formatter, inner: Debug): Fm */ export function fmtFlatten(it: Iter, f: Formatter, name: string, source: Debug, inner: Debug): FmtResult { const flat = it as FlattenIter; - const fused = (f: Formatter): FmtResult => fmtDebugStructFields(f, "Fuse", ["iter"], [(f) => fmtOption(flat.outer as S | undefined, f, source)]); - const fields = [fused, (f: Formatter) => fmtOption(flat.front as I | undefined, f, inner), (f: Formatter) => fmtOption(flat.back as I | undefined, f, inner)]; + const fused = (f: Formatter): FmtResult => fmtDebugStructFields(f, "Fuse", ["iter"], [(f) => fmtOption(flat.outer && iterHeld(flat.outer), f, source)]); + const fields = [fused, (f: Formatter) => fmtOption(flat.front && iterHeld(flat.front), f, inner), (f: Formatter) => fmtOption(flat.back && iterHeld(flat.back), f, inner)]; return fmtDebugStructFields(f, name, ["inner"], [(f) => fmtDebugStructFields(f, "FlattenCompat", ["iter", "frontiter", "backiter"], fields)]); } @@ -2257,7 +2268,7 @@ class OptionIter extends Iter implements Disposable { * reads by the methods it has of its own. */ class FromNext extends Iter implements Disposable { - private readonly source: S; + readonly source: S; private readonly step: (source: S) => T | Done; private drop: Drop | undefined; readonly own: Own | undefined; From f72df3848d85e3a961d29d4096bea95dd88a13d4 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:29:22 -0800 Subject: [PATCH 04/11] test(ts): update a snapshot main's slices added for the exact fused flag Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/slices/expected/slices.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index 268f93b7e..de3f48189 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2119,7 +2119,7 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_195 !== undefined) { _195.v = _195.v ^ 255; } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const kept2: rt.u16[] | undefined = copy$Option_array2_u16(rt.sliceFirst(rt.sliceAsChunks(words, 2)[0])); const _208: rt.Place | undefined = rt.sliceFirstMut(words); if (_208 !== undefined) { From c6d21ab65fdeb33a21520f15933a35b01657f70b Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:35:15 -0800 Subject: [PATCH 05/11] fix(ts): write an adaptor's boxed or borrowed iterator as what it points at Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/shapes/expected/fmt.ts | 92 ++++++++++++++++++------- ts/fixtures/lang/shapes/src/fmt.rs | 8 +++ ts/runtime/rt/iter.ts | 15 ++-- ts/src/lower/fmt.rs | 62 +++++++++-------- 4 files changed, 120 insertions(+), 57 deletions(-) diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index ad477c655..b4aff73cd 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -1890,7 +1890,7 @@ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part7, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; put(out, rt.fmtFormat([args12[0], "|", rt.fmtSpec({ alternate: true }, args12[0])])); const part8 = ends$adaptors_iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), front, back); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(part8, f, rt.u8Debug, ["Iter"])])]; + const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCopied(part8, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ alternate: true }, args14[0]), "|", rt.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args14[0])])); const part9 = ends$adaptors_iter_Cloned_slice_Iter_u8(rt.iterCloned(rt.iterSlice(rt.byteSliceView(bytes))), front, back); const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part9, f, "Cloned", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), "it")]; @@ -2069,7 +2069,7 @@ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { return [97, 55296, 56320, 233, 56319][_517]; }), undefined, 2, true); const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterSlice(units)), front); - const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part41, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])]))]; + const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part41, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtCopied(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])))]; put(out, rt.fmtFormat([args96[0], "|", rt.fmtSpec({ alternate: true }, args96[0]), "|", rt.fmtSpec({ debugHex: "x" }, args96[0])])); const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rt.charDecodeUtf16(rt.iterSlice([55296, 97, 98])), rt.u8Rem(at(2), 3) as rt.usize); const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part42, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["IntoIter"]))]; @@ -2082,34 +2082,47 @@ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part43, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; put(out, rt.fmtFormat([args100[0], "|", rt.fmtSpec({ alternate: true }, args100[0])])); const part44 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterBorrow(rt.iterSlice(units))), front); - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part44, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])]))]; + const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part44, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtCopied(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])))]; put(out, rt.fmtFormat([args102[0]])); - const part45 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure18(rt.iterEnumerate(rt.iterMap(rt.iterFrom({ _0: rt.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rt.u8): rt.u8 => { + const part45 = fronts$adaptors_iter_Copied_mut_slice_Iter_u8(rt.iterBorrow(rt.iterSlice(rt.byteSliceView(bytes))), front); + const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCopied(part45, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args104[0], "|", rt.fmtSpec({ alternate: true }, args104[0])])); + const part46 = fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure18(rt.iterMap(rt.iterBox(rt.iterSlice(rt.byteSliceView(bytes))), (b15: rt.u8): rt.u8 => { + return rt.u8Add(b15, 1); + }), front); + const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part46, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args106[0]])); + const boxed: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(bytes))); + const _970: Countdown.Countdown = { _0: 4 }; + const part47 = fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(rt.iterZip(rt.iterBorrow(rt.iterBox(rt.iterBorrow(boxed))), rt.iterBox(rt.iterFrom(_970, Countdown.next$iter_Iterator))), front); + const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part47, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args108[0]])); + const part48 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure19(rt.iterEnumerate(rt.iterMap(rt.iterFrom({ _0: rt.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rt.u8): rt.u8 => { return rt.u8Mul(n, 2); })), front); - const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEnumerate(part45, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; - put(out, rt.fmtFormat([args104[0], "|", rt.fmtSpec({ alternate: true }, args104[0])])); + const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEnumerate(part48, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; + put(out, rt.fmtFormat([args110[0], "|", rt.fmtSpec({ alternate: true }, args110[0])])); const own: Countdown.Countdown = { _0: rt.u8Rem(at(3), 5) }; - const part46 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); - const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part46, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; - put(out, rt.fmtFormat([args106[0]])); - const part47 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure19_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { + const part49 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); + const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part49, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; + put(out, rt.fmtFormat([args112[0]])); + const part50 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure20_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { return { _0: rt.u8Rem(v2.data[rt.idx(v2, 0)], 3) }; }, (value: Countdown.Countdown) => rt.iterFrom(value, Countdown.next$iter_Iterator), true), rt.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); - const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part47, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args108[0]])); - const part48 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure20(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_219: rt.u8): Pair.Pair => { + const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part50, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args114[0]])); + const part51 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure21(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_219: rt.u8): Pair.Pair => { return { _0: _219, _1: -1 }; })), 1)), 3), front, back); - const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part48, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; - put(out, rt.fmtFormat([args110[0], "|", rt.fmtSpec({ alternate: true }, args110[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args110[0])])); - const it50: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); - rt.peekablePeek(it50); - const part49 = rt.iterChain(rt.iterFilter(rt.iterZip(it50, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { + const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part51, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; + put(out, rt.fmtFormat([args116[0], "|", rt.fmtSpec({ alternate: true }, args116[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args116[0])])); + const it53: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); + rt.peekablePeek(it53); + const part52 = rt.iterChain(rt.iterFilter(rt.iterZip(it53, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { return p[0] !== 0; }), rt.iterSlice(copy$array_tuple2_u8_u8([[9, 9] as [rt.u8, rt.u8]]).map(copy$tuple2_u8_u8))); - const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part49, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtDebugStructFields(f, "Copied", ["it"], [(f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])]), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; - put(out, rt.fmtFormat([args112[0], "|", rt.fmtSpec({ alternate: true }, args112[0])])); + const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part52, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtCopied(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; + put(out, rt.fmtFormat([args118[0], "|", rt.fmtSpec({ alternate: true }, args118[0])])); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { @@ -2416,7 +2429,7 @@ export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rt.Iter, fron } } -export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure20(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { +export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure21(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (iterStart++ < iterEnd) { @@ -2513,7 +2526,18 @@ export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter, front: rt.usize): rt.Iter { +export function fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure20_fmt_Countdown(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Copied_mut_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (true) { @@ -2535,7 +2559,7 @@ export function fronts$adaptors_iter_Cycle_slice_Iter_u8(it: rt.Iter, fro } } -export function fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure18(it: rt.Iter<[rt.usize, rt.u8]>, front: rt.usize): rt.Iter<[rt.usize, rt.u8]> { +export function fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure19(it: rt.Iter<[rt.usize, rt.u8]>, front: rt.usize): rt.Iter<[rt.usize, rt.u8]> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (true) { @@ -2601,6 +2625,17 @@ export function fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure } } +export function fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure18(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_iter_Peekable_mut_fmt_Countdown(it: rt.Peekable, front: rt.usize): rt.Peekable { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; @@ -2667,6 +2702,17 @@ export function fronts$adaptors_iter_StepBy_ops_Range_u8(it: rt.Iter, fro } } +export function fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(it: rt.Iter<[rt.u8, rt.u8]>, front: rt.usize): rt.Iter<[rt.u8, rt.u8]> { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(it: rt.Iter<[rt.char, rt.u8]>, front: rt.usize): rt.Iter<[rt.char, rt.u8]> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; diff --git a/ts/fixtures/lang/shapes/src/fmt.rs b/ts/fixtures/lang/shapes/src/fmt.rs index a5ce52290..fa79eea96 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -1142,6 +1142,14 @@ pub fn adaptors(data: &[u8], out: &mut Vec) { let mut base = units.iter().copied(); let it = fronts(char::decode_utf16(base.by_ref()), front); put(out, &format!("{it:?}")); + let mut base = bytes.iter(); + let it = fronts(base.by_ref().copied(), front); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts(Box::new(bytes.iter()).map(|b| b + 1), front); + put(out, &format!("{it:?}")); + let mut boxed = Box::new(bytes.iter().rev()); + let it = fronts((&mut boxed).zip(Box::new(Countdown(4))), front); + put(out, &format!("{it:?}")); let it = fronts(Countdown(at(2) % 5).map(|n| n * 2).enumerate(), front); put(out, &format!("{it:?}|{it:#?}")); let mut own = Countdown(at(3) % 5); diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 2b80a1c4b..7dbdb5fe4 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -949,13 +949,13 @@ export function iterFlatten(it: Iter, into?: (value: T) => Iter, fus // each iterator it wraps, an `I`, by the function given for its type, and no closure. /** - * What an adaptor's field holds as Rust sees it, from the iterator the adaptor reads: one - * borrowed by `&mut`, or the crate's own, which `iterFrom` reads. + * What an adaptor's field holds as Rust sees it, from the iterator the adaptor reads: what + * a box or a `&mut` borrow forwards to, through any number of them, and the crate's own + * iterator, which `iterFrom` reads. */ export function iterHeld(it: Iter): I { - if (it instanceof Borrowed) return it.inner as I; - if (it instanceof FromNext) return it.source as I; - return it as I; + while (it instanceof Forward) it = it.inner; + return (it instanceof FromNext ? it.source : it) as I; } /** `Debug` of an adaptor std writes as the iterator it wraps alone, under `field`. */ @@ -963,6 +963,11 @@ export function fmtAdaptor(it: Iter, f: Formatter, name: string, inn return fmtDebugStructFields(f, name, [field], [(f) => inner(iterHeld((it as Adaptor).inner), f)]); } +/** `Debug` of a `Copied` that is the iterator it copies from, as `iterCopied` leaves one of items JS reads as is. */ +export function fmtCopied(it: Iter, f: Formatter, inner: Debug): FmtResult { + return fmtDebugStructFields(f, "Copied", ["it"], [(f) => inner(iterHeld(it), f)]); +} + /** `Debug` of an `Enumerate`: its iterator and the index it yields next. */ export function fmtEnumerate(it: Iter, f: Formatter, inner: Debug): FmtResult { const e = it as EnumerateIter; diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index ba1eb855f..5d3a9ea46 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -341,7 +341,7 @@ pub fn std_impl<'tcx>( } ty::Adt(adt, args) if tr == Trait::Debug - && let Some(e) = adaptor_debug(b, adt.did(), args, &value, &f, span, out) => + && let Some(e) = adaptor_debug(b, adt.did(), args, &value, &f, span) => { e } @@ -642,7 +642,6 @@ fn adaptor_debug<'tcx>( value: &Expr, f: &Expr, span: Span, - out: &mut Vec, ) -> Option { let tcx = b.t.tcx; let path = library::std_path(tcx, did); @@ -650,53 +649,46 @@ fn adaptor_debug<'tcx>( let arg = |n: usize| args.types().nth(n); let call = |name: &str, rest: Vec| Expr::rt(name, [vec![value.clone(), f.clone()], rest].concat()); let name = |name: &str| Expr::Str(name.into()); + // What writes an iterator it wraps, as `rt.iterHeld` reads it. + let wrapped = |b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>| b.fmt_fn(Trait::Debug, held(ty), span); Some(match path.as_slice() { [ "iter", "adapters", _, adaptor @ ("Map" | "Filter" | "FilterMap" | "Inspect" | "MapWhile" | "Rev"), - ] => call("fmtAdaptor", vec![name(adaptor), b.fmt_fn(Trait::Debug, arg(0)?, span)]), + ] => call("fmtAdaptor", vec![name(adaptor), wrapped(b, arg(0)?)]), // A `copied` that JS reads its items as is is its iterator itself. ["iter", "adapters", "copied", "Copied"] if let ty::Ref(_, item, _) = b.t.iter_item(arg(0)?)?.kind() && super::iter::copies_itself(b.t, *item) => { - let it = b.fmt_value(Trait::Debug, arg(0)?, value.clone(), span, out); - let call = vec![ - f.clone(), - name("Copied"), - Expr::Array(vec![name("it")]), - Expr::Array(vec![it]), - ]; - Expr::rt_of("fmt", "debugStructFields").call(call) + call("fmtCopied", vec![wrapped(b, arg(0)?)]) } ["iter", "adapters", _, adaptor @ ("Copied" | "Cloned")] => { - let inner = b.fmt_fn(Trait::Debug, arg(0)?, span); + let inner = wrapped(b, arg(0)?); call("fmtAdaptor", vec![name(adaptor), inner, name("it")]) } - ["iter", "adapters", "enumerate", "Enumerate"] => { - call("fmtEnumerate", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]) - } + ["iter", "adapters", "enumerate", "Enumerate"] => call("fmtEnumerate", vec![wrapped(b, arg(0)?)]), ["iter", "adapters", _, adaptor @ ("Skip" | "Take")] => { - call("fmtCounted", vec![name(adaptor), b.fmt_fn(Trait::Debug, arg(0)?, span)]) + call("fmtCounted", vec![name(adaptor), wrapped(b, arg(0)?)]) } ["iter", "adapters", _, adaptor @ ("SkipWhile" | "TakeWhile")] => { - call("fmtFlagged", vec![name(adaptor), b.fmt_fn(Trait::Debug, arg(0)?, span)]) + call("fmtFlagged", vec![name(adaptor), wrapped(b, arg(0)?)]) } ["iter", "adapters", "scan", "Scan"] => { - let inner = b.fmt_fn(Trait::Debug, arg(0)?, span); + let inner = wrapped(b, arg(0)?); call("fmtScan", vec![inner, b.fmt_fn(Trait::Debug, arg(1)?, span)]) } ["iter", "adapters", "peekable", "Peekable"] => { - let inner = b.fmt_fn(Trait::Debug, arg(0)?, span); + let inner = wrapped(b, arg(0)?); let item = b.t.iter_item(arg(0)?)?; call("fmtPeekable", vec![inner, b.fmt_fn(Trait::Debug, item, span)]) } - ["iter", "adapters", "step_by", "StepBy"] => call("fmtStepBy", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + ["iter", "adapters", "step_by", "StepBy"] => call("fmtStepBy", vec![wrapped(b, arg(0)?)]), ["iter", "adapters", "chain", "Chain"] => { - let a = b.fmt_fn(Trait::Debug, arg(0)?, span); - call("fmtChain", vec![a, b.fmt_fn(Trait::Debug, arg(1)?, span)]) + let a = wrapped(b, arg(0)?); + call("fmtChain", vec![a, wrapped(b, arg(1)?)]) } // std's specializes it to write neither of two it reads by index. ["iter", "adapters", "zip", "Zip"] => { @@ -707,13 +699,13 @@ fn adaptor_debug<'tcx>( { true => call("fmtZip", Vec::new()), false => { - let a = b.fmt_fn(Trait::Debug, a, span); - call("fmtZip", vec![a, b.fmt_fn(Trait::Debug, other, span)]) + let a = wrapped(b, a); + call("fmtZip", vec![a, wrapped(b, other)]) } } } - ["iter", "adapters", "cycle", "Cycle"] => call("fmtCycle", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), - ["iter", "adapters", "fuse", "Fuse"] => call("fmtFuse", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + ["iter", "adapters", "cycle", "Cycle"] => call("fmtCycle", vec![wrapped(b, arg(0)?)]), + ["iter", "adapters", "fuse", "Fuse"] => call("fmtFuse", vec![wrapped(b, arg(0)?)]), // Its `FlattenCompat`'s source and the iterator of each item, as its field's type // names them. ["iter", "adapters", "flatten", adaptor @ ("Flatten" | "FlatMap")] => { @@ -721,15 +713,27 @@ fn adaptor_debug<'tcx>( let ty::Adt(_, compat) = b.t.field_ty(field.did, args).kind() else { return None; }; - let source = b.fmt_fn(Trait::Debug, compat.type_at(0), span); - let inner = b.fmt_fn(Trait::Debug, compat.type_at(1), span); + let source = wrapped(b, compat.type_at(0)); + let inner = wrapped(b, compat.type_at(1)); call("fmtFlatten", vec![name(adaptor), source, inner]) } - ["char", "decode", "DecodeUtf16"] => call("fmtDecodeUtf16", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + ["char", "decode", "DecodeUtf16"] => call("fmtDecodeUtf16", vec![wrapped(b, arg(0)?)]), _ => return None, }) } +/// The iterator an adaptor's field of type `ty` holds, through the references and boxes +/// whose `Debug` is what they point at, as `rt.iterHeld` reads it. +fn held(mut ty: Ty<'_>) -> Ty<'_> { + loop { + ty = match *ty.kind() { + ty::Ref(_, inner, _) => inner, + _ if let Some(inner) = ty.boxed_ty() => inner, + _ => return ty, + } + } +} + /// One part of a `format_args!` template. pub enum Piece { Lit(String), From 1404ed3f3789b2d6a57b1120abedf4889160869d Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:40:57 -0800 Subject: [PATCH 06/11] test(ts): update a snapshot main's ends added for the exact fused flag Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/ends/expected/ends.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ts/fixtures/lang/ends/expected/ends.ts b/ts/fixtures/lang/ends/expected/ends.ts index 5c09eb955..dc5be8c7a 100644 --- a/ts/fixtures/lang/ends/expected/ends.ts +++ b/ts/fixtures/lang/ends/expected/ends.ts @@ -2754,7 +2754,7 @@ export function collected$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2); }; b0: { const other: rt.Range = new rt.Range(0, k & 0xff); @@ -2840,7 +2840,7 @@ export function collected$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2); }; b0: { const other: rt.Range = new rt.Range(0, k & 0xff); @@ -2926,7 +2926,7 @@ export function collected$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: r const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2); }; b0: { const other: rt.Range = new rt.Range(0, k & 0xff); @@ -3012,7 +3012,7 @@ export function collected$mut_ends_Overrides(it: Overrides.Overrides, pick: rt.u const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2); }; b0: { const other: rt.Range = new rt.Range(0, k & 0xff); From c4f18b43756aa4aa57dfe0e2f920d0e3faedf2b9 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:49:19 -0800 Subject: [PATCH 07/11] fix(ts): write an adaptor's own iterator as its next reads it, through the place of a value Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 1 + quest/m3/ts-own-iter-value.md | 16 +++++++ .../lang/shapes/expected/fmt.Toggle.ts | 29 ++++++++++++ ts/fixtures/lang/shapes/expected/fmt.ts | 44 ++++++++++++------- ts/fixtures/lang/shapes/src/fmt.rs | 25 +++++++++++ ts/src/lower/fmt.rs | 16 +++++-- ts/src/lower/iter.rs | 2 +- 7 files changed, 112 insertions(+), 21 deletions(-) create mode 100644 quest/m3/ts-own-iter-value.md create mode 100644 ts/fixtures/lang/shapes/expected/fmt.Toggle.ts diff --git a/quest/m3/README.md b/quest/m3/README.md index 533d7e1e3..d435ca1d2 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -27,6 +27,7 @@ generic std gap is planned here even when moq never calls it. - [A String from UTF-16](/quest/m3/ts-string-from-utf16.md) - `String::from_utf16` and `from_utf16_lossy` translate with std's error and replacement chars - [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 +- [An adaptor of the crate's own iterator held as a value](/quest/m3/ts-own-iter-value.md) - `map` and the other adaptors of a fieldless enum that implements `Iterator`, taken by value, translate - [Debug of std's other iterators](/quest/m3/ts-iter-source-debug.md) - `Debug` of `Once`, `Repeat`, `FromFn`, an array's `IntoIter`, and std's other iterators writes what std's does - [A vector's exact capacity as it shrinks](/quest/m3/ts-vec-exact-capacity.md) - a deque made from a `Vec` splits its slices where std's does - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number diff --git a/quest/m3/ts-own-iter-value.md b/quest/m3/ts-own-iter-value.md new file mode 100644 index 000000000..7596a06ec --- /dev/null +++ b/quest/m3/ts-own-iter-value.md @@ -0,0 +1,16 @@ +# [S] An adaptor of the crate's own iterator held as a value + +## Goal + +[rust2-ts](/ts/README.md) translates an adaptor taking by value an iterator of the +crate's own whose JS value is copied, as a fieldless enum's is, such as +`Toggle::Ready.map(f)`, so its `next` reads and writes the iterator's place. Proven by +differential tests against native Rust. + +## Plan + +Found while translating `Debug` of std's adaptors: `toggle.map(|x| x)` of a fieldless +enum that implements `Iterator` fails to type-check, as `rt.iterFrom` is given the enum's +value where its `next` takes a `rt.Place`; `(&mut toggle).map(|x| x)` translates. Find +where `into_iter` of an owned iterator of the crate's own makes its source, and give it +the place its `next` reads through. diff --git a/ts/fixtures/lang/shapes/expected/fmt.Toggle.ts b/ts/fixtures/lang/shapes/expected/fmt.Toggle.ts new file mode 100644 index 000000000..56c21a492 --- /dev/null +++ b/ts/fixtures/lang/shapes/expected/fmt.Toggle.ts @@ -0,0 +1,29 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function fmt$fmt_Debug(self: Toggle, f: rt.Formatter): rt.Result { + let _3!: string; + if (self === "Ready") { + _3 = "Ready"; + } else { + _3 = "Done"; + } + return rt.fmtWriteStr(f, _3); +} + +/** + * An iterator of the crate's own that JS holds as a value, which its `next` reads through + * its place. + */ +export type Toggle = "Ready" | "Done"; + +export function next$iter_Iterator(self: rt.Place): rt.u8 | rt.Done { + if (self.v === "Ready") { + self.v = "Done" as Toggle; + return 1; + } + return rt.DONE; +} + +//# sourceMappingURL=fmt.Toggle.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index 672cf8899..0af9d5929 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -23,6 +23,7 @@ import * as Placed from "./fmt.Placed.ts"; import * as Seq from "./fmt.Seq.ts"; import * as Shared from "./fmt.Shared.ts"; import * as Six from "./fmt.Six.ts"; +import * as Toggle from "./fmt.Toggle.ts"; import * as Tup from "./fmt.Tup.ts"; import * as Twice from "./fmt.Twice.ts"; import * as Unit from "./fmt.Unit.ts"; @@ -1856,6 +1857,7 @@ export function ends$iters_vec_IntoIter_u8(it: rt.Iter, front: rt.usize, * `Peekable` its peeked item and a `Skip` what it has left to skip, plain and pretty. */ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { + let toggle!: Toggle.Toggle; const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); }; @@ -2118,27 +2120,37 @@ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { })), front); const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEnumerate(part51, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; put(out, rt.fmtFormat([args116[0], "|", rt.fmtSpec({ alternate: true }, args116[0])])); + if (!(rt.u8Rem(at(3), 2) === 0)) { + toggle = "Done" as Toggle.Toggle; + } else { + toggle = "Ready" as Toggle.Toggle; + } + const part52 = rt.iterMap(rt.iterFrom(rt.place(() => toggle, (value2) => toggle = value2), Toggle.next$iter_Iterator), (x: rt.u8): rt.u8 => { + return x; + }); + const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part52, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rt.fmtFormat([args118[0], "|", rt.fmtSpec({ alternate: true }, args118[0])])); const own: Countdown.Countdown = { _0: rt.u8Rem(at(3), 5) }; - const part52 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); - const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part52, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; - put(out, rt.fmtFormat([args118[0]])); - const part53 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure21_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { + const part53 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); + const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part53, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; + put(out, rt.fmtFormat([args120[0]])); + const part54 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure22_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { return { _0: rt.u8Rem(v2.data[rt.idx(v2, 0)], 3) }; }, (value: Countdown.Countdown) => rt.iterFrom(value, Countdown.next$iter_Iterator), true), rt.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); - const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part53, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args120[0]])); - const part54 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure22(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_221: rt.u8): Pair.Pair => { + const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part54, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args122[0]])); + const part55 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure23(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_221: rt.u8): Pair.Pair => { return { _0: _221, _1: -1 }; })), 1)), 3), front, back); - const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part54, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; - put(out, rt.fmtFormat([args122[0], "|", rt.fmtSpec({ alternate: true }, args122[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args122[0])])); - const it56: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); - rt.peekablePeek(it56); - const part55 = rt.iterChain(rt.iterFilter(rt.iterZip(it56, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { + const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part55, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; + put(out, rt.fmtFormat([args124[0], "|", rt.fmtSpec({ alternate: true }, args124[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args124[0])])); + const it57: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); + rt.peekablePeek(it57); + const part56 = rt.iterChain(rt.iterFilter(rt.iterZip(it57, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { return p[0] !== 0; }), rt.iterSlice(copy$array_tuple2_u8_u8([[9, 9] as [rt.u8, rt.u8]]).map(copy$tuple2_u8_u8))); - const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part55, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; - put(out, rt.fmtFormat([args124[0], "|", rt.fmtSpec({ alternate: true }, args124[0])])); + const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part56, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; + put(out, rt.fmtFormat([args126[0], "|", rt.fmtSpec({ alternate: true }, args126[0])])); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { @@ -2445,7 +2457,7 @@ export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rt.Iter, fron } } -export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure22(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { +export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure23(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (iterStart++ < iterEnd) { @@ -2542,7 +2554,7 @@ export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter, front: rt.usize): rt.Iter { +export function fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure22_fmt_Countdown(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (true) { diff --git a/ts/fixtures/lang/shapes/src/fmt.rs b/ts/fixtures/lang/shapes/src/fmt.rs index 6460d178b..5359b4d78 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -949,6 +949,28 @@ pub fn iters(data: &[u8], out: &mut Vec) { #[derive(Debug)] struct Countdown(u8); +/// An iterator of the crate's own that JS holds as a value, which its `next` reads through +/// its place. +#[derive(Debug, Clone, Copy)] +enum Toggle { + Ready, + Done, +} + +impl Iterator for Toggle { + type Item = u8; + + fn next(&mut self) -> Option { + match self { + Self::Ready => { + *self = Self::Done; + Some(1) + } + Self::Done => None, + } + } +} + impl Iterator for Countdown { type Item = u8; @@ -1164,6 +1186,9 @@ pub fn adaptors(data: &[u8], out: &mut Vec) { put(out, &format!("{it:?}")); let it = fronts(Countdown(at(2) % 5).map(|n| n * 2).enumerate(), front); put(out, &format!("{it:?}|{it:#?}")); + let mut toggle = if at(3) % 2 == 0 { Toggle::Ready } else { Toggle::Done }; + let it = (&mut toggle).map(|x| x); + put(out, &format!("{it:?}|{it:#?}")); let mut own = Countdown(at(3) % 5); let it = fronts(own.by_ref().peekable(), front); put(out, &format!("{it:?}")); diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 0bd944c06..2af469241 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -671,7 +671,10 @@ fn adaptor_debug<'tcx>( let call = |name: &str, rest: Vec| Expr::rt(name, [vec![value.clone(), f.clone()], rest].concat()); let name = |name: &str| Expr::Str(name.into()); // What writes an iterator it wraps, as `rt.iterHeld` reads it. - let wrapped = |b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>| b.fmt_fn(Trait::Debug, held(ty), span); + let wrapped = |b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>| { + let ty = held(b, ty); + b.fmt_fn(Trait::Debug, ty, span) + }; Some(match path.as_slice() { [ "iter", @@ -754,14 +757,19 @@ fn adaptor_debug<'tcx>( } /// The iterator an adaptor's field of type `ty` holds, through the references and boxes -/// whose `Debug` is what they point at, as `rt.iterHeld` reads it. -fn held(mut ty: Ty<'_>) -> Ty<'_> { +/// whose `Debug` is what they point at, as `rt.iterHeld` reads it: the crate's own as its +/// `next` reads it, through the reference to it, which a value JS copies is the place of. +fn held<'tcx>(b: &Body<'_, '_, 'tcx>, mut ty: Ty<'tcx>) -> Ty<'tcx> { loop { - ty = match *ty.kind() { + let inner = match *ty.kind() { ty::Ref(_, inner, _) => inner, _ if let Some(inner) = ty.boxed_ty() => inner, _ => return ty, + }; + if ty.is_ref() && super::iter::own_next(b, inner).is_some() { + return ty; } + ty = inner; } } diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 9538ff48c..5c42ecacb 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -68,7 +68,7 @@ impl<'tcx> Translator<'_, 'tcx> { /// The crate's own iterator a `ty` is, through any references: its `next`, whose /// instance the translation names. -fn own_next<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option> { +pub(super) fn own_next<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option> { own_method(b, ty, "Iterator", "next") } From 93364cbb2646640b64a856c06342f19feb395758 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:55:47 -0800 Subject: [PATCH 08/11] fix(ts): find a borrowed own iterator's place through any references to it Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/shapes/expected/fmt.ts | 37 ++++++++++++++----------- ts/fixtures/lang/shapes/src/fmt.rs | 3 ++ ts/src/lower/fmt.rs | 3 +- 3 files changed, 26 insertions(+), 17 deletions(-) diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index 0af9d5929..692413dc8 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -2130,27 +2130,32 @@ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { }); const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part52, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; put(out, rt.fmtFormat([args118[0], "|", rt.fmtSpec({ alternate: true }, args118[0])])); - const own: Countdown.Countdown = { _0: rt.u8Rem(at(3), 5) }; - const part53 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); - const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part53, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; + const part53 = rt.iterMap(rt.iterFrom(rt.place(() => toggle, (value3) => toggle = value3), Toggle.next$iter_Iterator), (x2: rt.u8): rt.u8 => { + return x2; + }); + const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part53, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; put(out, rt.fmtFormat([args120[0]])); - const part54 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure22_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { + const own: Countdown.Countdown = { _0: rt.u8Rem(at(3), 5) }; + const part54 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); + const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part54, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; + put(out, rt.fmtFormat([args122[0]])); + const part55 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure23_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { return { _0: rt.u8Rem(v2.data[rt.idx(v2, 0)], 3) }; }, (value: Countdown.Countdown) => rt.iterFrom(value, Countdown.next$iter_Iterator), true), rt.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); - const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part54, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args122[0]])); - const part55 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure23(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_221: rt.u8): Pair.Pair => { + const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part55, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args124[0]])); + const part56 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure24(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_221: rt.u8): Pair.Pair => { return { _0: _221, _1: -1 }; })), 1)), 3), front, back); - const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part55, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; - put(out, rt.fmtFormat([args124[0], "|", rt.fmtSpec({ alternate: true }, args124[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args124[0])])); - const it57: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); - rt.peekablePeek(it57); - const part56 = rt.iterChain(rt.iterFilter(rt.iterZip(it57, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { + const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part56, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; + put(out, rt.fmtFormat([args126[0], "|", rt.fmtSpec({ alternate: true }, args126[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args126[0])])); + const it58: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); + rt.peekablePeek(it58); + const part57 = rt.iterChain(rt.iterFilter(rt.iterZip(it58, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { return p[0] !== 0; }), rt.iterSlice(copy$array_tuple2_u8_u8([[9, 9] as [rt.u8, rt.u8]]).map(copy$tuple2_u8_u8))); - const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part56, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; - put(out, rt.fmtFormat([args126[0], "|", rt.fmtSpec({ alternate: true }, args126[0])])); + const args128: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part57, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; + put(out, rt.fmtFormat([args128[0], "|", rt.fmtSpec({ alternate: true }, args128[0])])); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { @@ -2457,7 +2462,7 @@ export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rt.Iter, fron } } -export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure23(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { +export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure24(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (iterStart++ < iterEnd) { @@ -2554,7 +2559,7 @@ export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter, front: rt.usize): rt.Iter { +export function fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure23_fmt_Countdown(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (true) { diff --git a/ts/fixtures/lang/shapes/src/fmt.rs b/ts/fixtures/lang/shapes/src/fmt.rs index 5359b4d78..a7fae7fce 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -1189,6 +1189,9 @@ pub fn adaptors(data: &[u8], out: &mut Vec) { let mut toggle = if at(3) % 2 == 0 { Toggle::Ready } else { Toggle::Done }; let it = (&mut toggle).map(|x| x); put(out, &format!("{it:?}|{it:#?}")); + let mut borrowed = &mut toggle; + let it = (&mut borrowed).map(|x| x); + put(out, &format!("{it:?}")); let mut own = Countdown(at(3) % 5); let it = fronts(own.by_ref().peekable(), front); put(out, &format!("{it:?}")); diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 2af469241..0946ccc28 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -766,7 +766,8 @@ fn held<'tcx>(b: &Body<'_, '_, 'tcx>, mut ty: Ty<'tcx>) -> Ty<'tcx> { _ if let Some(inner) = ty.boxed_ty() => inner, _ => return ty, }; - if ty.is_ref() && super::iter::own_next(b, inner).is_some() { + // `own_next` reads through references, which the next step peels. + if ty.is_ref() && !inner.is_ref() && super::iter::own_next(b, inner).is_some() { return ty; } ty = inner; From b9b955d184a2347763ccf78aa0edb76e4e3d3d61 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 06:06:18 -0800 Subject: [PATCH 09/11] test(ts): update snapshots main's edits and strs added for the exact fused flag Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/edits/expected/edits.ts | 12 ++++++------ ts/fixtures/lang/strs/expected/strs.ts | 4 ++-- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/ts/fixtures/lang/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 993c8767f..bc57aae8d 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -960,7 +960,7 @@ export function resizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _11: (a0: Tracked.Tracked[]) => rt.ByteVec = (v7: Tracked.Tracked[]): rt.ByteVec => { return rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(v7), (t: Tracked.Tracked): Uint8Array => { return Uint8Array.of(t.id, t.copies); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); }; const _196: (a0: rt.u16) => Named.Named = (w: rt.u16): Named.Named => { return { id: w, name: text(rt.byteSliceFrom(Uint8Array.of(w & 0xff))) }; @@ -1099,7 +1099,7 @@ export function resizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void _325[1] = rt.u16Add(_325[1], 10); } rt.vecAppend(pairs, moved, 4); - const iter6: rt.Iter = rt.iterFlatten(rt.iterSlice(pairs), (value: rt.u16[]) => rt.iterSlice(value), false, 2); + const iter6: rt.Iter = rt.iterFlatten(rt.iterSlice(pairs), (value: rt.u16[]) => rt.iterSlice(value), true, 2); while (true) { const _339: rt.u16 | rt.Done = iter6.next(); if (_339 === rt.DONE) { @@ -1136,7 +1136,7 @@ export function resizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void _395[1].data[_395[1].start + _400] = _395[1].data[_395[1].start + _400] ^ 255; } rt.vecAppend(keys, rest, 2); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(keys), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(keys), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); } else if (_12 === 2) { const iter9: rt.Iter = rt.iterChain(rt.iterMap(new rt.Range(0, rt.min(data.length, 3)), (n3: rt.usize): rt.ByteSlice => { return rt.byteSliceRange(data, 0, n3); @@ -1209,14 +1209,14 @@ export function resizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void mark(242); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(tail3), (t2: Tracked.Tracked): Uint8Array => { return Uint8Array.of(t2.id, t2.copies); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const _587: Tracked.Tracked = tracked(208); rt.dequePushFront(tail3, _587); rt.dequeAppend(q, tail3); rt.byteVecPush(out, tail3.n & 0xff); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (t3: Tracked.Tracked): Uint8Array => { return Uint8Array.of(t3.id, t3.copies); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); mark(243); const v6: Tracked.Tracked[] = rt.dequeToVec(q); rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(v6)), undefined, true); @@ -1342,7 +1342,7 @@ export function resizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void _852[1][_858] = rt.u16Add(_852[1][_858], i5 & 0xffff); } rt.dequeAppend(pairs2, moved2); - const iter16: rt.Iter = rt.iterFlatten(rt.iterSlice(rt.dequeToVec(pairs2)), (value: rt.u16[]) => rt.iterSlice(value), false, 2); + const iter16: rt.Iter = rt.iterFlatten(rt.iterSlice(rt.dequeToVec(pairs2)), (value: rt.u16[]) => rt.iterSlice(value), true, 2); while (true) { const _873: rt.u16 | rt.Done = iter16.next(); if (_873 === rt.DONE) { diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 46dbd2681..b7f798cc8 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -2002,10 +2002,10 @@ export function utf16(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args4[0]])); const le: rt.ByteVec = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(units), (u: rt.u16): Uint8Array => { return rt.u16ToBeBytes(u).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const be: rt.ByteVec = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(units), (u2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(u2); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); + }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); const _57: [rt.ByteSlice, rt.ByteSlice] = [rt.byteSliceRange(rt.byteVecSlice(le), 0), rt.byteSliceRange(rt.byteVecSlice(be), 0)]; const iter: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterSlice([_57, [option_unwrapOr$1rbuegs(rt.byteSliceGetRange(rt.byteVecSlice(le), 1), rt.byteSliceFrom(Uint8Array.of())), option_unwrapOr$1rbuegs(rt.byteSliceGetRange(rt.byteVecSlice(be), 1), rt.byteSliceFrom(Uint8Array.of()))] as [rt.ByteSlice, rt.ByteSlice], [data, data] as [rt.ByteSlice, rt.ByteSlice]]); while (true) { From a302191c44b29f82dc12454ba1257d89f9e8a32e Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 06:15:39 -0800 Subject: [PATCH 10/11] fix(ts): write an adaptor's wrapped iterator as peel_iter holds it The Debug lowering kept its own copy of how references and boxes peel to the iterator, which dropped the place of a `&mut Box` to the crate's own iterator. It now reads the type `peel_iter` gives, and the fixture covers the boxed and borrowed orders std forwards through. Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/shapes/expected/fmt.ts | 114 ++++++++++++++++++++---- ts/fixtures/lang/shapes/src/fmt.rs | 14 +++ ts/src/lower/fmt.rs | 22 +---- ts/src/lower/iter.rs | 2 +- 4 files changed, 115 insertions(+), 37 deletions(-) diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index 692413dc8..05c281d20 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -2135,27 +2135,54 @@ export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { }); const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part53, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; put(out, rt.fmtFormat([args120[0]])); + let boxed2: Toggle.Toggle = toggle; + const part54 = fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterFrom(rt.place(() => boxed2, (value5) => boxed2 = value5), Toggle.next$iter_Iterator))), (x3: rt.u8): rt.u8 => { + return x3; + }), front); + const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part54, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rt.fmtFormat([args122[0], "|", rt.fmtSpec({ alternate: true }, args122[0])])); + const part55 = fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(rt.iterMap(rt.iterBox(rt.iterBorrow(rt.iterBox(rt.iterFrom(rt.place(() => boxed2, (value6) => boxed2 = value6), Toggle.next$iter_Iterator)))), (x4: rt.u8): rt.u8 => { + return x4; + }), front); + const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part55, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rt.fmtFormat([args124[0]])); + const part56 = fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(rt.iterMap(rt.iterBox(rt.iterFrom(rt.place(() => toggle, (value7) => toggle = value7), Toggle.next$iter_Iterator)), (x5: rt.u8): rt.u8 => { + return x5; + }), front); + const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part56, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rt.fmtFormat([args126[0]])); + let nested: Countdown.Countdown = { _0: rt.u8Rem(at(4), 5) }; + const part57 = fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterFrom(nested, Countdown.next$iter_Iterator))), (n2: rt.u8): rt.u8 => { + return n2; + }), front); + const args128: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args128[0]])); + const part58 = fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(rt.iterMap(rt.iterBox(rt.iterFrom({ _0: rt.u8Rem(at(5), 5) }, Countdown.next$iter_Iterator)), (n3: rt.u8): rt.u8 => { + return n3; + }), front); + const args130: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args130[0]])); const own: Countdown.Countdown = { _0: rt.u8Rem(at(3), 5) }; - const part54 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); - const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part54, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; - put(out, rt.fmtFormat([args122[0]])); - const part55 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure23_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { + const part59 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); + const args132: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; + put(out, rt.fmtFormat([args132[0]])); + const part60 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists), (v2: rt.ByteVec): Countdown.Countdown => { return { _0: rt.u8Rem(v2.data[rt.idx(v2, 0)], 3) }; }, (value: Countdown.Countdown) => rt.iterFrom(value, Countdown.next$iter_Iterator), true), rt.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); - const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part55, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args124[0]])); - const part56 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure24(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_221: rt.u8): Pair.Pair => { + const args134: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part60, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rt.fmtFormat([args134[0]])); + const part61 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_221: rt.u8): Pair.Pair => { return { _0: _221, _1: -1 }; })), 1)), 3), front, back); - const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part56, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; - put(out, rt.fmtFormat([args126[0], "|", rt.fmtSpec({ alternate: true }, args126[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args126[0])])); - const it58: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); - rt.peekablePeek(it58); - const part57 = rt.iterChain(rt.iterFilter(rt.iterZip(it58, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { + const args136: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part61, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; + put(out, rt.fmtFormat([args136[0], "|", rt.fmtSpec({ alternate: true }, args136[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args136[0])])); + const it63: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); + rt.peekablePeek(it63); + const part62 = rt.iterChain(rt.iterFilter(rt.iterZip(it63, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { return p[0] !== 0; }), rt.iterSlice(copy$array_tuple2_u8_u8([[9, 9] as [rt.u8, rt.u8]]).map(copy$tuple2_u8_u8))); - const args128: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part57, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; - put(out, rt.fmtFormat([args128[0], "|", rt.fmtSpec({ alternate: true }, args128[0])])); + const args138: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part62, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, 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), ["IntoIter"]))]; + put(out, rt.fmtFormat([args138[0], "|", rt.fmtSpec({ alternate: true }, args138[0])])); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { @@ -2462,7 +2489,7 @@ export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rt.Iter, fron } } -export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure24(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { +export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (iterStart++ < iterEnd) { @@ -2559,7 +2586,7 @@ export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter, front: rt.usize): rt.Iter { +export function fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; while (true) { @@ -2658,6 +2685,39 @@ export function fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure } } +export function fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(it: rt.Iter, front: rt.usize): rt.Iter { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; @@ -2669,6 +2729,28 @@ export function fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_cl } } +export function fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(it: rt.Iter, front: rt.usize): rt.Iter { + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = front; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + export function fronts$adaptors_iter_Peekable_mut_fmt_Countdown(it: rt.Peekable, front: rt.usize): rt.Peekable { let iterStart: rt.usize = 0; const iterEnd: rt.usize = front; diff --git a/ts/fixtures/lang/shapes/src/fmt.rs b/ts/fixtures/lang/shapes/src/fmt.rs index a7fae7fce..10fe40760 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -1192,6 +1192,20 @@ pub fn adaptors(data: &[u8], out: &mut Vec) { let mut borrowed = &mut toggle; let it = (&mut borrowed).map(|x| x); put(out, &format!("{it:?}")); + // The crate's own iterator through boxes and references, in each order std forwards. + let mut boxed = Box::new(toggle); + let it = fronts((&mut boxed).map(|x| x), front); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts(Box::new(&mut boxed).map(|x| x), front); + put(out, &format!("{it:?}")); + let it = fronts(Box::new(&mut toggle).map(|x| x), front); + put(out, &format!("{it:?}")); + let mut nested = Box::new(Box::new(Countdown(at(4) % 5))); + let mut nested = &mut nested; + let it = fronts((&mut nested).map(|n| n), front); + put(out, &format!("{it:?}")); + let it = fronts(Box::new(Box::new(Countdown(at(5) % 5))).map(|n| n), front); + put(out, &format!("{it:?}")); let mut own = Countdown(at(3) % 5); let it = fronts(own.by_ref().peekable(), front); put(out, &format!("{it:?}")); diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 91745ca27..26bac5dda 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -672,9 +672,9 @@ fn adaptor_debug<'tcx>( let arg = |n: usize| args.types().nth(n); let call = |name: &str, rest: Vec| Expr::rt(name, [vec![value.clone(), f.clone()], rest].concat()); let name = |name: &str| Expr::Str(name.into()); - // What writes an iterator it wraps, as `rt.iterHeld` reads it. + // What writes an iterator it wraps, as the adaptor holds it and `rt.iterHeld` reads it. let wrapped = |b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>| { - let ty = held(b, ty); + let (ty, _) = super::iter::peel_iter(b, ty, Expr::undefined()); b.fmt_fn(Trait::Debug, ty, span) }; Some(match path.as_slice() { @@ -758,24 +758,6 @@ fn adaptor_debug<'tcx>( }) } -/// The iterator an adaptor's field of type `ty` holds, through the references and boxes -/// whose `Debug` is what they point at, as `rt.iterHeld` reads it: the crate's own as its -/// `next` reads it, through the reference to it, which a value JS copies is the place of. -fn held<'tcx>(b: &Body<'_, '_, 'tcx>, mut ty: Ty<'tcx>) -> Ty<'tcx> { - loop { - let inner = match *ty.kind() { - ty::Ref(_, inner, _) => inner, - _ if let Some(inner) = ty.boxed_ty() => inner, - _ => return ty, - }; - // `own_next` reads through references, which the next step peels. - if ty.is_ref() && !inner.is_ref() && super::iter::own_next(b, inner).is_some() { - return ty; - } - ty = inner; - } -} - /// 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 5c42ecacb..9538ff48c 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -68,7 +68,7 @@ impl<'tcx> Translator<'_, 'tcx> { /// The crate's own iterator a `ty` is, through any references: its `next`, whose /// instance the translation names. -pub(super) fn own_next<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option> { +fn own_next<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option> { own_method(b, ty, "Iterator", "next") } From 9dd26af9026b64b6624398a166877a8fd4954d00 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Tue, 3 Nov 2026 06:49:11 -0800 Subject: [PATCH 11/11] test(ts): update the clones snapshot main added for the exact fused flag Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/clones/expected/clones.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index fa3e98ef4..ec3d90534 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -7754,7 +7754,7 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const vecs2: rt.ByteVec[] = _308[1]; rt.byteVecPush(vecs2[0], 1); rt.iterExtendBytes(out, rt.strBytes(rt.strsJoin(words2, "")), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterChain(rt.iterSlice(vecs), rt.iterSlice(vecs2)), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value))), "next"); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterChain(rt.iterSlice(vecs), rt.iterSlice(vecs2)), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), "next"); rt.dropAll(copy2, drop$array2_clones_Logged); flush(log.value, out); } else if (_14 === 5) {