diff --git a/quest/m3/README.md b/quest/m3/README.md index 8d105a58a..6d53dbed1 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -22,9 +22,10 @@ generic std gap is planned here even when moq never calls it. - [Waiting: drop the lang fixture's mul_add allowance](/quest/m3/ts-fma-allowance.md) - the differential fails on any `mul_add` difference again once wasm32's `fma` rounds exactly - [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 -- [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 +- [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 keeps the capacity its pushes grew as it shrinks](/quest/m3/ts-vec-clear-capacity.md) - every step that drops a pushed `Vec`'s length keeps its capacity, as std guarantees - [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 6d421674e..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`, -`char::DecodeUtf16`, and `str`'s escapes, each a `FlatMap` in a struct, 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/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/README.md b/ts/README.md index eb0df64e4..e4150c30e 100644 --- a/ts/README.md +++ b/ts/README.md @@ -277,7 +277,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`, +`DecodeUtf16`, and a `str`'s escapes, 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 bba71ceef..6942ef842 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 3df98e4f6..5176ecfaf 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 2a589acf5..7ae43e851 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 21710cdcc..be9046b1f 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -6841,7 +6841,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; @@ -6858,19 +6858,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; @@ -7235,7 +7235,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; @@ -7757,7 +7757,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) { diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index 9e8f1f05d..2f2a13ee9 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) }]; @@ -5350,7 +5350,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); @@ -5399,7 +5399,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); @@ -5448,7 +5448,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/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 00b662466..0c87d2ba9 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/elements/expected/elements.ts b/ts/fixtures/lang/elements/expected/elements.ts index 2f25cee01..78dea2554 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/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); 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 bc34413d6..33530a09d 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 3debf8901..6444941b8 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 5346dedca..36f3acddc 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 588ed5870..25f31b7c1 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 7ded0eb4f..8f52cea4a 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.ts @@ -175,22 +175,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); } /** @@ -1584,7 +1584,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); } @@ -1635,7 +1635,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); } @@ -1686,7 +1686,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); } @@ -1737,7 +1737,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); } @@ -1790,7 +1790,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); } @@ -1843,7 +1843,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); } @@ -1896,7 +1896,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); } @@ -1949,7 +1949,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 8db5e2763..4f2d07856 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.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.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 0d0fe9527..705095988 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -1,13 +1,14 @@ // 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"; 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"; @@ -22,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"; @@ -1849,6 +1851,1027 @@ 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 { + 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); + }; + 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.fmtAround(part8, f, "Copied", "it", (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")]; + 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 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); + 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.fmtAround(value, f, "Copied", "it", (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"]))]; + put(out, rt.fmtFormat([args98[0]])); + const quoted: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_219: rt.u8): rt.char => { + const _519: rt.usize = rt.u8Rem(_219, 6) as rt.usize; + if (!(_519 < 6)) { + rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _519); + } + return [97, 34, 10, 769, 233, 39][_519]; + })); + const part43 = fronts$adaptors_str_EscapeDebug(rt.strEscapeDebug(quoted), rt.usizeMul(front, 2)); + const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part43, f, "EscapeDebug", "inner", (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", rt.fmtChars), (value: rt.Iter, f: rt.Formatter) => rt.fmtCharsDebug(value, f, "EscapeDebug")))]; + put(out, rt.fmtFormat([args100[0], "|", rt.fmtSpec({ alternate: true }, args100[0])])); + const part44 = fronts$adaptors_str_EscapeDefault(rt.strEscapeDefault(quoted), rt.usizeMul(front, 3)); + const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part44, f, "EscapeDefault", "inner", (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", rt.fmtChars), (value: rt.Iter, f: rt.Formatter) => rt.fmtCharsDebug(value, f, "EscapeDefault")))]; + put(out, rt.fmtFormat([args102[0]])); + const part45 = fronts$adaptors_str_EscapeUnicode(rt.strEscapeUnicode(quoted), rt.usizeMul(front, 5)); + const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part45, f, "EscapeUnicode", "inner", (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", rt.fmtChars), (value: rt.Iter, f: rt.Formatter) => rt.fmtCharsDebug(value, f, "EscapeUnicode")))]; + put(out, rt.fmtFormat([args104[0], "|", rt.fmtSpec({ alternate: true }, args104[0])])); + const base: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + base.next(); + const part46 = rt.iterSkip(rt.iterMap(rt.iterBorrow(base), (b15: rt.u8): rt.u8 => { + return rt.u8Add(b15, 1); + }), 1); + const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part46, 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([args106[0], "|", rt.fmtSpec({ alternate: true }, args106[0])])); + const part47 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterBorrow(rt.iterSlice(units))), front); + const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part47, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])))]; + put(out, rt.fmtFormat([args108[0]])); + const part48 = fronts$adaptors_iter_Copied_mut_slice_Iter_u8(rt.iterBorrow(rt.iterSlice(rt.byteSliceView(bytes))), front); + const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part48, f, "Copied", "it", (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])])); + const part49 = fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(rt.iterMap(rt.iterBox(rt.iterSlice(rt.byteSliceView(bytes))), (b16: rt.u8): rt.u8 => { + return rt.u8Add(b16, 1); + }), front); + const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part49, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; + put(out, rt.fmtFormat([args112[0]])); + const boxed: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(bytes))); + const _1027: Countdown.Countdown = { _0: 4 }; + const part50 = 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(_1027, Countdown.next$iter_Iterator))), front); + const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part50, 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([args114[0]])); + const part51 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(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 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 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]])); + 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 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 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 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 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 { + 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_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) { + 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_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; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +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) { + 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) { + 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_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(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; + 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_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; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +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; + 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_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; + while (true) { + if (!(iterStart++ < iterEnd)) { + return it; + } + rt.iterToOption(it.next()); + } +} + +export function fronts$adaptors_str_EscapeDebug(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_str_EscapeDefault(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_str_EscapeUnicode(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()); + } +} + /** * 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..10fe40760 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -944,6 +944,290 @@ 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); + +/// 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; + + 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. +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:?}")); + + // A `str`'s escapes, each the `flat_map` of its chars, partly read. + let quoted: String = bytes + .iter() + .map(|&b| ['a', '"', '\n', '\u{301}', 'é', '\''][usize::from(b % 6)]) + .collect(); + let it = fronts(quoted.escape_debug(), front * 2); + put(out, &format!("{it:?}|{it:#?}")); + let it = fronts(quoted.escape_default(), front * 3); + put(out, &format!("{it:?}")); + let it = fronts(quoted.escape_unicode(), front * 5); + put(out, &format!("{it:?}|{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 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 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:?}")); + // 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:?}")); + 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), + 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/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) { 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 ca43b1d3f..478718c21 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); @@ -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) { diff --git a/ts/fixtures/lang/tuples/expected/tuples.ts b/ts/fixtures/lang/tuples/expected/tuples.ts index 523a6074d..822b31526 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 5cbad34a8..029155fd7 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 e3466276c..507806755 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 720cb7aef..524f4ea46 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 { _248[0][1][1][Symbol.dispose](); return _034; }); - 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 b367a6e29..68cd3d507 100644 --- a/ts/runtime/rt/char.ts +++ b/ts/runtime/rt/char.ts @@ -4,9 +4,9 @@ // 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, 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, 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, iterFlatMap, type SizeHint } from "./iter.ts"; +import { type Clones, DONE, type Done, Iter, iterFlatMap, iterHeld, type SizeHint } from "./iter.ts"; import { strChars } from "./str.ts"; import { drop as dispose } from "./task.ts"; import { ALPHABETIC, CASE_IGNORABLE, LOWERCASE, NUMERIC, TITLECASE, TO_LOWERCASE, TO_LOWERCASE_MULTI, TO_UPPERCASE, TO_UPPERCASE_MULTI, UNPRINTABLE, UPPERCASE } from "./unicode.ts"; @@ -448,31 +448,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(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. */ 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); @@ -480,19 +486,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 9911e4964..24c76590e 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. */ @@ -873,9 +873,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; } /** @@ -922,7 +930,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); @@ -933,12 +941,119 @@ 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. + +/** + * 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 { + 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`. */ +export function fmtAdaptor(it: Iter, f: Formatter, name: string, inner: Debug, field = "iter"): FmtResult { + return fmtDebugStructFields(f, name, [field], [(f) => inner(iterHeld((it as Adaptor).inner), f)]); +} + +/** + * `Debug` of a struct std writes around one field, `field`, that is the iterator it is + * itself: a `Copied` of items JS reads as is, and a `str`'s escape, its `flat_map`. + */ +export function fmtAround(it: Iter, f: Formatter, name: string, field: string, inner: Debug): FmtResult { + return fmtDebugStructFields(f, name, [field], [(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; + 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(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(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(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`. */ +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 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(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(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 && iterHeld(c.a), f, a), (f) => fmtOption(c.b && iterHeld(c.b), 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(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(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 { + const fused = (it as FuseIter).inner; + return fmtDebugStructFields(f, "Fuse", ["iter"], [(f) => fmtOption(fused && iterHeld(fused), 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 && 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)]); +} + // 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. @@ -2148,7 +2263,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; @@ -3494,7 +3609,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 +3666,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 +3740,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 +3916,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 80ecb9edf..26bac5dda 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -353,6 +353,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) => + { + 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]), @@ -649,6 +655,109 @@ 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, +) -> 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()); + // 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, _) = super::iter::peel_iter(b, ty, Expr::undefined()); + b.fmt_fn(Trait::Debug, ty, span) + }; + Some(match path.as_slice() { + [ + "iter", + "adapters", + _, + adaptor @ ("Map" | "Filter" | "FilterMap" | "Inspect" | "MapWhile" | "Rev"), + ] => 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) => + { + call("fmtAround", vec![name("Copied"), name("it"), wrapped(b, arg(0)?)]) + } + ["iter", "adapters", _, adaptor @ ("Copied" | "Cloned")] => { + let inner = wrapped(b, arg(0)?); + call("fmtAdaptor", vec![name(adaptor), inner, name("it")]) + } + ["iter", "adapters", "enumerate", "Enumerate"] => call("fmtEnumerate", vec![wrapped(b, arg(0)?)]), + ["iter", "adapters", _, adaptor @ ("Skip" | "Take")] => { + call("fmtCounted", vec![name(adaptor), wrapped(b, arg(0)?)]) + } + ["iter", "adapters", _, adaptor @ ("SkipWhile" | "TakeWhile")] => { + call("fmtFlagged", vec![name(adaptor), wrapped(b, arg(0)?)]) + } + ["iter", "adapters", "scan", "Scan"] => { + let inner = wrapped(b, arg(0)?); + call("fmtScan", vec![inner, b.fmt_fn(Trait::Debug, arg(1)?, span)]) + } + ["iter", "adapters", "peekable", "Peekable"] => { + 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![wrapped(b, arg(0)?)]), + ["iter", "adapters", "chain", "Chain"] => { + 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"] => { + 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 = wrapped(b, a); + call("fmtZip", vec![a, wrapped(b, other)]) + } + } + } + ["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")] => { + 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 = 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![wrapped(b, arg(0)?)]), + // A `str`'s escape is the `flat_map` of its chars it holds. + [ + "str", + "iter", + escape @ ("EscapeDebug" | "EscapeDefault" | "EscapeUnicode"), + ] => { + let field = tcx.adt_def(did).non_enum_variant().fields.iter().next()?; + let inner = b.fmt_fn(Trait::Debug, b.t.field_ty(field.did, args), span); + call("fmtAround", vec![name(escape), name("inner"), inner]) + } + _ => 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 4ca34a233..9538ff48c 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -1111,7 +1111,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. @@ -1121,7 +1138,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. @@ -1344,7 +1361,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])) @@ -1352,7 +1369,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])) @@ -1365,6 +1382,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" @@ -1485,18 +1505,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`