diff --git a/quest/m2/ts-model/std-rest.md b/quest/m2/ts-model/std-rest.md index f67814daa..cff1ad2bf 100644 --- a/quest/m2/ts-model/std-rest.md +++ b/quest/m2/ts-model/std-rest.md @@ -18,6 +18,11 @@ the rest of what the census refused in std. Decided with the maintainer on 2026- capacity by element size, `with_capacity` exact, `shrink_to`, and what `collect` and `clone` allocate), through every runtime function that allocates. Measure push cost on the TS benchmark before and after. +- An extend reserves by the size hint only once the collection is full, so its `capacity + overflow` depends on capacity. Until it is modeled, `rt.vecCapacity` takes every `Vec`, + `VecDeque`, and `BinaryHeap` an extend starts from as full, which is std's for one + `Vec::new`, `vec!`, or a `TrustedLen` collect made, but not after a `reserve` or `pop`: + replace it with the real capacity. - `RandomState` and `BuildHasher::hash_one` landed first, in [#261](https://github.com/moq-dev/rust2/pull/261), for hashbrown's default hasher. diff --git a/quest/m3/README.md b/quest/m3/README.md index cea1dee97..48c107267 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -28,7 +28,6 @@ generic std gap is planned here even when moq never calls it. - [Drop order in std's folds and iterators](/quest/m3/ts-drop-order.md) - the values that drop still refused in std's folds, zips, flattens, and collects drop as std's do - [Set operations](/quest/m3/ts-set-ops.md) - `union`, `intersection`, `difference`, and `symmetric_difference` of hash and B-tree sets translate - [References to byte arrays std takes](/quest/m3/ts-byte-refs-taken.md) - `extend` by references to arrays, adaptors' closures over held arrays, and a collection of both forms translate -- [Size hints of std's iterators](/quest/m3/ts-size-hints.md) - `size_hint` translates, and `Vec`'s collect and extend panic past `isize::MAX` as std's do - [A closure's () result as a value](/quest/m3/ts-unit-closures.md) - a closure returning `()` whose result is a value, as in a `Vec<()>` collected from `map`, type-checks - [std accessors with no mapping](/quest/m3/ts-unmapped-accessors.md) - `VecDeque::swap_remove_*`, `HashSet::replace`, `BTreeSet::get`, `take`, and `replace`, `Vec::pop_if`, and `Arc` and `Rc::into_inner` translate - [Equality of std containers of unlike elements](/quest/m3/ts-eq-unlike.md) - `==` and `next_if_eq` of a `Vec` against a `&[Right]`, and of `VecDeque` against `Vec`, translate @@ -37,3 +36,6 @@ generic std gap is planned here even when moq never calls it. - [Waiting: a slice object for a mutable part of other values](/quest/m3/ts-slice-object.md) - waits on a moq profile showing the `Proxy` view's traps matter, then decides on an `rt.ByteSlice`-like form - [Port the workflow guard to kixelated/quest](/quest/m3/quest-workflow-guard.md) - quest's environment guard parses YAML as this repository's does - [A parameter read only where lowering leaves nothing](/quest/m3/ts-unread-params.md) - an instance whose lowering drops every read of a parameter marks it unused, so `tsc` accepts it +- [Zero-sized values made out of sight](/quest/m3/ts-zero-sized.md) - unit structs and empty arrays returned, and std adaptors of only zero-sized fields, translate +- [Array keys a collection holds](/quest/m3/ts-array-keys.md) - collections of `[T; N]` keys type-check +- [Zip's next_back in constant time](/quest/m3/ts-zip-back.md) - a reversed zip of random-access iterators skips the longer side's excess at once diff --git a/quest/m3/ts-array-keys.md b/quest/m3/ts-array-keys.md new file mode 100644 index 000000000..1b7748459 --- /dev/null +++ b/quest/m3/ts-array-keys.md @@ -0,0 +1,15 @@ +# [S] Array keys a collection holds + +## Goal + +rust2-ts translates a `HashMap`, `HashSet`, `BTreeMap`, or `BTreeSet` of `[T; N]` keys +to TypeScript `tsc` accepts, proven by a differential test against native Rust. + +## Plan + +Found by `hints.rs` in the lang fixture: a collection of `[u32; 275]` keys casts its +`rt.cmpSlice` collection of `ArrayLike` keys to one of `u32[]`, which `tsc` rejects. Its +`[u8; 3]` items, collected in a function generic over them, refuse as +[ts-byte-refs-taken](/quest/m3/ts-byte-refs-taken.md) describes. + +Public API: the translator's output. diff --git a/quest/m3/ts-size-hints.md b/quest/m3/ts-size-hints.md deleted file mode 100644 index e421f7a4a..000000000 --- a/quest/m3/ts-size-hints.md +++ /dev/null @@ -1,20 +0,0 @@ -# [M] Size hints of std's iterators - -## Goal - -[rust2-ts](/ts/README.md) translates `Iterator::size_hint` of std's iterators, and each -collect and extend of a collection that reserves by one, such as `Vec`'s `collect` and -`extend`, panics with std's `capacity overflow` where std's does, proven by differential -tests against native Rust. - -## Plan - -Found by [#284](https://github.com/moq-dev/rust2/pull/284) on 2026-10-30, which gives -`rt.Iter` a `lower` bound, exact for ranges and what adapts them, and reserves it in -`String`'s `Extend`. `Vec`'s `collect` of a `TrustedLen` iterator reserves its upper -bound and panics without one, and its `extend` reserves the lower bound; `rt.iterToArray` -and `rt.iterExtend` reserve neither, so `(0..u32::MAX).map(f).collect::>()` reads -on until memory runs out where std's panics before calling `f`. A call of `size_hint` -itself needs the upper bound too, and the crate's own `size_hint` is refused. - -Public API: the translator's output. diff --git a/quest/m3/ts-zero-sized.md b/quest/m3/ts-zero-sized.md new file mode 100644 index 000000000..e19587303 --- /dev/null +++ b/quest/m3/ts-zero-sized.md @@ -0,0 +1,18 @@ +# [M] Zero-sized values made out of sight + +## Goal + +rust2-ts translates the zero-sized values MIR never assigns, proven by differential tests +against native Rust: a function or closure returning a unit struct or an empty array, as +`#[derive(Clone)]` of a unit struct and `|_| [0u8; 0]` do, and a std adaptor of only +zero-sized fields, as `iter::from_fn` of a closure capturing nothing is. + +## Plan + +Found by `hints.rs` in the lang fixture. The first emits `return _0` of a return place +`unassigned` skips, which `tsc` rejects, and the second refuses as "constructing +`std::iter::FromFn<..>` from another crate". Once they translate, along with +[ts-unit-closures](/quest/m3/ts-unit-closures.md), `hints::reserves` covers a `Vec` of +zero-sized elements, which holds `usize::MAX`, and `hints::hints` a flatten of `[T; 0]`. + +Public API: the translator's output. diff --git a/quest/m3/ts-zip-back.md b/quest/m3/ts-zip-back.md new file mode 100644 index 000000000..15a7cea1a --- /dev/null +++ b/quest/m3/ts-zip-back.md @@ -0,0 +1,15 @@ +# [XS] Zip's next_back in constant time + +## Goal + +`next_back` of a `Zip` of two `TrustedRandomAccess` iterators, such as ranges or slices, +skips the longer side's excess in constant time as std's does, rather than reading each +item, so a zip of `0..u32::MAX` with `0..1` reversed returns at once. Benchmarked. + +## Plan + +`rt.TrustedZipIter` inherits `ZipIter`'s trim, which calls `nextBack` once per excess item. +std reads no excess item of a side whose `MAY_HAVE_SIDE_EFFECT` is false and indexes by +position; a side that may have side effects still runs them. + +Public API: the translator's output. diff --git a/ts/README.md b/ts/README.md index a715d5387..afadb6d6f 100644 --- a/ts/README.md +++ b/ts/README.md @@ -222,7 +222,11 @@ An iterator over a slice, array, or `Vec`, or a small range, that only its `next moves read steps in place, as two variables: the array and an index into it, or the range's bounds, with no `rt.Iter` made. The crate's own `impl Iterator` returns `rt.DONE` from its `next` too, and joins std's adaptors through `rt.iterFrom`. A caller calls `next()` for one item, or iterates -an `rt.Iter` with `for ... of`. +an `rt.Iter` with `for ... of`. Each `rt.Iter`'s `sizeHint` is std's `size_hint`, its upper +bound `undefined` for `None`, and a `collect` or `extend` into a `Vec`, `VecDeque`, +`BinaryHeap`, B-tree, or hash collection reserves by it where std's does, panicking with +std's capacity overflow past the most it holds. Capacity isn't modeled, so a collection +an `extend` starts from is taken as full. A `str` is a JS string, which is UTF-16: `chars` steps by code point, and a search by a `char`, a `&str`, a predicate, or an array or slice of chars, as in `rt.strSplit(s, "/")`, takes the text or the diff --git a/ts/fixtures/bind/expected/harness.ts b/ts/fixtures/bind/expected/harness.ts index f9dd684c4..f73fad43b 100644 --- a/ts/fixtures/bind/expected/harness.ts +++ b/ts/fixtures/bind/expected/harness.ts @@ -157,7 +157,7 @@ export function keys(input: rt.ByteSlice, bytes: Blob.Blob, out: rt.ByteVec): vo } rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(ordered), (n2: Nibble.Nibble): rt.u8 => { return Nibble.get(n2); - })); + }), undefined, true); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 2539171df..234596605 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -312,7 +312,7 @@ export function ordered(data: rt.ByteSlice, out: rt.ByteVec): void { export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let v: rt.u32[] = rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u64Low(rt.u64Clamp(takeU64(data)[0], 1, 65536))), (i: rt.u32): rt.u32 => { return rt.u32Rem(rt.u32Mul(i, 40503), 1 << 16); - })); + }), undefined, 4, true); if (selector === 0) { rt.sliceSort(v, rt.lt); } else if (selector === 1) { diff --git a/ts/fixtures/crates/expected/harness.ts b/ts/fixtures/crates/expected/harness.ts index 11cacaee3..8f0298560 100644 --- a/ts/fixtures/crates/expected/harness.ts +++ b/ts/fixtures/crates/expected/harness.ts @@ -17,18 +17,18 @@ export function run(input: rt.ByteSlice): rt.ByteVec { const p: Point.Point = { x: input.data[input.start] as rt.i32, y: input.data[input.start + 1] as rt.i32 }; const q: Point.Point = copy$Point(p); Point.shift(q, 1, -1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(p.x & 0xff, p.y & 0xff, q.x & 0xff, q.y & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(p.x & 0xff, p.y & 0xff, q.x & 0xff, q.y & 0xff)), undefined, true); } const _29: Item.Item | undefined = heaviest$Item(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(input)), (_2: rt.u8): Item.Item => { return { _0: _2 }; - }))); + }), undefined, 1, true)); if (_29 !== undefined) { rt.byteVecPush(out, _29._0); } const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const guards: Guard.Guard[] = rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(input)), 3), (_26: rt.u8): Guard.Guard => { return Guard.new(_26, log); - })); + }), undefined, 8, true); const held: Guard.Guard = Guard.new(255, log); rt.dropAll(guards); const _late: Guard.Guard = Guard.new(254, log); @@ -36,7 +36,7 @@ export function run(input: rt.ByteSlice): rt.ByteVec { _late[Symbol.dispose](); const _58: rt.Mutex = rt.mutexLock(log.value); const _54: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_58.value))); - rt.iterExtendBytes(out, _54); + rt.iterExtendBytes(out, _54, undefined, true); rt.mutexUnlock(_58); if (input.length >= 3) { const item: Item.Item = { _0: input.data[input.start] }; @@ -44,8 +44,8 @@ export function run(input: rt.ByteSlice): rt.ByteVec { const guard: Guard.Guard = Guard.new(input.data[input.start + 2], log); const _77: Tally.Tally[] = [new Tally.Item(item), new Tally.u32$Place(rt.place(() => n, (value) => n = value)), new Tally.Guard(guard)]; const _87: Uint8Array = rt.u32ToBeBytes(tally(_77, input.data[input.start])).reverse(); - rt.iterExtendBytes(out, rt.iterSlice(_87)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(item._0, n & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(_87), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(item._0, n & 0xff)), undefined, true); const boxed: Tally.Tally[] = [new Tally.Guard(guard), new Tally.Item(item), new Tally.u32(n)]; rt.sliceSwap(boxed, 0, 2); rt.vecTruncate(boxed, 2, rt.drop); @@ -62,7 +62,7 @@ export function run(input: rt.ByteSlice): rt.ByteVec { rt.dropAll(boxed); const _133: rt.Mutex = rt.mutexLock(log.value); const _129: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_133.value))); - rt.iterExtendBytes(out, _129); + rt.iterExtendBytes(out, _129, undefined, true); rt.mutexUnlock(_133); } const iter2: Countdown.Countdown = Countdown.new(rt.min(input.length, 4) & 0xff); @@ -76,7 +76,7 @@ export function run(input: rt.ByteSlice): rt.ByteVec { const kept: rt.i16[] = [(input.length << 16) >> 16, 7]; const filled: rt.i16[] = copy$i16s(kept); Slots.fill(Slots.withBase(kept[0]), filled); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(kept[0] & 0xff, kept[1] & 0xff, filled[0] & 0xff, filled[1] & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(kept[0] & 0xff, kept[1] & 0xff, filled[0] & 0xff, filled[1] & 0xff)), undefined, true); const _181: rt.u8 = first(input); rt.byteVecPush(out, _181); const _184: rt.u8 = last.last(input); diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 762d4e242..2a2b622fe 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -484,4 +484,21 @@ const iters = Array.from({ length: 12 }, (_, kind) => [[], [2, 7, 9, 14], [0, 2, const hintedOp = op("strs::hinted"); const hinted = Array.from({ length: 10 * 7 * 21 }, (_, i) => Uint8Array.of(hintedOp, i % 10, Math.floor(i / 10) % 7, Math.floor(i / 70))); -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers]; +/** + * `hints::hints` of each iterator, each pair of lengths, and each of its arms, read three + * times each way, with as many bytes as the first length's index. + */ +const hintsOp = op("hints::hints"); +const hints = Array.from({ length: 24 * 8 * 8 * 8 * 2 }, (_, i) => { + const [kind, n, m, arm, back] = [i % 24, Math.floor(i / 24) % 8, Math.floor(i / 192) % 8, Math.floor(i / 1536) % 8, Math.floor(i / 12288)]; + const steps = (arm << 5) | ((back ? 0b101 : 0b010) << 2) | 3; + return Uint8Array.of(hintsOp, kind, n, m, steps, ...Array.from({ length: n }, (_, b) => b * 37)); +}); + +/** `hints::reserves` of each collection and element type, each shape, length, and limit on what it reads. */ +const reservesOp = op("hints::reserves"); +const reserves = Array.from({ length: 13 * 5 * 5 * 4 * 5 }, (_, i) => + Uint8Array.of(reservesOp, i % 65, Math.floor(i / 65) % 5, Math.floor(i / 325) % 4, Math.floor(i / 1300)), +); + +export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves]; diff --git a/ts/fixtures/lang/expected/bounds.ts b/ts/fixtures/lang/expected/bounds.ts index e3eb8e462..411fee8bd 100644 --- a/ts/fixtures/lang/expected/bounds.ts +++ b/ts/fixtures/lang/expected/bounds.ts @@ -129,7 +129,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const j: rt.usize = _18[1]; const items: Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))), (_2: rt.u8): Item.Item => { return new Item.Item(_2); - })); + }), undefined, 1, true); const _28: rt.u8 = rt.u8Rem(kind, 6); if (_28 === 0) { const range: [rt.RangeBound, rt.RangeBound] = [bound$usize$2(s, i), bound$usize$2(e, j)]; @@ -147,20 +147,20 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.drop(iter); const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 4)); const _49: [rt.RangeBound, rt.RangeBound] = [bound$usize(s, i), bound$usize(e, j)]; - rt.iterExtendBytes(out, rt.iterRev(rt.byteVecDrain(bytes, _49)), "fold"); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); + rt.iterExtendBytes(out, rt.iterRev(rt.byteVecDrain(bytes, _49)), "fold", true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))), (_216: rt.u8): rt.u32 => { return rt.u32Add(_216 as rt.u32, 1000); - })); + }), undefined, 4, true); const drain: rt.Iter = rt.vecDrain(words, range); rt.iterExtendBytes(out, rt.iterOption(map$0a57co2(rt.iterToOption(drain.nextBack()), (w: rt.u32): rt.u8 => { return w & 0xff; - }))); + })), undefined, true); rt.byteVecPush(out, drain.len() & 0xff); rt.drop(drain); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_217: rt.u32): rt.u8 => { return _217 & 0xff; - })); + }), undefined, true); } else if (_28 === 1) { const _78: Asked.Asked = asked$usize(s, e, i, j); const drain2: rt.Iter = rt.vecDrain(items, rt.boundsOf(_78, Asked.startBound$RangeBounds_usize_usize, Asked.endBound$RangeBounds_usize_usize), rt.drop); @@ -169,7 +169,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _09: rt.u8 = x5.tag; x5[Symbol.dispose](); return _09; - }))); + })), undefined, true); flush(out); rt.drop(drain2); flush(out); @@ -177,7 +177,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _94: Asked.Asked = asked$usize(s, e, i, j); rt.byteVecPush(out, rt.ownedCount(rt.byteVecDrain(bytes2, rt.boundsOf(_94, Asked.startBound$RangeBounds_usize_usize, Asked.endBound$RangeBounds_usize_usize))) & 0xff); flush(out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes2))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes2)), undefined, true); } else if (_28 === 2) { const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))); @@ -200,13 +200,13 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _06: rt.u8 = x2.tag; x2[Symbol.dispose](); return _06; - }))); + })), undefined, true); flush(out); rt.drop(drain3); flush(out); rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(queue), (x3: Item.Item): rt.u8 => { return x3.tag; - })); + }), undefined, true); const reach2: rt.usize = rt.usizeAdd(queue.n, 1); const _138: Asked.Asked = asked$usize(s, e, rt.usizeRem(a as rt.usize, reach2), rt.usizeRem(b as rt.usize, reach2)); const drain4: rt.Iter = rt.dequeDrain(queue, rt.boundsOf(_138, Asked.startBound$RangeBounds_usize_usize, Asked.endBound$RangeBounds_usize_usize), rt.drop); @@ -215,13 +215,13 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(out); rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(queue), (x4: Item.Item): rt.u8 => { return x4.tag; - })); + }), undefined, true); rt.dequeDrop(queue, rt.drop); } else if (_28 === 3) { const _155: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))), (_210: [rt.usize, rt.u8]): [rt.u8, rt.u8] => { return [_210[1], _210[0] & 0xff] as [rt.u8, rt.u8]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _155, true); + const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _155, true, undefined, undefined, undefined, 2, true); const range2: [rt.RangeBound, rt.RangeBound] = [bound$u8$2(s, a), bound$u8$2(e, b)]; const iter3: rt.Iter<[rt.u8, rt.u8]> = rt.btreeRange(map, range2); while (true) { @@ -235,7 +235,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _180: [rt.RangeBound, rt.RangeBound] = [bound$u8(s, a), bound$u8(e, b)]; rt.iterExtendBytes(out, rt.iterOption(map$1hdkvwd(rt.iterToOption(rt.btreeRange(map, _180).nextBack()), (_214: [rt.u8, rt.u8]): rt.u8 => { return _214[0]; - }))); + })), undefined, true); const iter4: rt.Iter<[rt.u8, rt.Place]> = rt.btreeRangeMut(map, range2); while (true) { const _189: [rt.u8, rt.Place] | rt.Done = iter4.next(); @@ -244,9 +244,9 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } _189[1].v = rt.u8WrappingAdd(_189[1].v, 100); } - rt.iterExtendBytes(out, rt.btreeValues(map)); + rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); const _199: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _199, true); + const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _199, true, undefined, undefined, 1, true); rt.iterExtendBytes(out, rt.iterRev(rt.btreeRangeKeys(set, range2))); rt.byteVecPush(out, within$Bound_u8_Bound_u8(set, range2) & 0xff); } else if (_28 === 4) { @@ -255,12 +255,12 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.iterCount(rt.btreeRange(empty, rt.boundsOf(_215, Asked.startBound$RangeBounds_u8_u8, Asked.endBound$RangeBounds_u8_u8))) & 0xff); flush(out); const _218: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))); - const set2: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _218, true); + const set2: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _218, true, undefined, undefined, 1, true); const _222: Asked.Asked = asked$u8(s, e, a, b); const range3: rt.Iter = rt.btreeRangeKeys(set2, rt.boundsOf(_222, Asked.startBound$RangeBounds_u8_u8, Asked.endBound$RangeBounds_u8_u8)); flush(out); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(range3.next()))); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(range3.nextBack()))); + rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(range3.next())), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(range3.nextBack())), undefined, true); const _234: Asked.Asked = asked$u8(s, e, a, b); rt.byteVecPush(out, within$Asked_u8(set2, _234) & 0xff); flush(out); @@ -297,7 +297,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { _278[1].v = _278[1].v ^ 128; } flush(out); - rt.iterExtendBytes(out, rt.btreeValues(map2)); + rt.iterExtendBytes(out, rt.btreeValues(map2), undefined, true); const pairs: rt.BTreeSet<[rt.u8, Key.Key]> = rt.btreeNew(rt.cmpTuple([rt.cmp, Key.cmp$Ord])) as rt.BTreeSet<[rt.u8, Key.Key]>; for (const k2 of rt.byteSliceView(rt.byteSliceRange(data, 4))) { rt.btreeAdd(pairs, [k2, { _0: k2 }] as [rt.u8, Key.Key]); @@ -314,7 +314,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(out); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(items), (x6: Item.Item): rt.u8 => { return x6.tag; - })); + }), undefined, true); rt.dropAll(items); flush(out); } diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 992e07504..34a26886c 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -94,7 +94,7 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_4 === 2) { const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { return rt.charFromU32(a0); - })); + }), undefined, 4); const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; const seen: rt.HashSet = rt.hashNew() as rt.HashSet; const iter3: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(cs)); diff --git a/ts/fixtures/lang/expected/chunks.ts b/ts/fixtures/lang/expected/chunks.ts index 816d4b951..0fb4486f1 100644 --- a/ts/fixtures/lang/expected/chunks.ts +++ b/ts/fixtures/lang/expected/chunks.ts @@ -143,7 +143,7 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { const b2: rt.u8 = _2; return Uint8Array.of(b2, rt.u8WrappingAdd(b2, 3)); - })); + }), undefined, 2, true); if (pairs.length >= 2) { const first2: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(pairs[rt.idx(pairs, 0)])); const _195: rt.ByteSlice = rt.byteSliceFrom(pairs[rt.idx(pairs, 1)]); @@ -170,12 +170,12 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } _234.data[_234.start] = _234.data[_234.start + 1]; } - const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray)); + const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); rt.iterExtendBytes(out, rt.iterChain(rt.iterMap(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), (p: rt.ByteSlice): rt.u8 => { return p.data[p.start]; }), rt.iterMap(rt.iterMap(rt.iterSlice(copies), rt.byteSliceFrom), (p2: rt.ByteSlice): rt.u8 => { return p2.data[p2.start + 1]; - }))); + })), undefined, true); } else { let restData2: Uint8Array = data.data; let restStart2: number = data.start; diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index a71883d6b..2fb647c1c 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -102,7 +102,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _80: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map), (_231: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { return [_231[0], _231[1]] as [rt.u8, rt.u16]; }); - const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _80, true)); + const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _80, true, undefined, undefined, undefined, 4)); while (true) { const _86: [rt.u8, rt.u16] | rt.Done = iter2.next(); if (_86 === rt.DONE) { @@ -134,7 +134,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } } const _136: rt.Iter = rt.hashKeys(map2); - const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _136, true)); + const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _136, true, undefined, undefined, 8)); while (true) { const _142: rt.u64 | rt.Done = iter4.next(); if (_142 === rt.DONE) { @@ -189,7 +189,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _238: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.hashIter(map3), (_212: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { return [_212[0]._0, _212[1]] as [rt.u8, rt.u8]; }); - const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _238, true)); + const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _238, true, undefined, undefined, undefined, 2)); while (true) { const _243: [rt.u8, rt.u8] | rt.Done = iter6.next(); if (_243 === rt.DONE) { @@ -213,7 +213,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, before.n & 0xff); rt.byteVecPush(out, rt.hashIndex(pairs, key).n & 0xff); const _278: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.hashIter(pairs); - const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _278, true)); + const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _278, true, undefined, undefined, undefined, 6)); while (true) { const _282: [Pair.Pair, Tally.Tally] | rt.Done = iter7.next(); if (_282 === rt.DONE) { @@ -271,7 +271,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const b8: rt.u8 = _227; return [rt.u8Rem(b8, 8), { n: b8 as rt.u16 }] as [rt.u8, Tally.Tally]; }); - const bytes: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _361); + const bytes: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _361, undefined, undefined, undefined, 234881024); const copy2: rt.HashMap = rt.hashClone(bytes, undefined, copy$Tally); const iter9: rt.Iter = rt.hashValues(copy2); while (true) { @@ -300,7 +300,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void stamp(stamped); rt.byteVecPush(out, rt.hashLen(stamped) & 0xff); const extended: rt.HashMap = rt.hashNew() as rt.HashMap; - rt.hashExtend(extended, rt.iterMap(rt.hashIter(bytes), copy$u8_Tally)); + rt.hashExtend(extended, rt.iterMap(rt.hashIter(bytes), copy$u8_Tally), undefined, undefined, undefined, 234881024); const iter12: rt.Iter = rt.hashValues(extended); while (true) { const _422: Tally.Tally | rt.Done = iter12.next(); @@ -339,7 +339,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _486: rt.Iter<[Rank.Rank, rt.u16]> = rt.iterMap(rt.hashIter(ranks), (_230: [Rank.Rank, Tally.Tally]): [Rank.Rank, rt.u16] => { return [_230[0], _230[1].n] as [Rank.Rank, rt.u16]; }); - const iter14: rt.Iter<[Rank.Rank, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap, _486, true)); + const iter14: rt.Iter<[Rank.Rank, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap, _486, true, undefined, undefined, undefined, 6)); while (true) { const _492: [Rank.Rank, rt.u16] | rt.Done = iter14.next(); if (_492 === rt.DONE) { @@ -416,7 +416,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _596: rt.Iter = rt.iterMap(rt.hashKeys(clashes), (k8: Clash.Clash): rt.u8 => { return k8._0; }); - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _596, true))); + rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _596, true, undefined, undefined, 1)), undefined, true); const copy3: rt.HashMap = rt.hashClone(clashes, undefined, copy$Tally); rt.byteVecPush(out, rt.hashLen(copy3) & 0xff); rt.byteVecPush(out, rt.hashContains(copy3, { _0: 1 }) ? 1 : 0); @@ -486,7 +486,7 @@ export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, unwrapOr$1j4op5y(rt.btreeFirstKey(sorted), 255) & 0xff); rt.byteVecPush(out, unwrapOr$1j4op5y(rt.btreeFirstKey(sorted, true), 255) & 0xff); - rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12))).length & 0xff); + rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12)), undefined, 2).length & 0xff); rt.hashRetain(hashed, (v3: rt.u16): boolean => { return rt.u16Rem(v3, 3) !== 0; }); @@ -496,7 +496,7 @@ export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(sorted), (v5: rt.u16): rt.u8 => { return v5 & 0xff; - })); + }), undefined, true); } else if (_4 === 1) { const nibbles: rt.BTreeSet = rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet; const seen: rt.HashSet = rt.hashNew(rt.hashing(Nibble.hash$Hash_DefaultHasher, Nibble.eq$PartialEq)) as rt.HashSet; @@ -556,7 +556,7 @@ export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _200: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u64 => { return wide(_2); }); - const iter8: rt.Iter = rt.iterRev(rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _200, true))); + const iter8: rt.Iter = rt.iterRev(rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _200, true, undefined, undefined, 8, true))); while (true) { const _207: rt.u64 | rt.Done = iter8.next(); if (_207 === rt.DONE) { @@ -642,8 +642,8 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } rt.byteVecPush(out, _101); } - rt.iterExtendBytes(out, rt.btreeKeys(map)); - rt.iterExtendBytes(out, rt.btreeValues(map)); + rt.iterExtendBytes(out, rt.btreeKeys(map), undefined, true); + rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); rt.byteVecPush(out, mapOr$1surhce(rt.iterToOption(rt.btreeKeys(map).nextBack()), 255, (k4: rt.u8): rt.u8 => { return k4; })); @@ -677,7 +677,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi })); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(within)); - rt.iterExtendBytes(out, rt.btreeValues(map)); + rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); } else if (_4 === 1) { const ranks: rt.BTreeMap = rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap; const pairs: rt.BTreeMap<[rt.u8, rt.u8], rt.u8> = rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; @@ -751,7 +751,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi const b8: rt.u8 = _221; return [{ _0: b8 }, { _0: b8 ^ 90 }] as [Fussy.Fussy, Fussy.Fussy]; }); - const iter10: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.btreeIter(rt.btreeClone(rt.btreeExtend(rt.btreeNew(Fussy.cmp$Ord) as rt.BTreeMap, _308, true), Fussy.clone$Clone, Fussy.clone$Clone)); + const iter10: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.btreeIter(rt.btreeClone(rt.btreeExtend(rt.btreeNew(Fussy.cmp$Ord) as rt.BTreeMap, _308, true, undefined, undefined, undefined, 2, true), Fussy.clone$Clone, Fussy.clone$Clone)); while (true) { const _315: [Fussy.Fussy, Fussy.Fussy] | rt.Done = iter10.next(); if (_315 === rt.DONE) { @@ -816,11 +816,11 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi const b5: rt.u8 = _2; return [{ _0: b5 }, b5] as [Nibble.Nibble, rt.u8]; }); - const collected: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap, _430, true); + const collected: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeMap, _430, true, undefined, undefined, undefined, 2, true); const _433: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): Nibble.Nibble => { return { _0: _216 }; }); - const keys: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet, _433, true); + const keys: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Nibble.cmp$Ord) as rt.BTreeSet, _433, true, undefined, undefined, 1, true); const _437: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_219: rt.u8): Nibble.Nibble => { return { _0: _219 ^ 48 }; }); @@ -888,14 +888,14 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { touch(q); touch(q); rt.byteVecPush(out, q.n & 0xff); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); + rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); if (!((q.n === 0))) { rt.byteVecPush(out, rt.dequeIndex(q, rt.usizeDiv(q.n, 2))); } rt.dequeRetain(q, (b3: rt.u8): boolean => { return rt.u8Rem(b3, 2) === 0; }); - rt.iterExtendBytes(out, rt.dequeIter(q)); + rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.dequeIter(pairs); while (true) { const _83: [rt.u8, rt.u8] | rt.Done = iter2.next(); @@ -909,7 +909,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { const _101: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tally.Tally => { return { n: _2 as rt.u16 }; }); - const tallies: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _101); + const tallies: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _101, undefined, 2, true); const copy: rt.VecDeque = rt.dequeClone(tallies, copy$Tally); const _105: Tally.Tally | undefined = rt.dequeEnd(copy); if (_105 !== undefined) { @@ -917,33 +917,33 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t: Tally.Tally): rt.u8 => { return t.n & 0xff; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t2: Tally.Tally): rt.u8 => { return t2.n & 0xff; - })); + }), undefined, true); const _119: rt.Iter = rt.dequeIter(tallies); - rt.dequeExtend(copy, rt.iterMap(_119, copy$Tally)); + rt.dequeExtend(copy, rt.iterMap(_119, copy$Tally), undefined, 2, true); const _121: Tally.Tally | undefined = rt.dequeEnd(copy, true); if (_121 !== undefined) { _121.n = _121.n ^ 255; } rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t3: Tally.Tally): rt.u8 => { return t3.n & 0xff; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t4: Tally.Tally): rt.u8 => { return t4.n & 0xff; - })); + }), undefined, true); const _135: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.dequeExtend(q, _135); + rt.dequeExtend(q, _135, undefined, 1, true); rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66); rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.dequeRemove(q, 1), 233)); rt.dequeTruncate(q, 5); rt.byteVecPush(out, rt.dequeContains(q, 66, rt.same) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q))); + rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); const a: rt.usize = rt.usizeRem(unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, 8); const b2: rt.usize = rt.usizeRem(unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0) as rt.usize, 8); const _171: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _171); + const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _171, undefined, 1, true); const _174: rt.usize = rt.usizeRem(a, 4); if (_174 === 0) { drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2))); @@ -956,7 +956,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a })); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(drained2)); - rt.iterExtendBytes(out, rt.dequeIter(q2)); + rt.iterExtendBytes(out, rt.dequeIter(q2), undefined, true); rt.byteVecPush(out, rt.dequeIndex(q2, b2)); } @@ -988,25 +988,25 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecOf(b, n))); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem(rt.u16Mul(a as rt.u16, 257), n, undefined)), (w: rt.u16): rt.u8 => { return rt.u16Shr(w, 4) & 0xff; - })); + }), undefined, true); const tuples: [rt.u8, rt.u8][] = rt.vecFromElem([a, b] as [rt.u8, rt.u8], n, copy$u8_u8); if (n > 0) { tuples[rt.idx(tuples, 0)][0] = 238; } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(tuples), (t: [rt.u8, rt.u8]): rt.u8 => { return t[0] ^ t[1]; - })); + }), undefined, true); rt.byteVecPush(out, rt.vecFromElem(name, n, undefined).length & 0xff); const cloned: Cloned.Cloned[] = rt.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(cloned), (c: Cloned.Cloned): rt.u8 => { return c.depth; - })); + }), undefined, true); rt.byteVecPush(out, rt.iterAll(rt.iterSlice(cloned), (c2: Cloned.Cloned): boolean => { return rt.stringLen(c2.name) === data.length; }) ? 1 : 0); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem({ _0: b }, n, Bumped.clone$Clone)), (o: Bumped.Bumped): rt.u8 => { return o._0; - })); + }), undefined, true); const pair: [rt.u8, rt.u8] = [a, b]; const held: Bumped.Bumped = { _0: a }; const listed: [rt.u8, rt.u8][] = copy$u8_u8s([pair, pair]).map(copy$u8_u8); @@ -1025,10 +1025,10 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, b, listed[rt.idx(listed, 1)][0], a))); rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(repeated), rt.iterSlice(again)), (t2: [rt.u8, rt.u8]): rt.u8 => { return t2[1]; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(bumps), rt.iterSlice(kept)), (o2: Bumped.Bumped): rt.u8 => { return o2._0; - })); + }), undefined, true); const grown: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(bytes)); const _167: rt.ByteSlice = rt.byteVecSlice(grown); rt.idx(_167, 0); @@ -1049,10 +1049,10 @@ export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(wrapped), (w2: Wrap.Wrap): rt.u8 => { return w2.value ^ w2.count; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(names), (s2: string): rt.u8 => { return rt.stringLen(s2) & 0xff; - })); + }), undefined, true); } /** Stores `p` by value in `v`. */ @@ -1103,7 +1103,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { const at4 = rt.idx(v, 4); v[at4][0] = v[at4][0] ^ 64; const _36: [rt.u8, rt.u8] = copy$u8_u8(changed); - rt.iterExtend(v, rt.iterSlice([copy$u8_u8(pair), _36])); + rt.iterExtend(v, rt.iterSlice([copy$u8_u8(pair), _36]), undefined, 2, true); const at5 = rt.idx(v, 5); v[at5][1] = v[at5][1] ^ 128; const at6 = rt.idx(v, 6); @@ -1116,7 +1116,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)); + }, (value: Uint8Array) => rt.iterSlice(value), false, 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() as rt.VecDeque; @@ -1133,7 +1133,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(q), (t: Tally.Tally): rt.u8 => { return t.n & 0xff; - })); + }), undefined, true); rt.byteVecPush(out, tally.n & 0xff); const hash: rt.HashMap = rt.hashNew() as rt.HashMap; rt.hashInsert(hash, 0, copy$u8_u8(pair)); @@ -1148,7 +1148,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { return 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)); + }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; rt.btreeInsert(tree, 0, copy$u8_u8(pair)); rt.btreeInsert(tree, 1, copy$u8_u8(pair)); @@ -1158,7 +1158,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)); + }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); const boxed: [rt.u8, rt.u8] = copy$u8_u8(pair); boxed[0] = boxed[0] ^ 1; const holders: Holder.Holder[] = [{ pair: copy$u8_u8(pair) }]; @@ -1228,7 +1228,7 @@ export function getMut$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap): [rt.u8, string | undefined][] { const all: [rt.u8, string | undefined][] = rt.iterToArray(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, string | undefined]): [rt.u8, string | undefined] => { return [_2[0], clone$14nprly(_2[1])] as [rt.u8, string | undefined]; - })); + }), undefined, 16); rt.sliceSortByKey(all, (_22: [rt.u8, string | undefined]): rt.u8 => { return _22[0]; }, rt.lt); @@ -1238,7 +1238,7 @@ export function sorted$OptionMap_Option_String_HashMap_u8_Option_String(self: rt export function sorted$OptionMap_Option_u8_HashMap_u8_Option_u8(self: rt.HashMap): [rt.u8, rt.u8 | undefined][] { const all: [rt.u8, rt.u8 | undefined][] = rt.iterToArray(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, rt.u8 | undefined]): [rt.u8, rt.u8 | undefined] => { return [_2[0], _2[1]] as [rt.u8, rt.u8 | undefined]; - })); + }), undefined, 3); rt.sliceSortByKey(all, (_22: [rt.u8, rt.u8 | undefined]): rt.u8 => { return _22[0]; }, rt.lt); @@ -1250,7 +1250,7 @@ export function sorted$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap { return _22[0]; }, rt.lt); @@ -1292,7 +1292,7 @@ export function getMut$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap): [rt.u8, rt.u8 | undefined][] { return rt.iterToArray(rt.iterMap(rt.btreeIter(self), (_22: [rt.u8, rt.u8 | undefined]): [rt.u8, rt.u8 | undefined] => { return [_22[0], _22[1]] as [rt.u8, rt.u8 | undefined]; - })); + }), undefined, 3, true); } export function sorted$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap): [rt.u8, undefined][] { @@ -1300,7 +1300,7 @@ export function sorted$OptionMap_unit_BTreeMap_u8_unit(self: rt.BTreeMap rt.fmtOption(_56, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_50, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBool(_53, f)]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]))); } - const all: [[rt.u8, boolean], rt.u8 | undefined][] = rt.iterToArray(rt.hashIter(map)); + const all: [[rt.u8, boolean], rt.u8 | undefined][] = rt.iterToArray(rt.hashIter(map), undefined, 4); rt.sliceSort(all, rt.cmpLt(rt.cmpTuple([rt.cmpTuple([rt.cmp, rt.cmp]), rt.cmpOption(rt.cmp)]))); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(all, f, (value: [[rt.u8, boolean], rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0][0], f), (f: rt.Formatter) => rt.fmtBool(value[0][1], f)], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index f42c511b3..c95023403 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -17,6 +17,7 @@ import type * as Twin from "../counts.Twin.ts"; import * as Made from "../defaults.Made.ts"; import type * as Shape from "../dyns.Shape.ts"; import * as Named from "../edits.Named.ts"; +import type * as Big from "../hints.Big.ts"; import type * as Quarter from "../iters.Quarter.ts"; import type * as Tilt from "../iters.Tilt.ts"; import { side, order } from "../keys.ts"; @@ -675,6 +676,13 @@ export function mapOr$1unqgn7(self: rt.Arc[] | undefined, de return f(self); } +export function mapOr$1cxlmys(self: Big.Big[] | undefined, default_: rt.usize, f: (a0: Big.Big[]) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1kiffmd(self: rt.u16[] | undefined, default_: rt.u8, f: (a0: rt.u16[]) => rt.u8): rt.u8 { if (self === undefined) { return default_; @@ -682,6 +690,20 @@ export function mapOr$1kiffmd(self: rt.u16[] | undefined, default_: rt.u8, f: (a return f(self); } +export function mapOr$1umcrqz(self: rt.u32[] | undefined, default_: rt.usize, f: (a0: rt.u32[]) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0pdoq6p(self: [rt.u64, rt.u8][] | undefined, default_: rt.usize, f: (a0: [rt.u64, rt.u8][]) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1a3irjf(self: rt.ByteVec | undefined, default_: rt.u8, f: (a0: rt.ByteVec) => rt.u8): rt.u8 { if (self === undefined) { return default_; @@ -689,6 +711,20 @@ export function mapOr$1a3irjf(self: rt.ByteVec | undefined, default_: rt.u8, f: return f(self); } +export function mapOr$0amk6zv(self: [rt.u8, rt.u8, rt.u8][] | undefined, default_: rt.usize, f: (a0: [rt.u8, rt.u8, rt.u8][]) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$08xwngs(self: rt.ByteVec | undefined, default_: rt.usize, f: (a0: rt.ByteVec) => rt.usize): rt.usize { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0atjiti(self: rt.char | undefined, default_: rt.u32, _: (a0: rt.char) => rt.u32): rt.u32 { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/expected/core/result.ts b/ts/fixtures/lang/expected/core/result.ts index d88a3e060..6930b9c03 100644 --- a/ts/fixtures/lang/expected/core/result.ts +++ b/ts/fixtures/lang/expected/core/result.ts @@ -557,6 +557,13 @@ export function unwrapOr$0hnup9g(self: rt.Result, default_: rt.u return default_; } +export function unwrapOr$0u9zzk3(self: rt.Result, default_: rt.u32): rt.u32 { + if (self.ok) { + return self.value; + } + return default_; +} + export function unwrapOr$1dnnsw8(self: rt.Result, default_: rt.u32): rt.u32 { if (self.ok) { return self.value; diff --git a/ts/fixtures/lang/expected/counts.ArcNode.ts b/ts/fixtures/lang/expected/counts.ArcNode.ts index 6d17f83b2..f835637b5 100644 --- a/ts/fixtures/lang/expected/counts.ArcNode.ts +++ b/ts/fixtures/lang/expected/counts.ArcNode.ts @@ -31,7 +31,7 @@ function new_(this_: rt.Weak, noisy: Noisy.Noisy, more: rt.u8): ArcNode const _4: rt.Weak = rt.weakClone(this_); const _5: rt.Weak[] = rt.iterToArray(rt.iterMap(new rt.Range(0, more), (_2: rt.u8): rt.Weak => { return rt.weakClone(this_); - })); + }), undefined, 4, true); const _13: rt.Arc | undefined = rt.weakUpgrade(this_); const _0: ArcNode = new ArcNode(_4, _5, noisy, Uint8Array.of(_13 === undefined ? 1 : 0, this_.arc.strong & 0xff, rt.weakWeakCount(this_) & 0xff)); rt.drop(_13); diff --git a/ts/fixtures/lang/expected/counts.RcNode.ts b/ts/fixtures/lang/expected/counts.RcNode.ts index 28452a41e..2b25a362f 100644 --- a/ts/fixtures/lang/expected/counts.RcNode.ts +++ b/ts/fixtures/lang/expected/counts.RcNode.ts @@ -31,7 +31,7 @@ function new_(this_: rt.Weak, noisy: Noisy.Noisy, more: rt.u8): RcNode { const _4: rt.Weak = rt.weakClone(this_); const _5: rt.Weak[] = rt.iterToArray(rt.iterMap(new rt.Range(0, more), (_2: rt.u8): rt.Weak => { return rt.weakClone(this_); - })); + }), undefined, 4, true); const _13: rt.Arc | undefined = rt.weakUpgrade(this_); const _0: RcNode = new RcNode(_4, _5, noisy, Uint8Array.of(_13 === undefined ? 1 : 0, this_.arc.strong & 0xff, rt.weakWeakCount(this_) & 0xff)); rt.drop(_13); diff --git a/ts/fixtures/lang/expected/counts.ts b/ts/fixtures/lang/expected/counts.ts index bff242858..04314cd1f 100644 --- a/ts/fixtures/lang/expected/counts.ts +++ b/ts/fixtures/lang/expected/counts.ts @@ -179,10 +179,10 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _05: rt.u8 = _53 === undefined ? 1 : 0; rt.drop(_53); return _05; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(weak), (w2: rt.Weak): rt.u8 => { return rt.weakWeakCount(w2) & 0xff; - })); + }), undefined, true); rt.dropAll(weak); const _236: rt.Mutex = rt.mutexLock(log.value); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_236.value)); @@ -202,7 +202,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const handles: rt.Arc[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (id: rt.u8): rt.Arc => { return new rt.Arc(new Noisy.Noisy(rt.u8Mul(id, 16), rt.arcClone(log))); - })); + }), undefined, 4, true); const kept: rt.Arc[] = []; const shared: ArcShared.ArcShared[] = []; const noisy: Noisy.Noisy[] = []; @@ -222,13 +222,13 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _48: rt.Arc | undefined = filter$1qg98un(again, (_210: rt.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_48, rt.drop), "fold"); + rt.iterExtend(kept, rt.iterOption(_48, rt.drop), "fold", 4, true); } else if (_34 === 1) { const _54: rt.Place> | undefined = rt.sliceGetMut(handles, rt.usizeRem(pick, handles.length)); const _61: rt.Arc | undefined = filter$1qg98un(_54 === undefined ? undefined : rt.arcClone(_54.v), (_29: rt.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_61, rt.drop), "fold"); + rt.iterExtend(kept, rt.iterOption(_61, rt.drop), "fold", 4, true); } else if (_34 === 2) { const _70: ArcShared.ArcShared[] = [new ArcShared.ArcShared(rt.arcClone(handles[at]), op)]; const _67: ArcShared.ArcShared | undefined = rt.sliceFirst(_70); @@ -240,7 +240,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _77: ArcShared.ArcShared | undefined = filter$1asvriw(one, (_26: ArcShared.ArcShared): boolean => { return keep; }); - rt.iterExtend(shared, rt.iterOption(_77, rt.drop), "fold"); + rt.iterExtend(shared, rt.iterOption(_77, rt.drop), "fold", 8, true); } else if (_34 === 3) { const made2: Noisy.Noisy = new Noisy.Noisy(op, rt.arcClone(log)); const _84: Noisy.Noisy | undefined = made2; @@ -251,12 +251,12 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _92: Noisy.Noisy | undefined = filter$1gka6nq(one2, (_25: Noisy.Noisy): boolean => { return keep; }); - rt.iterExtend(noisy, rt.iterOption(_92, rt.drop), "fold"); + rt.iterExtend(noisy, rt.iterOption(_92, rt.drop), "fold", 8, true); made2[Symbol.dispose](); } else if (_34 === 4) { const all: rt.Arc[] = rt.iterToArray(rt.iterMap(rt.iterSlice(handles), (a04: rt.Arc): rt.Arc => { return rt.arcClone(a04); - })); + }), undefined, 4, true); _191 = true; rt.byteVecPush(out, handles[at].strong & 0xff); if (keep) { @@ -268,15 +268,15 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { } _191 = false; } else if (_34 === 5) { - const again3: ArcShared.ArcShared[] = rt.iterToArray(rt.iterMap(rt.iterSlice(shared), ArcShared.clone$Clone)); + const again3: ArcShared.ArcShared[] = rt.iterToArray(rt.iterMap(rt.iterSlice(shared), ArcShared.clone$Clone), undefined, 8, true); _192 = true; - const ids: Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(noisy), Noisy.clone$Clone)); + const ids: Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(noisy), Noisy.clone$Clone), undefined, 8, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(ids), (n: Noisy.Noisy): rt.u8 => { return n.id; - })); + }), undefined, true); if (keep) { _192 = false; - rt.iterExtend(shared, rt.iterSlice(again3, rt.drop), "fold"); + rt.iterExtend(shared, rt.iterSlice(again3, rt.drop), "fold", 8, true); } rt.dropAll(ids); if (_192) { @@ -294,7 +294,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _134: rt.Arc[] | undefined = filter$16q8euf(list, (_2: rt.Arc[]): boolean => { return keep; }); - rt.iterExtend(lists, rt.iterOption(_134, drop$Vec_Arc_Noisy), "fold"); + rt.iterExtend(lists, rt.iterOption(_134, drop$Vec_Arc_Noisy), "fold", 12, true); } else { const _137: rt.u8 = op >> 6; if (_137 === 0) { @@ -326,7 +326,7 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(handles), (h2: rt.Arc): rt.u8 => { return h2.strong & 0xff; - })); + }), undefined, true); drop$Vec_Arc_Noisy_Vec_Arc_Noisy_Vec_ArcShared_Vec_Noisy_Vec_Vec_Arc_Noisy([handles, kept, shared, noisy, lists] as [rt.Arc[], rt.Arc[], ArcShared.ArcShared[], Noisy.Noisy[], rt.Arc[][]]); flush(log.value, out); log[Symbol.dispose](); @@ -384,7 +384,7 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { return ArcNode.new(this_, new Noisy.Noisy(238, rt.arcClone(log)), more); }); } - rt.iterExtendBytes(out, rt.iterSlice(node.value.seen)); + rt.iterExtendBytes(out, rt.iterSlice(node.value.seen), undefined, true); rt.byteVecPush(out, node.strong & 0xff); rt.byteVecPush(out, node.weak & 0xff); rt.byteVecPush(out, node.value.more.length & 0xff); @@ -417,7 +417,7 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.dropAll(kept); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(outside), (w: rt.Weak): rt.u8 => { return w.arc.strong & 0xff; - })); + }), undefined, true); flush(log.value, out); rt.dropAll(outside); log[Symbol.dispose](); @@ -509,7 +509,7 @@ export function uniqueArcs(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(strong), (s2: rt.Arc): rt.u8 => { return s2.value; - })); + }), undefined, true); const _121: rt.Arc[] = []; const others: rt.Arc[]>> = new rt.Arc(new rt.RefCell(_121)); const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); @@ -521,7 +521,7 @@ export function uniqueArcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _141: rt.Iter> = rt.iterMap(new rt.Range(0, shared), (_2: rt.u8): rt.Arc => { return rt.arcClone(first); }); - rt.iterExtend(_138.value, _141); + rt.iterExtend(_138.value, _141, undefined, 4, true); rt.refMutRelease(_138); const _145: ArcReleasing.ArcReleasing = rt.arcMakeMut(rt.place(() => first, (value6) => first = value6), ArcReleasing.clone$Clone, rt.drop); _145.id = _145.id ^ 64; @@ -551,7 +551,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); const handles: rt.Arc[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (id: rt.u8): rt.Arc => { return new rt.Arc(new Noisy.Noisy(rt.u8Mul(id, 16), rt.arcClone(log))); - })); + }), undefined, 4, true); const kept: rt.Arc[] = []; const shared: RcShared.RcShared[] = []; const noisy: Noisy.Noisy[] = []; @@ -571,13 +571,13 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _48: rt.Arc | undefined = filter$1qg98un(again, (_210: rt.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_48, rt.drop), "fold"); + rt.iterExtend(kept, rt.iterOption(_48, rt.drop), "fold", 4, true); } else if (_34 === 1) { const _54: rt.Place> | undefined = rt.sliceGetMut(handles, rt.usizeRem(pick, handles.length)); const _61: rt.Arc | undefined = filter$1qg98un(_54 === undefined ? undefined : rt.arcClone(_54.v), (_29: rt.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_61, rt.drop), "fold"); + rt.iterExtend(kept, rt.iterOption(_61, rt.drop), "fold", 4, true); } else if (_34 === 2) { const _70: RcShared.RcShared[] = [new RcShared.RcShared(rt.arcClone(handles[at]), op)]; const _67: RcShared.RcShared | undefined = rt.sliceFirst(_70); @@ -589,7 +589,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _77: RcShared.RcShared | undefined = filter$14b5774(one, (_26: RcShared.RcShared): boolean => { return keep; }); - rt.iterExtend(shared, rt.iterOption(_77, rt.drop), "fold"); + rt.iterExtend(shared, rt.iterOption(_77, rt.drop), "fold", 8, true); } else if (_34 === 3) { const made2: Noisy.Noisy = new Noisy.Noisy(op, rt.arcClone(log)); const _84: Noisy.Noisy | undefined = made2; @@ -600,12 +600,12 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _92: Noisy.Noisy | undefined = filter$1gka6nq(one2, (_25: Noisy.Noisy): boolean => { return keep; }); - rt.iterExtend(noisy, rt.iterOption(_92, rt.drop), "fold"); + rt.iterExtend(noisy, rt.iterOption(_92, rt.drop), "fold", 8, true); made2[Symbol.dispose](); } else if (_34 === 4) { const all: rt.Arc[] = rt.iterToArray(rt.iterMap(rt.iterSlice(handles), (a04: rt.Arc): rt.Arc => { return rt.arcClone(a04); - })); + }), undefined, 4, true); _191 = true; rt.byteVecPush(out, handles[at].strong & 0xff); if (keep) { @@ -617,15 +617,15 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { } _191 = false; } else if (_34 === 5) { - const again3: RcShared.RcShared[] = rt.iterToArray(rt.iterMap(rt.iterSlice(shared), RcShared.clone$Clone)); + const again3: RcShared.RcShared[] = rt.iterToArray(rt.iterMap(rt.iterSlice(shared), RcShared.clone$Clone), undefined, 8, true); _192 = true; - const ids: Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(noisy), Noisy.clone$Clone)); + const ids: Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(noisy), Noisy.clone$Clone), undefined, 8, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(ids), (n: Noisy.Noisy): rt.u8 => { return n.id; - })); + }), undefined, true); if (keep) { _192 = false; - rt.iterExtend(shared, rt.iterSlice(again3, rt.drop), "fold"); + rt.iterExtend(shared, rt.iterSlice(again3, rt.drop), "fold", 8, true); } rt.dropAll(ids); if (_192) { @@ -643,7 +643,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _134: rt.Arc[] | undefined = filter$16q8euf(list, (_2: rt.Arc[]): boolean => { return keep; }); - rt.iterExtend(lists, rt.iterOption(_134, drop$Vec_Rc_Noisy), "fold"); + rt.iterExtend(lists, rt.iterOption(_134, drop$Vec_Rc_Noisy), "fold", 12, true); } else { const _137: rt.u8 = op >> 6; if (_137 === 0) { @@ -675,7 +675,7 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(handles), (h2: rt.Arc): rt.u8 => { return h2.strong & 0xff; - })); + }), undefined, true); drop$Vec_Rc_Noisy_Vec_Rc_Noisy_Vec_RcShared_Vec_Noisy_Vec_Vec_Rc_Noisy([handles, kept, shared, noisy, lists] as [rt.Arc[], rt.Arc[], RcShared.RcShared[], Noisy.Noisy[], rt.Arc[][]]); flush(log.value, out); log[Symbol.dispose](); @@ -733,7 +733,7 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { return RcNode.new(this_, new Noisy.Noisy(238, rt.arcClone(log)), more); }); } - rt.iterExtendBytes(out, rt.iterSlice(node.value.seen)); + rt.iterExtendBytes(out, rt.iterSlice(node.value.seen), undefined, true); rt.byteVecPush(out, node.strong & 0xff); rt.byteVecPush(out, node.weak & 0xff); rt.byteVecPush(out, node.value.more.length & 0xff); @@ -766,7 +766,7 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.dropAll(kept); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(outside), (w: rt.Weak): rt.u8 => { return w.arc.strong & 0xff; - })); + }), undefined, true); flush(log.value, out); rt.dropAll(outside); log[Symbol.dispose](); @@ -926,10 +926,10 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _05: rt.u8 = _53 === undefined ? 1 : 0; rt.drop(_53); return _05; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(weak), (w2: rt.Weak): rt.u8 => { return rt.weakWeakCount(w2) & 0xff; - })); + }), undefined, true); rt.dropAll(weak); const _236: rt.Mutex = rt.mutexLock(log.value); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_236.value)); @@ -1023,7 +1023,7 @@ export function uniqueRcs(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(strong), (s2: rt.Arc): rt.u8 => { return s2.value; - })); + }), undefined, true); const _121: rt.Arc[] = []; const others: rt.Arc[]>> = new rt.Arc(new rt.RefCell(_121)); const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); @@ -1035,7 +1035,7 @@ export function uniqueRcs(data: rt.ByteSlice, out: rt.ByteVec): void { const _141: rt.Iter> = rt.iterMap(new rt.Range(0, shared), (_2: rt.u8): rt.Arc => { return rt.arcClone(first); }); - rt.iterExtend(_138.value, _141); + rt.iterExtend(_138.value, _141, undefined, 4, true); rt.refMutRelease(_138); const _145: RcReleasing.RcReleasing = rt.arcMakeMut(rt.place(() => first, (value6) => first = value6), RcReleasing.clone$Clone, rt.drop); _145.id = _145.id ^ 64; @@ -1062,16 +1062,16 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const clones: rt.Cell = new rt.Cell(0); const counted: Counted.Counted[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Counted.Counted => { return { id: _2, clones }; - })); + }), undefined, 8, true); const twins: Twin.Twin[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): Twin.Twin => { const b: rt.u8 = _22; return { _0: b, _1: ~b & 0xff }; - })); + }), undefined, 2, true); const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); const maybes: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.u8 | undefined => { const b2: rt.u8 = _23; return thenSome$0d5am30(rt.u8Rem(b2, 3) !== 0, b2); - })); + }), undefined, 2, true); const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _20: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -1113,7 +1113,7 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 253)); } else if (_33 === 1) { const twin: Twin.Twin = unwrapOr$0ujf6zi(rt.sliceGet(twins, pick), { _0: 0, _1: 0 }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(twin._0, twin._1))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(twin._0, twin._1)), undefined, true); } else if (_33 === 2) { const _95: Counted.Counted | undefined = rt.sliceGet(counted, pick); rt.byteVecPush(out, mapOr$1ailw2a(_95 === undefined ? undefined : Counted.clone$Clone(_95), 253, (c4: Counted.Counted): rt.u8 => { @@ -1126,14 +1126,14 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_33 === 4) { rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(counted), Counted.clone$Clone), (c2: Counted.Counted): rt.u8 => { return c2.id; - })); + }), undefined, true); } else { rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(counted), (c: Counted.Counted): rt.u8 => { return c.id; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterCloned(rt.iterSlice(twins)), (t: Twin.Twin): rt.u8 => { return t._0 ^ t._1; - })); + }), undefined, true); } rt.byteVecPush(out, clones.v); } diff --git a/ts/fixtures/lang/expected/defaults.ts b/ts/fixtures/lang/expected/defaults.ts index 4365ec151..7e1e3ff35 100644 --- a/ts/fixtures/lang/expected/defaults.ts +++ b/ts/fixtures/lang/expected/defaults.ts @@ -73,7 +73,7 @@ export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { rt.atomicFetch(counts[0], rt.u64WrappingAdd, 1, 0); const part2 = rt.iterToArray(rt.iterMap(rt.iterSlice(counts), (c: rt.Atomic): rt.u64 => { return rt.atomicLoad(c, 0); - })); + }), undefined, 8, true); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2, f, rt.u64Debug)]; s = rt.fmtFormat([args6[0]]); } else if (_10 === 3) { diff --git a/ts/fixtures/lang/expected/durations.ts b/ts/fixtures/lang/expected/durations.ts index 17ee20222..06f2e53b3 100644 --- a/ts/fixtures/lang/expected/durations.ts +++ b/ts/fixtures/lang/expected/durations.ts @@ -146,7 +146,7 @@ export function durations(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.byteVecPush(out, _171[1]); } const _181: rt.Iter = rt.iterSlice([a, b, { secs: 1, nanos: 500000000 }]); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.durationHash, rt.durationEq)) as rt.HashSet, _181); + const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.durationHash, rt.durationEq)) as rt.HashSet, _181, undefined, undefined, 58720256); rt.byteVecPush(out, rt.hashLen(set) & 0xff); const _192: rt.Duration = rt.durationNew(rt.durationAsSecs(a), rt.durationSubsecNanos(a)); rt.byteVecPush(out, rt.hashContains(set, _192) ? 1 : 0); @@ -233,7 +233,7 @@ export function durations(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.byteVecPush(out, Window.cmp$Ord(w2, { start: b, len: undefined }) < 0 ? 1 : 0); const _400: Window.Window = copy$Window(Window.default$Default()); const _398: rt.Iter = rt.iterSlice([copy$Window(w2), copy$Window(w2), _400]); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Window.hash$Hash_DefaultHasher, Window.eq$PartialEq)) as rt.HashSet, _398)) & 0xff); + rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Window.hash$Hash_DefaultHasher, Window.eq$PartialEq)) as rt.HashSet, _398, undefined, undefined, 29360128)) & 0xff); const _413: Window.Window = Window.default$Default(); const args8: rt.Fmt[] = [(f: rt.Formatter) => Window.fmt$Debug(w2, f), (f: rt.Formatter) => Window.fmt$Debug(_413, f)]; put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[1])])); diff --git a/ts/fixtures/lang/expected/dyns.ts b/ts/fixtures/lang/expected/dyns.ts index b19dcd327..440e6274d 100644 --- a/ts/fixtures/lang/expected/dyns.ts +++ b/ts/fixtures/lang/expected/dyns.ts @@ -160,28 +160,28 @@ export function counts$Hits(arcs: rt.Arc[]): string { return rt.iterToArray(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { const _42: rt.usize = a.strong; return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); - })).join(","); + }), undefined, 12, true).join(","); } export function counts$Square(arcs: rt.Arc[]): string { return rt.iterToArray(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { const _42: rt.usize = a.strong; return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); - })).join(","); + }), undefined, 12, true).join(","); } export function counts$dyn_Named(arcs: rt.Arc[]): string { return rt.iterToArray(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { const _42: rt.usize = a.strong; return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); - })).join(","); + }), undefined, 12, true).join(","); } export function counts$dyn_Shape(arcs: rt.Arc[]): string { return rt.iterToArray(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { const _42: rt.usize = a.strong; return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); - })).join(","); + }), undefined, 12, true).join(","); } export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { @@ -245,7 +245,7 @@ export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { const objects: rt.Arc[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 3), (_2: rt.i32): rt.Arc => { const _34: rt.Arc = rt.arcClone(hits); return new rt.ArcDyn(_34, new Shape.Hits(_34.value)); - })); + }), undefined, 8, true); const sum: rt.u32 = rt.iterFold(rt.iterSlice(objects), 0, (sum2: rt.u32, s2: rt.Arc): rt.u32 => { return rt.u32WrappingAdd(sum2, s2.value.area$Shape()); }); @@ -278,10 +278,10 @@ export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { } const _112: rt.Arc = new rt.Arc({ side: x as rt.u16 }); return new rt.ArcDyn(_112, new Named.Square(_112.value)); - })); + }), undefined, 8, true); const kept: rt.Arc[] = rt.iterToArray(rt.iterMap(rt.iterStepBy(rt.iterSlice(tris), 2), (a0: rt.Arc): rt.Arc => { return rt.arcClone(a0); - })); + }), undefined, 8, true); for (const _292 of tris) { const _304: string = _292.value.label$Named(); const _307: rt.u32 = _292.value.area$Shape(); @@ -294,7 +294,7 @@ export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { for (const _322 of kept) { _322.value.tally$Shape(rt.place(() => total_, (value) => total_ = value)); } - const _337: string = counts$dyn_Named(rt.iterToArray(rt.iterSlice(kept))); + const _337: string = counts$dyn_Named(rt.iterToArray(rt.iterSlice(kept), undefined, 4, true)); const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(total_, f), (f: rt.Formatter) => rt.fmtPad(f, _337)]; put(out, rt.fmtFormat([args24[0], " ", args24[1]])); rt.dropAll(kept); diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index f4252c405..6d7dca409 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -36,11 +36,11 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _576: (a0: Named.Named[]) => rt.u16[] = (v7: Named.Named[]): rt.u16[] => { return rt.iterToArray(rt.iterMap(rt.iterSlice(v7), (n: Named.Named): rt.u16 => { return n.id; - })); + }), undefined, 2, true); }; const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 3); - })); + }), undefined, 2, true); const at: (a0: rt.usize) => rt.u8 = (i3: rt.usize): rt.u8 => { return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i3), 0); }; @@ -57,7 +57,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putU16s(out, v); const pairs: [rt.u16, rt.u16][] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_232: rt.u16): [rt.u16, rt.u16] => { return [_232, 0] as [rt.u16, rt.u16]; - })); + }), undefined, 4, true); rt.vecRetain(pairs, (p3: [rt.u16, rt.u16]): boolean => { p3[1] = rt.u16Div(p3[0], 2); return rt.u16Rem(p3[0], 3) === 0; @@ -67,7 +67,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const names: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_233: rt.u8): string => { return text(rt.byteSliceFrom(Uint8Array.of(_233))); - })); + }), undefined, 12, true); rt.vecRetain(names, (s2: string): boolean => { return rt.stringLen(s2) > 1; }); @@ -87,12 +87,12 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_8 === 1) { const v2: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_219: rt.u8): rt.u16 => { return rt.u8Rem(_219, 4) as rt.u16; - })); + }), undefined, 2, true); rt.vecDedupBy(v2, rt.same); putU16s(out, v2); const keyed: Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_221: rt.u16): Named.Named => { return _75(_221); - })); + }), undefined, 16, true); rt.vecDedupByKey(keyed, (n3: Named.Named): rt.u16 => { return rt.u16Div(n3.id, 24); }, rt.same); @@ -101,7 +101,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const tested: Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_225: rt.u16): Named.Named => { return _75(_225); - })); + }), undefined, 16, true); const seen2: rt.u16[] = []; rt.vecDedupBy(tested, (a3: Named.Named, b10: Named.Named): boolean => { seen2.push(a3.id); @@ -114,7 +114,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const names2: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_228: rt.u8): string => { return text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_228, 3)))); - })); + }), undefined, 12, true); rt.vecDedupBy(names2, rt.same); rt.byteVecPush(out, names2.length & 0xff); } else if (_8 === 2) { @@ -128,7 +128,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putU16s(out, v4); const pairs2: [rt.u16, rt.u16][] = rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(words)), (_214: [rt.usize, rt.u16]): [rt.u16, rt.u16] => { return [rt.u16Rem(_214[1], 5), _214[0] & 0xffff] as [rt.u16, rt.u16]; - })); + }), undefined, 4, true); rt.sliceSortByKey(pairs2, (p2: [rt.u16, rt.u16]): rt.u16 => { return p2[0]; }, rt.lt); @@ -155,7 +155,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return w8; } return undefined; - })); + }), undefined, 4, true); rt.sliceSort(options, rt.cmpLt(rt.cmpOption(rt.cmp))); for (const _215 of options) { putU16s(out, [mapOr$1llunel(_215, 65535, (o: rt.u16): rt.u16 => { @@ -165,7 +165,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const names3: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): string => { const b8: rt.u8 = _218; return text(rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16)))); - })); + }), undefined, 12, true); rt.sliceSort(names3, rt.cmpLt(rt.cmpStr)); for (const _234 of names3) { put(out, _234); @@ -175,7 +175,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putU16s(out, [unwrapOr$1j4op5y(rt.sliceLast(v5), 65535)]); const runs: [rt.u16, rt.u16 | undefined][] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_211: rt.u16): [rt.u16, rt.u16 | undefined] => { return [_211, undefined] as [rt.u16, rt.u16 | undefined]; - })); + }), undefined, 6, true); const _256: [rt.u16, rt.u16 | undefined] | undefined = rt.sliceLast(runs); if (_256 !== undefined) { _256[1] = _256[0]; @@ -192,7 +192,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const named: Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_213: rt.u16): Named.Named => { const w6: rt.u16 = _213; return { id: w6, name: text(rt.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; - })); + }), undefined, 16, true); const probe: Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3)))) }; rt.byteVecPush(out, rt.sliceContains(named, probe, Named.eq$PartialEq) ? 1 : 0); rt.byteVecPush(out, rt.sliceContains(words, rt.u16Mul(at(2) as rt.u16, 3), rt.same) ? 1 : 0); @@ -210,7 +210,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const named2: Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_28: rt.u16): Named.Named => { const w4: rt.u16 = _28; return { id: w4, name: text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; - })); + }), undefined, 16, true); const cloned: Named.Named[] = named2.map(Named.clone$Clone); rt.byteVecPush(out, rt.eqSlice(Named.eq$PartialEq)(cloned, named2) ? 1 : 0); const changed: Named.Named[] = named2.map(Named.clone$Clone); @@ -228,8 +228,8 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const b5: rt.u8 = _29; return rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(b5, 3)), (i4: rt.u8): rt.u16 => { return rt.u16Add(i4 as rt.u16, b5 as rt.u16); - })); - })); + }), undefined, 2, true); + }), undefined, 12, true); const _424: rt.u16[][] = nested.map((a027: rt.u16[]): rt.u16[] => { return a027.slice(); }); @@ -255,14 +255,14 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, tally.n); put(out, tally.names[rt.idx(tally.names, 0)]); const _496: rt.Iter = rt.iterSlice(words); - let queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _496); + let queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _496, undefined, 2, true); const default_2 = rt.dequeNew() as rt.VecDeque; const taken4 = queue; queue = default_2; rt.byteVecPush(out, taken4.n & 0xff); rt.byteVecPush(out, queue.n & 0xff); const _511: rt.Iter = rt.iterSlice(words); - let set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _511, true); + let set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _511, true, undefined, undefined, 2, true); const default_3 = rt.btreeNew(rt.cmp) as rt.BTreeSet; const taken5 = set; set = default_3; @@ -285,7 +285,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_8 === 6) { const v6: Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_23: rt.u16): Named.Named => { return _575(_23); - })); + }), undefined, 16, true); const _586: rt.usize = rt.usizeRem(at(0) as rt.usize, 8); const _592: Named.Named = _575(511); rt.vecInsert(v6, _586, _592); @@ -375,8 +375,8 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, rt.strIsCharBoundary(s, _843) ? 1 : 0); } - rt.iterExtendBytes(out, rt.strBytes(s)); - rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.strBytes(s)), 3)); + rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); + rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.strBytes(s)), 3), undefined, true); rt.byteVecPush(out, rt.strBytes(s).len() & 0xff); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.strBytes(s), (_22: rt.u8): boolean => { return _22 >= 128; @@ -395,7 +395,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }; const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 3); - })); + }), undefined, 2, true); const prefixes: 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); }), rt.iterSlice([data])); @@ -439,7 +439,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const v3: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(_53)), (b6: rt.u8): rt.u8 => { return rt.u8Rem(b6, 4); - })); + }), undefined, true); rt.byteVecDedup(v3); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v3)); const v4: rt.ByteVec = rt.byteSliceToByteVec(_53); diff --git a/ts/fixtures/lang/expected/errors.ts b/ts/fixtures/lang/expected/errors.ts index 5c9e37182..4aa9574ee 100644 --- a/ts/fixtures/lang/expected/errors.ts +++ b/ts/fixtures/lang/expected/errors.ts @@ -379,49 +379,49 @@ export function pairs$Vec_Result_bool_ParseBoolError(values: rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return parse$1o8vfr6(s); - })); + }), undefined, 8, true); } export function parsed$bool(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return parse$0vh4cry(s); - })); + }), undefined, 1, true); } export function parsed$char(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return rt.charFromStr(s); - })); + }), undefined, 8, true); } export function parsed$f64(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return rt.f64FromStr(s); - })); + }), undefined, 16, true); } export function parsed$i128(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return parse$0zwe7sh(s); - })); + }), undefined, 32, true); } export function parsed$i8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return parse$1fq462u(s); - })); + }), undefined, 2, true); } export function parsed$u64(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return parse$1q1obm6(s); - })); + }), undefined, 16, true); } export function parsed$u8(all: string[]): rt.Result[] { return rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { return parse$0yt2578(s); - })); + }), undefined, 2, true); } /** @@ -462,74 +462,74 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _78: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.i64 => { return rt.i64Mul((_27 << 24) >> 24 as rt.i64, 2); }); - rt.iterExtend(ints, _78); + rt.iterExtend(ints, _78, undefined, 8, true); pairs$Result_i8_TryFromIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(ints), (a03: rt.i64): rt.Result => { return rt.i8TryFrom(a03); - })), out); + }), undefined, 2, true), out); } else if (_32 === 9) { pairs$Result_str_Utf8Error(rt.iterToArray(rt.iterMap(rt.iterSlice(bytes), (b6: rt.ByteSlice): rt.Result => { return rt.strFromUtf8(b6); - })), out); + }), undefined, 12, true), out); } else if (_32 === 10) { pairs$Result_String_FromUtf8Error(rt.iterToArray(rt.iterMap(rt.iterSlice(bytes), (b5: rt.ByteSlice): rt.Result => { return rt.stringFromUtf8(rt.byteSliceToByteVec(b5)); - })), out); + }), undefined, 20, true), out); } else if (_32 === 11) { const secs: rt.f64[] = [0.0, -0.0, 1.5, -1.0, NaN, Infinity, -Infinity, 1e30]; const _105: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.f64 => { return (((_25 << 24) >> 24 as rt.f64)) / 4.0; }); - rt.iterExtend(secs, _105); + rt.iterExtend(secs, _105, undefined, 8, true); pairs$Result_Duration_TryFromFloatSecsError(rt.iterToArray(rt.iterMap(rt.iterSlice(secs), (a02: rt.f64): rt.Result => { return rt.durationTryFromSecsF64(a02); - })), out); + }), undefined, 16, true), out); } else if (_32 === 12) { pairs$Result_Option_u8_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s6: string): rt.Result => { return map$0r57egs(parse$0yt2578(s6), (v10: rt.u8): rt.u8 | undefined => { return rt.u8CheckedSub(v10, 1); }); - })), out); + }), undefined, 2, true), out); pairs$Result_Result_char_ParseCharError_ParseBoolError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s7: string): rt.Result, rt.ParseBoolError> => { const _68: string = s7; return map$0fm1w6u(parse$0vh4cry(s7), (_24: boolean): rt.Result => { return rt.charFromStr(_68); }); - })), out); + }), undefined, 8, true), out); pairs$Result_u8_IntErrorKind(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s8: string): rt.Result => { return mapErr$0u5yxjj(parse$0yt2578(s8), (e: rt.ParseIntError): rt.IntErrorKind => { return e.kind; }); - })), out); + }), undefined, 2, true), out); } else if (_32 === 13) { pairs$Result_u16_never(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result => { return rt.Ok(_2 as rt.u16); - })), out); + }), undefined, 2, true), out); pairs$Result_unit_Error(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.Result => { if (!(rt.u8Rem(_22, 2) === 0)) { return rt.Err(new rt.FmtError()); } return rt.OK; - })), out); + }), undefined, 1, true), out); } else { pairs$Option_Result_u8_ParseIntError(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result | undefined => { const _73: string = s; return then$0afp4no(!((s.length === 0)), (): rt.Result => { return parse$0yt2578(_73); }); - })), out); - pairs$Vec_Result_bool_ParseBoolError(rt.iterToArray(rt.iterMap(rt.sliceChunks(all, 2), parsed$bool)), out); + }), undefined, 2, true), out); + pairs$Vec_Result_bool_ParseBoolError(rt.iterToArray(rt.iterMap(rt.sliceChunks(all, 2), parsed$bool), undefined, 12, true), out); pairs$Result_char_ParseCharError_usize(rt.iterToArray(rt.iterMap(rt.iterSlice(all), (s2: string): [rt.Result, rt.usize] => { return [rt.charFromStr(s2), rt.usizeRem(rt.stringLen(s2), 2)] as [rt.Result, rt.usize]; - })), out); + }), undefined, 12, true), out); pairs$ParseCharError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s3: string): rt.ParseCharError | undefined => { return err$02r96h1(rt.charFromStr(s3)); - })), out); + }), undefined, 1), out); pairs$ParseBoolError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s4: string): rt.ParseBoolError | undefined => { return err$1ujom0k(parse$0vh4cry(s4)); - })), out); + }), undefined, 0), out); pairs$ParseIntError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s5: string): rt.ParseIntError | undefined => { return err$0jf6smd(parse$1fq462u(s5)); - })), out); + }), undefined, 1), out); } } diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 76ee08217..7299a3f7a 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -22,6 +22,7 @@ import { floats, formats, parses } from "./floats.ts"; import { ints, strings, derived, written, counts, rounding, panics, wrapped, writes } from "./fmt.ts"; import { methods } from "./generics.ts"; import { values, random, bytes as hashes_bytes } from "./hashes.ts"; +import { hints, reserves } from "./hints.ts"; import { holds } from "./holds.ts"; import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert, parses as ints_parses, widenings } from "./ints.ts"; import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, own, values as iters_values, returned } from "./iters.ts"; @@ -185,7 +186,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) uninhabited(data67, out68); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::lent_keys", lentKeys] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::lent_values", lentValues] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::singles", singles] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::formats", singles_formats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::parses", singles_parses] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): void => { peekedOthers(data68, out69); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["hints::hints", hints] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["hints::reserves", reserves] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/hashes.ts b/ts/fixtures/lang/expected/hashes.ts index e08bbd85f..85ecf2f79 100644 --- a/ts/fixtures/lang/expected/hashes.ts +++ b/ts/fixtures/lang/expected/hashes.ts @@ -388,7 +388,7 @@ export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { digest$u8_str_u64([n & 0xff, "pair", rt.u64Cast(w(4, 8))] as [rt.u8, string, rt.u64], out); const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.u16 => { return rt.u16Mul(_23 as rt.u16, 257); - })); + }), undefined, 2, true); digest$Vec_u16(words, out); digest$u16s(rt.sliceRange(words, rt.usizeDiv(words.length, 2)), out); digest$u32s([n, (n ^ 1) >>> 0, n >>> 3], out); @@ -400,7 +400,7 @@ export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const n2: rt.u64 = rt.u64Cast(w(0, 8)); digest$Packet({ id: n2, flags: unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), name: unwrapOr$01jdcm7(rt.strFromUtf8(data), "?"), tags: rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { return _2 as rt.u16; - })), next: thenSome$0n2gkz4(rt.u64Rem(n2, 3) !== 0, rt.u64Low(n2) | 0) }, out); + }), undefined, 2, true), next: thenSome$0n2gkz4(rt.u64Rem(n2, 3) !== 0, rt.u64Low(n2) | 0) }, out); const _188: rt.u64 = rt.u64Rem(n2, 3); if (_188 === 0) { shape = { tag: "Dot" } as Shape.Shape; @@ -498,7 +498,7 @@ export function random(data: rt.ByteSlice, out: rt.ByteVec): void { } const keys: rt.u64[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u64 => { return rt.u64Mul(_2 as rt.u64, 1103823438081); - })); + }), undefined, 8, true); rt.sliceSortByKey(keys, (k2: rt.u64): rt.u64 => { return rt.hashOne(other.state, k2, rt.hash64); }, rt.lt); diff --git a/ts/fixtures/lang/expected/hints.Big.ts b/ts/fixtures/lang/expected/hints.Big.ts new file mode 100644 index 000000000..55acb3b39 --- /dev/null +++ b/ts/fixtures/lang/expected/hints.Big.ts @@ -0,0 +1,31 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { copy$u32s } from "./lib.ts"; + +export function clone$Clone(self: Big): Big { + return { _0: copy$u32s(self._0) }; +} + +export function eq$PartialEq(self: Big, other: Big): boolean { + return rt.eqSlice(rt.same)(self._0, other._0); +} + +export function partialCmp$PartialOrd(self: Big, other: Big): rt.Ordering | undefined { + return cmp$Ord(self, other); +} + +export function cmp$Ord(self: Big, other: Big): rt.Ordering { + return rt.cmpSlice(rt.cmp)(self._0, other._0); +} + +export function hash$Hash_DefaultHasher(self: Big, state: rt.Hasher): void { + rt.hashSlice(rt.hash32)(self._0, state); +} + +/** Over 1024 bytes, which a `Vec` grows by as few as one of. */ +export interface Big { + _0: rt.u32[]; +} + +//# sourceMappingURL=hints.Big.ts.map diff --git a/ts/fixtures/lang/expected/hints.Countdown.ts b/ts/fixtures/lang/expected/hints.Countdown.ts new file mode 100644 index 000000000..70116f241 --- /dev/null +++ b/ts/fixtures/lang/expected/hints.Countdown.ts @@ -0,0 +1,19 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** An iterator of the crate's own, which keeps std's hint. */ +export interface Countdown { + _0: rt.u8; +} + +export function next$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=hints.Countdown.ts.map diff --git a/ts/fixtures/lang/expected/hints.Endless.ts b/ts/fixtures/lang/expected/hints.Endless.ts new file mode 100644 index 000000000..15b87f61d --- /dev/null +++ b/ts/fixtures/lang/expected/hints.Endless.ts @@ -0,0 +1,14 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** An iterator of the crate's own that never ends. */ +export interface Endless { + _0: rt.u64; +} + +export function next$Iterator(self: Endless): rt.u64 | rt.Done { + return self._0; +} + +//# sourceMappingURL=hints.Endless.ts.map diff --git a/ts/fixtures/lang/expected/hints.Most.ts b/ts/fixtures/lang/expected/hints.Most.ts new file mode 100644 index 000000000..a22d89cd3 --- /dev/null +++ b/ts/fixtures/lang/expected/hints.Most.ts @@ -0,0 +1,17 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +/** + * The most of each element type std's collections hold on wasm32, past which they panic + * with a capacity overflow: a `Vec` of it, a `Vec` of it paired with a `u32`, a hash set + * of it, and a hash map of it to a `u32`. + */ +export interface Most { + vec: rt.u64; + pairs: rt.u64; + set: rt.u64; + map: rt.u64; +} + +//# sourceMappingURL=hints.Most.ts.map diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts new file mode 100644 index 000000000..304c22101 --- /dev/null +++ b/ts/fixtures/lang/expected/hints.ts @@ -0,0 +1,4239 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { copy$u64s } from "./lib.ts"; +import { thenSome$1ugl8af } from "./core/bool.ts"; +import { unwrapOr$0r2bmpr, unwrapOr$1rbuegs, mapOr$1cxlmys, mapOr$1umcrqz, mapOr$0pdoq6p, mapOr$0amk6zv, mapOr$08xwngs } from "./core/option.ts"; +import { unwrapOr$0u9zzk3 } from "./core/result.ts"; +import * as Big from "./hints.Big.ts"; +import * as Countdown from "./hints.Countdown.ts"; +import * as Endless from "./hints.Endless.ts"; +import type * as Most from "./hints.Most.ts"; + +/** A hint, as four bytes each, the upper bound after whether it has one. */ +export function put(out: rt.ByteVec, _2: [rt.usize, rt.usize | undefined]): void { + const lower: rt.usize = _2[0]; + const upper: rt.usize | undefined = _2[1]; + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(lower as rt.u32))); + if (upper === undefined) { + rt.byteVecPush(out, 0); + } else { + const upper2: rt.usize = upper; + rt.byteVecPush(out, 1); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(upper2 as rt.u32))); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Bytes(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Chain_Flatten_Map_Range_u64_hints_closure25_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Chain_Range_u32_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Chain_Range_u64_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, rt.iterBorrow(it).sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, rt.iterBorrow(it).sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Chain_Range_u64_Range_u64$2(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Chars(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$ChunksExact_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Chunks_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Cloned_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Copied_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Drain(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } + rt.drop(it); +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Drain_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Drain_u8$2(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } + rt.drop(it); +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Empty_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Enumerate_Range_u32(it: rt.Iter<[rt.usize, rt.u32]>, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$FilterMap_Range_u64_hints_closure2(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Filter_Range_u64_hints_closure1(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$FlatMap_Range_u64_Filter_IntoIter_u64_hints_closure15_closure0_hints_closure15(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$FlatMap_Range_u64_Flatten_IntoIter_u64s_hints_closure12(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$FlatMap_Range_u64_Once_u64_once(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$FlatMap_Range_u64_Option_u64_hints_closure14(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$FlatMap_Range_u64_u64s_hints_closure10(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Flatten_Chunks_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Flatten_Iter_u8s(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Flatten_Map_Iter_u8_hints_closure16(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Flatten_Map_Range_u64_hints_closure11(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Flatten_Map_Range_u64_hints_closure13(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Flatten_Map_Range_u64_hints_closure9(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Fuse_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Inspect_Range_u64_hints_closure8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$IntoIter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$IntoIter_u8$2(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$IntoIter_u8$3(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, rt.iterBorrow(it).sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, rt.iterBorrow(it).sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Iter_u8$2(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Iter_u8$3(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Iter_u8$4(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Iter_u8$5(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Iter_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Map_Range_u64_hints_closure7(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Once_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$RChunksExact_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$RChunks_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$RangeInclusive_i8(it: rt.RangeInclusive, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$RangeInclusive_u32(it: rt.RangeInclusive, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$RangeInclusive_u64(it: rt.RangeInclusive, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_i128(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_i32(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + it.start < it.end ? it.start++ : undefined; + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_i64(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_u128(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_u32(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + it.start < it.end ? it.start++ : undefined; + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_u64(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_u8(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + it.start < it.end ? it.start++ : undefined; + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Range_usize(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + it.start < it.end ? it.start++ : undefined; + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Rev_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$StepBy_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$StepBy_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$StepBy_Rev_Zip_Range_u32_Range_u32(it: rt.Iter<[rt.u32, rt.u32]>, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Take_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Values_u8_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Windows_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** + * `it`'s hint, and again after each of up to three items, read from the back where + * `steps` has the item's bit set. + */ +export function walk$Zip_Iter_u8_Skip_Iter_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { + let _12!: rt.u8; + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while ((_12 = iterStart++) < iterEnd) { + if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + rt.iterToOption(it.next()); + } else { + rt.iterToOption(it.nextBack()); + } + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Chain_Map_Zip_Range_u64_Range_u64_hints_closure27_Once_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Chain_Take_Endless_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Countdown(it: Countdown.Countdown, steps: rt.u8, out: rt.ByteVec): void { + put(out, rt.iterFrom(it, (it: Countdown.Countdown) => Countdown.next$Iterator(it)).sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(Countdown.next$Iterator(it)); + put(out, rt.iterFrom(it, (it: Countdown.Countdown) => Countdown.next$Iterator(it)).sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Drain_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Filter_Endless_hints_closure6(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$FromFn_hints_closure20(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Fuse_Countdown(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Fuse_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Fuse_Take_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$IntoIter_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Iter_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Keys_u8_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$MapWhile_Range_u64_hints_closure5(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Peekable_Filter_Range_u64_hints_closure26(it: rt.Peekable, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$SkipWhile_Range_u64_hints_closure3(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Skip_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Skip_Flatten_Map_Range_u32_hints_closure28(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Skip_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Split_char(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$StepBy_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$StepBy_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Successors_u64_hints_closure18(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Successors_u8_hints_closure19(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$TakeWhile_Range_u64_hints_closure4(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Take_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Take_FlatMap_Range_u64_Range_u64_hints_closure29(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Take_Skip_Chain_Range_u64_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Zip_Endless_Range_u32(it: rt.Iter<[rt.u64, rt.u32]>, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Zip_Range_u32_Endless(it: rt.Iter<[rt.u32, rt.u64]>, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** As `walk`, of an iterator that reads only from the front. */ +export function walkFront$Zip_Range_u64_Range_u64(it: rt.Iter<[rt.u64, rt.u64]>, steps: rt.u8, out: rt.ByteVec): void { + put(out, it.sizeHint()); + const _9: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _9; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + put(out, it.sizeHint()); + } +} + +/** `n`, or `u32::MAX` past it. */ +export function u32Of(n: rt.u64): rt.u32 { + return unwrapOr$0u9zzk3(rt.u32TryFrom(n), 4294967295); +} + +/** + * The hints of the iterator `kind` and the top three bits of `data`'s third byte pick, of + * lengths `data`'s first two bytes pick or of its fourth byte on, as each reads from the + * front or the back by the third byte's other bits. + */ +export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + let it!: rt.Peekable; + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const _10: rt.usize = rt.usizeRem(at(0) as rt.usize, 8); + if (!(_10 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _10); + } + const _8: rt.u64 = [0, 1, 5, 2147483647, 2147483648, 4294967295, 4294967296, { hi: 0x10000000, lo: 0 } as rt.u64][_10]; + const _19: rt.usize = rt.usizeRem(at(1) as rt.usize, 8); + if (!(_19 < 8)) { + rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _19); + } + const _7: [rt.u64, rt.u64] = [_8, [0, 1, 5, 2147483647, 2147483648, 4294967295, 4294967296, { hi: 0x10000000, lo: 0 } as rt.u64][_19]]; + const n: rt.u64 = _8; + const m: rt.u64 = _7[1]; + const steps: rt.u8 = at(2); + const arm: rt.u8 = steps >> 5; + const bytes: rt.ByteSlice = unwrapOr$1rbuegs(rt.byteSliceGetRange(data, 3), rt.byteSliceFrom(Uint8Array.of())); + const _37: rt.u8 = rt.u8Rem(kind, 24); + if (_37 === 0) { + const _39: rt.u8 = rt.u8Rem(arm, 5); + if (_39 === 0) { + walk$Range_u32(new rt.Range(0, u32Of(n)), steps, out); + } else if (_39 === 1) { + walk$Range_u32(new rt.Range(u32Of(m), u32Of(n)), steps, out); + } else if (_39 === 2) { + walk$Range_u8(new rt.Range(rt.u64Low(n) & 0xff, rt.u64Low(m) & 0xff), steps, out); + } else if (_39 === 3) { + walk$Range_i32(new rt.Range(rt.i32Neg(rt.u64Low(n) | 0), rt.u64Low(m) | 0), steps, out); + } else { + walk$Range_usize(new rt.Range(0, rt.u64Low(n)), steps, out); + } + } else if (_37 === 1) { + const _56: rt.u8 = rt.u8Rem(arm, 4); + if (_56 === 0) { + walk$Range_u64(new rt.Range(0, n, rt.u64Step), steps, out); + } else if (_56 === 1) { + walk$Range_u64(new rt.Range({ hi: 0x80000000, lo: 0 } as rt.u64, rt.u64Add({ hi: 0x80000000, lo: 0 } as rt.u64, n), rt.u64Step), steps, out); + } else if (_56 === 2) { + walk$Range_i64(new rt.Range(rt.i64Neg(rt.i64Cast(n)), rt.i64Cast(m), rt.i64Step), steps, out); + } else { + walk$Range_i64(new rt.Range({ hi: -0x80000000, lo: 0 } as rt.i64, rt.i64Add({ hi: -0x80000000, lo: 0 } as rt.i64, rt.i64Cast(n)), rt.i64Step), steps, out); + } + } else if (_37 === 2) { + const _77: rt.u8 = rt.u8Rem(arm, 3); + if (_77 === 0) { + walk$Range_u128(new rt.Range(rt.u128Shl(1, 100), rt.u128Add(rt.u128Shl(1, 100), rt.u128Cast(n)), rt.u128Step), steps, out); + } else if (_77 === 1) { + walk$Range_i128(new rt.Range(rt.i128Neg(rt.i128Shl(1, 100)), rt.i128Sub(rt.i128Cast(n), rt.i128Shl(1, 100)), rt.i128Step), steps, out); + } else { + walk$Range_i128(new rt.Range({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, rt.i128Step), steps, out); + } + } else if (_37 === 3) { + const _102: rt.u8 = rt.u8Rem(arm, 5); + if (_102 === 0) { + walk$RangeInclusive_u32(new rt.RangeInclusive(0, u32Of(n), rt.u32Step), steps, out); + } else if (_102 === 1) { + walk$RangeInclusive_u32(new rt.RangeInclusive(0, 4294967295, rt.u32Step), steps, out); + } else if (_102 === 2) { + walk$RangeInclusive_i8(new rt.RangeInclusive(-128, 127, rt.i8Step), steps, out); + } else if (_102 === 3) { + walk$RangeInclusive_u64(new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, n), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step), steps, out); + } else { + walk$RangeInclusive_u32(new rt.RangeInclusive(u32Of(n), u32Of(m), rt.u32Step), steps, out); + } + } else if (_37 === 4) { + const _114: rt.u8 = rt.u8Rem(arm, 4); + if (_114 === 0) { + walk$Chain_Range_u32_Range_u32(rt.iterChain(new rt.Range(0, u32Of(rt.u64Min(n, 9))), new rt.Range(0, u32Of(m))), steps, out); + } else if (_114 === 1) { + walk$Chain_Range_u64_Range_u64$2(rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)), steps, out); + } else if (_114 === 2) { + walk$Chain_Range_u32_Range_u32(rt.iterChain(new rt.Range(0, u32Of(n)), new rt.Range(0, 4294967295)), steps, out); + } else { + const _131: Endless.Endless = { _0: n }; + const _132: rt.usize = rt.usizeRem(rt.u64Low(n), 9); + walkFront$Chain_Take_Endless_Range_u64(rt.iterChain(rt.iterTake(rt.iterFrom(_131, (it: Endless.Endless) => Endless.next$Iterator(it)), _132), new rt.Range(0, m, rt.u64Step)), steps, out); + } + } else if (_37 === 5) { + const _136: rt.u8 = rt.u8Rem(arm, 4); + if (_136 === 0) { + walkFront$Zip_Range_u64_Range_u64(rt.iterZip(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)), steps, out); + } else if (_136 === 1) { + const _142: Endless.Endless = { _0: n }; + const _143: rt.Range = new rt.Range(0, u32Of(m)); + walkFront$Zip_Endless_Range_u32(rt.iterZip(rt.iterFrom(_142, (it: Endless.Endless) => Endless.next$Iterator(it)), _143), steps, out); + } else if (_136 === 2) { + walk$Zip_Iter_u8_Skip_Iter_u8(rt.iterZip(rt.iterSlice(rt.byteSliceView(bytes)), rt.iterSkip(rt.iterSlice(rt.byteSliceView(bytes)), 1), true), steps, out); + } else { + walkFront$Zip_Range_u32_Endless(rt.iterZip(new rt.Range(0, u32Of(n)), rt.iterFrom({ _0: n }, (it: Endless.Endless) => Endless.next$Iterator(it))), steps, out); + } + } else if (_37 === 6) { + const _153: rt.u8 = rt.u8Rem(arm, 4); + if (_153 === 0) { + walkFront$Skip_Range_u64(rt.iterSkip(new rt.Range(0, n, rt.u64Step), rt.u64Low(m)), steps, out); + } else if (_153 === 1) { + walk$Take_Range_u32(rt.iterTake(new rt.Range(0, u32Of(n)), rt.u64Low(m)), steps, out); + } else if (_153 === 2) { + walkFront$Take_Endless(rt.iterTake(rt.iterFrom({ _0: n }, (it: Endless.Endless) => Endless.next$Iterator(it)), rt.u64Low(m)), steps, out); + } else { + const _166: Endless.Endless = { _0: n }; + const _167: rt.usize = rt.usizeRem(rt.u64Low(m), 9); + walkFront$Skip_Endless(rt.iterSkip(rt.iterFrom(_166, (it: Endless.Endless) => Endless.next$Iterator(it)), _167), steps, out); + } + } else if (_37 === 7) { + 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$StepBy_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step), steps, out); + } else if (_178 === 1) { + walkFront$StepBy_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step), steps, out); + } else if (_178 === 2) { + walkFront$StepBy_Range_u64(rt.iterStepBy(new rt.Range(0, n, rt.u64Step), step), steps, out); + } else { + walk$StepBy_Iter_u8(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(bytes)), step), steps, out); + } + } else if (_37 === 8) { + const _190: rt.u8 = rt.u8Rem(arm, 6); + if (_190 === 0) { + walk$Filter_Range_u64_hints_closure1(rt.iterFilter(new rt.Range(0, n, rt.u64Step), (i20: rt.u64): boolean => { + return rt.u64Rem(i20, 2) === 0; + }), steps, out); + } else if (_190 === 1) { + walk$FilterMap_Range_u64_hints_closure2(rt.iterFilterMap(new rt.Range(0, n, rt.u64Step), (i19: rt.u64): rt.u64 | undefined => { + return rt.u64CheckedSub(i19, 1); + }), steps, out); + } else if (_190 === 2) { + walkFront$SkipWhile_Range_u64_hints_closure3(rt.iterSkipWhile(new rt.Range(0, n, rt.u64Step), (_252: rt.u64): boolean => { + return rt.u64Lt(_252, 2); + }), steps, out); + } else if (_190 === 3) { + walkFront$TakeWhile_Range_u64_hints_closure4(rt.iterTakeWhile(new rt.Range(0, n, rt.u64Step), (_250: rt.u64): boolean => { + return rt.u64Lt(_250, 1); + }), steps, out); + } else if (_190 === 4) { + walkFront$MapWhile_Range_u64_hints_closure5(rt.iterMapWhile(new rt.Range(0, n, rt.u64Step), (i16: rt.u64): rt.u64 | undefined => { + return rt.u64CheckedSub(i16, 1); + }), steps, out); + } else { + walkFront$Filter_Endless_hints_closure6(rt.iterFilter(rt.iterFrom({ _0: n }, (it: Endless.Endless) => Endless.next$Iterator(it)), (_248: rt.u64): boolean => { + return true; + }), steps, out); + } + } else if (_37 === 9) { + const _204: rt.u8 = rt.u8Rem(arm, 6); + if (_204 === 0) { + walk$Map_Range_u64_hints_closure7(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i15: rt.u64): rt.u64 => { + return rt.u64Add(i15, 1); + }), steps, out); + } else if (_204 === 1) { + walk$Inspect_Range_u64_hints_closure8(rt.iterInspect(new rt.Range(0, n, rt.u64Step), (_247: rt.u64): void => {}), steps, out); + } else if (_204 === 2) { + walk$Enumerate_Range_u32(rt.iterEnumerate(new rt.Range(0, u32Of(n))), steps, out); + } else if (_204 === 3) { + walk$Rev_Range_u64(rt.iterRev(new rt.Range(0, n, rt.u64Step)), steps, out); + } else if (_204 === 4) { + walk$Copied_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); + } else { + walk$Cloned_Iter_u8(rt.iterCloned(rt.iterSlice(rt.byteSliceView(bytes))), steps, out); + } + } else if (_37 === 10) { + const _219: rt.u8 = rt.u8Rem(arm, 4); + if (_219 === 0) { + walkFront$Fuse_Endless(rt.iterFuse(rt.iterFrom({ _0: n }, (it: Endless.Endless) => Endless.next$Iterator(it))), steps, out); + } else if (_219 === 1) { + walkFront$Fuse_Take_Endless(rt.iterFuse(rt.iterTake(rt.iterFrom({ _0: n }, (it: Endless.Endless) => Endless.next$Iterator(it)), 2)), steps, out); + } else if (_219 === 2) { + walk$Fuse_Range_u64(rt.iterFuse(new rt.Range(0, n, rt.u64Step)), steps, out); + } else { + walkFront$Fuse_Countdown(rt.iterFuse(rt.iterFrom({ _0: rt.u64Low(n) & 0xff }, (it: Countdown.Countdown) => Countdown.next$Iterator(it))), steps, out); + } + } else if (_37 === 11) { + it = rt.iterPeekable(rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step))); + put(out, it.sizeHint()); + const _240: rt.u8 = rt.u8Rem(steps, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _240; + while (iterStart++ < iterEnd) { + rt.peekablePeek(it); + put(out, it.sizeHint()); + it.next(); + put(out, it.sizeHint()); + } + const few: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); + while (rt.iterToOption(few.next()) !== undefined) { + } + rt.peekablePeek(few); + put(out, few.sizeHint()); + } else if (_37 === 12) { + const _267: rt.u8 = rt.u8Rem(arm, 5); + if (_267 === 0) { + walk$Flatten_Map_Range_u64_hints_closure9(rt.iterFlatten(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i14: rt.u64): rt.u64[] => { + return Array.from({ length: 3 }, (): rt.u64 => { + return i14; + }); + }), (value: rt.u64[]) => rt.iterSlice(value), false, 3), steps, out); + } else if (_267 === 1) { + walk$FlatMap_Range_u64_u64s_hints_closure10(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i13: rt.u64): rt.u64[] => { + return [i13]; + }, (value: rt.u64[]) => rt.iterSlice(value), false, 1, true), steps, out); + } else if (_267 === 2) { + walk$Flatten_Chunks_u8(rt.iterFlatten(rt.byteSliceChunks(bytes, 2), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value))), steps, out); + } else if (_267 === 3) { + walk$Flatten_Map_Range_u64_hints_closure11(rt.iterFlatten(rt.iterMap(new rt.Range(0, rt.u64Min(n, 9), rt.u64Step), (i12: rt.u64): rt.Range => { + return new rt.Range(0, i12, rt.u64Step); + })), steps, out); + } else { + walk$FlatMap_Range_u64_Flatten_IntoIter_u64s_hints_closure12(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i11: rt.u64): rt.Iter => { + const item = copy$u64s(Array.from({ length: 2 }, (): rt.u64 => { + return i11; + })); + return rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): rt.u64[] => { + return copy$u64s(item); + })), (value: rt.u64[]) => rt.iterSlice(value), false, 2); + }), steps, out); + } + } else if (_37 === 13) { + const _282: rt.u8 = rt.u8Rem(arm, 6); + if (_282 === 0) { + walk$Flatten_Map_Range_u64_hints_closure13(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); + } else if (_282 === 1) { + walk$FlatMap_Range_u64_Option_u64_hints_closure14(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); + } else if (_282 === 2) { + walk$FlatMap_Range_u64_Once_u64_once(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (a0: rt.u64): rt.Iter => { + return rt.iterOnce(a0); + }, undefined, false, undefined, true), steps, out); + } else if (_282 === 3) { + walk$FlatMap_Range_u64_Filter_IntoIter_u64_hints_closure15_closure0_hints_closure15(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); + } else if (_282 === 4) { + walk$Flatten_Map_Iter_u8_hints_closure16(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); + } else { + walk$Flatten_Iter_u8s(rt.iterFlatten(rt.iterMap(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); + } + } else if (_37 === 14) { + const _304: rt.u8 = rt.u8Rem(arm, 6); + if (_304 === 0) { + walk$Iter_u8$5(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); + } else if (_304 === 1) { + walk$IntoIter_u8$3(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(bytes))), steps, out); + } else if (_304 === 2) { + walk$IntoIter_u8(rt.iterSlice(Uint8Array.of(at(3), at(4), at(5))), steps, out); + } else if (_304 === 3) { + walk$IntoIter_u8$2(rt.iterOption(rt.byteSliceFirst(bytes)), steps, out); + } else if (_304 === 4) { + walk$Once_u64(rt.iterOnce(n), steps, out); + } else { + rt.iterEmpty(); + walk$Empty_u8(rt.iterEmpty(), steps, out); + } + } else if (_37 === 15) { + const _324: rt.u8 = rt.u8Rem(arm, 5); + if (_324 === 0) { + walkFront$Successors_u64_hints_closure18(rt.iterSuccessors(rt.u64Rem(n, 4), (_242: rt.u64): rt.u64 | undefined => { + return rt.u64CheckedSub(_242, 1); + }), steps, out); + } else if (_324 === 1) { + walkFront$Successors_u8_hints_closure19(rt.iterSuccessors(undefined as rt.u8 | undefined, (_237: rt.u8): rt.u8 | undefined => { + return _237; + }), steps, out); + } else if (_324 === 2) { + walkFront$Countdown({ _0: rt.u64Low(n) & 0xff }, steps, out); + } else if (_324 === 3) { + const captured = n; + walkFront$FromFn_hints_closure20(rt.iterFromFn((): rt.u64 | undefined => { + return captured; + }), steps, out); + } else { + const it2: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + walk$Iter_u8(it2, steps, out); + put(out, it2.sizeHint()); + } + } else if (_37 === 16) { + const s: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_29: rt.u8): rt.char => { + const _5: rt.usize = rt.u8Rem(_29, 4) as rt.usize; + if (!(_5 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _5); + } + return [97, 233, 128512, 2048][_5]; + })); + const _346: rt.u8 = rt.u8Rem(arm, 4); + if (_346 === 0) { + walk$Chars(rt.strChars(s), steps, out); + } else if (_346 === 1) { + walkFront$Split_char(rt.strSplit(s, "é"), steps, out); + } else if (_346 === 2) { + walk$Bytes(rt.strBytes(s), steps, out); + } else { + let t: string = s; + const _370: { start: rt.usize } = { start: rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.usizeDiv(bytes.length, 2)))), (_231: rt.u8): rt.usize => { + const _510: rt.usize = rt.u8Rem(_231, 4) as rt.usize; + if (!(_510 < 4)) { + rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _510); + } + return [1, 2, 4, 3][_510]; + }), rt.usizeAdd, 0) }; + walk$Drain(rt.stringDrain(rt.place(() => t, (value) => t = value), _370), steps, out); + } + } else if (_37 === 17) { + const size: rt.usize = rt.usizeAdd(rt.usizeRem(at(1) as rt.usize, 4), 1); + const _379: rt.u8 = rt.u8Rem(arm, 5); + if (_379 === 0) { + walk$Windows_u8(rt.byteSliceWindows(bytes, size), steps, out); + } else if (_379 === 1) { + walk$Chunks_u8(rt.byteSliceChunks(bytes, size), steps, out); + } else if (_379 === 2) { + walk$ChunksExact_u8(rt.byteSliceChunksExact(bytes, size), steps, out); + } else if (_379 === 3) { + walk$RChunks_u8(rt.byteSliceRchunks(bytes, size), steps, out); + } else { + walk$RChunksExact_u8(rt.byteSliceRchunksExact(bytes, size), steps, out); + } + } else if (_37 === 18) { + const _387: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_27: rt.u8): [rt.u8, rt.u8] => { + const b2: rt.u8 = _27; + return [b2, b2] as [rt.u8, rt.u8]; + }); + const map: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _387, undefined, undefined, undefined, 469762048); + const _390: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _390, undefined, undefined, 469762048); + const _392: rt.u8 = rt.u8Rem(arm, 5); + if (_392 === 0) { + walkFront$Iter_u8_u8(rt.hashIter(map), steps, out); + } else if (_392 === 1) { + walkFront$Keys_u8_u8(rt.hashKeys(map), steps, out); + } else if (_392 === 2) { + walkFront$Iter_u8(rt.hashKeys(set), steps, out); + } else if (_392 === 3) { + walkFront$IntoIter_u8_u8(rt.hashIter(rt.hashClone(map, undefined, undefined)), steps, out); + } else { + walkFront$Drain_u8_u8(rt.hashDrain(rt.hashClone(map, undefined, undefined)), steps, out); + } + } else if (_37 === 19) { + const _408: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_26: rt.u8): [rt.u8, rt.u8] => { + const b: rt.u8 = _26; + return [b, b] as [rt.u8, rt.u8]; + }); + const map2: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _408, true, undefined, undefined, undefined, 2, true); + const _411: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + const set2: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _411, true, undefined, undefined, 1, true); + const _413: rt.u8 = rt.u8Rem(arm, 4); + if (_413 === 0) { + walk$Iter_u8_u8(rt.btreeIter(map2), steps, out); + } else if (_413 === 1) { + const _419: { start: rt.u8 } = { start: at(3) }; + walk$Range_u8_u8(rt.btreeRange(map2, _419), steps, out); + } else if (_413 === 2) { + walk$Iter_u8$3(rt.btreeKeys(set2), steps, out); + } else { + walk$Values_u8_u8(rt.btreeValues(map2), steps, out); + } + } else if (_37 === 20) { + const _428: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + const deque: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _428, undefined, 1, true); + const v: rt.ByteVec = rt.byteSliceToByteVec(bytes); + const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), rt.le, rt.ge, rt.lt); + const half2: rt.usize = rt.usizeDiv(bytes.length, 2); + const _437: rt.u8 = rt.u8Rem(arm, 4); + if (_437 === 0) { + walk$Iter_u8$4(rt.dequeIter(deque), steps, out); + } else if (_437 === 1) { + walk$Drain_u8(rt.dequeDrain(deque, { start: half2 }), steps, out); + } else if (_437 === 2) { + walk$Drain_u8$2(rt.byteVecDrain(v, { end: half2 }), steps, out); + } else { + walk$Iter_u8$2(rt.heapIter(heap), steps, out); + } + } else if (_37 === 21) { + const _449: rt.u8 = rt.u8Rem(arm, 4); + if (_449 === 0) { + walkFront$Take_Skip_Chain_Range_u64_Range_u64(rt.iterTake(rt.iterSkip(rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)), 3), u32Of(n) as rt.usize), steps, out); + } else if (_449 === 1) { + walk$StepBy_Rev_Zip_Range_u32_Range_u32(rt.iterStepBy(rt.iterRev(rt.iterZip(new rt.Range(0, u32Of(rt.u64Min(n, 9))), new rt.Range(0, u32Of(rt.u64Min(m, 9))), true)), 2), steps, out); + } else if (_449 === 2) { + walk$Chain_Flatten_Map_Range_u64_hints_closure25_Range_u64(rt.iterChain(rt.iterFlatten(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i4: rt.u64): rt.u64[] => { + 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); + } else { + walkFront$Peekable_Filter_Range_u64_hints_closure26(rt.iterPeekable(rt.iterFilter(new rt.Range(0, n, rt.u64Step), (_22: rt.u64): boolean => { + return true; + })), steps, out); + } + } else if (_37 === 22) { + const it3: rt.Iter = rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)); + walk$Chain_Range_u64_Range_u64(it3, steps, out); + put(out, it3.sizeHint()); + } else { + const _483: rt.u8 = rt.u8Rem(arm, 3); + if (_483 === 0) { + walkFront$Chain_Map_Zip_Range_u64_Range_u64_hints_closure27_Once_u64(rt.iterChain(rt.iterMap(rt.iterZip(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)), (_2: [rt.u64, rt.u64]): rt.u64 => { + return _2[0]; + }), rt.iterOnce(0)), steps, out); + } else if (_483 === 1) { + walkFront$Skip_Flatten_Map_Range_u32_hints_closure28(rt.iterSkip(rt.iterFlatten(rt.iterMap(new rt.Range(0, u32Of(n)), (i3: rt.u32): rt.u32[] => { + 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); + } else { + walkFront$Take_FlatMap_Range_u64_Range_u64_hints_closure29(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); + } + } +} + +/** + * Each collection `kind` picks, collected or extended by `0..=last` of `u32`s, mapped by + * a closure that panics with `consumed` past the call `data`'s third byte picks, the way + * `data`'s first byte picks, and as long as its second picks: a few, one past the most it + * holds, `u32::MAX`, and `usize::MAX` and one more, whose upper bound is `None`. std's + * reserves by its size hint first, which panics past the most before it reads an item of + * a `TrustedLen` iterator, and after the first of another, which it reserves for again + * whenever it fills. + */ +export function reserves(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const _4: rt.u8 = rt.u8Rem(rt.u8Div(kind, 13), 5); + if (_4 === 0) { + typed$u8_reserves_closure0(kind, data, (i5: rt.u32): rt.u8 => { + return i5 & 0xff; + }, { vec: 2147483647, pairs: 268435455, set: 469762048, map: 117440512 }, out); + } else if (_4 === 1) { + typed$u32_reserves_closure1(kind, data, (i4: rt.u32): rt.u32 => { + return i4; + }, { vec: 536870911, pairs: 268435455, set: 234881024, map: 117440512 }, out); + } else if (_4 === 2) { + typed$u8_u8_u8_reserves_closure2(kind, data, (i3: rt.u32): [rt.u8, rt.u8, rt.u8] => { + return [i3 & 0xff, 0, 0] as [rt.u8, rt.u8, rt.u8]; + }, { vec: 715827882, pairs: 268435455, set: 234881024, map: 117440512 }, out); + } else if (_4 === 3) { + typed$u64_u8_reserves_closure3(kind, data, (i2: rt.u32): [rt.u64, rt.u8] => { + return [i2 as rt.u64, i2 & 0xff] as [rt.u64, rt.u8]; + }, { vec: 134217727, pairs: 89478485, set: 58720256, map: 58720256 }, out); + } else { + typed$Big_reserves_closure4(kind, data, (i: rt.u32): Big.Big => { + return { _0: Array.from({ length: 275 }, (): rt.u32 => { + return i; + }) }; + }, { vec: 1952257, pairs: 1945184, set: 917504, map: 917504 }, out); + } +} + +/** `reserves` of elements `make` makes. */ +export function typed$Big_reserves_closure4(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => Big.Big, most: Most.Most, out: rt.ByteVec): void { + let _20!: [rt.u64, rt.u64]; + let past!: rt.u64; + let count!: rt.u64; + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const coll: rt.u8 = rt.u8Rem(kind, 13); + const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + if (!(_11 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + } + const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 2 || coll === 4 || coll === 6) { + _20 = [2, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 7) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 8) { + _20 = [0, most.set] as [rt.u64, rt.u64]; + } else if (coll === 9) { + _20 = [1, most.map] as [rt.u64, rt.u64]; + } else { + _20 = [0, most.pairs] as [rt.u64, rt.u64]; + } + const held: rt.u64 = _20[0]; + const most2: rt.u64 = _20[1]; + if (coll === 9) { + past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + } else { + past = rt.u64Add(rt.u64Sub(most2, held), 1); + } + const shape: rt.u8 = rt.u8Rem(at(0), 5); + const _42: rt.u8 = rt.u8Rem(at(1), 4); + if (_42 === 0) { + count = 3; + } else if (_42 === 1) { + count = rt.u64Add(past, shape === 1 ? 1 : 0); + } else if (_42 === 2) { + count = 4294967295 as rt.u64; + } else { + count = 4294967296; + } + const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); + const seed: Big.Big = make(7); + const calls: rt.Cell = new rt.Cell(0); + const f: (a0: rt.u32) => Big.Big = (i2: rt.u32): Big.Big => { + rt.cellSet(calls, rt.u8Add(calls.v, 1)); + if (!(calls.v <= limit)) { + rt.panicFmt(["consumed"]); + } else { + return make(i2); + } + }; + if (shape === 0) { + fill$Big_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + } else if (shape === 1) { + fill$Big_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + } else if (shape === 2) { + fill$Big_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: Big.Big): boolean => { + return true; + }), seed, out); + } else if (shape === 3) { + fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_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); + } else { + fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(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); + } + rt.byteVecPush(out, calls.v); +} + +/** `reserves` of elements `make` makes. */ +export function typed$u32_reserves_closure1(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32, most: Most.Most, out: rt.ByteVec): void { + let _20!: [rt.u64, rt.u64]; + let past!: rt.u64; + let count!: rt.u64; + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const coll: rt.u8 = rt.u8Rem(kind, 13); + const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + if (!(_11 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + } + const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 2 || coll === 4 || coll === 6) { + _20 = [2, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 7) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 8) { + _20 = [0, most.set] as [rt.u64, rt.u64]; + } else if (coll === 9) { + _20 = [1, most.map] as [rt.u64, rt.u64]; + } else { + _20 = [0, most.pairs] as [rt.u64, rt.u64]; + } + const held: rt.u64 = _20[0]; + const most2: rt.u64 = _20[1]; + if (coll === 9) { + past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + } else { + past = rt.u64Add(rt.u64Sub(most2, held), 1); + } + const shape: rt.u8 = rt.u8Rem(at(0), 5); + const _42: rt.u8 = rt.u8Rem(at(1), 4); + if (_42 === 0) { + count = 3; + } else if (_42 === 1) { + count = rt.u64Add(past, shape === 1 ? 1 : 0); + } else if (_42 === 2) { + count = 4294967295 as rt.u64; + } else { + count = 4294967296; + } + const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); + const seed: rt.u32 = make(7); + const calls: rt.Cell = new rt.Cell(0); + const f: (a0: rt.u32) => rt.u32 = (i2: rt.u32): rt.u32 => { + rt.cellSet(calls, rt.u8Add(calls.v, 1)); + if (!(calls.v <= limit)) { + rt.panicFmt(["consumed"]); + } else { + return make(i2); + } + }; + if (shape === 0) { + fill$u32_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + } else if (shape === 1) { + fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + } else if (shape === 2) { + fill$u32_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u32): boolean => { + return true; + }), seed, out); + } else if (shape === 3) { + fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_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); + } else { + fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(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); + } + rt.byteVecPush(out, calls.v); +} + +/** `reserves` of elements `make` makes. */ +export function typed$u64_u8_reserves_closure3(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => [rt.u64, rt.u8], most: Most.Most, out: rt.ByteVec): void { + let _20!: [rt.u64, rt.u64]; + let past!: rt.u64; + let count!: rt.u64; + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const coll: rt.u8 = rt.u8Rem(kind, 13); + const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + if (!(_11 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + } + const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 2 || coll === 4 || coll === 6) { + _20 = [2, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 7) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 8) { + _20 = [0, most.set] as [rt.u64, rt.u64]; + } else if (coll === 9) { + _20 = [1, most.map] as [rt.u64, rt.u64]; + } else { + _20 = [0, most.pairs] as [rt.u64, rt.u64]; + } + const held: rt.u64 = _20[0]; + const most2: rt.u64 = _20[1]; + if (coll === 9) { + past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + } else { + past = rt.u64Add(rt.u64Sub(most2, held), 1); + } + const shape: rt.u8 = rt.u8Rem(at(0), 5); + const _42: rt.u8 = rt.u8Rem(at(1), 4); + if (_42 === 0) { + count = 3; + } else if (_42 === 1) { + count = rt.u64Add(past, shape === 1 ? 1 : 0); + } else if (_42 === 2) { + count = 4294967295 as rt.u64; + } else { + count = 4294967296; + } + const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); + const seed: [rt.u64, rt.u8] = make(7); + const calls: rt.Cell = new rt.Cell(0); + const f: (a0: rt.u32) => [rt.u64, rt.u8] = (i2: rt.u32): [rt.u64, rt.u8] => { + rt.cellSet(calls, rt.u8Add(calls.v, 1)); + if (!(calls.v <= limit)) { + rt.panicFmt(["consumed"]); + } else { + return make(i2); + } + }; + if (shape === 0) { + fill$u64_u8_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + } else if (shape === 1) { + fill$u64_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + } else if (shape === 2) { + fill$u64_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: [rt.u64, rt.u8]): boolean => { + return true; + }), seed, out); + } else if (shape === 3) { + fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_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); + } else { + fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(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); + } + rt.byteVecPush(out, calls.v); +} + +/** `reserves` of elements `make` makes. */ +export function typed$u8_reserves_closure0(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u8, most: Most.Most, out: rt.ByteVec): void { + let _20!: [rt.u64, rt.u64]; + let past!: rt.u64; + let count!: rt.u64; + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const coll: rt.u8 = rt.u8Rem(kind, 13); + const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + if (!(_11 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + } + const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 2 || coll === 4 || coll === 6) { + _20 = [2, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 7) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 8) { + _20 = [0, most.set] as [rt.u64, rt.u64]; + } else if (coll === 9) { + _20 = [1, most.map] as [rt.u64, rt.u64]; + } else { + _20 = [0, most.pairs] as [rt.u64, rt.u64]; + } + const held: rt.u64 = _20[0]; + const most2: rt.u64 = _20[1]; + if (coll === 9) { + past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + } else { + past = rt.u64Add(rt.u64Sub(most2, held), 1); + } + const shape: rt.u8 = rt.u8Rem(at(0), 5); + const _42: rt.u8 = rt.u8Rem(at(1), 4); + if (_42 === 0) { + count = 3; + } else if (_42 === 1) { + count = rt.u64Add(past, shape === 1 ? 1 : 0); + } else if (_42 === 2) { + count = 4294967295 as rt.u64; + } else { + count = 4294967296; + } + const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); + const seed: rt.u8 = make(7); + const calls: rt.Cell = new rt.Cell(0); + const f: (a0: rt.u32) => rt.u8 = (i2: rt.u32): rt.u8 => { + rt.cellSet(calls, rt.u8Add(calls.v, 1)); + if (!(calls.v <= limit)) { + rt.panicFmt(["consumed"]); + } else { + return make(i2); + } + }; + if (shape === 0) { + fill$u8_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + } else if (shape === 1) { + fill$u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + } else if (shape === 2) { + fill$u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u8): boolean => { + return true; + }), seed, out); + } else if (shape === 3) { + fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_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); + } else { + fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(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); + } + rt.byteVecPush(out, calls.v); +} + +/** `reserves` of elements `make` makes. */ +export function typed$u8_u8_u8_reserves_closure2(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => [rt.u8, rt.u8, rt.u8], most: Most.Most, out: rt.ByteVec): void { + let _20!: [rt.u64, rt.u64]; + let past!: rt.u64; + let count!: rt.u64; + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const coll: rt.u8 = rt.u8Rem(kind, 13); + const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + if (!(_11 < 5)) { + rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + } + const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 2 || coll === 4 || coll === 6) { + _20 = [2, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 7) { + _20 = [0, most.vec] as [rt.u64, rt.u64]; + } else if (coll === 8) { + _20 = [0, most.set] as [rt.u64, rt.u64]; + } else if (coll === 9) { + _20 = [1, most.map] as [rt.u64, rt.u64]; + } else { + _20 = [0, most.pairs] as [rt.u64, rt.u64]; + } + const held: rt.u64 = _20[0]; + const most2: rt.u64 = _20[1]; + if (coll === 9) { + past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + } else { + past = rt.u64Add(rt.u64Sub(most2, held), 1); + } + const shape: rt.u8 = rt.u8Rem(at(0), 5); + const _42: rt.u8 = rt.u8Rem(at(1), 4); + if (_42 === 0) { + count = 3; + } else if (_42 === 1) { + count = rt.u64Add(past, shape === 1 ? 1 : 0); + } else if (_42 === 2) { + count = 4294967295 as rt.u64; + } else { + count = 4294967296; + } + const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); + const seed: [rt.u8, rt.u8, rt.u8] = make(7); + const calls: rt.Cell = new rt.Cell(0); + const f: (a0: rt.u32) => [rt.u8, rt.u8, rt.u8] = (i2: rt.u32): [rt.u8, rt.u8, rt.u8] => { + rt.cellSet(calls, rt.u8Add(calls.v, 1)); + if (!(calls.v <= limit)) { + rt.panicFmt(["consumed"]); + } else { + return make(i2); + } + }; + if (shape === 0) { + fill$u8_u8_u8_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + } else if (shape === 1) { + fill$u8_u8_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + } else if (shape === 2) { + fill$u8_u8_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: [rt.u8, rt.u8, rt.u8]): boolean => { + return true; + }), seed, out); + } else if (shape === 3) { + fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_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); + } else { + fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(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); + } + rt.byteVecPush(out, calls.v); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$Big_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 1100).length; + } else if (coll === 1) { + const v: Big.Big[] = []; + rt.iterExtend(v, items, undefined, 1100); + len = v.length; + } else if (coll === 2) { + const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + rt.iterExtend(v2, items, undefined, 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + } else if (coll === 4) { + const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, undefined, 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), undefined, 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, undefined, 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { + return [t3, 1] as [Big.Big, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { + return [t2, 1] as [Big.Big, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104)); + } else if (coll === 11) { + len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)), 255, (v4: Big.Big[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: Big.Big = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 1100).length; + } else if (coll === 1) { + const v: Big.Big[] = []; + rt.iterExtend(v, items, undefined, 1100); + len = v.length; + } else if (coll === 2) { + const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + rt.iterExtend(v2, items, undefined, 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + } else if (coll === 4) { + const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, undefined, 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), undefined, 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, undefined, 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { + return [t3, 1] as [Big.Big, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { + return [t2, 1] as [Big.Big, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104)); + } else if (coll === 11) { + len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)), 255, (v4: Big.Big[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: Big.Big = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 1100).length; + } else if (coll === 1) { + const v: Big.Big[] = []; + rt.iterExtend(v, items, undefined, 1100); + len = v.length; + } else if (coll === 2) { + const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + rt.iterExtend(v2, items, undefined, 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + } else if (coll === 4) { + const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, undefined, 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), undefined, 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, undefined, 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { + return [t3, 1] as [Big.Big, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { + return [t2, 1] as [Big.Big, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104)); + } else if (coll === 11) { + len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)), 255, (v4: Big.Big[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: Big.Big = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$Big_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 1100, true).length; + } else if (coll === 1) { + const v: Big.Big[] = []; + rt.iterExtend(v, items, undefined, 1100, true); + len = v.length; + } else if (coll === 2) { + const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + rt.iterExtend(v2, items, undefined, 1100, true); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100, true).n; + } else if (coll === 4) { + const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, undefined, 1100, true); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1100, true), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), undefined, 1100, true); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, undefined, 1100, true)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { + return [t3, 1] as [Big.Big, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { + return [t2, 1] as [Big.Big, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104, true)); + } else if (coll === 11) { + len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)), 255, (v4: Big.Big[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: Big.Big = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$Big_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: Big.Big, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 1100).length; + } else if (coll === 1) { + const v: Big.Big[] = []; + rt.iterExtend(v, items, undefined, 1100); + len = v.length; + } else if (coll === 2) { + const v2: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + rt.iterExtend(v2, items, undefined, 1100); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + } else if (coll === 4) { + const _21: Big.Big[] = rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 1100, true); + rt.dequeExtend(q, items, undefined, 1100); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1100), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Big.clone$Clone(seed), 2, Big.clone$Clone), rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd)); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), undefined, 1100); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, undefined, 1100)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); + } else if (coll === 9) { + const _41: [Big.Big, rt.u32][] = [[seed, 0] as [Big.Big, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher, Big.eq$PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t3: Big.Big): [Big.Big, rt.u32] => { + return [t3, 1] as [Big.Big, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[Big.Big, rt.u32]> = rt.iterMap(items, (t2: Big.Big): [Big.Big, rt.u32] => { + return [t2, 1] as [Big.Big, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104)); + } else if (coll === 11) { + len = mapOr$1cxlmys(rt.iterCollectOption(rt.iterMap(items, (a0: Big.Big): Big.Big | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)), 255, (v4: Big.Big[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Big.Big]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: Big.Big = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 4).length; + } else if (coll === 1) { + const v: rt.u32[] = []; + rt.iterExtend(v, items, undefined, 4); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 4); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + } else if (coll === 4) { + const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + rt.dequeExtend(q, items, undefined, 4); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 4)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { + return [t3, 1] as [rt.u32, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { + return [t2, 1] as [rt.u32, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$1umcrqz(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)), 255, (v4: rt.u32[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 4).length; + } else if (coll === 1) { + const v: rt.u32[] = []; + rt.iterExtend(v, items, undefined, 4); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 4); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + } else if (coll === 4) { + const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + rt.dequeExtend(q, items, undefined, 4); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 4)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { + return [t3, 1] as [rt.u32, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { + return [t2, 1] as [rt.u32, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$1umcrqz(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)), 255, (v4: rt.u32[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 4).length; + } else if (coll === 1) { + const v: rt.u32[] = []; + rt.iterExtend(v, items, undefined, 4); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 4); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + } else if (coll === 4) { + const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + rt.dequeExtend(q, items, undefined, 4); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 4)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { + return [t3, 1] as [rt.u32, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { + return [t2, 1] as [rt.u32, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$1umcrqz(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)), 255, (v4: rt.u32[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 4, true).length; + } else if (coll === 1) { + const v: rt.u32[] = []; + rt.iterExtend(v, items, undefined, 4, true); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 4, true); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4, true).n; + } else if (coll === 4) { + const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + rt.dequeExtend(q, items, undefined, 4, true); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 4, true), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4, true); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 4, true)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { + return [t3, 1] as [rt.u32, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { + return [t2, 1] as [rt.u32, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8, true)); + } else if (coll === 11) { + len = mapOr$1umcrqz(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)), 255, (v4: rt.u32[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 4).length; + } else if (coll === 1) { + const v: rt.u32[] = []; + rt.iterExtend(v, items, undefined, 4); + len = v.length; + } else if (coll === 2) { + const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 4); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + } else if (coll === 4) { + const _21: rt.u32[] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_21), undefined, 4, true); + rt.dequeExtend(q, items, undefined, 4); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 4)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { + return [t3, 1] as [rt.u32, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { + return [t2, 1] as [rt.u32, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$1umcrqz(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)), 255, (v4: rt.u32[]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u32 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u64_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 16).length; + } else if (coll === 1) { + const v: [rt.u64, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 16); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 16); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + } else if (coll === 4) { + const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), undefined, 16, true); + rt.dequeExtend(q, items, undefined, 16); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 16), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])), undefined, 16); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, undefined, 16)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + } else if (coll === 9) { + const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 24)); + } else if (coll === 11) { + len = mapOr$0pdoq6p(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u64, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u64, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 16).length; + } else if (coll === 1) { + const v: [rt.u64, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 16); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 16); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + } else if (coll === 4) { + const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), undefined, 16, true); + rt.dequeExtend(q, items, undefined, 16); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 16), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])), undefined, 16); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, undefined, 16)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + } else if (coll === 9) { + const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 24)); + } else if (coll === 11) { + len = mapOr$0pdoq6p(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u64, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u64, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 16).length; + } else if (coll === 1) { + const v: [rt.u64, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 16); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 16); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + } else if (coll === 4) { + const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), undefined, 16, true); + rt.dequeExtend(q, items, undefined, 16); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 16), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])), undefined, 16); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, undefined, 16)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + } else if (coll === 9) { + const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 24)); + } else if (coll === 11) { + len = mapOr$0pdoq6p(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u64, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u64, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u64_u8_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 16, true).length; + } else if (coll === 1) { + const v: [rt.u64, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 16, true); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 16, true); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16, true).n; + } else if (coll === 4) { + const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), undefined, 16, true); + rt.dequeExtend(q, items, undefined, 16, true); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 16, true), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])), undefined, 16, true); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, undefined, 16, true)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + } else if (coll === 9) { + const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 24, true)); + } else if (coll === 11) { + len = mapOr$0pdoq6p(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u64, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u64, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u64_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 16).length; + } else if (coll === 1) { + const v: [rt.u64, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 16); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 16); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + } else if (coll === 4) { + const _21: [rt.u64, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_21), undefined, 16, true); + rt.dequeExtend(q, items, undefined, 16); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 16), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])), undefined, 16); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, undefined, 16)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + } else if (coll === 9) { + const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 24)); + } else if (coll === 11) { + len = mapOr$0pdoq6p(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u64, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u64, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToByteVec(items).length; + } else if (coll === 1) { + const v: rt.ByteVec = new rt.ByteVec(); + rt.iterExtendBytes(v, items); + len = v.length; + } else if (coll === 2) { + const v2: rt.ByteVec = rt.byteVecOf(seed, 2); + rt.iterExtendBytes(v2, items); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + } else if (coll === 4) { + const _21: rt.ByteVec = rt.byteVecOf(seed, 2); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + rt.dequeExtend(q, items, undefined, 1); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 1); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 1)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + } else if (coll === 9) { + const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { + return [t3, 1] as [rt.u8, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { + return [t2, 1] as [rt.u8, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToByteVec(values)), 255, (v4: rt.ByteVec): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u8 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToByteVec(values)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToByteVec(items).length; + } else if (coll === 1) { + const v: rt.ByteVec = new rt.ByteVec(); + rt.iterExtendBytes(v, items); + len = v.length; + } else if (coll === 2) { + const v2: rt.ByteVec = rt.byteVecOf(seed, 2); + rt.iterExtendBytes(v2, items); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + } else if (coll === 4) { + const _21: rt.ByteVec = rt.byteVecOf(seed, 2); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + rt.dequeExtend(q, items, undefined, 1); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 1); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 1)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + } else if (coll === 9) { + const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { + return [t3, 1] as [rt.u8, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { + return [t2, 1] as [rt.u8, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToByteVec(values)), 255, (v4: rt.ByteVec): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u8 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToByteVec(values)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToByteVec(items).length; + } else if (coll === 1) { + const v: rt.ByteVec = new rt.ByteVec(); + rt.iterExtendBytes(v, items); + len = v.length; + } else if (coll === 2) { + const v2: rt.ByteVec = rt.byteVecOf(seed, 2); + rt.iterExtendBytes(v2, items); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + } else if (coll === 4) { + const _21: rt.ByteVec = rt.byteVecOf(seed, 2); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + rt.dequeExtend(q, items, undefined, 1); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 1); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 1)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + } else if (coll === 9) { + const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { + return [t3, 1] as [rt.u8, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { + return [t2, 1] as [rt.u8, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToByteVec(values)), 255, (v4: rt.ByteVec): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u8 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToByteVec(values)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToByteVec(items, undefined, true).length; + } else if (coll === 1) { + const v: rt.ByteVec = new rt.ByteVec(); + rt.iterExtendBytes(v, items, undefined, true); + len = v.length; + } else if (coll === 2) { + const v2: rt.ByteVec = rt.byteVecOf(seed, 2); + rt.iterExtendBytes(v2, items, undefined, true); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1, true).n; + } else if (coll === 4) { + const _21: rt.ByteVec = rt.byteVecOf(seed, 2); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + rt.dequeExtend(q, items, undefined, 1, true); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1, true), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 1, true); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 1, true)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + } else if (coll === 9) { + const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { + return [t3, 1] as [rt.u8, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { + return [t2, 1] as [rt.u8, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8, true)); + } else if (coll === 11) { + len = mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToByteVec(values)), 255, (v4: rt.ByteVec): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u8 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToByteVec(values)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToByteVec(items).length; + } else if (coll === 1) { + const v: rt.ByteVec = new rt.ByteVec(); + rt.iterExtendBytes(v, items); + len = v.length; + } else if (coll === 2) { + const v2: rt.ByteVec = rt.byteVecOf(seed, 2); + rt.iterExtendBytes(v2, items); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + } else if (coll === 4) { + const _21: rt.ByteVec = rt.byteVecOf(seed, 2); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.byteVecView(_21)), undefined, 1, true); + rt.dequeExtend(q, items, undefined, 1); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteVecOf(seed, 2))), rt.le, rt.ge, rt.lt); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 1); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 1)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + } else if (coll === 9) { + const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; + const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { + return [t3, 1] as [rt.u8, rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { + return [t2, 1] as [rt.u8, rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + return a0; + }), (values: rt.Iter) => rt.iterToByteVec(values)), 255, (v4: rt.ByteVec): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { + let _0!: rt.Result; + const i2: rt.usize = _2[0]; + const t: rt.u8 = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter) => rt.iterToByteVec(values)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_u8_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closure2(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 3).length; + } else if (coll === 1) { + const v: [rt.u8, rt.u8, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 3); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 3); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, undefined, 3).n; + } else if (coll === 4) { + const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + rt.dequeExtend(q, items, undefined, 3); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 3), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), undefined, 3); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, undefined, 3)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$0amk6zv(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u8, rt.u8, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 3).length; + } else if (coll === 1) { + const v: [rt.u8, rt.u8, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 3); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 3); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, undefined, 3).n; + } else if (coll === 4) { + const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + rt.dequeExtend(q, items, undefined, 3); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 3), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), undefined, 3); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, undefined, 3)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$0amk6zv(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u8, rt.u8, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 3).length; + } else if (coll === 1) { + const v: [rt.u8, rt.u8, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 3); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 3); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, undefined, 3).n; + } else if (coll === 4) { + const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + rt.dequeExtend(q, items, undefined, 3); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 3), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), undefined, 3); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, undefined, 3)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$0amk6zv(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u8, rt.u8, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_u8_u8_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 3, true).length; + } else if (coll === 1) { + const v: [rt.u8, rt.u8, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 3, true); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 3, true); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, undefined, 3, true).n; + } else if (coll === 4) { + const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + rt.dequeExtend(q, items, undefined, 3, true); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 3, true), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), undefined, 3, true); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, undefined, 3, true)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 8, true)); + } else if (coll === 11) { + len = mapOr$0amk6zv(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u8, rt.u8, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +/** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ +export function fill$u8_u8_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { + let len!: rt.usize; + if (coll === 0) { + len = rt.iterToArray(items, undefined, 3).length; + } else if (coll === 1) { + const v: [rt.u8, rt.u8, rt.u8][] = []; + rt.iterExtend(v, items, undefined, 3); + len = v.length; + } else if (coll === 2) { + const v2: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + rt.iterExtend(v2, items, undefined, 3); + len = v2.length; + } else if (coll === 3) { + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, undefined, 3).n; + } else if (coll === 4) { + const _21: [rt.u8, rt.u8, rt.u8][] = rt.vecFromElem(seed, 2, undefined); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, rt.iterSlice(_21), undefined, 3, true); + rt.dequeExtend(q, items, undefined, 3); + len = q.n; + } else if (coll === 5) { + len = rt.heapFrom(rt.iterToArray(items, undefined, 3), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))).d.length; + } else if (coll === 6) { + const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp]))); + rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])), undefined, 3); + len = h.d.length; + } else if (coll === 7) { + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, undefined, 3)); + } else if (coll === 8) { + len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + } else if (coll === 9) { + const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; + const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rt.hashLen(m); + } else if (coll === 10) { + const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { + return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + }); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 8)); + } else if (coll === 11) { + len = mapOr$0amk6zv(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + return a0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { + return v4.length; + }); + } else { + const _53: rt.Result<[rt.u8, rt.u8, rt.u8][], rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { + let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; + const i2: rt.usize = _2[0]; + const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + if (!(i2 < 3)) { + _0 = rt.Err(i2); + } else { + _0 = rt.Ok(t); + } + return _0; + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + if (_53.ok) { + len = _53.value.length; + } else { + len = rt.usizeAdd(256, _53.error); + } + } + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); +} + +//# sourceMappingURL=hints.ts.map diff --git a/ts/fixtures/lang/expected/holds.ts b/ts/fixtures/lang/expected/holds.ts index 5efa4d95a..6c0124b4c 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -69,9 +69,9 @@ export function places(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): set(rt.place(() => grid[_30][_32], (value) => grid[_30][_32] = value), k); set(rt.place(() => rows[_35].cells[_39], (value2) => rows[_35].cells[_39] = value2), k ^ 1); } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 4)); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 4), undefined, true); for (const _61 of rows) { - rt.iterExtendBytes(out, rt.iterSlice(_61.cells)); + rt.iterExtendBytes(out, rt.iterSlice(_61.cells), undefined, true); } const x: Uint8Array = rt.bytes(4).fill(a); const y: Uint8Array = rt.bytes(4).fill(b); @@ -96,8 +96,8 @@ export function places(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): rt.panic("index out of bounds: the len is " + _88 + " but the index is " + 0); } r.data[r.start] = _80; - rt.iterExtendBytes(out, rt.iterSlice(x)); - rt.iterExtendBytes(out, rt.iterSlice(y)); + rt.iterExtendBytes(out, rt.iterSlice(x), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(y), undefined, true); } /** @@ -114,7 +114,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, data.data[data.start + _9]); kept.push(data.data[data.start + _9]); } - rt.iterExtendBytes(out, rt.iterSlice(kept)); + rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); const v: rt.ByteVec = rt.byteSliceToByteVec(data); let i2: rt.usize = 0; while (i2 < v.length) { @@ -123,7 +123,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const _31: rt.u8 = rt.u8WrappingAdd(v.data[at], i2 & 0xff); v.data[at] = _31; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); } /** @@ -138,16 +138,16 @@ export function reborrows(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVe r = rt.place(() => y, (value2) => y = value2); s.v = rt.u8WrappingAdd(s.v, 1); r.v = rt.u8WrappingAdd(r.v, 2); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(x, y))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(x, y)), undefined, true); let r2: rt.u8 = a; const kept: rt.u8[] = []; for (const _25 of rt.byteSliceView(data)) { const s2: rt.u8 = r2; r2 = _25; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(s2, r2))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(s2, r2)), undefined, true); kept.push(s2); } - rt.iterExtendBytes(out, rt.iterSlice(kept)); + rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); } /** @@ -162,7 +162,7 @@ export function copies(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { r = _9; kept.push(s); } - rt.iterExtendBytes(out, rt.iterSlice(kept)); + rt.iterExtendBytes(out, rt.iterSlice(kept), undefined, true); const range: rt.Range = new rt.Range(0, data.length); let cur: rt.usize | undefined = range.start < range.end ? range.start++ : undefined; const some: boolean = cur !== undefined; @@ -285,7 +285,7 @@ export function parts(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): x = rows[1]; n = rt.u8WrappingAdd(n, 1); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_17)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_18.cells[0], pair[2], whole(pair)))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_18.cells[0], pair[2], whole(pair))), undefined, true); rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); rt.byteVecPush(out, x.cells[0] ^ n); let total: rt.u8 = 0; @@ -315,7 +315,7 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { _16 = range2.start++; } if (_16Some) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before2 & 0xff, _16 & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before2 & 0xff, _16 & 0xff)), undefined, true); } else { break; } diff --git a/ts/fixtures/lang/expected/ints.ts b/ts/fixtures/lang/expected/ints.ts index 046353f16..feeb291a6 100644 --- a/ts/fixtures/lang/expected/ints.ts +++ b/ts/fixtures/lang/expected/ints.ts @@ -2644,12 +2644,12 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) return b; } return rt.u8Sub(b, 32); - })); + }), undefined, true); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, top)]; const _54: string = rt.fmtFormat(["-", args8[0]]); const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, past)]; const _53: string[] = [_54, rt.fmtFormat(["000", args10[0]]), rt.resultUnwrap(rt.stringFromUtf8(upper), rt.fmtFromUtf8ErrorDebug)]; - rt.iterExtend(all, rt.iterSlice(_53)); + rt.iterExtend(all, rt.iterSlice(_53), undefined, 12, true); if (rt.u128Gt(min, 0)) { const _77: [string, string] = [digits(min, radix), succ(digits(min, radix), radix)]; const bottom: string = _77[0]; @@ -2662,7 +2662,7 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) const _104: string = rt.fmtFormat(["-000", args16[0]]); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, below)]; const _85: string[] = [_86, _95, _104, rt.fmtFormat(["-00", args18[0]])]; - rt.iterExtend(all, rt.iterSlice(_85)); + rt.iterExtend(all, rt.iterSlice(_85), undefined, 12, true); } const unchecked: rt.usize = rt.usizeSub(rt.usizeDiv(bits, 4), rt.u128Gt(min, 0) ? 1 : 0); const _131: rt.usize = rt.usizeSub(radix as rt.usize, 1); @@ -2687,7 +2687,7 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) } const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, run)]; const _158: string[] = [rt.fmtFormat(["-", args20[0]]), run]; - rt.iterExtend(all, rt.iterSlice(_158)); + rt.iterExtend(all, rt.iterSlice(_158), undefined, 12, true); } const _172: rt.usize = rt.usizeRem(radix as rt.usize, 36); if (!(_172 < 36)) { @@ -2707,7 +2707,7 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) const _203: string = rt.fmtFormat(["1", args22[0]]); const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(stray, f)]; const _202: string[] = [_203, rt.fmtFormat([args24[0]])]; - rt.iterExtend(all, rt.iterSlice(_202)); + rt.iterExtend(all, rt.iterSlice(_202), undefined, 12, true); return all; } diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index f396dd002..65c759154 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -30,7 +30,7 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void for (const _18 of rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): rt.u16 | undefined => { const b12: rt.u8 = _218; return thenSome$0b23a33(b12 < 100, rt.u16Mul(b12 as rt.u16, 200)); - }))) { + }), undefined, 2)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_18))); } } else { @@ -64,8 +64,8 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const back: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + mid, data.length - mid); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(front)), rt.iterRev(rt.iterSlice(rt.byteSliceView(back)))), (_216: [rt.u8, rt.u8]): rt.u8 => { return _216[0] ^ _216[1]; - })))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(rt.byteSliceView(front)), rt.iterSlice(rt.byteSliceView(back))))))); + }), undefined, true))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(rt.byteSliceView(front)), rt.iterSlice(rt.byteSliceView(back)))), undefined, true))); } else if (_4 === 3) { const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): boolean => { return _213 !== 0; @@ -115,7 +115,7 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } if (_4 === 6) { const it2: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterBorrow(it2), 2)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterBorrow(it2), 2), undefined, true))); rt.byteVecPush(out, it2.len() & 0xff); const _152: rt.u8 | undefined = rt.iterToOption(it2.nextBack()); if (_152 === undefined) { @@ -128,8 +128,8 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { const b3: rt.u8 = _2; return Uint8Array.of(b3, ~b3 & 0xff); - })); - const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray)); + }), undefined, 2, true); + const copies: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); if (!((copies.length === 0))) { const _174: rt.ByteSlice = rt.byteSliceFrom(copies[rt.idx(copies, 0)]); _174.data[_174.start] = 85; @@ -146,7 +146,7 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _196: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.u16 => { return rt.u16Add(_22 as rt.u16, 1); }); - rt.iterExtend(v2, _196); + rt.iterExtend(v2, _196, undefined, 2, true); rt.byteVecPush(out, v2.length & 0xff); rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { return _210 > 128; @@ -303,7 +303,7 @@ export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi }), (_29: rt.u8): rt.u16 | undefined => { const b5: rt.u8 = _29; return thenSome$0b23a33(b5 !== 32, b5 as rt.u16); - }), (values__: rt.Iter) => rt.iterToArray(values__)), 255, (v2: rt.u16[]): rt.u8 => { + }), (values__: rt.Iter) => rt.iterToArray(values__, undefined, 2)), 255, (v2: rt.u16[]): rt.u8 => { return v2.length & 0xff; })); } @@ -319,11 +319,11 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterMaxBy(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8, _3: rt.u8): rt.Ordering => { const a: rt.u8 = _2; const b: rt.u8 = _3; - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(a, b))); + rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(a, b)), undefined, true); return rt.cmp(rt.u8Rem(a, 4), rt.u8Rem(b, 4)); }), 238)); rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterMinBy(rt.iterSlice(rt.byteSliceView(data)), (a2: rt.u8, b2: rt.u8): rt.Ordering => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(a2, b2))); + rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(a2, b2)), undefined, true); return rt.cmp(rt.u8Div(a2, 64), rt.u8Div(b2, 64)); }), 238)); rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterReduce(rt.iterSlice(rt.byteSliceView(data)), (acc: rt.u8, b3: rt.u8): rt.u8 => { @@ -341,9 +341,9 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { return rt.byteVecFrom(Uint8Array.of(_23)); }), (a4: rt.ByteVec, b7: rt.ByteVec): rt.ByteVec => { - rt.iterExtendBytes(a4, rt.iterSlice(rt.byteVecView(b7))); + rt.iterExtendBytes(a4, rt.iterSlice(rt.byteVecView(b7)), undefined, true); return a4; - }))))); + })))), undefined, true); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); const _38: rt.Place | undefined = rt.peekablePeekMut(it, true); if (_38 !== undefined) { @@ -365,7 +365,7 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_73 !== undefined) { rt.byteVecPush(_73, 153); } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(unwrapOrDefault$0wx44sw(rt.iterToOption(words.next()))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(unwrapOrDefault$0wx44sw(rt.iterToOption(words.next())))), undefined, true); const _87: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(first)); rt.byteVecPush(out, mapOr$1a3irjf(rt.peekableNextIfEq(words, _87, rt.eqBytes), 136, (w: rt.ByteVec): rt.u8 => { return w.data[rt.idx(w, 0)]; @@ -378,8 +378,8 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_94 !== undefined) { _94.v = 119; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log)), undefined, true); } export function eq$PartialEq_Quarter_u8(self: rt.u8, other: Quarter.Quarter): boolean { @@ -424,7 +424,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }; const words: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): string => { return _3(_2); - })); + }), undefined, 12, true); const _12: string | undefined = rt.sliceFirst(words); const first: string = unwrapOrDefault$165pyh5(_12 === undefined ? undefined : _12); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(words.slice())); @@ -565,7 +565,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 170, (b9: rt.Place): rt.u8 => { return b9.v; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); const it11: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Quarter.Quarter => { return { _0: _210, _1: calls }; })); @@ -985,7 +985,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const rest14: rt.Iter<[rt.u8, rt.u8]> = rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): [rt.u8, rt.u8] => { const b3: rt.u8 = _25; return [b3, ~b3 & 0xff] as [rt.u8, rt.u8]; - }))); + }), undefined, 2, true)); const it29: rt.Iter<[rt.u8, rt.u8]> = rt.iterCopied(rt.iterTake(rt.iterBorrow(rest14), limit), copy$u8_u8); if (!back) { item27 = rt.iterNth(it29, n); @@ -999,7 +999,7 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const rest15: rt.Iter = rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Uint8Array => { const b5: rt.u8 = _29; return Uint8Array.of(b5, ~b5 & 0xff); - }))), rt.byteSliceFrom); + }), undefined, 2, true)), rt.byteSliceFrom); const it30: rt.Iter = rt.iterCopied(rt.iterTake(rt.iterBorrow(rest15), limit), rt.byteSliceToArray); if (!back) { item28 = rt.iterNth(it30, n); @@ -1048,7 +1048,7 @@ export function ranked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }; const tilts: Tilt.Tilt[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): Tilt.Tilt => { return { _0: rt.u8Rem(_27, 8) }; - })); + }), undefined, 1, true); const _10: rt.u8 = rt.u8Rem(kind, 4); if (_10 === 0) { const part5 = rt.iterMinByKey(items(), (_216: [rt.usize, rt.u8]): [rt.u8, rt.u8 | undefined] => { @@ -1173,7 +1173,7 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, _47); } rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterNth(new rt.Range(a, b), 5), 238)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step), undefined, true))); const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); @@ -1207,7 +1207,7 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step)), (i5: rt.i8): rt.u8 => { return i5 & 0xff; - })); + }), undefined, true); const wide: rt.Range = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterBorrow(wide), (n2: rt.u64): rt.u64 => { return rt.u64Rem(n2, 5); @@ -1228,7 +1228,7 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { return _24; }, rt.lt), 0)))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(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)))) { + for (const _295 of rt.iterToArray(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8)), undefined, 4, true)) { rt.byteVecPush(out, _295 & 0xff); } updates(a, b, data, out); @@ -1296,7 +1296,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { return b4; } return undefined; - })); + }), undefined, 2, true); rt.byteVecPush(out, all.length & 0xff); const iter: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b5: rt.u8): rt.u8 | undefined => { if (!(rt.u8Rem(b5, 3) === 0)) { @@ -1321,7 +1321,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { return b6; } return undefined; - }), (value: rt.u8 | undefined) => rt.iterOption(value))))); + }), (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true)))); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); @@ -1342,7 +1342,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { } const _57: rt.Iter = rt.iterOption(first); rt.iterEmpty(); - rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty())); + rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty()), undefined, true); let n: rt.u8 = 0; rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { n = rt.u8Add(n, 1); @@ -1468,8 +1468,8 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const tags: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tag.Tag => { const b3: rt.u8 = _2; return { bytes: rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(b3, ~b3 & 0xff))) }; - })); - const cloned: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone)); + }), undefined, 12, true); + const cloned: Tag.Tag[] = rt.iterToArray(rt.iterMap(rt.iterSlice(tags), Tag.clone$Clone), undefined, 12, true); const iter3: rt.Iter = rt.iterSlice(cloned); while (true) { const _59: Tag.Tag | rt.Done = iter3.next(); @@ -1488,18 +1488,18 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { } const bumps: Bumped.Bumped[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): Bumped.Bumped => { return { _0: _22 }; - })); + }), undefined, 1, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { return b5._0; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterCopied(rt.iterSlice(bumps), copy$Bumped), (b6: Bumped.Bumped): rt.u8 => { return b6._0; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): Wrapper.Wrapper => { return new Wrapper.Wrapper({ _0: _23 }); - }))), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { + }), undefined, 1, true)), Wrapper.clone$Clone_Bumped), (w: Wrapper.Wrapper): rt.u8 => { return w._0._0; - })); + }), undefined, true); } /** @@ -1552,7 +1552,7 @@ export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { _3(part8, out); rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(mapOr$0atjiti(first$Chars(rt.strChars(unwrapOr$01jdcm7(rt.strFromUtf8(data), "é"))), 0, (a0: rt.char): rt.u32 => { return a0 as rt.u32; - })).reverse())); + })).reverse()), undefined, true); const part9 = byMut$Copied_Iter_u8(rt.iterSlice(rt.byteSliceView(data))); _3(part9, out); const gaps: Gaps.Gaps = { data, at: 0 }; @@ -1578,7 +1578,7 @@ export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { return b8; } return undefined; - })), n); + }), undefined, 2, true), n); _4(part18, out); } diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 72b125e12..6ab87fcb6 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -423,11 +423,11 @@ export function overrides(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, compare$u8_Reverse_Arc_Lopsided(_108, _114)); drop$u8_Reverse_Arc_Lopsided(_114); drop$u8_Reverse_Arc_Lopsided(_108); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.ordMax(a, b, Lopsided.lt$PartialOrd)._0, rt.ordMin(a, b, Lopsided.lt$PartialOrd)._0, rt.ordMax(a, b, Lopsided.lt$PartialOrd)._0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.ordMax(a, b, Lopsided.lt$PartialOrd)._0, rt.ordMin(a, b, Lopsided.lt$PartialOrd)._0, rt.ordMax(a, b, Lopsided.lt$PartialOrd)._0)), undefined, true); const _131: [[rt.u8, Lopsided.Lopsided], rt.Arc] = [rt.ordMax([rt.u8Rem(c, 2), a] as [rt.u8, Lopsided.Lopsided], [rt.u8Rem(d, 2), b] as [rt.u8, Lopsided.Lopsided], rt.testTuple([rt.cmp], rt.cmpReverse(Lopsided.lt$PartialOrd), -1)), rt.ordMin(new rt.Arc(a), new rt.Arc(b), rt.cmpArc(Lopsided.lt$PartialOrd), rt.drop)]; const m: [rt.u8, Lopsided.Lopsided] = _131[0]; const n: rt.Arc = _131[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(m[0], m[1]._0, n.value._0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(m[0], m[1]._0, n.value._0)), undefined, true); const x: Lopsided.Lopsided = { _0: c ^ d }; if (Lopsided.le$PartialOrd(a, b)) { rt.byteVecPush(out, rt.ordClamp(x, a, b, Lopsided.le$PartialOrd, Lopsided.lt$PartialOrd, Lopsided.gt$PartialOrd)._0); @@ -436,26 +436,26 @@ export function overrides(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } const v: Lopsided.Lopsided[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Lopsided.Lopsided => { return { _0: _2 }; - })); + }), undefined, 1, true); rt.sliceSort(v, Lopsided.lt$PartialOrd); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v), (x2: Lopsided.Lopsided): rt.u8 => { return x2._0; - })); + }), undefined, true); rt.sliceSortByKey(v, (_23: Lopsided.Lopsided): [rt.u8, Lopsided.Lopsided] => { const x3: Lopsided.Lopsided = _23; return [rt.u8Rem(x3._0, 3), x3] as [rt.u8, Lopsided.Lopsided]; }, rt.testTuple([rt.cmp], rt.cmpReverse(Lopsided.lt$PartialOrd), -1)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v), (x4: Lopsided.Lopsided): rt.u8 => { return x4._0; - })); + }), undefined, true); const pairs: [rt.u8, Lopsided.Lopsided][] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [rt.u8, Lopsided.Lopsided] => { const c4: rt.u8 = _24; return [rt.u8Rem(c4, 4), { _0: c4 }] as [rt.u8, Lopsided.Lopsided]; - })); + }), undefined, 2, true); rt.sliceSort(pairs, rt.testTuple([rt.cmp], Lopsided.lt$PartialOrd, -1)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(pairs), (p: [rt.u8, Lopsided.Lopsided]): rt.u8 => { return p[1]._0; - })); + }), undefined, true); if (data.length >= 3) { rt.byteVecPush(out, rt.ordClamp({ _0: data.data[data.start] }, { _0: data.data[data.start + 1] }, { _0: data.data[data.start + 2] }, Lopsided.le$PartialOrd, Lopsided.lt$PartialOrd, Lopsided.gt$PartialOrd)._0); } @@ -615,7 +615,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { const _316: rt.u8 = rt.hashAdd(deep, _319) ? 1 : 0; const _327: Way.Way | undefined | rt.None = _313(d); rt.byteVecPush(out, _316 | (((rt.hashContains(deep, _327) ? 1 : 0) << 1) & 0xff)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(bare) & 0xff, rt.hashLen(deep) & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(bare) & 0xff, rt.hashLen(deep) & 0xff)), undefined, true); const _345: [rt.u8, Horizon.Horizon] = [rt.u8Rem(d, 3), { exclude: b, local: false }]; rt.byteVecPush(out, rt.hashContains(hashed, _345) ? 1 : 0); s2[Symbol.dispose](); @@ -896,18 +896,18 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _52: rt.u8 = rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0; const _61: Uint8Array | undefined = a; const _63: Uint8Array | undefined = b; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_44, _48, _52, rt.eqOption(rt.eqBytes)(_61, _63) ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_44, _48, _52, rt.eqOption(rt.eqBytes)(_61, _63) ? 1 : 0)), undefined, true); rt.idx(_9, 0); const _69: [Uint8Array, rt.u8] = [a, _9.data[_9.start]]; rt.idx(_9, 1); const _75: [Uint8Array, rt.u8] = [b, _9.data[_9.start + 1]]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqTuple([rt.eqBytes, rt.same])(_69, _75) ? 1 : 0, rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceToByteVec(rt.byteSliceFrom(b))) ? 1 : 0))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.byteSliceEq(rt.byteSliceRange(rt.byteSliceFrom(a), 0), rt.byteSliceRange(rt.byteSliceFrom(b), 0)) ? 1 : 0, rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceFrom(a)) ? 1 : 0, rt.eqBytes(rt.byteSliceRange(rt.byteSliceFrom(a), 0), rt.byteSliceToByteVec(rt.byteSliceFrom(b))) ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqTuple([rt.eqBytes, rt.same])(_69, _75) ? 1 : 0, rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceToByteVec(rt.byteSliceFrom(b))) ? 1 : 0)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.byteSliceEq(rt.byteSliceRange(rt.byteSliceFrom(a), 0), rt.byteSliceRange(rt.byteSliceFrom(b), 0)) ? 1 : 0, rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceFrom(a)) ? 1 : 0, rt.eqBytes(rt.byteSliceRange(rt.byteSliceFrom(a), 0), rt.byteSliceToByteVec(rt.byteSliceFrom(b))) ? 1 : 0)), undefined, true); const _117: rt.u8 = rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceRange(rt.byteSliceFrom(b), 0)) ? 1 : 0; const _127: rt.u8 = rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceRange(rt.byteSliceFrom(b), 0)) ? 1 : 0; const _135: rt.Arc = new rt.Arc(copy$u8s(a)); const _137: rt.Arc = new rt.Arc(copy$u8s(b)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_117, _127, rt.eqArc(rt.eqBytes, true)(_135, _137) ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_117, _127, rt.eqArc(rt.eqBytes, true)(_135, _137) ? 1 : 0)), undefined, true); _137[Symbol.dispose](); _135[Symbol.dispose](); } @@ -925,8 +925,8 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); rt.idx(w, 1); return Uint8Array.of(_3, rt.u8Rem(w.data[w.start + 1], 4)); - }))), rt.byteSliceFrom); - const borrowed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _151); + }), undefined, 2, true)), rt.byteSliceFrom); + const borrowed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _151, undefined, undefined, 234881024); const iter2: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); while (true) { const _158: [rt.usize, rt.ByteSlice] | rt.Done = iter2.next(); @@ -1052,7 +1052,7 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _354: rt.Iter = rt.iterMap(rt.byteSliceChunks(data, 2), (a0: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(a0); }); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _354); + const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _354, undefined, undefined, 117440512); rt.byteVecPush(out, rt.hashLen(set) & 0xff); const _364: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); rt.byteVecPush(out, rt.hashContains(set, _364) ? 1 : 0); @@ -1072,7 +1072,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); rt.idx(w, 1); return Uint8Array.of(_3, rt.u8Rem(w.data[w.start + 1], 4)); - })); + }), undefined, 2, true); const probe: Uint8Array = Uint8Array.of(rt.u8Rem(kind, 4), rt.u8Rem(rt.u8Div(kind, 4), 4)); const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; @@ -1093,10 +1093,10 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void key[0] = key[0] ^ 16; rt.byteVecPush(out, rt.hashContains(map, rt.byteSliceView(rt.byteSliceFrom(key))) ? 1 : 0); } - const lent: rt.ByteSlice[] = rt.iterToArray(rt.iterMap(rt.hashKeys(map), rt.byteSliceFrom)); + const lent: rt.ByteSlice[] = rt.iterToArray(rt.iterMap(rt.hashKeys(map), rt.byteSliceFrom), undefined, 4); rt.sliceSort(lent, rt.cmpLt(rt.cmpBytes)); for (const k of lent) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(k.data[k.start], k.data[k.start + 1], rt.hashIndex(map, rt.byteSliceView(k)), rt.hashContains(map, rt.byteSliceView(k)) ? 1 : 0, rt.eqBytes(k, rt.byteSliceFrom(probe)) ? 1 : 0, rt.cmpBytes(k, rt.byteSliceFrom(probe)) === -1 ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(k.data[k.start], k.data[k.start + 1], rt.hashIndex(map, rt.byteSliceView(k)), rt.hashContains(map, rt.byteSliceView(k)) ? 1 : 0, rt.eqBytes(k, rt.byteSliceFrom(probe)) ? 1 : 0, rt.cmpBytes(k, rt.byteSliceFrom(probe)) === -1 ? 1 : 0)), undefined, true); rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeGet(tree, rt.byteSliceView(k)), 221)); rt.byteVecPush(out, mapOr$1w1gbwl(rt.optionMap(rt.hashKey(set, rt.byteSliceView(k)), rt.byteSliceFrom), 221, (s: rt.ByteSlice): rt.u8 => { return rt.eqBytes(s, k) ? 1 : 0; @@ -1173,13 +1173,13 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _212: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o)); const _211: rt.u8 = _212.data[_212.start]; const _217: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(1, _211, _217.data[_217.start + 1], rt.entryGet(o)))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(1, _211, _217.data[_217.start + 1], rt.entryGet(o))), undefined, true); } else { const v: rt.Entry = _206; const _227: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v)); const _226: rt.u8 = _227.data[_227.start]; const _232: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(0, _226, _232.data[_232.start + 1]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(0, _226, _232.data[_232.start + 1])), undefined, true); } const _239: rt.Entry = rt.entry(map, copy$u8s(probe)); const f = (k4: rt.ByteSlice): rt.u8 => { @@ -1194,13 +1194,13 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _272: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v2)); const _271: rt.u8 = _272.data[_272.start]; const _277: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v2)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(0, _271, _277.data[_277.start + 1]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(0, _271, _277.data[_277.start + 1])), undefined, true); } else { const o2: rt.Entry = _251; const _257: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o2)); const _256: rt.u8 = _257.data[_257.start]; const _262: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o2)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(1, _256, _262.data[_262.start + 1], rt.entryGet(o2)))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(1, _256, _262.data[_262.start + 1], rt.entryGet(o2))), undefined, true); } const _284: rt.Entry = rt.entry(tree, copy$u8s(probe)); const f2 = (k5: rt.ByteSlice): rt.u8 => { @@ -1215,7 +1215,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_294 !== undefined) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.entryKey(_294))); } - const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray)); + const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2); rt.sliceSort(members, rt.cmpLt(rt.cmpBytes)); const iter8: rt.Iter = rt.iterMap(rt.iterSlice(members), rt.byteSliceFrom); while (true) { @@ -1258,7 +1258,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_365 === rt.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_365[0].data[_365[0].start], _365[0].data[_365[0].start + 1], _365[1]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_365[0].data[_365[0].start], _365[0].data[_365[0].start + 1], _365[1])), undefined, true); } const iter11: rt.Iter = rt.iterMap(rt.btreeKeys(tree), rt.byteSliceFrom); while (true) { @@ -1276,7 +1276,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_396 === rt.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_396[0].data[_396[0].start], _396[0].data[_396[0].start + 1], _396[1]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_396[0].data[_396[0].start], _396[0].data[_396[0].start + 1], _396[1])), undefined, true); } const iter13: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterMap(rt.btreeRangeMut(tree, { start: copy$u8s(probe) }), (held11): [rt.ByteSlice, rt.Place] => { return [rt.byteSliceFrom(held11[0]), held11[1]]; @@ -1296,7 +1296,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_428 === rt.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_428[0].data[_428[0].start + 1], _428[1]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_428[0].data[_428[0].start + 1], _428[1])), undefined, true); } const iter15: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterMap(rt.btreeIterMut(tree), (held13): [rt.ByteSlice, rt.Place] => { return [rt.byteSliceFrom(held13[0]), held13[1]]; @@ -1344,10 +1344,10 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.optionMap(rt.btreeFirstKey(ordered), rt.byteSliceFrom), rt.bytes(2).fill(221), (k10: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(k10); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.optionMap(rt.btreeFirstKey(ordered, true), rt.byteSliceFrom), rt.bytes(2).fill(221), (k11: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(k11); - }))); + })), undefined, true); const f3 = (k12: rt.ByteSlice, v3: rt.Place): boolean => { if (!(k12.data[k12.start] <= k12.data[k12.start + 1])) { return rt.u8Rem(v3.v, 2) === 0; @@ -1368,7 +1368,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return k15.data[k15.start] < 2; }; rt.btreeRetain(ordered, (held21) => f5(rt.byteSliceFrom(held21))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(map) & 0xff, rt.btreeLen(tree) & 0xff, rt.hashLen(set) & 0xff, rt.btreeLen(ordered) & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(map) & 0xff, rt.btreeLen(tree) & 0xff, rt.hashLen(set) & 0xff, rt.btreeLen(ordered) & 0xff)), undefined, true); const _529: rt.ByteSlice | undefined = rt.optionMap(rt.btreeFirstKey(ordered), rt.byteSliceFrom); if (_529 !== undefined) { const copy2: Uint8Array = rt.byteSliceToArray(_529); @@ -1381,7 +1381,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _548: rt.Iter<[rt.ByteVec, rt.u8]> = rt.iterMap(rt.byteSliceChunks(data, 3), (c: rt.ByteSlice): [rt.ByteVec, rt.u8] => { return [rt.byteSliceToByteVec(c), c.length & 0xff] as [rt.ByteVec, rt.u8]; }); - const lens: rt.ByteVec[] = rt.iterToArray(rt.hashKeys(rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _548))); + const lens: rt.ByteVec[] = rt.iterToArray(rt.hashKeys(rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _548, undefined, undefined, undefined, 58720256)), undefined, 4); rt.sliceSort(lens, rt.cmpLt(rt.cmpBytes)); for (const _559 of lens) { rt.byteVecPush(out, _559.length & 0xff); @@ -1390,11 +1390,11 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _569: rt.Iter = rt.iterMap(rt.byteSliceChunks(data, 2), (a0: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(a0); }); - rt.byteVecPush(out, mapOr$1a3irjf(rt.hashKey(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _569), window), 221, (k17: rt.ByteVec): rt.u8 => { + rt.byteVecPush(out, mapOr$1a3irjf(rt.hashKey(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _569, undefined, undefined, 117440512), window), 221, (k17: rt.ByteVec): rt.u8 => { return k17.length & 0xff; })); const _576: rt.Iter = rt.byteSliceChunks(data, 2); - const borrowed: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, _576, true); + const borrowed: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, _576, true, undefined, undefined, 8, true); const iter20: rt.Iter = rt.btreeKeys(borrowed); while (true) { const _580: rt.ByteSlice | rt.Done = iter20.next(); @@ -1412,7 +1412,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return [rt.byteSliceFrom(held22[0]), held22[1]]; }) === undefined ? 1 : 0, rt.iterCount(rt.iterMap(rt.btreeRange(empty, { start: copy$u8s(probe) }), (held23): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held23[0]), held23[1]]; - })) & 0xff, rt.iterCount(rt.iterMap(rt.hashKeys(none), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.hashKey(none, rt.byteSliceView(rt.byteSliceFrom(probe))), rt.byteSliceFrom) === undefined ? 1 : 0))); + })) & 0xff, rt.iterCount(rt.iterMap(rt.hashKeys(none), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.hashKey(none, rt.byteSliceView(rt.byteSliceFrom(probe))), rt.byteSliceFrom) === undefined ? 1 : 0)), undefined, true); } /** @@ -1444,10 +1444,10 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const at: rt.u8 = rt.u8Rem(kind, 8); rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.optionMap(rt.hashGet(map, at), rt.byteSliceFrom), rt.bytes(2).fill(221), (v2: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(v2); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.optionMap(rt.btreeGet(tree, at), rt.byteSliceFrom), rt.bytes(2).fill(221), (v3: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(v3); - }))); + })), undefined, true); const _60: rt.ByteSlice | undefined = rt.optionMap(rt.hashGet(map, at), rt.byteSliceFrom); if (_60 !== undefined) { _60.data[_60.start] = _60.data[_60.start] ^ 64; @@ -1457,10 +1457,10 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo _67.data[_67.start + 1] = _67.data[_67.start + 1] ^ 64; } if (rt.hashContains(map, at)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.hashIndex(map, at))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.hashIndex(map, at)))), undefined, true); } if (rt.btreeContains(tree, at)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.btreeIndex(tree, at))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.btreeIndex(tree, at)))), undefined, true); } const _90: rt.ByteSlice = rt.byteSliceFrom(rt.entryOrInsert(rt.entry(map, at), Uint8Array.of(at, at))); _90.data[_90.start + 1] = _90.data[_90.start + 1] ^ 1; @@ -1494,7 +1494,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const _128: rt.u8 = rt.u8WrappingAdd(_124[1].data[_124[1].start], _124[1].data[_124[1].start + 1]); _124[1].data[_124[1].start] = _128; } - const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashValues(map), rt.byteSliceFrom), rt.byteSliceToArray)); + const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashValues(map), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2); rt.sliceSort(values, rt.cmpLt(rt.cmpBytes)); const iter4: rt.Iter = rt.iterMap(rt.iterSlice(values), rt.byteSliceFrom); while (true) { @@ -1512,14 +1512,14 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo if (_156 === rt.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_156[0], _156[1].data[_156[1].start], _156[1].data[_156[1].start + 1]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_156[0], _156[1].data[_156[1].start], _156[1].data[_156[1].start + 1])), undefined, true); } rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.optionMap(rt.dequeEnd(deque), rt.byteSliceFrom), rt.bytes(2).fill(221), (v5: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(v5); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.optionMap(rt.dequeEnd(deque, true), rt.byteSliceFrom), rt.bytes(2).fill(221), (v6: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(v6); - }))); + })), undefined, true); const _180: rt.ByteSlice | undefined = rt.optionMap(rt.dequeEnd(deque), rt.byteSliceFrom); if (_180 !== undefined) { _180.data[_180.start] = _180.data[_180.start] ^ 128; @@ -1531,7 +1531,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo if (!((deque.n === 0))) { const _201: rt.ByteSlice = rt.byteSliceFrom(rt.dequeIndex(deque, rt.usizeSub(deque.n, 1))); _201.data[_201.start] = _201.data[_201.start] ^ 1; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.dequeIndex(deque, 0))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.dequeIndex(deque, 0)))), undefined, true); } const iter6: rt.Iter = rt.iterMap(rt.dequeIter(deque), rt.byteSliceFrom); while (true) { @@ -1560,7 +1560,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo })) & 0xff); rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.optionMap(heap.d[0], rt.byteSliceFrom), rt.bytes(2).fill(221), (v9: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(v9); - }))); + })), undefined, true); const _247: (a0: rt.ByteSlice) => boolean = (v10: rt.ByteSlice): boolean => { return v10.data[v10.start + 1] !== rt.u8Rem(kind, 8); }; @@ -1582,7 +1582,7 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.byteVecPush(out, _262.data[_262.start] ^ _262.data[_262.start + 1]); } for (const _278 of rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes))) { - rt.iterExtendBytes(out, rt.iterSlice(_278)); + rt.iterExtendBytes(out, rt.iterSlice(_278), undefined, true); } } diff --git a/ts/fixtures/lang/expected/lib.ts b/ts/fixtures/lang/expected/lib.ts index 427eb828e..6ef64ea81 100644 --- a/ts/fixtures/lang/expected/lib.ts +++ b/ts/fixtures/lang/expected/lib.ts @@ -250,6 +250,10 @@ export function copy$u64_u64(v: [rt.u64, rt.u64]): [rt.u64, rt.u64] { return [v[0], v[1]]; } +export function copy$u64s(v: rt.u64[]): rt.u64[] { + return v.slice(); +} + export function copy$u8_Arc_u8(v: [rt.u8, rt.Arc]): [rt.u8, rt.Arc] { return [v[0], v[1]]; } diff --git a/ts/fixtures/lang/expected/locals.ts b/ts/fixtures/lang/expected/locals.ts index 2a42210bc..a6f9accf0 100644 --- a/ts/fixtures/lang/expected/locals.ts +++ b/ts/fixtures/lang/expected/locals.ts @@ -63,7 +63,7 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { })(COUNT.get()) & 0xff); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { return rt.byteVecFrom(rt.byteVecView(log2)); - })))); + }))), undefined, true); rt.byteVecPush(out, ((p: Polling.Polling): rt.u8 => { return mapOr$0ucbp7g(copy$Option_u64_u64(p.current.v), 253, (_2: [rt.u64, rt.u64]): rt.u8 => { return rt.u64Low(_2[0]) & 0xff; @@ -84,7 +84,7 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { return tally & 0xff; })); const _26: [Twin.Twin, Twin.Twin] = get$1jdtkm4(PAIRS); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_26[0]._0 & 0xff, _26[0]._1 & 0xff, _26[1]._0 & 0xff, _26[1]._1 & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_26[0]._0 & 0xff, _26[0]._1 & 0xff, _26[1]._0 & 0xff, _26[1]._1 & 0xff)), undefined, true); rt.byteVecPush(out, serial(false)); const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); for (const op of rt.byteSliceView(data)) { @@ -154,7 +154,7 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, take$09yi5f2(COUNT) & 0xff); set$0fx7125(COUNT, rt.u32Add(op as rt.u32, 1)); const _103: [Twin.Twin, Twin.Twin] = get$1jdtkm4(PAIRS); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_103[0]._0 & 0xff, _103[0]._1 & 0xff, _103[1]._0 & 0xff, _103[1]._1 & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_103[0]._0 & 0xff, _103[0]._1 & 0xff, _103[1]._0 & 0xff, _103[1]._1 & 0xff)), undefined, true); rt.byteVecPush(out, mapOr$1w5qtj7(thenSome$1d6toqn(rt.u8Rem(op, 2) === 0, undefined), 253, (_22: undefined): rt.u8 => { return 1; })); @@ -165,9 +165,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, withBorrow$0r4ucls(LOG, (log4: rt.ByteVec): rt.u8 => { return log4.length & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op)))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op))))), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(op, op))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(take$122f15k(LOG)))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(take$122f15k(LOG))), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(1, 2, 3))); const _141: rt.LocalKey> = HELD; const _144: rt.Arc> = rt.arcClone(log); @@ -199,7 +199,7 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, serial(false)); } const _181: rt.Mutex = rt.mutexLock(log.value); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_181.value)))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_181.value))), undefined, true); rt.mutexUnlock(_181); const _188: rt.Mutex = rt.mutexLock(log.value); rt.byteVecClear(_188.value); @@ -234,7 +234,7 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { })(HELD.get())); serial(true); const _208: rt.Mutex = rt.mutexLock(log.value); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_208.value)))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_208.value))), undefined, true); rt.mutexUnlock(_208); log[Symbol.dispose](); } diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index fcca1ef55..395eaba40 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -191,7 +191,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const items: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 | undefined => { const b: rt.u8 = _2; return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); - })); + }), undefined, 2, true); const at: rt.usize = mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (b2: rt.u8): rt.usize => { return rt.usizeRem(b2 as rt.usize, 4); }); @@ -244,7 +244,7 @@ export function consumers(data: rt.ByteSlice, out: rt.ByteVec): void { const items: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 | undefined => { const b: rt.u8 = _2; return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); - })); + }), undefined, 2, true); const n: rt.usize = mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (b2: rt.u8): rt.usize => { return rt.usizeRem(b2 as rt.usize, 8); }); @@ -344,7 +344,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { const b2: rt.u8 = _2; _8.v = rt.u8Add(_8.v, 1); return pick(b2); - }, rt.None)), called))); + }, rt.None)), called)), undefined, true); rt.byteVecPush(out, mapOr$18ph0j9(rt.iterFindMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): undefined | rt.None => { return unit(_23 ^ 1); }, rt.None), 208, (_: undefined): rt.u8 => { @@ -356,15 +356,15 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { const b4: rt.u8 = _27; _22.v = rt.u8Add(_22.v, 1); return pick(b4); - }, rt.None))), (_28: rt.u8 | undefined): rt.u8 => { + }, rt.None), undefined, 2)), (_28: rt.u8 | undefined): rt.u8 => { return code(_28); - })); + }), undefined, true); rt.byteVecPush(out, called); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterRev(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): rt.u8 | undefined | rt.None => { return pick(_210); - }, rt.None)))), (_211: rt.u8 | undefined): rt.u8 => { + }, rt.None)), undefined, 2)), (_211: rt.u8 | undefined): rt.u8 => { return code(_211); - })); + }), undefined, true); rt.byteVecPush(out, rt.iterFold(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): rt.u8 | undefined | rt.None => { return pick(_212); }, rt.None), 0, (n: rt.u8, o3: rt.u8 | undefined): rt.u8 => { @@ -379,11 +379,11 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { const b8: rt.u8 = _214; _52.v = rt.u8Add(_52.v, 1); return pick(b8); - }, rt.None)); + }, rt.None), undefined, 2); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(whiles), (_215: rt.u8 | undefined): rt.u8 => { return code(_215); - })); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(whiles.length & 0xff, called))); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(whiles.length & 0xff, called)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): undefined | rt.None => { return unit(_216); }, rt.None)) & 0xff); @@ -398,12 +398,12 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.None; }, rt.None); - const first: Array = rt.iterToArray(rt.iterBorrow(made_)); + const first: Array = rt.iterToArray(rt.iterBorrow(made_), undefined, 2); const after: rt.u8 | undefined | rt.None = rt.iterToOption(made_.next(), rt.None); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(first), (_218: rt.u8 | undefined): rt.u8 => { return code(_218); - })); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(first.length & 0xff, code(after), called))); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(first.length & 0xff, code(after), called)), undefined, true); let left: rt.usize = data.length; rt.byteVecPush(out, rt.iterCount(rt.iterFromFn((): undefined | rt.None => { const _219: rt.usize | undefined = rt.usizeCheckedSub(left, 1); @@ -424,15 +424,15 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { return pick(_84); } return rt.None; - }, undefined, rt.None))), (_222: rt.u8 | undefined): rt.u8 => { + }, undefined, rt.None), undefined, 2)), (_222: rt.u8 | undefined): rt.u8 => { return code(_222); - })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen))); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen)), undefined, true); let steps: rt.u8 = 0; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterSuccessors(undefined, (_223: undefined): undefined | rt.None => { steps = rt.u8Add(steps, 1); return thenSome$1j8foe9(steps < 3, undefined); - }, undefined, rt.None)) & 0xff, steps))); + }, undefined, rt.None)) & 0xff, steps)), undefined, true); if (data.length === 1) { if (240 <= data.data[data.start]) { if (data.data[data.start] <= 255) { @@ -471,12 +471,12 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { const items: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 | undefined => { const b: rt.u8 = _2; return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); - })); + }), undefined, 2, true); const at: rt.usize = mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (b2: rt.u8): rt.usize => { return rt.usizeRem(b2 as rt.usize, 8); }); const v: Array = items.slice(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.sliceFirst(v, rt.None)), code(rt.sliceLast(v, rt.None)), code(rt.sliceGet(v, at, rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.sliceFirst(v, rt.None)), code(rt.sliceLast(v, rt.None)), code(rt.sliceGet(v, at, rt.None)))), undefined, true); rt.byteVecPush(out, code(andThen$0ocv8av(rt.sliceGetRange(rt.sliceRange(v, 0), at), (s: Array): rt.u8 | undefined | rt.None => { return rt.sliceFirst(s, rt.None); }))); @@ -495,7 +495,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { return undefined; }); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.sliceFirst(v, rt.None)), code(rt.sliceLast(v, rt.None)), code(rt.sliceGet(v, at, rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.sliceFirst(v, rt.None)), code(rt.sliceLast(v, rt.None)), code(rt.sliceGet(v, at, rt.None)))), undefined, true); while (true) { const _64: rt.u8 | undefined | rt.None = rt.vecPop(v, rt.None); if (_64 !== rt.None) { @@ -506,8 +506,8 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, code(rt.vecPop(v, rt.None))); const units: undefined[] = rt.vecFromElem(undefined, data.length, undefined); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirst(units, rt.None) !== rt.None ? 1 : 0, rt.sliceLast(units, rt.None) !== rt.None ? 1 : 0, rt.sliceGet(units, at, rt.None) !== rt.None ? 1 : 0))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirstMut(units) !== undefined ? 1 : 0, rt.sliceLastMut(units) !== undefined ? 1 : 0, rt.sliceGetMut(units, at) !== undefined ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirst(units, rt.None) !== rt.None ? 1 : 0, rt.sliceLast(units, rt.None) !== rt.None ? 1 : 0, rt.sliceGet(units, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirstMut(units) !== undefined ? 1 : 0, rt.sliceLastMut(units) !== undefined ? 1 : 0, rt.sliceGetMut(units, at) !== undefined ? 1 : 0)), undefined, true); let popped: rt.u8 = 0; while (rt.vecPop(units, rt.None) !== rt.None) { popped = rt.u8Add(popped, 1); @@ -528,7 +528,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { rt.dequePushFront(q, o2); } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None)))), undefined, true); map$0ju5zoy(rt.dequeEndMut(q), (o11: rt.Place): void => { o11.v = mapOr$06rr3sb(o11.v, 66, (_211: rt.u8): rt.u8 | undefined => { return undefined; @@ -544,7 +544,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { return undefined; }); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None)))), undefined, true); rt.byteVecPush(out, code(rt.dequeRemove(q, at, rt.None))); while (true) { const _182: rt.u8 | undefined | rt.None = rt.dequePopFront(q, rt.None); @@ -558,12 +558,12 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequePopFront(q, rt.None)), code(rt.dequePopBack(q, rt.None)), code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeRemove(q, 0, rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequePopFront(q, rt.None)), code(rt.dequePopBack(q, rt.None)), code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeRemove(q, 0, rt.None)))), undefined, true); const _212: undefined[] = rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined); - const unitQ: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_212)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequeEnd(unitQ, false, rt.None) !== rt.None ? 1 : 0, rt.dequeEnd(unitQ, true, rt.None) !== rt.None ? 1 : 0, rt.dequeGet(unitQ, at, rt.None) !== rt.None ? 1 : 0))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequePopBack(unitQ, rt.None) !== rt.None ? 1 : 0, rt.dequeRemove(unitQ, at, rt.None) !== rt.None ? 1 : 0, rt.dequePopFront(unitQ, rt.None) !== rt.None ? 1 : 0))); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(items)), rt.cmpLe(rt.cmpOption(rt.cmp)), rt.cmpGe(rt.cmpOption(rt.cmp)), rt.cmpLt(rt.cmpOption(rt.cmp))); + const unitQ: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_212), undefined, 0, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequeEnd(unitQ, false, rt.None) !== rt.None ? 1 : 0, rt.dequeEnd(unitQ, true, rt.None) !== rt.None ? 1 : 0, rt.dequeGet(unitQ, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequePopBack(unitQ, rt.None) !== rt.None ? 1 : 0, rt.dequeRemove(unitQ, at, rt.None) !== rt.None ? 1 : 0, rt.dequePopFront(unitQ, rt.None) !== rt.None ? 1 : 0)), undefined, true); + const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(items), undefined, 2, true), rt.cmpLe(rt.cmpOption(rt.cmp)), rt.cmpGe(rt.cmpOption(rt.cmp)), rt.cmpLt(rt.cmpOption(rt.cmp))); rt.byteVecPush(out, code(rt.heapPeek(heap, rt.None))); while (true) { const _260: rt.u8 | undefined | rt.None = rt.heapPop(heap, rt.cmpLe(rt.cmpOption(rt.cmp)), rt.None); @@ -573,24 +573,24 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.heapPeek(heap, rt.None)), code(rt.heapPop(heap, rt.cmpLe(rt.cmpOption(rt.cmp)), rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.heapPeek(heap, rt.None)), code(rt.heapPop(heap, rt.cmpLe(rt.cmpOption(rt.cmp)), rt.None)))), undefined, true); const hashed: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, false, rt.None)), code(rt.hashKey(hashed, undefined, true, rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, false, rt.None)), code(rt.hashKey(hashed, undefined, true, rt.None)))), undefined, true); const _290: rt.Iter = rt.iterSlice(items); - rt.hashExtendKeys(hashed, _290); + rt.hashExtendKeys(hashed, _290, undefined, undefined, 469762048); const probe: rt.u8 | undefined | rt.None = map$0rbsrz6(rt.byteSliceLast(data), (_222: rt.u8): rt.u8 | undefined => { const b3: rt.u8 = _222; return thenSome$0d5am30(rt.u8Rem(b3, 2) === 0, b3); }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, false, rt.None)), code(andThen$0qni7te(probe, (p: rt.u8 | undefined): rt.u8 | undefined | rt.None => { return rt.hashKey(hashed, p, false, rt.None); - }))))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, true, rt.None)), code(rt.hashKey(hashed, undefined, true, rt.None)), code(rt.hashKey(hashed, 1, false, rt.None))))); + })))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, true, rt.None)), code(rt.hashKey(hashed, undefined, true, rt.None)), code(rt.hashKey(hashed, 1, false, rt.None)))), undefined, true); rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); const _328: rt.Iter = rt.iterSlice(items); - const sorted: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, _328, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreeFirstKey(sorted, false, rt.None)), code(rt.btreeFirstKey(sorted, true, rt.None))))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreePopKey(sorted, false, rt.None)), code(rt.btreePopKey(sorted, true, rt.None))))); + const sorted: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, _328, true, undefined, undefined, 2, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreeFirstKey(sorted, false, rt.None)), code(rt.btreeFirstKey(sorted, true, rt.None)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreePopKey(sorted, false, rt.None)), code(rt.btreePopKey(sorted, true, rt.None)))), undefined, true); while (true) { const _350: rt.u8 | undefined | rt.None = rt.btreePopKey(sorted, true, rt.None); if (_350 !== rt.None) { @@ -599,7 +599,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreeFirstKey(sorted, false, rt.None)), code(rt.btreeFirstKey(sorted, true, rt.None)), code(rt.btreePopKey(sorted, false, rt.None))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreeFirstKey(sorted, false, rt.None)), code(rt.btreeFirstKey(sorted, true, rt.None)), code(rt.btreePopKey(sorted, false, rt.None)))), undefined, true); const by: rt.BTreeMap = rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeMap; const hashBy: rt.HashMap = rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashMap; const iter2: rt.Iter<[rt.usize, rt.u8 | undefined]> = rt.iterEnumerate(rt.iterSlice(items)); @@ -629,7 +629,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { const k2: rt.u8 | undefined = _225[0]; const n3: rt.u8 = _225[1]; return Uint8Array.of(code(k2), n3); - }), rt.bytes(2).fill(204)))); + }), rt.bytes(2).fill(204))), undefined, true); const iter4: rt.Iter<[rt.u8 | undefined, rt.u8]> = rt.btreeIter(by); while (true) { const _426: [rt.u8 | undefined, rt.u8] | rt.Done = iter4.next(); @@ -638,7 +638,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } const k: rt.u8 | undefined = _426[0]; const n2: rt.u8 = _426[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(k), n2))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(k), n2)), undefined, true); } rt.byteVecPush(out, rt.hashLen(hashBy) & 0xff); } diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index 1bb1036ae..9df39affa 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -150,10 +150,10 @@ export function replaceCaptured(a: rt.u16[], to: rt.u16): rt.u16[] { export function repinAll(v: rt.Arc[], with_: rt.Arc, n: rt.u8): rt.usize { const old: rt.Arc[] = rt.replaceIn(v, rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(n, 3)), (_2: rt.u8): rt.Arc => { return rt.arcClone(with_); - }))); + }), undefined, 4, true)); const _12: rt.Arc[] = rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(n, 4)), (_22: rt.u8): rt.Arc => { return rt.arcClone(with_); - })); + }), undefined, 4, true); rt.dropAll(v); rt.vecAssign(v, _12); const _0: rt.usize = old.length; @@ -180,7 +180,7 @@ export function swapAll(a: rt.Arc[], b: rt.Arc[]): void { export function refill(v: rt.Arc[], bytes: rt.ByteVec, with_: rt.Arc, n: rt.u8): void { const _5: rt.Arc[] = rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(n, 4)), (_2: rt.u8): rt.Arc => { return rt.arcClone(with_); - })); + }), undefined, 4, true); rt.dropAll(v); rt.vecAssign(v, _5); Object.assign(bytes, rt.byteVecOf(n, rt.u8Rem(n, 3) as rt.usize)); @@ -188,8 +188,8 @@ export function refill(v: rt.Arc[], bytes: rt.ByteVec, with_: rt.Arc, map: rt.HashMap, n: rt.u8): rt.usize { const _6: rt.Range = new rt.Range(0, rt.u8Rem(n, 5)); - const old: rt.VecDeque = rt.replaceIn(q, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _6)); - Object.assign(map, rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[n, n] as [rt.u8, rt.u8]]))); + const old: rt.VecDeque = rt.replaceIn(q, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _6, undefined, 1, true)); + Object.assign(map, rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[n, n] as [rt.u8, rt.u8]]), undefined, undefined, undefined, 469762048)); return old.n; } @@ -215,7 +215,7 @@ export function counts(out: rt.ByteVec, arcs: rt.Arc[], items: rt.Arc): rt.u8 => { return a.value; - })); + }), undefined, true); } export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { @@ -225,7 +225,7 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { const two: rt.Arc = new rt.Arc(rt.u8WrappingAdd(by, 1)); const v: rt.Arc[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Arc => { return rt.arcClone(one); - })); + }), undefined, 4, true); const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _18: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -377,22 +377,22 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { rt.refRelease(_357); const sets: rt.HashMap> = rt.hashNew() as rt.HashMap>; const _363: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const _362: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _363, true); + const _362: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _363, true, undefined, undefined, 1, true); rt.hashInsert(sets, by, _362); const _365: rt.BTreeSet | undefined = rt.hashGet(sets, by); if (_365 !== undefined) { const _372: Uint8Array = Uint8Array.of(rt.u8WrappingAdd(by, 1)); - rt.byteVecPush(out, rt.btreeLen(rt.replaceIn(_365, rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_372), true))) & 0xff); + rt.byteVecPush(out, rt.btreeLen(rt.replaceIn(_365, rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_372), true, undefined, undefined, 1, true))) & 0xff); } const _379: Uint8Array = Uint8Array.of(by); - const _378: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_379), true); + const _378: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_379), true, undefined, undefined, 1, true); const _383: rt.u8 = rt.u8WrappingAdd(by, 1); Object.assign(rt.entryOrInsertWith(rt.entry(sets, _383), (): rt.BTreeSet => { return rt.btreeNew(rt.cmp) as rt.BTreeSet; }), _378); const keys: [rt.u8, rt.u8][] = rt.iterToArray(rt.iterMap(rt.hashIter(sets), (_22: [rt.u8, rt.BTreeSet]): [rt.u8, rt.u8] => { return [_22[0], rt.btreeLen(_22[1]) & 0xff] as [rt.u8, rt.u8]; - })); + }), undefined, 2); rt.sliceSort(keys, rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); for (const _394 of keys) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_394[0], _394[1]))); @@ -444,12 +444,12 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { counts(out, [one, two], w.held); counts(out, [one, two], other); const _515: Uint8Array = Uint8Array.of(by); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_515)); + const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_515), undefined, 1, true); const map: rt.HashMap = rt.hashNew() as rt.HashMap; for (const _519 of rt.byteSliceView(data)) { rt.byteVecPush(out, requeue(q, map, _519) & 0xff); } - rt.iterExtendBytes(out, rt.dequeIter(q)); + rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); rt.iterExtendBytes(out, rt.hashValues(map)); const weak: rt.Weak = new rt.Weak(); relink(weak, two); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index 5b947534d..47132ab83 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -15,7 +15,7 @@ export function LOG$init(): rt.RefCell { export function log(entry: Uint8Array): void { const _5: rt.ByteSlice = rt.byteSliceFrom(entry); rt.localKeyWithBorrowMut(LOG, (log_: rt.ByteVec): void => { - rt.iterExtendBytes(log_, rt.iterSlice(rt.byteSliceToArray(_5))); + rt.iterExtendBytes(log_, rt.iterSlice(rt.byteSliceToArray(_5)), undefined, true); }); } @@ -63,12 +63,12 @@ export function cmps(data: rt.ByteSlice, out: rt.ByteVec): void { const _13: [rt.u8, rt.u8] = [_14, data.data[data.start + i]]; const a: rt.u8 = _14; const b: rt.u8 = _13[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max$0g5g0ks(a, b), min$1mtc1eg(a, b), max$0i3ups8((a << 24) >> 24, (b << 24) >> 24) & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max$0g5g0ks(a, b), min$1mtc1eg(a, b), max$0i3ups8((a << 24) >> 24, (b << 24) >> 24) & 0xff)), undefined, true); const _37: rt.u8 = rt.u8Div(b, 2); const _32: [string, string] = [rt.fmtToString((f: rt.Formatter) => rt.u8Display(a, f)), rt.fmtToString((f: rt.Formatter) => rt.u8Display(_37, f))]; const s: string = _32[0]; const t: string = _32[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.stringLen(max$17dwnpn(s, t)) & 0xff, rt.stringLen(min$1ljcpv9(s, t)) & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.stringLen(max$17dwnpn(s, t)) & 0xff, rt.stringLen(min$1ljcpv9(s, t)) & 0xff)), undefined, true); const _55: [Item.Item, Item.Item] = [item(rt.usizeMul(2, i), a), item(rt.usizeAdd(rt.usizeMul(2, i), 1), b)]; const x: Item.Item = _55[0]; const y: Item.Item = _55[1]; @@ -135,7 +135,7 @@ export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { return item(_24[0], _24[1]); }); }; - const v: Item.Item[] = rt.iterToArray(items()); + const v: Item.Item[] = rt.iterToArray(items(), undefined, 2, true); rt.byteVecPush(out, rt.sliceIsSorted(v, Item.le$PartialOrd) ? 1 : 0); rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterSlice(v), (a: Item.Item, b3: Item.Item): boolean => { return a.key >= b3.key; @@ -161,7 +161,7 @@ export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { x3[Symbol.dispose](); return _09; }), rt.cmpLe(rt.cmpReverse(rt.cmp))) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterSlice(rt.iterToArray(items()), rt.drop), Item.le$PartialOrd, true, rt.drop) ? 1 : 0); + rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterSlice(rt.iterToArray(items(), undefined, 2, true), rt.drop), Item.le$PartialOrd, true, rt.drop) ? 1 : 0); flush(out); const _82: [Item.Item, Item.Item, Item.Item, Item.Item] = [_77(), _77(), _77(), _77()]; const g: Item.Item = _82[0]; @@ -178,7 +178,7 @@ export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { }, (): void => { captured[Symbol.dispose](); }), undefined, rt.drop, rt.drop) ? 1 : 0); - const _103: rt.Iter = rt.iterSlice(rt.iterToArray(items()), rt.drop); + const _103: rt.Iter = rt.iterSlice(rt.iterToArray(items(), undefined, 2, true), rt.drop); const captured2 = h; rt.byteVecPush(out, rt.iterIsSortedBy(_103, rt.closure((a4: Item.Item, b6: Item.Item): boolean => { return a4.key <= rt.u8Add(b6.key, captured2.key); @@ -203,13 +203,13 @@ export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { }, (): void => { captured4[Symbol.dispose](); }); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.iterToArray(items()), rt.drop), rt.lent(key)), rt.le, true) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.iterToArray(items()), rt.drop), rt.lent(key)), rt.le, true) ? 1 : 0); + rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.iterToArray(items(), undefined, 2, true), rt.drop), rt.lent(key)), rt.le, true) ? 1 : 0); + rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.iterToArray(items(), undefined, 2, true), rt.drop), rt.lent(key)), rt.le, true) ? 1 : 0); flush(out); const strings: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(_12)), (b7: rt.u8): string => { const _415: rt.u8 = rt.u8Rem(b7, 16); return rt.fmtToString((f: rt.Formatter) => rt.u8Display(_415, f)); - })); + }), undefined, 12, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceIsSorted(rt.byteSliceView(_12), rt.le) ? 1 : 0, rt.iterIsSortedBy(rt.iterSlice(rt.byteSliceView(_12)), (a5: rt.u8, b8: rt.u8): boolean => { return rt.u8Div(a5, 4) <= rt.u8Div(b8, 4); }) ? 1 : 0, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.byteSliceView(_12)), (_25: rt.u8): rt.u8 => { @@ -218,7 +218,7 @@ export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { return rt.stringLen(a06); }), rt.le) ? 1 : 0, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.byteSliceView(_12)), (_29: rt.u8): rt.f64 => { return (_29 as rt.f64) / 3.0; - }), rt.cmpLe(rt.f64PartialCmp)) ? 1 : 0))); + }), rt.cmpLe(rt.f64PartialCmp)) ? 1 : 0)), undefined, true); rt.drop(key); } } @@ -310,12 +310,12 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_17 === 9) { rt.heapExtend(heap, rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), rt.usizeRem(v as rt.usize, 6)), (_28: rt.u8): Item.Item => { return item(rt.usizeAdd(i, 50), _28); - }), Item.le$PartialOrd, Item.ge$PartialOrd, Item.lt$PartialOrd); + }), Item.le$PartialOrd, Item.ge$PartialOrd, Item.lt$PartialOrd, undefined, 2, true); } else if (_17 === 10) { const sorted_: Item.Item[] = rt.heapIntoSortedVec(rt.replaceIn(heap, rt.heapNew() as rt.BinaryHeap), Item.le$PartialOrd, Item.ge$PartialOrd, Item.lt$PartialOrd); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted_), (x3: Item.Item): rt.u8 => { return x3.tag; - })); + }), undefined, true); flush(out); const _81: rt.BinaryHeap = rt.heapFrom(sorted_, Item.le$PartialOrd, Item.ge$PartialOrd, Item.lt$PartialOrd); rt.heapDrop(heap, rt.drop); @@ -326,7 +326,7 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { })); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(mapOr$14aggam(heap.d[0], 255, (x2: Item.Item): rt.u8 => { return x2.tag; - }), heap.d.length & 0xff, heap.d.length === 0 ? 1 : 0))); + }), heap.d.length & 0xff, heap.d.length === 0 ? 1 : 0)), undefined, true); } } flush(out); @@ -344,7 +344,7 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { flush(out); const collected: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_29: [rt.usize, rt.u8]): Item.Item => { return item(_29[0], _29[1]); - })), Item.le$PartialOrd, Item.ge$PartialOrd, Item.lt$PartialOrd); + }), undefined, 2, true), Item.le$PartialOrd, Item.ge$PartialOrd, Item.lt$PartialOrd); rt.byteVecPush(out, mapOr$14aggam(rt.heapPop(collected, Item.le$PartialOrd), 255, (x7: Item.Item): rt.u8 => { const _09: rt.u8 = x7.tag; x7[Symbol.dispose](); @@ -371,18 +371,18 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes_: rt.BinaryHeap = rt.heapFrom(Array.from(rt.byteVecView(rt.byteSliceToByteVec(data))), rt.le, rt.ge, rt.lt); rt.heapPush(bytes_, data.length & 0xff, rt.le); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.from(bytes_.d))))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(rt.heapIntoSortedVec(rt.heapClone(bytes_), rt.le, rt.ge, rt.lt)))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.from(bytes_.d)))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(rt.heapIntoSortedVec(rt.heapClone(bytes_), rt.le, rt.ge, rt.lt))))), undefined, true); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(bytes_.d, f, rt.u8Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]]))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(bytes_.d))))); + rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFrom(Uint8Array.from(bytes_.d)))), undefined, true); const least: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { return _2; - })), rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); + }), undefined, 1, true), rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); const _37: rt.Iter = rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3), (_23: rt.u8): rt.u8 => { return rt.u8Div(_23, 2); }); - rt.heapExtend(least, _37, rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); + rt.heapExtend(least, _37, rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp)), undefined, 1, true); while (true) { const _40: rt.u8 | undefined = rt.heapPop(least, rt.cmpLe(rt.cmpReverse(rt.cmp))); if (_40 !== undefined) { @@ -392,13 +392,13 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { } } const _51: rt.usize = data.length; - const strings: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(["pear", "apple", rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_51, f))])), rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); + const strings: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(["pear", "apple", rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_51, f))]), undefined, 12, true), rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); const copy: rt.BinaryHeap = rt.heapClone(strings); const _56: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b4: rt.u8): string => { const _43: rt.u8 = rt.u8Rem(b4, 10); return rt.fmtToString((f: rt.Formatter) => rt.u8Display(_43, f)); }); - rt.heapExtend(copy, _56, rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); + rt.heapExtend(copy, _56, rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr), undefined, 12, true); rt.heapRetain(copy, (s: string): boolean => { if (!(rt.stringLen(s) > 1)) { return rt.cmpStr(s, "5") === -1; @@ -416,9 +416,9 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const b5: rt.u8 = _24; return [rt.u8Rem(b5, 4), rt.u8Div(b5, 64)] as [rt.u8, rt.u8]; }); - rt.heapExtend(pairs, _73, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); + rt.heapExtend(pairs, _73, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])), undefined, 2, true); const _78: [rt.u8, rt.u8][] = [[rt.u8Rem(data.length & 0xff, 4), 9] as [rt.u8, rt.u8]]; - rt.heapExtend(pairs, rt.iterMap(rt.iterSlice(_78), copy$u8_u8), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); + rt.heapExtend(pairs, rt.iterMap(rt.iterSlice(_78), copy$u8_u8), rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])), undefined, 2, true); const _84: rt.PeekMut<[rt.u8, rt.u8]> | undefined = rt.heapPeekMut(pairs, rt.cmpLe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp]))); if (_84 !== undefined) { const top: rt.PeekMut<[rt.u8, rt.u8]> = _84; @@ -436,7 +436,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.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple([rt.cmp, rt.cmp])))), (_25: [rt.u8, rt.u8]): Uint8Array => { return Uint8Array.of(_25[0], _25[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2)); + }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); } /** @@ -466,9 +466,9 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { const _45: rt.u8 = order !== undefined && order <= 0 ? 1 : 0; const _49: rt.u8 = rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) === 1 ? 1 : 0; const order2 = rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_41, _45, _49, order2 !== undefined && order2 >= 0 ? 1 : 0))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) & 0xff, rt.optionUnwrap(rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b))) & 0xff))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max$1s8mlx0(a, b)[0], rt.ordMin(a, b, rt.cmpLt(rt.cmpBytes))[1], rt.ordClamp(a, Uint8Array.of(1, 1), Uint8Array.of(2, 2), rt.cmpLe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), rt.cmpGt(rt.cmpBytes))[1]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_41, _45, _49, order2 !== undefined && order2 >= 0 ? 1 : 0)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) & 0xff, rt.optionUnwrap(rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b))) & 0xff)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max$1s8mlx0(a, b)[0], rt.ordMin(a, b, rt.cmpLt(rt.cmpBytes))[1], rt.ordClamp(a, Uint8Array.of(1, 1), Uint8Array.of(2, 2), rt.cmpLe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), rt.cmpGt(rt.cmpBytes))[1])), undefined, true); const pair: [Uint8Array, rt.u8] = [a, b[0]]; const _95: [Uint8Array, rt.u8] = [b, a[1]]; rt.byteVecPush(out, rt.cmpTuple([rt.cmpBytes, rt.cmp])(pair, _95) === -1 ? 1 : 0); @@ -494,14 +494,14 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { const _124: rt.u8 = rt.cmpBytes(s, _120) & 0xff; const _127: rt.u8 = rt.cmpBytes(s, _120) === -1 ? 1 : 0; const order3 = rt.cmpBytes(s, _120); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_124, _127, order3 !== undefined && order3 >= 0 ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_124, _127, order3 !== undefined && order3 >= 0 ? 1 : 0)), undefined, true); const _139: [rt.ByteVec, rt.ByteVec] = [rt.byteSliceToByteVec(s), rt.byteSliceToByteVec(_120)]; const v: rt.ByteVec = _139[0]; const u: rt.ByteVec = _139[1]; const _144: rt.u8 = rt.cmpBytes(v, u) & 0xff; const _149: rt.u8 = rt.cmpBytes(v, u) === 1 ? 1 : 0; const order4 = rt.cmpBytes(v, u); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_144, _149, order4 !== undefined && order4 <= 0 ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_144, _149, order4 !== undefined && order4 <= 0 ? 1 : 0)), undefined, true); } } const arrays: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceChunks(data, 2), (c: rt.ByteSlice): Uint8Array => { @@ -509,18 +509,18 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { return Uint8Array.of(rt.u8Rem(c.data[c.start], 4), mapOr$1surhce(rt.byteSliceGet(c, 1), 0, (b2: rt.u8): rt.u8 => { return rt.u8Rem(b2, 4); })); - })); + }), undefined, 2, true); rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.iterMax(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a4: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(a4); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(mapOr$0z7fb2w(rt.iterMin(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a5: rt.ByteSlice): Uint8Array => { return rt.byteSliceToArray(a5); - }))); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.byteSliceToArray)), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)); + })), undefined, true); + const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterCopied(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)); while (true) { const _179: Uint8Array | undefined = rt.heapPop(heap, rt.cmpLe(rt.cmpBytes)); if (_179 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(_179)); + rt.iterExtendBytes(out, rt.iterSlice(_179), undefined, true); } else { break; } @@ -528,27 +528,27 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { const _185: rt.Iter<[Uint8Array, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterCopied(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), rt.byteSliceToArray)), (_2: [rt.usize, Uint8Array]): [Uint8Array, rt.usize] => { return [_2[1], _2[0]] as [Uint8Array, rt.usize]; }); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpBytes) as rt.BTreeMap, _185, true)), (_22: [Uint8Array, rt.usize]): Uint8Array => { + 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)); + }, (value: Uint8Array) => rt.iterSlice(value), false, 3), undefined, true); rt.sliceSort(arrays, rt.cmpLt(rt.cmpBytes)); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2)); - const slices: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(data, 3)); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.iterSlice(arrays), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); + const slices: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(data, 3), undefined, 8, true); rt.sliceSortBy(slices, (a7: rt.ByteSlice, b3: rt.ByteSlice): rt.Ordering => { return rt.cmpBytes(b3, a7); }); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(slices), (s2: rt.ByteSlice): rt.u8 => { return s2.length & 0xff; - })); + }), undefined, true); const vecs: [rt.ByteVec, rt.usize][] = rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.byteSliceChunks(data, 3)), (_29: [rt.usize, rt.ByteSlice]): [rt.ByteVec, rt.usize] => { const i4: rt.usize = _29[0]; return [rt.byteSliceToByteVec(_29[1]), i4] as [rt.ByteVec, rt.usize]; - })); + }), undefined, 16, true); rt.sliceSort(vecs, rt.cmpLt(rt.cmpTuple([rt.cmpBytes, rt.cmp]))); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(vecs), (_211: [rt.ByteVec, rt.usize]): rt.u8 => { return _211[1] & 0xff; - })); + }), undefined, true); const refs: [rt.ByteSlice, rt.u8][] = []; const iter4: rt.Iter = rt.byteSliceWindows(data, 2); while (true) { @@ -565,7 +565,7 @@ export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(refs), (_212: [rt.ByteSlice, rt.u8]): rt.u8 => { const _86: rt.ByteSlice = _212[0]; return _86.data[_86.start] ^ _212[1]; - })); + }), undefined, true); } //# sourceMappingURL=orders.ts.map diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index b927a129e..fb48b702c 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -381,13 +381,13 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { const before: rt.u32 = num.v; const _32: rt.u32 = rt.u32WrappingAdd(num.v, (((n as rt.u32)) << 26) >>> 0); num.v = _32; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(before).reverse())); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(before).reverse()), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse()), undefined, true); } else if (_23 === 1) { const _46: rt.u32 = n as rt.u32; const _47: rt.Place = num; _47.v = (_47.v ^ _46) >>> 0; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse()), undefined, true); } else if (_23 === 2) { const before2: Duo.Duo = copy$Duo(pair.v); pair.v._0 = n; @@ -396,13 +396,13 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { rt.ptrWrite(p, { _0: p._1, _1: p._0 }); const _67: Duo.Duo = pair.v; _67._1 = _67._1 ^ 128; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before2._0, before2._1, between._0, between._1, pair.v._0, pair.v._1))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before2._0, before2._1, between._0, between._1, pair.v._0, pair.v._1)), undefined, true); } else if (_23 === 3) { const _83: rt.Place = text; _83.v = _83.v + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(n, 26)) as rt.char); const _91: rt.Place = text; _91.v = _91.v + "!"; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text.v)))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text.v))), undefined, true); } else if (_23 === 4) { const _99: rt.Arc = rt.arcClone(count); const fresh: Held.Held = new Held.Held(n, _99); @@ -425,7 +425,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Wrapped.with$Held_u8_cells_closure2(held, (p7: Held.Held): rt.u8 => { return p7.n; - }), count.strong & 0xff))); + }), count.strong & 0xff)), undefined, true); } else if (_23 === 5) { Wrapped.withMut$Held_unit_cells_closure3(held, (p3: Held.Held): void => { p3.n = rt.u8WrappingAdd(p3.n, n); @@ -436,9 +436,9 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { return p4.n; })); } else if (_23 === 6) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(renewNum(num, n as rt.u32)).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(renewNum(num, n as rt.u32)).reverse()), undefined, true); const _134: string = rt.fmtToString((f: rt.Formatter) => rt.u8Display(n, f)); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(renewText(text, _134))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(renewText(text, _134)))), undefined, true); const _136: Duo.Duo = { _0: n, _1: ~n & 0xff }; Object.assign(pair.v, _136); } else { @@ -454,10 +454,10 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, count.strong & 0xff); } } - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse()), undefined, true); const _165: Duo.Duo = pair.v; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_165._0, _165._1))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text.v)))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_165._0, _165._1)), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text.v))), undefined, true); held[Symbol.dispose](); rt.byteVecPush(out, count.strong & 0xff); count[Symbol.dispose](); @@ -484,19 +484,19 @@ export function rebound(data: rt.ByteSlice, out: rt.ByteVec): void { for (const n of rt.byteSliceView(data)) { const _10: rt.u8 = rt.u8Rem(n, 7); if (_10 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(replacedBefore(n))); + rt.iterExtendBytes(out, rt.iterSlice(replacedBefore(n)), undefined, true); } else if (_10 === 6) { - rt.iterExtendBytes(out, rt.iterSlice(retargeted(n))); + rt.iterExtendBytes(out, rt.iterSlice(retargeted(n)), undefined, true); } else if (_10 === 5) { - rt.iterExtendBytes(out, rt.iterSlice(lentAsValue(n))); + rt.iterExtendBytes(out, rt.iterSlice(lentAsValue(n)), undefined, true); } else if (_10 === 1) { - rt.iterExtendBytes(out, rt.iterSlice(partsReplaced(n))); + rt.iterExtendBytes(out, rt.iterSlice(partsReplaced(n)), undefined, true); } else if (_10 === 2) { - rt.iterExtendBytes(out, rt.iterSlice(writtenInPlace(n))); + rt.iterExtendBytes(out, rt.iterSlice(writtenInPlace(n)), undefined, true); } else if (_10 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(cellWrittenInPlace(n))); + rt.iterExtendBytes(out, rt.iterSlice(cellWrittenInPlace(n)), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterSlice(borrowedThrough(n))); + rt.iterExtendBytes(out, rt.iterSlice(borrowedThrough(n)), undefined, true); } } } @@ -630,7 +630,7 @@ export function writers(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _12 = byClosure(n); } - rt.iterExtendBytes(out, rt.iterSlice(_12)); + rt.iterExtendBytes(out, rt.iterSlice(_12), undefined, true); } } @@ -671,7 +671,7 @@ export function nudge(g: Gauge.Gauge, n: rt.u8): void { */ export function made(data: rt.ByteSlice, out: rt.ByteVec): void { for (const _5 of rt.byteSliceView(data)) { - rt.iterExtendBytes(out, rt.iterSlice(madeParts(_5))); + rt.iterExtendBytes(out, rt.iterSlice(madeParts(_5)), undefined, true); } } diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index aed6f6b84..da1ef0b9f 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -184,7 +184,7 @@ export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { const held: rt.u32[] = [1, 2, 3]; const v: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { return _2 as rt.u32; - })); + }), undefined, 4, true); const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); while (true) { const _18: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -314,7 +314,7 @@ export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { } } const _257: rt.Iter<[rt.u8, rt.u32]> = rt.hashIter(hash); - const iter6: rt.Iter<[rt.u8, rt.u32]> = rt.iterChain(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _257, true)), rt.btreeIter(tree)); + const iter6: rt.Iter<[rt.u8, rt.u32]> = rt.iterChain(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _257, true, undefined, undefined, undefined, 8)), rt.btreeIter(tree)); while (true) { const _264: [rt.u8, rt.u32] | rt.Done = iter6.next(); if (_264 === rt.DONE) { @@ -557,7 +557,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { let held: rt.ByteVec = rt.byteSliceToByteVec(data); let wide: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { return rt.u32Mul(_2 as rt.u32, 1000); - })); + }), undefined, 4, true); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(poll$taken_closure1(data, (b4: rt.u8): boolean => { const taken_ = held; held = new rt.ByteVec(); @@ -574,7 +574,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { return _25 > ((b4 as rt.u32)); }), (x3: rt.u32): rt.u32 => { return rt.u32Div(x3, 2); - })); + }), undefined, 4); })(); return held.length === 0; }) as rt.u32))); @@ -591,7 +591,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { const swapped: rt.ByteVec = new rt.ByteVec(); for (const _39 of rt.byteSliceView(data)) { const _45: rt.ByteVec = swap(_39); - rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_45))); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_45)), undefined, true); } const list_: (a0: rt.u8) => void = (b6: rt.u8): void => { const taken2 = pair[1].listed; @@ -604,7 +604,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { }); for (const _57 of rt.byteSliceView(data)) { const _63: rt.ByteVec = unwrapOrDefault$0wx44sw(restock(pair[1], _57)); - rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63))); + rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63)), undefined, true); } const taken3 = pair[1].stale; pair[1].stale = new rt.ByteVec(); @@ -628,12 +628,12 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { let _326!: rt.u8; const v: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { return _2 as rt.u32; - })); + }), undefined, 4, true); const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); const pairs: [rt.u8, rt.u8 | undefined][] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): [rt.u8, rt.u8 | undefined] => { const b8: rt.u8 = _22; return [b8, rt.u8CheckedSub(b8, 100)] as [rt.u8, rt.u8 | undefined]; - })); + }), undefined, 3, true); const by: rt.u8 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 1); const _13: rt.Place | undefined = rt.sliceFirstMut(v); if (_13 !== undefined) { @@ -704,7 +704,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } const iter5: rt.Iter> = rt.iterSlice(rt.iterToArray(rt.iterFilter(rt.iterSliceMut(v), (x8: rt.Place): boolean => { return rt.u32Rem(x8.v, 2) === 0; - }))); + }), undefined, 4)); while (true) { const _120: rt.Place | rt.Done = iter5.next(); if (_120 === rt.DONE) { @@ -966,7 +966,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { _480.v = rt.u32Mul(_480.v, 3); } const _486: rt.Iter<[rt.u8, rt.u32]> = rt.hashIter(scalars); - const iter29: rt.Iter<[rt.u8, rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _486, true)); + const iter29: rt.Iter<[rt.u8, rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _486, true, undefined, undefined, undefined, 8)); while (true) { const _490: [rt.u8, rt.u32] | rt.Done = iter29.next(); if (_490 === rt.DONE) { @@ -1007,7 +1007,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { return k6[1] === 0; }); const _541: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.hashIter(paired); - const iter33: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u32>, _541, true)); + const iter33: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u32>, _541, true, undefined, undefined, undefined, 8)); while (true) { const _545: [[rt.u8, rt.u8], rt.u32] | rt.Done = iter33.next(); if (_545 === rt.DONE) { @@ -1020,7 +1020,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x3))); } const _560: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.hashIter(hash); - const iter34: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true)); + const iter34: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 3)); while (true) { const _564: [rt.u8, [rt.u8, rt.u8]] | rt.Done = iter34.next(); if (_564 === rt.DONE) { @@ -1261,7 +1261,7 @@ export function toRefs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, bytes.length & 0xff); let tail2: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))), (_2: rt.u8): rt.u32 => { return (((_2 as rt.u32)) << 8) >>> 0; - })); + }), undefined, 4, true); while (tail2.length >= 1) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tail2[0]))); tail2 = tail2.slice(1, tail2.length - 0); @@ -1298,7 +1298,7 @@ export function toRefs(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, left.length & 0xff); const pairs: Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))), (_22: rt.u8): Pair.Pair => { return { n: _22 }; - })); + }), undefined, 1, true); const first: Pair.Pair = { n: 0 }; let largest: Pair.Pair = first; for (const _147 of pairs) { diff --git a/ts/fixtures/lang/expected/shapes.ts b/ts/fixtures/lang/expected/shapes.ts index 7709d90f6..1bb32becb 100644 --- a/ts/fixtures/lang/expected/shapes.ts +++ b/ts/fixtures/lang/expected/shapes.ts @@ -380,7 +380,7 @@ export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { const lenses: Lens.Lens[] = []; lenses.push(copy$Lens(lens)); const _114: rt.Iter = rt.iterSlice([lens]); - rt.iterExtend(lenses, rt.iterMap(_114, copy$Lens)); + rt.iterExtend(lenses, rt.iterMap(_114, copy$Lens), undefined, 8, true); const iter4: rt.Iter = rt.iterCopied(rt.iterSlice(lenses), copy$Lens); while (true) { const _124: Lens.Lens | rt.Done = iter4.next(); diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index 2891c8bc3..f7a9c1669 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -43,34 +43,34 @@ export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const size: rt.usize = rt.u8Rem(rt.u8Div(kind, 2), 6) as rt.usize; const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); - })); + }), undefined, 2, true); if (rt.u8Rem(kind, 2) === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceWindows(data, size), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceWindows(data, size)), digest)); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceWindows(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceWindows(data, size)), digest), undefined, true); const it: rt.Iter = rt.byteSliceWindows(data, size); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.next()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.nextBack()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it, 1), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it, 1), digest))); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, digest)); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceWindows(data, size)), digest))); + rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceWindows(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceWindows(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceWindows(data, size), 2), 2), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceWindows(words, size), digestWords)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceWindows(words, size)), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceWindows(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.sliceWindows(words, size), digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceWindows(words, size)), digestWords), undefined, true); const it2: rt.Iter = rt.sliceWindows(words, size); rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.next()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.nextBack()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it2, 1), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it2, 1), digestWords))); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.next()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.nextBack()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it2, 1), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it2, 1), digestWords)), undefined, true); rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it2, digestWords)); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceWindows(words, size)), digestWords))); + rt.iterExtendBytes(out, rt.iterMap(it2, digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceWindows(words, size)), digestWords)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.sliceWindows(words, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceWindows(words, size), 2), 2), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceWindows(words, size), 2), 2), digestWords), undefined, true); const steps: rt.Iter = rt.byteSliceWindows(data, size); const _123: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(steps.next()), rt.iterToOption(steps.next())]; if (_123[0] !== undefined) { @@ -82,44 +82,44 @@ export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _138: rt.u8 = a.data[a.start]; const _143: rt.usize = rt.usizeSub(size, 1); rt.idx(b, _143); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_134, _138, b.data[b.start + _143]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_134, _138, b.data[b.start + _143])), undefined, true); } } } else { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunks(data, size), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunks(data, size)), digest)); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunks(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunks(data, size)), digest), undefined, true); const it3: rt.Iter = rt.byteSliceChunks(data, size); rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it3.next()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it3.nextBack()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it3, 1), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it3, 1), digest))); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it3.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it3.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it3, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it3, 1), digest)), undefined, true); rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it3, digest)); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceChunks(data, size)), digest))); + rt.iterExtendBytes(out, rt.iterMap(it3, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceChunks(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunks(data, size), 2), 2), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunks(words, size), digestWords)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunks(words, size)), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunks(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunks(words, size), digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunks(words, size)), digestWords), undefined, true); const it4: rt.Iter = rt.sliceChunks(words, size); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it4.next()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it4.nextBack()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it4, 1), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it4, 1), digestWords))); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it4.next()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it4.nextBack()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it4, 1), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it4, 1), digestWords)), undefined, true); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it4, digestWords)); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceChunks(words, size)), digestWords))); + rt.iterExtendBytes(out, rt.iterMap(it4, digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceChunks(words, size)), digestWords)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.sliceChunks(words, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunks(words, size), 2), 2), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunks(words, size), 2), 2), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$0c2keyb(rt.iterToOption(rt.byteSliceChunks(data, size).nextBack()), (c: rt.ByteSlice): rt.u8 => { return c.length & 0xff; - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterMap(rt.sliceChunks(words, size), (c2: rt.u16[]): rt.u16 => { return rt.iterSum(rt.iterSlice(c2), rt.u16Add, 0) >> 2; - }))), (_22: rt.u16): rt.u8 => { + }), undefined, 2, true)), (_22: rt.u16): rt.u8 => { return _22 & 0xff; - })); + }), undefined, true); } } @@ -208,40 +208,40 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); - })); + }), undefined, 2, true); const pairs: Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): Pair.Pair => { const b2: rt.u8 = _25; return { a: b2, b: rt.u16Mul(b2 as rt.u16, 3) }; - })); + }), undefined, 4, true); b0: { const _16: rt.u8 = rt.u8Rem(kind, 8); if (_16 === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunksExact(data, size), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunksExact(data, size)), digest)); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunksExact(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunksExact(data, size)), digest), undefined, true); const it: rt.Iter = rt.byteSliceChunksExact(data, size); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.next()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.nextBack()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it, 1), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it, 1), digest))); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, digest)); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceChunksExact(data, size)), digest))); + rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceChunksExact(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunksExact(data, size), 2), 2), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunksExact(words, size), digestWords)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunksExact(words, size)), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunksExact(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunksExact(words, size), digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunksExact(words, size)), digestWords), undefined, true); const it2: rt.Iter = rt.sliceChunksExact(words, size); rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.next()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.nextBack()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it2, 1), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it2, 1), digestWords))); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.next()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it2.nextBack()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it2, 1), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it2, 1), digestWords)), undefined, true); rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it2, digestWords)); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceChunksExact(words, size)), digestWords))); + rt.iterExtendBytes(out, rt.iterMap(it2, digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceChunksExact(words, size)), digestWords)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.sliceChunksExact(words, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunksExact(words, size), 2), 2), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunksExact(words, size), 2), 2), digestWords), undefined, true); const it3: rt.Iter = rt.byteSliceChunksExact(data, size); rt.byteVecPush(out, digest(rt.partsRemainder(it3))); it3.next(); @@ -249,62 +249,62 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, digest(rt.partsRemainder(it3))); rt.byteVecPush(out, digestWords(rt.partsRemainder(rt.sliceChunksExact(words, size)))); } else if (_16 === 1) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunks(data, size), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunks(data, size)), digest)); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunks(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunks(data, size)), digest), undefined, true); const it4: rt.Iter = rt.byteSliceRchunks(data, size); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it4.next()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it4.nextBack()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it4, 1), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it4, 1), digest))); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it4.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it4.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it4, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it4, 1), digest)), undefined, true); rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it4, digest)); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceRchunks(data, size)), digest))); + rt.iterExtendBytes(out, rt.iterMap(it4, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceRchunks(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunks(data, size), 2), 2), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunks(words, size), digestWords)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunks(words, size)), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunks(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunks(words, size), digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunks(words, size)), digestWords), undefined, true); const it5: rt.Iter = rt.sliceRchunks(words, size); rt.byteVecPush(out, it5.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it5.next()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it5.nextBack()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it5, 1), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it5, 1), digestWords))); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it5.next()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it5.nextBack()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it5, 1), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it5, 1), digestWords)), undefined, true); rt.byteVecPush(out, it5.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it5, digestWords)); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceRchunks(words, size)), digestWords))); + rt.iterExtendBytes(out, rt.iterMap(it5, digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceRchunks(words, size)), digestWords)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.sliceRchunks(words, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunks(words, size), 2), 2), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunks(words, size), 2), 2), digestWords), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$0c2keyb(rt.iterToOption(rt.byteSliceRchunks(data, size).nextBack()), (c13: rt.ByteSlice): rt.u8 => { return c13.length & 0xff; - }))); + })), undefined, true); } else if (_16 === 2) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunksExact(data, size), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunksExact(data, size)), digest)); + rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunksExact(data, size), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunksExact(data, size)), digest), undefined, true); const it6: rt.Iter = rt.byteSliceRchunksExact(data, size); rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it6.next()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it6.nextBack()), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it6, 1), digest))); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it6, 1), digest))); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it6.next()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterToOption(it6.nextBack()), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNth(it6, 1), digest)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterNthBack(it6, 1), digest)), undefined, true); rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it6, digest)); - rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceRchunksExact(data, size)), digest))); + rt.iterExtendBytes(out, rt.iterMap(it6, digest), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$1xk4yz1(rt.iterLast(rt.byteSliceRchunksExact(data, size)), digest)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunksExact(data, size), 2), 2), digest)); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunksExact(words, size), digestWords)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunksExact(words, size)), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunksExact(data, size), 2), 2), digest), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunksExact(words, size), digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunksExact(words, size)), digestWords), undefined, true); const it7: rt.Iter = rt.sliceRchunksExact(words, size); rt.byteVecPush(out, it7.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it7.next()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it7.nextBack()), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it7, 1), digestWords))); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it7, 1), digestWords))); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it7.next()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterToOption(it7.nextBack()), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNth(it7, 1), digestWords)), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterNthBack(it7, 1), digestWords)), undefined, true); rt.byteVecPush(out, it7.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it7, digestWords)); - rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceRchunksExact(words, size)), digestWords))); + rt.iterExtendBytes(out, rt.iterMap(it7, digestWords), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(map$0qyyft9(rt.iterLast(rt.sliceRchunksExact(words, size)), digestWords)), undefined, true); rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksExact(words, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunksExact(words, size), 2), 2), digestWords)); + rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunksExact(words, size), 2), 2), digestWords), undefined, true); const it8: rt.Iter = rt.byteSliceRchunksExact(data, size); rt.byteVecPush(out, digest(rt.partsRemainder(it8))); rt.iterNth(it8, 1); @@ -320,7 +320,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(_391[0], _391[1]); } rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(rt.byteVecSlice(bytes), size)); + const held: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunks(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter2: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held))); while (true) { const _412: [rt.usize, rt.Place] | rt.Done = iter2.next(); @@ -331,7 +331,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held), (c10: rt.ByteSlice): rt.u8 => { return digest(c10); - })); + }), undefined, true); const it9: rt.Iter = rt.byteSliceChunks(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it9.len() & 0xff); const _432: rt.ByteSlice | undefined = rt.iterToOption(it9.nextBack()); @@ -362,7 +362,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribbleWords(_472[0], _472[1]); } rt.byteVecPush(out, digestWords(words)); - const held2: rt.u16[][] = rt.iterToArray(rt.sliceChunksMut(words, size)); + const held2: rt.u16[][] = rt.iterToArray(rt.sliceChunksMut(words, size), undefined, 8, true); const iter4: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held2))); while (true) { const _493: [rt.usize, rt.Place] | rt.Done = iter4.next(); @@ -373,7 +373,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held2), (c11: rt.u16[]): rt.u8 => { return digestWords(c11); - })); + }), undefined, true); const it10: rt.Iter = rt.sliceChunksMut(words, size); rt.byteVecPush(out, it10.len() & 0xff); const _513: rt.u16[] | undefined = rt.iterToOption(it10.nextBack()); @@ -404,7 +404,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribblePairs(_553[0], _553[1]); } rt.byteVecPush(out, digestPairs(pairs)); - const held3: Pair.Pair[][] = rt.iterToArray(rt.sliceChunksMut(pairs, size)); + const held3: Pair.Pair[][] = rt.iterToArray(rt.sliceChunksMut(pairs, size), undefined, 8, true); const iter6: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held3))); while (true) { const _574: [rt.usize, rt.Place] | rt.Done = iter6.next(); @@ -415,7 +415,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held3), (c12: Pair.Pair[]): rt.u8 => { return digestPairs(c12); - })); + }), undefined, true); const it11: rt.Iter = rt.sliceChunksMut(pairs, size); rt.byteVecPush(out, it11.len() & 0xff); const _594: Pair.Pair[] | undefined = rt.iterToOption(it11.nextBack()); @@ -447,7 +447,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(_634[0], _634[1]); } rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held4: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size)); + const held4: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter8: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held4))); while (true) { const _655: [rt.usize, rt.Place] | rt.Done = iter8.next(); @@ -458,7 +458,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held4), (c7: rt.ByteSlice): rt.u8 => { return digest(c7); - })); + }), undefined, true); const it12: rt.Iter = rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it12.len() & 0xff); const _675: rt.ByteSlice | undefined = rt.iterToOption(it12.nextBack()); @@ -489,7 +489,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribbleWords(_715[0], _715[1]); } rt.byteVecPush(out, digestWords(words)); - const held5: rt.u16[][] = rt.iterToArray(rt.sliceChunksExactMut(words, size)); + const held5: rt.u16[][] = rt.iterToArray(rt.sliceChunksExactMut(words, size), undefined, 8, true); const iter10: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held5))); while (true) { const _736: [rt.usize, rt.Place] | rt.Done = iter10.next(); @@ -500,7 +500,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held5), (c8: rt.u16[]): rt.u8 => { return digestWords(c8); - })); + }), undefined, true); const it13: rt.Iter = rt.sliceChunksExactMut(words, size); rt.byteVecPush(out, it13.len() & 0xff); const _756: rt.u16[] | undefined = rt.iterToOption(it13.nextBack()); @@ -531,7 +531,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribblePairs(_796[0], _796[1]); } rt.byteVecPush(out, digestPairs(pairs)); - const held6: Pair.Pair[][] = rt.iterToArray(rt.sliceChunksExactMut(pairs, size)); + const held6: Pair.Pair[][] = rt.iterToArray(rt.sliceChunksExactMut(pairs, size), undefined, 8, true); const iter12: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held6))); while (true) { const _817: [rt.usize, rt.Place] | rt.Done = iter12.next(); @@ -542,7 +542,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held6), (c9: Pair.Pair[]): rt.u8 => { return digestPairs(c9); - })); + }), undefined, true); const it14: rt.Iter = rt.sliceChunksExactMut(pairs, size); rt.byteVecPush(out, it14.len() & 0xff); const _837: Pair.Pair[] | undefined = rt.iterToOption(it14.nextBack()); @@ -591,7 +591,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(_908[0], _908[1]); } rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held7: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size)); + const held7: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter15: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held7))); while (true) { const _929: [rt.usize, rt.Place] | rt.Done = iter15.next(); @@ -602,7 +602,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held7), (c4: rt.ByteSlice): rt.u8 => { return digest(c4); - })); + }), undefined, true); const it17: rt.Iter = rt.byteSliceRchunks(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it17.len() & 0xff); const _949: rt.ByteSlice | undefined = rt.iterToOption(it17.nextBack()); @@ -633,7 +633,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribbleWords(_989[0], _989[1]); } rt.byteVecPush(out, digestWords(words)); - const held8: rt.u16[][] = rt.iterToArray(rt.sliceRchunksMut(words, size)); + const held8: rt.u16[][] = rt.iterToArray(rt.sliceRchunksMut(words, size), undefined, 8, true); const iter17: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held8))); while (true) { const _1010: [rt.usize, rt.Place] | rt.Done = iter17.next(); @@ -644,7 +644,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held8), (c5: rt.u16[]): rt.u8 => { return digestWords(c5); - })); + }), undefined, true); const it18: rt.Iter = rt.sliceRchunksMut(words, size); rt.byteVecPush(out, it18.len() & 0xff); const _1030: rt.u16[] | undefined = rt.iterToOption(it18.nextBack()); @@ -675,7 +675,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribblePairs(_1070[0], _1070[1]); } rt.byteVecPush(out, digestPairs(pairs)); - const held9: Pair.Pair[][] = rt.iterToArray(rt.sliceRchunksMut(pairs, size)); + const held9: Pair.Pair[][] = rt.iterToArray(rt.sliceRchunksMut(pairs, size), undefined, 8, true); const iter19: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held9))); while (true) { const _1091: [rt.usize, rt.Place] | rt.Done = iter19.next(); @@ -686,7 +686,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held9), (c6: Pair.Pair[]): rt.u8 => { return digestPairs(c6); - })); + }), undefined, true); const it19: rt.Iter = rt.sliceRchunksMut(pairs, size); rt.byteVecPush(out, it19.len() & 0xff); const _1111: Pair.Pair[] | undefined = rt.iterToOption(it19.nextBack()); @@ -718,7 +718,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribble(_1151[0], _1151[1]); } rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held10: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size)); + const held10: rt.ByteSlice[] = rt.iterToArray(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); const iter21: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held10))); while (true) { const _1172: [rt.usize, rt.Place] | rt.Done = iter21.next(); @@ -729,7 +729,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held10), (c: rt.ByteSlice): rt.u8 => { return digest(c); - })); + }), undefined, true); const it20: rt.Iter = rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size); rt.byteVecPush(out, it20.len() & 0xff); const _1192: rt.ByteSlice | undefined = rt.iterToOption(it20.nextBack()); @@ -760,7 +760,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribbleWords(_1232[0], _1232[1]); } rt.byteVecPush(out, digestWords(words)); - const held11: rt.u16[][] = rt.iterToArray(rt.sliceRchunksExactMut(words, size)); + const held11: rt.u16[][] = rt.iterToArray(rt.sliceRchunksExactMut(words, size), undefined, 8, true); const iter23: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held11))); while (true) { const _1253: [rt.usize, rt.Place] | rt.Done = iter23.next(); @@ -771,7 +771,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held11), (c2: rt.u16[]): rt.u8 => { return digestWords(c2); - })); + }), undefined, true); const it21: rt.Iter = rt.sliceRchunksExactMut(words, size); rt.byteVecPush(out, it21.len() & 0xff); const _1273: rt.u16[] | undefined = rt.iterToOption(it21.nextBack()); @@ -802,7 +802,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void scribblePairs(_1313[0], _1313[1]); } rt.byteVecPush(out, digestPairs(pairs)); - const held12: Pair.Pair[][] = rt.iterToArray(rt.sliceRchunksExactMut(pairs, size)); + const held12: Pair.Pair[][] = rt.iterToArray(rt.sliceRchunksExactMut(pairs, size), undefined, 8, true); const iter25: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held12))); while (true) { const _1334: [rt.usize, rt.Place] | rt.Done = iter25.next(); @@ -813,7 +813,7 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held12), (c3: Pair.Pair[]): rt.u8 => { return digestPairs(c3); - })); + }), undefined, true); const it22: rt.Iter = rt.sliceRchunksExactMut(pairs, size); rt.byteVecPush(out, it22.len() & 0xff); const _1354: Pair.Pair[] | undefined = rt.iterToOption(it22.nextBack()); @@ -863,11 +863,11 @@ export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } } } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_26: rt.u16): rt.u8 => { const w: rt.u16 = _26; return (w ^ (w >> 8)) & 0xff; - })); + }), undefined, true); rt.byteVecPush(out, digestPairs(pairs)); } @@ -957,11 +957,11 @@ export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); - })); + }), undefined, 2, true); const pairs: Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): Pair.Pair => { const b4: rt.u8 = _23; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; - })); + }), undefined, 4, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); @@ -1127,16 +1127,16 @@ export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.byteVecPush(out, _322[0].length & 0xff); } } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_24: rt.u16): rt.u8 => { const w: rt.u16 = _24; return (w ^ (w >> 8)) & 0xff; - })); + }), undefined, true); rt.byteVecPush(out, digestPairs(pairs)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(array), (_27: rt.u32): rt.u8 => { const x: rt.u32 = _27; return ((x ^ (x >>> 13)) >>> 0) & 0xff; - })); + }), undefined, true); } } @@ -1153,11 +1153,11 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const b: rt.usize = _14[1]; const items: Item.Item[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): Item.Item => { return new Item.Item(_2); - })); + }), undefined, 1, true); const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); const words: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): rt.u32 => { return rt.u32Add(_23 as rt.u32, 1000); - })); + }), undefined, 4, true); const _31: rt.u8 = rt.u8Rem(kind, 8); if (_31 === 0) { const iter: rt.Iter = rt.vecDrain(items, new rt.Range(a, b), rt.drop); @@ -1172,10 +1172,10 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { x[Symbol.dispose](); } rt.drop(iter); - rt.iterExtendBytes(out, rt.byteVecDrain(bytes, new rt.Range(a, b)), "fold"); + rt.iterExtendBytes(out, rt.byteVecDrain(bytes, new rt.Range(a, b)), "fold", true); rt.iterExtendBytes(out, rt.iterMap(rt.vecDrain(words, new rt.Range(a, b)), (w3: rt.u32): rt.u8 => { return w3 & 0xff; - }), "fold"); + }), "fold", true); } else if (_31 === 1) { const _56: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); const drain: rt.Iter = rt.vecDrain(items, _56, rt.drop); @@ -1183,32 +1183,32 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _011: rt.u8 = x9.tag; x9[Symbol.dispose](); return _011; - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$003seos(rt.iterToOption(drain.nextBack()), (x10: Item.Item): rt.u8 => { const _012: rt.u8 = x10.tag; x10[Symbol.dispose](); return _012; - }))); + })), undefined, true); rt.byteVecPush(out, drain.len() & 0xff); rt.drop(drain); flush(out); const _74: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); const drain2: rt.Iter = rt.byteVecDrain(bytes, _74); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(drain2.nextBack()))); + rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(drain2.nextBack())), undefined, true); rt.drop(drain2); const _82: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); const drain3: rt.Iter = rt.vecDrain(words, _82); rt.iterExtendBytes(out, rt.iterOption(map$0a57co2(rt.iterToOption(drain3.next()), (w2: rt.u32): rt.u8 => { return w2 & 0xff; - }))); + })), undefined, true); rt.drop(drain3); } else if (_31 === 2) { - const taken: Item.Item[] = rt.iterToArray(rt.vecDrain(items, { end: b }, rt.drop), "fold"); + const taken: Item.Item[] = rt.iterToArray(rt.vecDrain(items, { end: b }, rt.drop), "fold", 1, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(taken), (x8: Item.Item): rt.u8 => { return x8.tag; - })); + }), undefined, true); rt.dropAll(taken); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold")))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true))), undefined, true); rt.drop(rt.vecDrain(words, { end: b })); } else if (_31 === 3) { const drain4: rt.Iter = rt.vecDrain(items, { start: a }, rt.drop); @@ -1216,37 +1216,37 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _07: rt.u8 = x6.tag; x6[Symbol.dispose](); return _07; - }))); + })), undefined, true); flush(out); rt.iterExtendBytes(out, rt.iterOption(map$003seos(rt.iterNthBack(drain4, 1, rt.drop), (x7: Item.Item): rt.u8 => { const _08: rt.u8 = x7.tag; x7[Symbol.dispose](); return _08; - }))); + })), undefined, true); flush(out); rt.byteVecPush(out, drain4.len() & 0xff); rt.drop(drain4); const _127: rt.Iter = rt.byteVecDrain(bytes, { start: a }); - rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(_127, 2))); + rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(_127, 2)), undefined, true); rt.drop(_127); rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.vecDrain(words, { start: a })), (w: rt.u32): rt.u8 => { return w & 0xff; - }), "fold"); + }), "fold", true); } else if (_31 === 4) { rt.iterExtendBytes(out, rt.iterOption(map$003seos(rt.ownedLast(rt.vecDrain(items, undefined, rt.drop), rt.drop), (x5: Item.Item): rt.u8 => { const _06: rt.u8 = x5.tag; x5[Symbol.dispose](); return _06; - }))); - rt.iterExtendBytes(out, rt.iterOption(rt.ownedLast(rt.byteVecDrain(bytes, undefined)))); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(rt.ownedLast(rt.byteVecDrain(bytes, undefined))), undefined, true); rt.byteVecPush(out, rt.ownedCount(rt.vecDrain(words, undefined)) & 0xff); } else if (_31 === 5) { rt.iterExtendBytes(out, rt.iterOption(map$003seos(rt.iterToOption(rt.vecDrain(items, new rt.Range(a, b), rt.drop).next()), (x4: Item.Item): rt.u8 => { const _05: rt.u8 = x4.tag; x4[Symbol.dispose](); return _05; - }))); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(rt.byteVecDrain(bytes, new rt.Range(a, b)).next()))); + })), undefined, true); + rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(rt.byteVecDrain(bytes, new rt.Range(a, b)).next())), undefined, true); rt.vecDrain(words, new rt.Range(a, b)); } else if (_31 === 6) { rt.byteVecPush(out, rt.ownedCount(rt.vecDrain(items, new rt.Range(a, b), rt.drop), rt.drop) & 0xff); @@ -1255,26 +1255,26 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _181: rt.Iter = rt.iterFilter(rt.vecDrain(items, new rt.Range(a, b), rt.drop), (x2: Item.Item): boolean => { return rt.u8Rem(x2.tag, 2) === 0; }, rt.drop); - rt.iterExtend(kept, _181, "next"); + rt.iterExtend(kept, _181, "next", 1); flush(out); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(kept), (x3: Item.Item): rt.u8 => { return x3.tag; - })); + }), undefined, true); const other: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(238)); const _195: rt.Iter = rt.iterRev(rt.byteVecDrain(bytes, new rt.Range(a, b))); - rt.iterExtendBytes(other, _195, "fold"); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(other))); + rt.iterExtendBytes(other, _195, "fold", true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(other)), undefined, true); rt.dropAll(kept); } flush(out); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(items), (x11: Item.Item): rt.u8 => { return x11.tag; - })); + }), undefined, true); rt.byteVecPush(out, items.length & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_26: rt.u32): rt.u8 => { return _26 & 0xff; - })); + }), undefined, true); items.push(new Item.Item(255)); rt.dropAll(items); flush(out); @@ -1337,11 +1337,11 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); - })); + }), undefined, 2, true); const pairs: Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_22: rt.u8): Pair.Pair => { const b4: rt.u8 = _22; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; - })); + }), undefined, 4, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); @@ -1545,7 +1545,7 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const folded: rt.RangeInclusive = new rt.RangeInclusive(a, rt.min(b, reach), rt.usizeStep); rt.iterSum(rt.iterBorrow(folded), rt.usizeAdd, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.rangeInclusiveIsEmpty(stepped) ? 1 : 0, rt.rangeInclusiveIsEmpty(folded) ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.rangeInclusiveIsEmpty(stepped) ? 1 : 0, rt.rangeInclusiveIsEmpty(folded) ? 1 : 0)), undefined, true); const _289: rt.u16[] = words; const bounds6 = rt.sliceGetBounds(rt.rangeInclusiveClone(stepped), _289.length); const _288: rt.u16[] | undefined = rt.sliceGetRange(_289, bounds6[0], bounds6[1]); @@ -1623,44 +1623,44 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_47 === 6) { rt.iterExtendBytes(out, rt.iterOption(map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 0), (c2: rt.ByteSlice): rt.u8 => { return digest(c2); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 3), (c3: rt.ByteSlice): rt.u8 => { return digest(c3); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 1), (c4: rt.ByteSlice): rt.u8 => { return digest(c4); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 4), (c5: rt.ByteSlice): rt.u8 => { return digest(c5); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$1wqzuhy(rt.sliceGetRange(words, 0, 4), (c6: rt.u16[]): rt.u8 => { return digestWords(c6); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$1wqzuhy(rt.sliceLastChunk(words, 0), (c7: rt.u16[]): rt.u8 => { return digestWords(c7); - }))); + })), undefined, true); rt.iterExtendBytes(out, rt.iterOption(map$11y9s7r(rt.sliceLastChunk(pairs, 3), (c8: Pair.Pair[]): rt.u8 => { return digestPairs(c8); - }))); + })), undefined, true); const slice: rt.ByteSlice = rt.byteVecSlice(bytes); if (slice.length >= 1) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(new rt.ByteSlice(slice.data, slice.start, 1)), digest(new rt.ByteSlice(slice.data, slice.start + 1, slice.length - 1))))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(new rt.ByteSlice(slice.data, slice.start, 1)), digest(new rt.ByteSlice(slice.data, slice.start + 1, slice.length - 1)))), undefined, true); } const _417: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitLastChunk(rt.byteVecSlice(bytes), 4); if (_417 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_417[0]), digest(_417[1])))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_417[0]), digest(_417[1]))), undefined, true); } const _428: [rt.u16[], rt.u16[]] | undefined = rt.sliceSplitAtChecked(words, 0); if (_428 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digestWords(_428[0]), digestWords(_428[1])))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digestWords(_428[0]), digestWords(_428[1]))), undefined, true); } const _439: [Pair.Pair[], Pair.Pair[]] | undefined = rt.sliceSplitLastChunk(pairs, 3); if (_439 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digestPairs(_439[0]), digestPairs(_439[1])))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digestPairs(_439[0]), digestPairs(_439[1]))), undefined, true); } const _450: [rt.u32[], rt.u32[]] | undefined = rt.sliceSplitLastChunk(array, 5); if (_450 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_46(_450[0]), _46(_450[1])))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_46(_450[0]), _46(_450[1]))), undefined, true); } } else { const _465: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 3); @@ -1716,16 +1716,16 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { pokeArray(_556[0]); } } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_25: rt.u16): rt.u8 => { const w: rt.u16 = _25; return (w ^ (w >> 8)) & 0xff; - })); + }), undefined, true); rt.byteVecPush(out, digestPairs(pairs)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(array), (_26: rt.u32): rt.u8 => { const x4: rt.u32 = _26; return ((x4 ^ (x4 >>> 13)) >>> 0) & 0xff; - })); + }), undefined, true); } } @@ -1747,17 +1747,17 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 3)); const words: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_2: rt.u8): rt.u16 => { return rt.u16Mul(_2 as rt.u16, 257); - })); + }), undefined, 2, true); const pairs: Pair.Pair[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_29: rt.u8): Pair.Pair => { const b4: rt.u8 = _29; return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; - })); + }), undefined, 4, true); const counted: Counted.Counted[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_211: rt.u8): Counted.Counted => { return { n: _211 }; - })); + }), undefined, 1, true); const items: Noisy.Noisy[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_212: rt.u8): Noisy.Noisy => { return new Noisy.Noisy(_212); - })); + }), undefined, 1, true); const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { return 0; }); @@ -1798,7 +1798,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.sliceRangeMut(array, rt.min(a, 5)).fill(c as rt.u32); const opts: Array = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_224: rt.u8): Noisy.Noisy | undefined => { return new Noisy.Noisy(_224); - })); + }), undefined, 2, true); rt.sliceFill(rt.sliceRangeMut(opts, a), undefined as Noisy.Noisy | undefined, clone$1omlcob, rt.drop); flush(out); rt.sliceFill(opts, new Noisy.Noisy(64), clone$1omlcob, rt.drop); @@ -1807,7 +1807,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return mapOr$189goit(o, 238, (x: Noisy.Noisy): rt.u8 => { return x.tag; }); - })); + }), undefined, true); rt.dropAll(opts); } else if (_60 === 1) { let n: rt.u8 = c & 0xff; @@ -1927,7 +1927,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const part8 = rt.usizeSub(rt.byteSliceRange(data, 3).length, a); rt.sliceCopyFromSlice(_357, rt.sliceRange(rt.iterToArray(rt.iterMap(new rt.Range(0, c), (n9: rt.usize): Counted.Counted => { return { n: n9 & 0xff }; - })), 0, part8)); + }), undefined, 1, true), 0, part8)); flush(out); const more: rt.u32[] = Array.from({ length: 3 }, (): rt.u32 => { return 0; @@ -1939,7 +1939,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_60 === 6) { const source2: Noisy.Noisy[] = rt.iterToArray(rt.iterMap(new rt.Range(0, c), (tag3: rt.usize): Noisy.Noisy => { return new Noisy.Noisy((tag3 & 0xff) | 80); - })); + }), undefined, 1, true); const n5: rt.usize = rt.min(rt.byteSliceRange(data, 3).length, c); rt.sliceCloneFromSlice(rt.sliceRangeMut(items, 0, n5), rt.sliceRange(source2, 0, n5), Noisy.clone$Clone, rt.drop); flush(out); @@ -2007,22 +2007,22 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(out); } flush(out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words), (_225: rt.u16): rt.u8 => { const w: rt.u16 = _225; return (w ^ (w >> 8)) & 0xff; - })); + }), undefined, true); rt.byteVecPush(out, digestPairs(pairs)); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(counted), (x2: Counted.Counted): rt.u8 => { return x2.n; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(items), (x3: Noisy.Noisy): rt.u8 => { return x3.tag; - })); + }), undefined, true); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(array), (_226: rt.u32): rt.u8 => { const x4: rt.u32 = _226; return ((x4 ^ (x4 >>> 13)) >>> 0) & 0xff; - })); + }), undefined, true); rt.dropAll(items); flush(out); } diff --git a/ts/fixtures/lang/expected/statics.ts b/ts/fixtures/lang/expected/statics.ts index 4a0cda708..acad6f742 100644 --- a/ts/fixtures/lang/expected/statics.ts +++ b/ts/fixtures/lang/expected/statics.ts @@ -27,15 +27,15 @@ export const TABLE: rt.ByteSlice = /* @__PURE__ */ rt.byteSliceFrom(Uint8Array.o */ export function statics(data: rt.ByteSlice, out: rt.ByteVec): void { let _68!: rt.u8; - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.atomicLoad(COUNT, 0)).reverse())); - rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(rt.atomicLoad(WIDE, 0)).reverse())); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicLoad(SIGNED, 0) & 0xff, rt.atomicLoad(FLAG, 0) ? 1 : 0, rt.atomicLoad(SIZE, 0) & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.atomicLoad(COUNT, 0)).reverse()), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(rt.atomicLoad(WIDE, 0)).reverse()), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicLoad(SIGNED, 0) & 0xff, rt.atomicLoad(FLAG, 0) ? 1 : 0, rt.atomicLoad(SIZE, 0) & 0xff)), undefined, true); rt.byteVecPush(out, next(false)); for (const op of rt.byteSliceView(data)) { const n: rt.u8 = rt.u8Div(op, 6); const _38: rt.u8 = rt.u8Rem(op, 6); if (_38 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.atomicFetch(COUNT, rt.u64WrappingAdd, n as rt.u64, 3)).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.atomicFetch(COUNT, rt.u64WrappingAdd, n as rt.u64, 3)).reverse()), undefined, true); continue; } if (_38 === 1) { @@ -47,7 +47,7 @@ export function statics(data: rt.ByteSlice, out: rt.ByteVec): void { continue; } if (_38 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(rt.atomicSwap(WIDE, rt.i64Neg(n as rt.i64), 2)).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(rt.atomicSwap(WIDE, rt.i64Neg(n as rt.i64), 2)).reverse()), undefined, true); continue; } if (_38 === 4) { @@ -72,7 +72,7 @@ export function statics(data: rt.ByteSlice, out: rt.ByteVec): void { if (!(_84 < 4)) { rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _84); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_83.data[_83.start + _84], table() === table() ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_83.data[_83.start + _84], table() === table() ? 1 : 0)), undefined, true); } rt.atomicStore(COUNT, { hi: 0xffffffff, lo: 0xfffffffd } as rt.u64, 0); rt.atomicStore(SIGNED, -128, 0); @@ -124,13 +124,13 @@ export const FORCED: rt.Atomic = /* @__PURE__ */ new rt.Atomic(0); /** Each byte an operation on statics and constants read from memory; each puts what it read. */ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(COUNTER.name)))); - rt.iterExtendBytes(out, rt.iterSlice(COUNTER.steps)); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(COUNTER.name))), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(COUNTER.steps), undefined, true); const _10: Counter.Counter = COUNTER; if (_10.state === undefined) { rt.byteVecPush(out, 255); } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_10.state[0], _10.state[1] & 0xff))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_10.state[0], _10.state[1] & 0xff)), undefined, true); } const a: Raw.Raw = { locked: new rt.Atomic(false), count: new rt.Atomic(200) }; const b: Raw.Raw = { locked: new rt.Atomic(false), count: new rt.Atomic(200) }; @@ -142,17 +142,17 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { const slice = _22[1]; const _31: rt.u8 = slice.data[rt.idx(slice, 0)]; const _35: rt.ByteVec = FIRST.force(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_26, _27, _31, _35.data[rt.idx(_35, 1)]))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_26, _27, _31, _35.data[rt.idx(_35, 1)])), undefined, true); const tally: rt.Cell = new rt.Cell(250); const _40: rt.u8 = rt.u8WrappingAdd(tally.v, 10); rt.cellSet(tally, _40); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tally.v, new rt.Cell(250).v, new rt.Cell([1, 2] as [rt.u8, rt.u8]).v[1]))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(new rt.Cell(new rt.Cell(3)).v.v, new rt.Cell(new rt.Cell(4)).v.v))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tally.v, new rt.Cell(250).v, new rt.Cell([1, 2] as [rt.u8, rt.u8]).v[1])), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(new rt.Cell(new rt.Cell(3)).v.v, new rt.Cell(new rt.Cell(4)).v.v)), undefined, true); for (const op of rt.byteSliceView(data)) { const n2: rt.u8 = rt.u8Div(op, 8); const _68: rt.u8 = rt.u8Rem(op, 8); if (_68 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicFetch(COUNTER.hits, rt.u32WrappingAdd, rt.u32Rem(n2 as rt.u32, COUNTER.limit), 3)).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicFetch(COUNTER.hits, rt.u32WrappingAdd, rt.u32Rem(n2 as rt.u32, COUNTER.limit), 3)).reverse()), undefined, true); continue; } if (_68 === 1) { @@ -160,7 +160,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { continue; } if (_68 === 2) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicFetch(a.count, rt.u8WrappingAdd, n2, 0), rt.atomicLoad(b.count, 0), rt.atomicLoad(_19.count, 0)))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicFetch(a.count, rt.u8WrappingAdd, n2, 0), rt.atomicLoad(b.count, 0), rt.atomicLoad(_19.count, 0))), undefined, true); continue; } if (_68 === 3) { @@ -191,7 +191,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { const _141: [rt.u8, rt.u32] = rt.onceGetOrInit(ONCE, (): [rt.u8, rt.u32] => { return [3, 9] as [rt.u8, rt.u32]; }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_141[0], _141[1] & 0xff, ONCE.v !== undefined ? 1 : 0))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_141[0], _141[1] & 0xff, ONCE.v !== undefined ? 1 : 0)), undefined, true); continue; } if (_68 === 6) { @@ -202,13 +202,13 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Add(rt.atomicFetch(FORCED, rt.u8WrappingAdd, 1, 0), 10); }); rt.byteVecPush(out, rt.atomicLoad(FORCED, 0)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(y.force(), x.force(), y.force(), x.force()))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(y.force(), x.force(), y.force(), x.force())), undefined, true); rt.byteVecPush(out, rt.atomicSwap(FORCED, 0, 0)); continue; } if (_68 === 7) { if (rt.u8Rem(n2, 2) === 0) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicFetch(SHARED.force(), rt.u8WrappingAdd, n2, 0), rt.atomicLoad(LATER, 0), read()))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicFetch(SHARED.force(), rt.u8WrappingAdd, n2, 0), rt.atomicLoad(LATER, 0), read())), undefined, true); rt.atomicStore(LATER, 40, 0); continue; } @@ -228,7 +228,7 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { if (!(i < 3)) { rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(slots[i]).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(slots[i]).reverse()), undefined, true); } rt.atomicStore(COUNTER.hits, 4294967295 - 1, 0); } @@ -258,7 +258,7 @@ export function onces(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_13 === 1) { const captured5 = rt.arcClone(owned); rt.onceCall(once, rt.closure((state: rt.OnceState): void => { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.onceIsPoisoned(state) ? 1 : 0, once.v === true ? 1 : 0, n))); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.onceIsPoisoned(state) ? 1 : 0, once.v === true ? 1 : 0, n)), undefined, true); captured5[Symbol.dispose](); }, (): void => { captured5[Symbol.dispose](); @@ -291,7 +291,7 @@ export function onces(data: rt.ByteSlice, out: rt.ByteVec): void { const collector: Collector.Collector = Lock.getOrInit$Collector_onces_closure5(COLLECTOR.force(), (): Collector.Collector => { return new Collector.Collector(new rt.Arc(16909060)); }); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(collector.global.value).reverse())); + rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(collector.global.value).reverse()), undefined, true); rt.byteVecPush(out, collector.global.strong & 0xff); } else if (!(rt.u8Rem(n, 3) === 0)) { if (!(rt.u8Rem(n, 3) === 1)) { diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index a51a77d1b..1ee92426e 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -197,7 +197,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { for (const _190 of rt.iterToArray(rt.iterMap(rt.strMatchIndices(s, "/"), (_2: [rt.usize, string]): rt.usize => { return _2[0]; - }))) { + }), undefined, 4)) { putOffset(out, _190); } break b0; @@ -356,11 +356,11 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }); put(out, rt.strSlice(s, part5)); } else if (_8 === 5) { - const parts: string[] = rt.iterToArray(rt.strSplit(s, "/")); + const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), undefined, 8); put(out, parts.join(p)); put(out, rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (part3: string): string => { return part3; - })).join(p)); + }), undefined, 12, true).join(p)); put(out, ["a", "", s].join("/")); } else { const at2: (a0: rt.u8) => rt.usize = (b2: rt.u8): rt.usize => { @@ -1184,8 +1184,8 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { */ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const s: string = text(data); - const chars: rt.char[] = rt.iterToArray(rt.strChars(s)); - const parts: string[] = rt.iterToArray(rt.strSplit(s, "/")); + const chars: rt.char[] = rt.iterToArray(rt.strChars(s), undefined, 4); + const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), undefined, 8); const nexts: rt.Cell = new rt.Cell(0); const named: Named.Named = { name: text(rt.byteSliceRange(data, 0, rt.usizeDiv(data.length, 2))) }; const _21: rt.u8 = rt.u8Rem(kind, 4); @@ -1218,7 +1218,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.stringExtend("", rt.iterSlice(parts))); const owned: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (p6: string): string => { return p6; - })); + }), undefined, 12, true); put(out, rt.stringFromStrings(rt.iterMap(rt.iterSlice(owned), (p7: string): string => { return p7; }))); diff --git a/ts/fixtures/lang/expected/utf8.ts b/ts/fixtures/lang/expected/utf8.ts index 3533c0799..79a66392a 100644 --- a/ts/fixtures/lang/expected/utf8.ts +++ b/ts/fixtures/lang/expected/utf8.ts @@ -15,7 +15,7 @@ export function decodes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.panic("index out of bounds: the len is " + 32 + " but the index is " + _54); } return Uint8Array.of(0, 65, 127, 192, 193, 194, 223, 224, 225, 237, 238, 239, 240, 241, 244, 245, 128, 143, 144, 159, 160, 191, 128, 143, 144, 159, 160, 191, 128, 191, 152, 187)[_54]; - })); + }), undefined, true); } const iter: rt.RangeInclusive = new rt.RangeInclusive(0, bytes.length, rt.usizeStep); while (true) { diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 65f96c964..6e663e10f 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -326,7 +326,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void putU64(out, unwrapOr$1tvry1i(rt.iterMax(rt.iterBorrow(most), rt.lt), 238)); bounds$RangeInclusive_u64(out, most); const collected: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, rt.iterToArray(rt.iterBorrow(collected)).length & 0xff); + rt.byteVecPush(out, rt.iterToArray(rt.iterBorrow(collected), undefined, 8, true).length & 0xff); bounds$RangeInclusive_u64(out, collected); const gathered: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const _154: Tally.Tally = rt.iterFold(rt.iterBorrow(gathered), new Tally.Tally(0), (t: Tally.Tally, x7: rt.u64): Tally.Tally => { @@ -339,23 +339,23 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void bounds$RangeInclusive_u64(out, gathered); const keyed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const _166: rt.RangeInclusive = keyed; - rt.byteVecPush(out, rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBorrow(_166), true)) & 0xff); + rt.byteVecPush(out, rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBorrow(_166), true, undefined, undefined, 8, true)) & 0xff); bounds$RangeInclusive_u64(out, keyed); const queued: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const _176: rt.RangeInclusive = queued; - rt.byteVecPush(out, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterBorrow(_176)).n & 0xff); + rt.byteVecPush(out, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterBorrow(_176), undefined, 8, true).n & 0xff); bounds$RangeInclusive_u64(out, queued); const hashed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const _186: rt.RangeInclusive = hashed; - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, rt.iterBorrow(_186))) & 0xff); + rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, rt.iterBorrow(_186), undefined, undefined, 117440512)) & 0xff); bounds$RangeInclusive_u64(out, hashed); const extended: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const held: rt.u64[] = []; - rt.iterExtend(held, rt.iterBorrow(extended)); + rt.iterExtend(held, rt.iterBorrow(extended), undefined, 8, true); rt.byteVecPush(out, held.length & 0xff); bounds$RangeInclusive_u64(out, extended); const narrow: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Low(lo) & 0xff, rt.u64Low(hi) & 0xff, rt.u8Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterBorrow(narrow))))); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true))), undefined, true); rt.byteVecPush(out, rt.rangeInclusiveStart(narrow)); rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(narrow) ? 1 : 0); bounds$RangeTo_u64(out, { end: b }); @@ -422,10 +422,10 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.btreeLen(map) & 0xff); rt.byteVecPush(out, rt.btreeLen(above) & 0xff); const _397: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _397, true); + const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _397, true, undefined, undefined, 1, true); const _402: rt.u8 = at(2); const high: rt.BTreeSet = rt.btreeSplitOff(set, _402); - rt.iterExtendBytes(out, rt.iterChain(rt.btreeKeys(set), rt.btreeKeys(high))); + rt.iterExtendBytes(out, rt.iterChain(rt.btreeKeys(set), rt.btreeKeys(high)), undefined, true); rt.byteVecPush(out, rt.btreeLen(high) & 0xff); } else if (_21 === 2) { const _417: [rt.u8, rt.u8] = [at(0), at(1)]; @@ -440,7 +440,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _461: rt.Iter<[rt.u8, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): [rt.u8, rt.usize] => { return [_2[1], _2[0]] as [rt.u8, rt.usize]; }); - const iter4: rt.Iter<[rt.u8, rt.usize]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpReverse(rt.cmp)) as rt.BTreeMap, _461, true)); + const iter4: rt.Iter<[rt.u8, rt.usize]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpReverse(rt.cmp)) as rt.BTreeMap, _461, true, undefined, undefined, undefined, 8, true)); while (true) { const _467: [rt.u8, rt.usize] | rt.Done = iter4.next(); if (_467 === rt.DONE) { @@ -451,7 +451,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } const ranked: [rt.u8, rt.usize][] = rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_23: [rt.usize, rt.u8]): [rt.u8, rt.usize] => { return [_23[1], _23[0]] as [rt.u8, rt.usize]; - })); + }), undefined, 8, true); rt.sliceSortByKey(ranked, (_25: [rt.u8, rt.usize]): [rt.u8, rt.usize] => { return [rt.u8Rem(_25[0], 4), _25[1]] as [rt.u8, rt.usize]; }, rt.cmpLt(rt.cmpTuple([rt.cmpReverse(rt.cmp), rt.cmp]))); diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 855f7b144..18315797a 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -3,8 +3,8 @@ use crate::{ arrays, atomics, borrows, bounds, captures, cells, chars, chunks, collections, combinators, counts, cows, defaults, - durations, dyns, edits, errors, floats, fmt, generics, hashes, holds, ints, iters, keys, locals, locks, nested, - objects, orders, pointers, refs, shapes, singles, slices, splits, statics, strs, utf8, wrappers, + durations, dyns, edits, errors, floats, fmt, generics, hashes, hints, holds, ints, iters, keys, locals, locks, + nested, objects, orders, pointers, refs, shapes, singles, slices, splits, statics, strs, utf8, wrappers, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -161,6 +161,8 @@ fn cases() -> Vec<(&'static str, Case)> { ("singles::formats", singles::formats), ("singles::parses", singles::parses), ("iters::peeked_others", |_, data, out| iters::peeked_others(data, out)), + ("hints::hints", hints::hints), + ("hints::reserves", hints::reserves), ] } diff --git a/ts/fixtures/lang/src/hints.rs b/ts/fixtures/lang/src/hints.rs new file mode 100644 index 000000000..47bbc2e75 --- /dev/null +++ b/ts/fixtures/lang/src/hints.rs @@ -0,0 +1,497 @@ +//! Size hints: each of std's iterators' and adaptors' `size_hint`, as it reads, and the +//! `capacity overflow` std's collections panic with as they reserve by one. + +use std::cell::Cell; +use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque}; +use std::hash::Hash; + +/// Lengths at the edges a hint meets: none, a few, `isize::MAX` and past it, `usize::MAX` +/// and past it, and past 2^53. +const LENGTHS: [u64; 8] = [0, 1, 5, 0x7fff_ffff, 0x8000_0000, 0xffff_ffff, 0x1_0000_0000, 1 << 60]; + +/// A hint, as four bytes each, the upper bound after whether it has one. +fn put(out: &mut Vec, (lower, upper): (usize, Option)) { + out.extend_from_slice(&(lower as u32).to_be_bytes()); + match upper { + Some(upper) => { + out.push(1); + out.extend_from_slice(&(upper as u32).to_be_bytes()); + } + None => out.push(0), + } +} + +/// `it`'s hint, and again after each of up to three items, read from the back where +/// `steps` has the item's bit set. +fn walk(mut it: I, steps: u8, out: &mut Vec) { + put(out, it.size_hint()); + for k in 0..steps % 4 { + match steps >> (2 + k) & 1 { + 0 => it.next(), + _ => it.next_back(), + }; + put(out, it.size_hint()); + } +} + +/// As `walk`, of an iterator that reads only from the front. +fn walk_front(mut it: I, steps: u8, out: &mut Vec) { + put(out, it.size_hint()); + for _ in 0..steps % 4 { + it.next(); + put(out, it.size_hint()); + } +} + +/// `n`, or `u32::MAX` past it. +fn u32_of(n: u64) -> u32 { + u32::try_from(n).unwrap_or(u32::MAX) +} + +/// An iterator of the crate's own, which keeps std's hint. +struct Countdown(u8); + +/// An iterator of the crate's own that never ends. +struct Endless(u64); + +impl Iterator for Endless { + type Item = u64; + + fn next(&mut self) -> Option { + Some(self.0) + } +} + +impl Iterator for Countdown { + type Item = u8; + + fn next(&mut self) -> Option { + self.0 = self.0.checked_sub(1)?; + Some(self.0) + } +} + +/// The hints of the iterator `kind` and the top three bits of `data`'s third byte pick, of +/// lengths `data`'s first two bytes pick or of its fourth byte on, as each reads from the +/// front or the back by the third byte's other bits. +pub fn hints(kind: u8, data: &[u8], out: &mut Vec) { + let at = |i: usize| data.get(i).copied().unwrap_or(0); + let (n, m) = (LENGTHS[usize::from(at(0)) % 8], LENGTHS[usize::from(at(1)) % 8]); + let steps = at(2); + let arm = steps >> 5; + let bytes = data.get(3..).unwrap_or(&[]); + match kind % 24 { + // Ranges of each width, past `usize::MAX` and 2^53, and empty ones. + 0 => match arm % 5 { + 0 => walk(0..u32_of(n), steps, out), + 1 => walk(u32_of(m)..u32_of(n), steps, out), + 2 => walk(n as u8..m as u8, steps, out), + 3 => walk(-(n as i32)..m as i32, steps, out), + _ => walk(0..n as usize, steps, out), + }, + 1 => match arm % 4 { + 0 => walk(0..n, steps, out), + 1 => walk(1 << 63..(1 << 63) + n, steps, out), + 2 => walk(-(n as i64)..m as i64, steps, out), + _ => walk(i64::MIN..i64::MIN + n as i64, steps, out), + }, + 2 => match arm % 3 { + 0 => walk(1u128 << 100..(1u128 << 100) + u128::from(n), steps, out), + 1 => walk(-(1i128 << 100)..i128::from(n) - (1i128 << 100), steps, out), + _ => walk(i128::MIN..i128::MAX, steps, out), + }, + 3 => match arm % 5 { + 0 => walk(0..=u32_of(n), steps, out), + 1 => walk(0..=u32::MAX, steps, out), + 2 => walk(i8::MIN..=i8::MAX, steps, out), + 3 => walk(u64::MAX - n..=u64::MAX, steps, out), + _ => walk(u32_of(n)..=u32_of(m), steps, out), + }, + // Chains, whose upper bound overflows to `None`, and which hint one side once the + // other ends. + 4 => match arm % 4 { + 0 => walk((0..u32_of(n.min(9))).chain(0..u32_of(m)), steps, out), + 1 => walk((0..n).chain(0..m), steps, out), + 2 => walk((0..u32_of(n)).chain(0..u32::MAX), steps, out), + _ => walk_front(Endless(n).take(n as usize % 9).chain(0..m), steps, out), + }, + // Zips: the shorter side's bounds, by index or not. + 5 => match arm % 4 { + 0 => walk_front((0..n).zip(0..m), steps, out), + 1 => walk_front(Endless(n).zip(0..u32_of(m)), steps, out), + 2 => walk(bytes.iter().zip(bytes.iter().skip(1)), steps, out), + _ => walk_front((0..u32_of(n)).zip(Endless(n)), steps, out), + }, + 6 => match arm % 4 { + 0 => walk_front((0..n).skip(m as usize), steps, out), + 1 => walk((0..u32_of(n)).take(m as usize), steps, out), + 2 => walk_front(Endless(n).take(m as usize), steps, out), + _ => walk_front(Endless(n).skip(m as usize % 9), steps, out), + }, + // Steps over ranges the step specializes on and over others. + 7 => { + let step = usize::from(at(1)) % 7 + 1; + match arm % 4 { + 0 => walk((0..u32_of(n)).step_by(step), steps, out), + 1 => walk_front((0..u32_of(n)).step_by(step), steps, out), + 2 => walk_front((0..n).step_by(step), steps, out), + _ => walk(bytes.iter().step_by(step), steps, out), + } + } + 8 => match arm % 6 { + 0 => walk((0..n).filter(|i| i % 2 == 0), steps, out), + 1 => walk((0..n).filter_map(|i| i.checked_sub(1)), steps, out), + 2 => walk_front((0..n).skip_while(|&i| i < 2), steps, out), + 3 => walk_front((0..n).take_while(|&i| i < 1), steps, out), + 4 => walk_front((0..n).map_while(|i| i.checked_sub(1)), steps, out), + _ => walk_front(Endless(n).filter(|_| true), steps, out), + }, + 9 => match arm % 6 { + 0 => walk((0..n).map(|i| i + 1), steps, out), + 1 => walk((0..n).inspect(|_| {}), steps, out), + 2 => walk((0..u32_of(n)).enumerate(), steps, out), + 3 => walk((0..n).rev(), steps, out), + 4 => walk(bytes.iter().copied(), steps, out), + _ => walk(bytes.iter().cloned(), steps, out), + }, + 10 => match arm % 4 { + 0 => walk_front(Endless(n).fuse(), steps, out), + 1 => walk_front(Endless(n).take(2).fuse(), steps, out), + 2 => walk((0..n).fuse(), steps, out), + _ => walk_front(Countdown(n as u8).fuse(), steps, out), + }, + // Peeked items, and a peeked end. + 11 => { + let mut it = (0..n).chain(0..m).peekable(); + put(out, it.size_hint()); + for _ in 0..steps % 4 { + it.peek(); + put(out, it.size_hint()); + it.next(); + put(out, it.size_hint()); + } + let mut few = bytes.iter().peekable(); + while few.next().is_some() {} + few.peek(); + put(out, few.size_hint()); + } + // Flattens of arrays, whose length counts, of iterators that may hold any number, + // and of ones that hold at most one, which std's hint specializes on. + 12 => match arm % 5 { + 0 => walk((0..n).map(|i| [i; 3]).flatten(), steps, out), + 1 => walk((0..n).flat_map(|i| [i]), steps, out), + 2 => walk(bytes.chunks(2).flatten(), steps, out), + 3 => walk((0..n.min(9)).map(|i| 0..i).flatten(), steps, out), + _ => walk((0..n).flat_map(|i| [[i; 2]; 2].into_iter().flatten()), steps, out), + }, + 13 => match arm % 6 { + 0 => walk((0..n).map(|i| i.checked_sub(2)).flatten(), steps, out), + 1 => walk((0..n).flat_map(|i| (i % 2 == 0).then_some(i)), steps, out), + 2 => walk((0..n).flat_map(std::iter::once), steps, out), + 3 => walk( + (0..n).flat_map(|i| Some(i).into_iter().filter(|i| i % 2 == 0)), + steps, + out, + ), + 4 => walk(bytes.iter().map(|&b| [b]).flatten(), steps, out), + _ => { + let arrays: Vec<[u8; 2]> = bytes.iter().map(|&b| [b, b]).collect(); + walk(arrays.iter().flatten(), steps, out); + } + }, + // Sources. + 14 => match arm % 6 { + 0 => walk(bytes.iter(), steps, out), + 1 => walk(bytes.to_vec().into_iter(), steps, out), + 2 => walk([at(3), at(4), at(5)].into_iter(), steps, out), + 3 => walk(bytes.first().into_iter(), steps, out), + 4 => walk(std::iter::once(n), steps, out), + _ => walk(std::iter::empty::(), steps, out), + }, + 15 => match arm % 5 { + 0 => walk_front(std::iter::successors(Some(n % 4), |&i| i.checked_sub(1)), steps, out), + 1 => walk_front(std::iter::successors(None::, |&i| Some(i)), steps, out), + 2 => walk_front(Countdown(n as u8), steps, out), + 3 => walk_front(std::iter::from_fn(move || Some(n)), steps, out), + _ => { + let mut it = bytes.iter(); + walk(it.by_ref(), steps, out); + put(out, it.size_hint()); + } + }, + 16 => { + let s: String = bytes + .iter() + .map(|&b| ['a', 'é', '😀', '\u{800}'][usize::from(b % 4)]) + .collect(); + match arm % 4 { + 0 => walk(s.chars(), steps, out), + 1 => walk_front(s.split('é'), steps, out), + 2 => walk(s.bytes(), steps, out), + _ => { + let mut t = s.clone(); + let half: usize = bytes[..bytes.len() / 2] + .iter() + .map(|&b| [1, 2, 4, 3][usize::from(b % 4)]) + .sum(); + walk(t.drain(half..), steps, out); + } + } + } + 17 => { + let size = usize::from(at(1)) % 4 + 1; + match arm % 5 { + 0 => walk(bytes.windows(size), steps, out), + 1 => walk(bytes.chunks(size), steps, out), + 2 => walk(bytes.chunks_exact(size), steps, out), + 3 => walk(bytes.rchunks(size), steps, out), + _ => walk(bytes.rchunks_exact(size), steps, out), + } + } + // Collections' iterators: each knows its length, but a B-tree's range. + 18 => { + let map: HashMap = bytes.iter().map(|&b| (b, b)).collect(); + let set: HashSet = bytes.iter().copied().collect(); + match arm % 5 { + 0 => walk_front(map.iter(), steps, out), + 1 => walk_front(map.keys(), steps, out), + 2 => walk_front(set.iter(), steps, out), + 3 => walk_front(map.clone().into_iter(), steps, out), + _ => walk_front(map.clone().drain(), steps, out), + } + } + 19 => { + let map: BTreeMap = bytes.iter().map(|&b| (b, b)).collect(); + let set: BTreeSet = bytes.iter().copied().collect(); + match arm % 4 { + 0 => walk(map.iter(), steps, out), + 1 => walk(map.range(at(3)..), steps, out), + 2 => walk(set.iter(), steps, out), + _ => walk(map.values(), steps, out), + } + } + 20 => { + let mut deque: VecDeque = bytes.iter().copied().collect(); + let mut v = bytes.to_vec(); + let heap: BinaryHeap = bytes.iter().copied().collect(); + let half = bytes.len() / 2; + match arm % 4 { + 0 => walk(deque.iter(), steps, out), + 1 => walk(deque.drain(half..), steps, out), + 2 => walk(v.drain(..half), steps, out), + _ => walk(heap.iter(), steps, out), + } + } + // Adaptors of adaptors. + 21 => match arm % 4 { + 0 => walk_front((0..n).chain(0..m).skip(3).take(u32_of(n) as usize), steps, out), + 1 => walk( + (0..u32_of(n.min(9))).zip(0..u32_of(m.min(9))).rev().step_by(2), + steps, + out, + ), + 2 => walk((0..n).map(|i| [i; 2]).flatten().chain(0..m), steps, out), + _ => walk_front((0..n).filter(|_| true).peekable(), steps, out), + }, + // Through `&mut`, which hints as what it borrows. + 22 => { + let mut it = (0..n).chain(0..m); + walk(&mut it, steps, out); + put(out, it.size_hint()); + } + _ => match arm % 3 { + 0 => walk_front((0..n).zip(0..m).map(|(a, _)| a).chain(std::iter::once(0)), steps, out), + 1 => walk_front( + (0..u32_of(n)).map(|i| [i; 2]).flatten().skip(m as usize % 9), + steps, + out, + ), + _ => walk_front((0..n).flat_map(|i| 0..i).take(m as usize), steps, out), + }, + } +} + +/// The most of each element type std's collections hold on wasm32, past which they panic +/// with a capacity overflow: a `Vec` of it, a `Vec` of it paired with a `u32`, a hash set +/// of it, and a hash map of it to a `u32`. +#[derive(Clone, Copy)] +struct Most { + vec: u64, + pairs: u64, + set: u64, + map: u64, +} + +/// What `reserves` collects into, by `kind`'s quotient. +const COLLECTIONS: u8 = 13; + +/// Each collection `kind` picks, collected or extended by `0..=last` of `u32`s, mapped by +/// a closure that panics with `consumed` past the call `data`'s third byte picks, the way +/// `data`'s first byte picks, and as long as its second picks: a few, one past the most it +/// holds, `u32::MAX`, and `usize::MAX` and one more, whose upper bound is `None`. std's +/// reserves by its size hint first, which panics past the most before it reads an item of +/// a `TrustedLen` iterator, and after the first of another, which it reserves for again +/// whenever it fills. +pub fn reserves(kind: u8, data: &[u8], out: &mut Vec) { + match kind / COLLECTIONS % 5 { + 0 => typed( + kind, + data, + |i| i as u8, + Most { + vec: 0x7fff_ffff, + pairs: 0x0fff_ffff, + set: 0x1c00_0000, + map: 0x0700_0000, + }, + out, + ), + 1 => typed( + kind, + data, + |i| i, + Most { + vec: 0x1fff_ffff, + pairs: 0x0fff_ffff, + set: 0x0e00_0000, + map: 0x0700_0000, + }, + out, + ), + 2 => typed( + kind, + data, + |i| (i as u8, 0u8, 0u8), + Most { + vec: 0x2aaa_aaaa, + pairs: 0x0fff_ffff, + set: 0x0e00_0000, + map: 0x0700_0000, + }, + out, + ), + 3 => typed( + kind, + data, + |i| (u64::from(i), i as u8), + Most { + vec: 0x07ff_ffff, + pairs: 0x0555_5555, + set: 0x0380_0000, + map: 0x0380_0000, + }, + out, + ), + _ => typed( + kind, + data, + |i| Big([i; 275]), + Most { + vec: 1_952_257, + pairs: 1_945_184, + set: 917_504, + map: 917_504, + }, + out, + ), + } +} + +/// Over 1024 bytes, which a `Vec` grows by as few as one of. +#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +struct Big([u32; 275]); + +/// `reserves` of elements `make` makes. +fn typed T>(kind: u8, data: &[u8], make: F, most: Most, out: &mut Vec) { + let at = |i: usize| data.get(i).copied().unwrap_or(0); + let coll = kind % COLLECTIONS; + let limit = [0u8, 1, 4, 5, 8][usize::from(at(2)) % 5]; + // What the collection holds before it extends, and the most it holds of the items. + let (held, most) = match coll { + 0 | 1 | 3 | 5 | 11 | 12 => (0, most.vec), + 2 | 4 | 6 => (2, most.vec), + 7 => (0, most.vec), + 8 => (0, most.set), + 9 => (1, most.map), + _ => (0, most.pairs), + }; + // The non-empty hash map reserves half what it is given, rounded up. + let past = match coll { + 9 => 2 * (most - held) + 1, + _ => most - held + 1, + }; + let shape = at(0) % 5; + let count = match at(1) % 4 { + 0 => 3, + // One more past a `skip(1)`, which hints one fewer. + 1 => past + u64::from(shape == 1), + 2 => u64::from(u32::MAX), + _ => 1 << 32, + }; + let last = u32::try_from(count.min(1 << 32) - 1).unwrap(); + let seed = make(7); + let calls = Cell::new(0u8); + let f = |i: u32| { + calls.set(calls.get() + 1); + assert!(calls.get() <= limit, "consumed"); + make(i) + }; + match shape { + 0 => fill(coll, (0..=last).map(f), seed, out), + 1 => fill(coll, (0..=last).map(f).skip(1), seed, out), + 2 => fill(coll, (0..=last).map(f).filter(|_| true), seed, out), + // Its lower bound grows once it reads into the last range, which the collection + // reserves for at the first item, or after it grows by the second range's. + 3 => fill(coll, [0..=2, 0..=last].into_iter().flatten().map(f), seed, out), + _ => fill(coll, [0..=2, 0..=2, 0..=last].into_iter().flatten().map(f), seed, out), + } + out.push(calls.get()); +} + +/// `items` collected into the collection `coll` picks, or extended into one holding `seed`. +fn fill>(coll: u8, items: I, seed: T, out: &mut Vec) { + let len = match coll { + 0 => items.collect::>().len(), + 1 => { + let mut v = Vec::new(); + v.extend(items); + v.len() + } + 2 => { + let mut v = vec![seed.clone(); 2]; + v.extend(items); + v.len() + } + 3 => items.collect::>().len(), + 4 => { + let mut q = VecDeque::from(vec![seed.clone(); 2]); + q.extend(items); + q.len() + } + 5 => items.collect::>().len(), + 6 => { + let mut h = BinaryHeap::from(vec![seed.clone(); 2]); + h.extend(items); + h.len() + } + 7 => items.collect::>().len(), + 8 => items.collect::>().len(), + 9 => { + let mut m = HashMap::from([(seed, 0u32)]); + m.extend(items.map(|t| (t, 1))); + m.len() + } + 10 => items.map(|t| (t, 1u32)).collect::>().len(), + // Through a shunt, whose length std's never trusts. + 11 => items.map(Some).collect::>>().map_or(0xff, |v| v.len()), + _ => match items + .enumerate() + .map(|(i, t)| if i < 3 { Ok(t) } else { Err(i) }) + .collect::, usize>>() + { + Ok(v) => v.len(), + Err(i) => 0x100 + i, + }, + }; + out.extend_from_slice(&(len as u32).to_be_bytes()); +} diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 0edc66b9a..21d2eae31 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -12,7 +12,8 @@ //! `Hash` writes into `DefaultHasher` and `RandomState`, slices' `windows` and chunks, //! mutable ones written through, their parts by inclusive and checked ranges and by fixed //! size, `Vec::drain`, the order, equality, and hashes of bytes, ranges of `Bound`s and of -//! the crate's own `RangeBounds`, and the equality of `Result`s and std's errors. +//! the crate's own `RangeBounds`, the equality of `Result`s and std's errors, iterators' +//! size hints, and the capacity overflows collections reserving by them panic with. //! //! `harness::run` is the entry point both sides of the differential test run, and //! `fmt::Fault` an error only `caller.ts` prints. @@ -39,6 +40,7 @@ mod fmt; mod generics; pub mod harness; mod hashes; +mod hints; mod holds; mod ints; mod iters; diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 348a0bd29..1cd7dd550 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -1062,7 +1062,7 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { return rt.iterToArray(rt.iterMap(rt.iterSlice(v13), (k: Key.Key): string => { const _43: rt.u32 = rt.u32Sub(k.id, id); return rt.fmtToString((f: rt.Formatter) => rt.u32Display(_43, f)); - })).join(","); + }), undefined, 12, true).join(","); }; const _8: rt.u8 = rt.u8Rem(arg, 9); if (_8 === 0) { diff --git a/ts/fixtures/task/expected/drops/closures.ts b/ts/fixtures/task/expected/drops/closures.ts index a0b5b00a6..4638a990b 100644 --- a/ts/fixtures/task/expected/drops/closures.ts +++ b/ts/fixtures/task/expected/drops/closures.ts @@ -511,7 +511,7 @@ export function iterated(log: Log.Log, id: rt.u32): void { return thenSome$1af3oea(n7 < 3, rt.u32Add(n7, Guard.id(captured9))); }, (): void => { captured9[Symbol.dispose](); - })), "next"); + })), "next", 4); const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part5, f, rt.u32Debug)]; Log.note(log, rt.fmtFormat(["map_while ", args12[0]])); const _237: [Guard.Guard, Guard.Guard] = [guard(19), guard(20)]; diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 7b9192a61..92d80077d 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -16,7 +16,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return Guard.new(rt.u32Add(id, n24), Log.clone$Clone(log)); }; const guards: (a0: rt.u32, a1: rt.u32) => Guard.Guard[] = (from: rt.u32, to: rt.u32): Guard.Guard[] => { - return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard)); + return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); }; const _10: [Guard.Guard, Guard.Guard] = [guard(10), guard(11)]; _1086 = true; @@ -193,7 +193,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g68; }, (): void => { captured56[Symbol.dispose](); - })), "next"); + })), "next", 8, true); const _174: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1085 = false; const captured57 = d; @@ -201,7 +201,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return [g69, Guard.id(captured57) as rt.u64] as [Guard.Guard, rt.u64]; }, (): void => { captured57[Symbol.dispose](); - })), "fold"); + })), "fold", 16, true); const _185: rt.usize = same.length; const _188: rt.usize = wider.length; const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_185, f), (f: rt.Formatter) => rt.usizeDisplay(_188, f)]; @@ -221,7 +221,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured54[Symbol.dispose](); })); - const queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_196, "next"))); + const queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_196, "next", 8, true))); const _204: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1085 = false; const captured55 = d; @@ -230,7 +230,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured55[Symbol.dispose](); })); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_203, "fold"), undefined, rt.drop); + const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_203, "fold", 12, true), undefined, rt.drop); const _215: rt.usize = queue.n; const _218: rt.usize = rt.btreeLen(tree); const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_215, f), (f: rt.Formatter) => rt.usizeDisplay(_218, f)]; @@ -251,7 +251,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured52[Symbol.dispose](); })); - rt.iterExtend(v, _230, "fold"); + rt.iterExtend(v, _230, "fold", 8, true); const tree2: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; const _240: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1085 = false; @@ -937,7 +937,7 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return Guard.new(rt.u32Add(id, n7), Log.clone$Clone(log)); }; const guards: (a0: rt.u32, a1: rt.u32) => Guard.Guard[] = (from: rt.u32, to: rt.u32): Guard.Guard[] => { - return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard)); + return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); }; const _11: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(10), guard(11), guard(12)]; const c: Guard.Guard = _11[0]; @@ -1281,7 +1281,7 @@ export function options(log: Log.Log, id: rt.u32): void { return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); }; const guards: (a0: rt.u32, a1: rt.u32) => Guard.Guard[] = (from: rt.u32, to: rt.u32): Guard.Guard[] => { - return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard)); + return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); }; const _10: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(10), guard(11), guard(12)]; const c: Guard.Guard = _10[0]; @@ -1334,7 +1334,7 @@ export function reducers(log: Log.Log, id: rt.u32): void { return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); }; const guards: (a0: rt.u32, a1: rt.u32) => Guard.Guard[] = (from: rt.u32, to: rt.u32): Guard.Guard[] => { - return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard)); + return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); }; const _9: [Guard.Guard, Guard.Guard] = [guard(10), guard(11)]; const c: Guard.Guard = _9[0]; @@ -1423,7 +1423,7 @@ export function closures(log: Log.Log, id: rt.u32): void { return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(log)); }; const guards: (a0: rt.u32, a1: rt.u32) => Guard.Guard[] = (from: rt.u32, to: rt.u32): Guard.Guard[] => { - return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard)); + return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); }; const _12: [Guard.Guard, Guard.Guard, Guard.Guard, Guard.Guard, Guard.Guard] = [guard(10), guard(11), guard(12), guard(13), guard(14)]; const c: Guard.Guard = _12[0]; @@ -1467,7 +1467,7 @@ export function closures(log: Log.Log, id: rt.u32): void { g3[Symbol.dispose](); return _06; }); - }), "next"); + }), "next", 8); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug))]; Log.note(log, rt.fmtFormat(["kept ", args2[0]])); const part3 = rt.iterFold(rt.iterFilterMap(rt.iterSlice(guards(1, 7), rt.drop), pick, rt.None), 0, (n3: rt.u32, o2: Guard.Guard | undefined): rt.u32 => { diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index cb48808c3..18053f9d5 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -72,7 +72,7 @@ export function looped(log: Log.Log, id: rt.u32): void { v2.push(_105); const even: Guard.Guard[] = rt.iterToArray(rt.iterFilter(rt.iterSlice(v2, rt.drop), (g4: Guard.Guard): boolean => { return rt.u32Rem(Guard.id(g4), 2) === 0; - }, rt.drop), "next"); + }, rt.drop), "next", 8); const part3 = even.length; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["even ", args6[0]])); @@ -166,7 +166,7 @@ export function looped(log: Log.Log, id: rt.u32): void { v10.push(_323); const _329: Guard.Guard | undefined = guard(32); v10.push(_329); - const _308: rt.Iter = rt.iterFlatten(rt.iterSlice(v10, rt.drop), (value: Guard.Guard | undefined) => rt.iterOption(value, rt.drop), true); + const _308: rt.Iter = rt.iterFlatten(rt.iterSlice(v10, rt.drop), (value: Guard.Guard | undefined) => rt.iterOption(value, rt.drop), true, undefined, true); const found: Guard.Guard | undefined = rt.iterFind(_308, (g10: Guard.Guard): boolean => { return Guard.id(g10) === rt.u32Add(id, 31); }, rt.drop); @@ -316,7 +316,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v.push(_18); const _23: Guard.Guard = guard(3); v.push(_23); - const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next"); + const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next", 8, true); const v2: Guard.Guard[] = []; const _33: Guard.Guard = guard(4); v2.push(_33); @@ -326,7 +326,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v2.push(_43); const wider: [Guard.Guard, rt.u32][] = rt.iterToArray(rt.iterMap(rt.iterSlice(v2, rt.drop), (g: Guard.Guard): [Guard.Guard, rt.u32] => { return [g, 0] as [Guard.Guard, rt.u32]; - }), "fold"); + }), "fold", 12, true); const v3: Guard.Guard[] = []; const _53: Guard.Guard = guard(7); v3.push(_53); @@ -336,7 +336,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v4.push(_60); const _65: Guard.Guard = guard(9); v4.push(_65); - const chained: Guard.Guard[] = rt.iterToArray(rt.iterChain(_48, rt.iterSlice(v4, rt.drop)), "fold"); + const chained: Guard.Guard[] = rt.iterToArray(rt.iterChain(_48, rt.iterSlice(v4, rt.drop)), "fold", 8, true); const _74: rt.usize = same.length; const _77: rt.usize = wider.length; const _80: rt.usize = chained.length; @@ -354,7 +354,7 @@ export function collected(log: Log.Log, id: rt.u32): void { return rt.Ok(g2); } return rt.Err(g2); - }), (values: rt.Iter) => rt.iterToArray(values, "next"), drop$Vec_Guard); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), drop$Vec_Guard); const part = results.ok; const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; Log.note(log, rt.fmtFormat(["result ", args4[0]])); @@ -368,7 +368,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v6.push(_140); const part2 = mapOr$0vxyhav(rt.iterCollectOption(rt.iterMap(rt.iterSlice(v6, rt.drop), (g3: Guard.Guard): Guard.Guard | undefined => { return g3; - }), (values: rt.Iter) => rt.iterToArray(values, "next"), drop$Vec_Guard), 0, (v12: Guard.Guard[]): rt.usize => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), drop$Vec_Guard), 0, (v12: Guard.Guard[]): rt.usize => { const _06: rt.usize = v12.length; rt.dropAll(v12); return _06; @@ -383,7 +383,7 @@ export function collected(log: Log.Log, id: rt.u32): void { const _172: [rt.u32, Guard.Guard] = [2, guard(18)]; v7.push(_172); const _155: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v7, drop$u32_Guard); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next"), undefined, rt.drop); + const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next", 12, true), undefined, rt.drop); const part3 = rt.btreeLen(tree); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["tree ", args8[0]])); @@ -396,7 +396,7 @@ export function collected(log: Log.Log, id: rt.u32): void { const at = rt.idx(same, 0); _2[Symbol.dispose](); return same[at]; - }), "next").length; + }), "next", 4, true).length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; Log.note(log, rt.fmtFormat(["refs ", args10[0]])); const v9: Guard.Guard[] = []; @@ -405,21 +405,21 @@ export function collected(log: Log.Log, id: rt.u32): void { const _228: Guard.Guard = guard(20); v9.push(_228); const _218: rt.Iter = rt.iterSlice(v9, rt.drop); - const queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_218, "next"))); + const queue: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(rt.iterToArray(_218, "next", 8, true))); const v10: [rt.u32, Guard.Guard][] = []; const _237: [rt.u32, Guard.Guard] = [1, guard(21)]; v10.push(_237); const _243: [rt.u32, Guard.Guard] = [1, guard(22)]; v10.push(_243); const _232: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v10, drop$u32_Guard); - const hashed: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _232, undefined, rt.drop, "fold"); + const hashed: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _232, undefined, rt.drop, "fold", 117440512); const v11: Key.Key[] = []; const _253: Key.Key = key(23); v11.push(_253); const _258: Key.Key = key(23); v11.push(_258); const _248: rt.Iter = rt.iterSlice(v11, rt.drop); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Key.hash$Hash_DefaultHasher, Key.eq$PartialEq)) as rt.HashSet, _248, rt.drop, "fold"); + const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Key.hash$Hash_DefaultHasher, Key.eq$PartialEq)) as rt.HashSet, _248, rt.drop, "fold", 117440512); const _267: rt.usize = queue.n; const _270: rt.usize = rt.hashLen(hashed); const _273: rt.usize = rt.hashLen(set); @@ -469,7 +469,7 @@ export function drained(log: Log.Log, id: rt.u32): void { drop$Option_Key_Guard(first); rt.drop(it); drop$Option_Key_Guard(back); - const keys: Key.Key[] = rt.iterToArray(rt.btreeKeys(tree(5), rt.drop, rt.drop, true), "fold"); + const keys: Key.Key[] = rt.iterToArray(rt.btreeKeys(tree(5), rt.drop, rt.drop, true), "fold", 12, true); const values: rt.Iter = rt.btreeValues(tree(9), rt.drop, rt.drop); const _37: rt.usize = keys.length; const _40: rt.u32 = mapOr$01ozsk3(rt.iterToOption(values.next()), 0, (g: Guard.Guard): rt.u32 => { @@ -600,7 +600,7 @@ export function extended(log: Log.Log, id: rt.u32): void { v2.push(_25); const _30: Guard.Guard = guard(4); v2.push(_30); - rt.iterExtend(list, rt.iterSlice(v2, rt.drop), "fold"); + rt.iterExtend(list, rt.iterSlice(v2, rt.drop), "fold", 8, true); const v3: Guard.Guard[] = []; const _41: Guard.Guard = guard(5); v3.push(_41); @@ -611,7 +611,7 @@ export function extended(log: Log.Log, id: rt.u32): void { const _35: rt.Iter = rt.iterFilter(rt.iterSlice(v3, rt.drop), (g: Guard.Guard): boolean => { return Guard.id(g) !== rt.u32Add(id, 5); }, rt.drop); - rt.iterExtend(list, _35, "next"); + rt.iterExtend(list, _35, "next", 8); const part = list.length; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part, f)]; Log.note(log, rt.fmtFormat(["list ", args2[0]])); @@ -624,7 +624,7 @@ export function extended(log: Log.Log, id: rt.u32): void { v4.push(_83); const _92: [Key.Key, Guard.Guard] = [key(8), guard(10)]; v4.push(_92); - rt.hashExtend(map, rt.iterSlice(v4, drop$Key_Guard), rt.drop, rt.drop, "fold"); + rt.hashExtend(map, rt.iterSlice(v4, drop$Key_Guard), rt.drop, rt.drop, "fold", 58720256); const set: rt.HashSet = rt.hashNew(rt.hashing(Key.hash$Hash_DefaultHasher, Key.eq$PartialEq)) as rt.HashSet; const _102: Key.Key = key(11); rt.hashAdd(set, _102, rt.drop); @@ -633,7 +633,7 @@ export function extended(log: Log.Log, id: rt.u32): void { v5.push(_111); const _116: Key.Key = key(11); v5.push(_116); - rt.hashExtendKeys(set, rt.iterSlice(v5, rt.drop), rt.drop, "fold"); + rt.hashExtendKeys(set, rt.iterSlice(v5, rt.drop), rt.drop, "fold", 117440512); const _125: rt.usize = rt.hashLen(map); const _128: rt.usize = rt.hashLen(set); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_125, f), (f: rt.Formatter) => rt.usizeDisplay(_128, f)]; @@ -667,7 +667,7 @@ export function extended(log: Log.Log, id: rt.u32): void { v8.push(_207); const _212: Guard.Guard = guard(20); v8.push(_212); - rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold"); + rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold", 8, true); const _221: rt.usize = rt.btreeLen(tree); const _224: rt.usize = rt.btreeLen(ordered); const _227: rt.usize = queue.n; diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index 29dfeb4a7..4318f0512 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -17,7 +17,22 @@ import { ByteSlice, type ByteVec, type None, type Place, panic, type RangeBound, rangeCheck } from "../rt.ts"; import type { Hashing } from "./hash.ts"; import { type Limbs, lt } from "./int.ts"; -import { DONE, type Done, Iter, iterMap, iterSlice, type RangeInclusive, rangeInclusiveEndBound, rangeInclusiveStartBound, type Take } from "./iter.ts"; +import { + DONE, + type Done, + exactHint, + Iter, + iterMap, + iterSlice, + type RangeInclusive, + rangeInclusiveEndBound, + rangeInclusiveStartBound, + type SizeHint, + type Take, + vecCapacity, + vecGrow, + vecReserveExact, +} from "./iter.ts"; import { type Arc, drop as dispose, dropAll, dropRange } from "./task.ts"; // Ordering @@ -668,8 +683,8 @@ export class HashIter extends Iter implements Disposable { return this.left; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } [Symbol.dispose](): void { @@ -742,10 +757,42 @@ function extending(c: C, items: Iter, add: (item: T) => void, take?: Ta } /** - * `extend` of a map with `[key, value]`s, and `collect` into one through `hashNew`. Of - * equal keys, the first stays and each later one drops, then the value it replaced. + * `extending` a `Vec` or `VecDeque` holding `len`, which with elements `size` bytes each + * reserves as `iterExtend` does: a `trusted` iterator up front, and any other by `next`. */ -export function hashExtend(m: HashMap, items: Iter<[K, V]>, k?: (key: K) => void, v?: (value: V) => void, take?: Take): HashMap { +function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false): C { + if (size === undefined || trusted) { + if (size !== undefined) vecReserveExact(items, len, size); + return extending(c, items, add, take); + } + let cap = vecCapacity(len, size); + for (let item = items.next(); item !== DONE; item = items.next()) { + if (len === cap) cap = vecGrow(items, cap, size); + add(item); + len++; + } + if (take !== undefined) dispose(items); + return c; +} + +/** + * hashbrown's reserve before it extends `m` by `items`: the lower bound, or half of it + * rounded up if `m` holds any, which panics past `max` entries, the most its table holds. + */ +function hashReserve(m: HashMap, items: Iter, max: number | undefined): void { + if (max === undefined) return; + const lower = items.sizeHint()[0]; + const n = hashLen(m); + if (n + (n === 0 ? lower : Math.ceil(lower / 2)) > max) panic("Hash table capacity overflow"); +} + +/** + * `extend` of a map with `[key, value]`s, and `collect` into one through `hashNew`, which + * reserves first as `hashReserve` does. Of equal keys, the first stays and each later one + * drops, then the value it replaced. + */ +export function hashExtend(m: HashMap, items: Iter<[K, V]>, k?: (key: K) => void, v?: (value: V) => void, take?: Take, max?: number): HashMap { + hashReserve(m, items, max); const add = (item: [K, V]) => { const old = hashInsert(m, item[0], item[1], k); if (old !== undefined) v?.(old); @@ -754,7 +801,8 @@ export function hashExtend(m: HashMap, items: Iter<[K, V]>, k?: (key } /** `extend` of a set with keys, and `collect` into one, as `hashExtend`: a key already there drops. */ -export function hashExtendKeys(m: HashSet, keys: Iter, k?: (key: K) => void, take?: Take): HashSet { +export function hashExtendKeys(m: HashSet, keys: Iter, k?: (key: K) => void, take?: Take, max?: number): HashSet { + hashReserve(m, keys, max); return extending(m, keys, (key) => hashAdd(m, key, k), take); } @@ -1325,9 +1373,9 @@ export class BTreeIter extends Iter implements Disposable { return this.n; } - override lower(): number { - // A range's count is unknown, and std's hint of one is 0. - return Math.max(this.n, 0); + override sizeHint(): SizeHint { + // A range's count is unknown, and std's hint of one is `(0, None)`. + return this.n < 0 ? [0, undefined] : exactHint(this.n); } [Symbol.dispose](): void { @@ -1472,7 +1520,8 @@ function edge(m: BTreeMap, key: K, past: boolean): [Leaf, numb * `extend` of a map with `[key, value]`s, which keeps an equal key already there and drops * the one given, then the value it replaced, and takes `items` as `take` says. With * `last`, `collect` and `from` of entries that drop nothing into an empty one, which keep - * the last of equal keys, as `btreeCollect` does. + * the last of equal keys, as `btreeCollect` does, and reserve as the `Vec` of `size`-byte + * entries std's collects into first does, as `iterExtend`. */ export function btreeExtend( m: BTreeMap, @@ -1481,6 +1530,8 @@ export function btreeExtend( k?: (key: K) => void, v?: (value: V) => void, take?: Take, + size?: number, + trusted = false, ): BTreeMap { const add = (item: [K, V]) => { if (!last) { @@ -1496,11 +1547,11 @@ export function btreeExtend( l.v[i] = item[1]; } }; - return extending(m, items, add, take); + return vecExtending(m, 0, items, add, take, size, trusted); } /** `extend` of a set with keys, and with `last`, `collect` and `from`, as `btreeExtend`. */ -export function btreeExtendKeys(m: BTreeSet, keys: Iter, last = false, k?: (key: K) => void, take?: Take): BTreeSet { +export function btreeExtendKeys(m: BTreeSet, keys: Iter, last = false, k?: (key: K) => void, take?: Take, size?: number, trusted = false): BTreeSet { const add = (key: K) => { if (!last) { btreeAdd(m, key, k); @@ -1511,7 +1562,7 @@ export function btreeExtendKeys(m: BTreeSet, keys: Iter, last = false, if (i < 0) insertAt(m, l, ~i, key, undefined); else l.k[i] = key; }; - return extending(m, keys, add, take); + return vecExtending(m, 0, keys, add, take, size, trusted); } /** @@ -1943,8 +1994,8 @@ class DequeIter extends Iter implements Disposable { return this.back - this.front; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } [Symbol.dispose](): void { @@ -1995,8 +2046,8 @@ class DequePlaces extends Iter> { return this.back - this.front; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } } @@ -2109,8 +2160,8 @@ class VecDrain extends Iter implements Disposable { return this.back - this.front; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } [Symbol.dispose](): void { @@ -2162,8 +2213,8 @@ class ByteVecDrain extends Iter implements Disposable { return this.back - this.front; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } [Symbol.dispose](): void { @@ -2174,9 +2225,12 @@ class ByteVecDrain extends Iter implements Disposable { } } -/** `extend`, and `collect` into a deque through `dequeNew`, which takes `items` as `take` says. */ -export function dequeExtend(q: VecDeque, items: Iter, take?: Take): VecDeque { - return extending(q, items, (item) => dequePushBack(q, item), take); +/** + * `extend`, and `collect` into a deque through `dequeNew`, which takes `items` as `take` + * says and reserves as `iterExtend` does. + */ +export function dequeExtend(q: VecDeque, items: Iter, take?: Take, size?: number, trusted = false): VecDeque { + return vecExtending(q, q.n, items, (item) => dequePushBack(q, item), take, size, trusted); } /** `clone`, with each item through its `Clone`, or as itself without one. */ @@ -2254,10 +2308,13 @@ export function heapAppend(h: BinaryHeap, other: BinaryHeap, le: Test(h: BinaryHeap, items: Iter, le: Test, ge: Test, lt: Test, take?: Take): BinaryHeap { +/** + * `extend`, taking `items` as `take` says and reserving as its `Vec`'s `iterExtend` does, + * and then the heap rebuilt past what it held. + */ +export function heapExtend(h: BinaryHeap, items: Iter, le: Test, ge: Test, lt: Test, take?: Take, size?: number, trusted = false): BinaryHeap { const start = h.d.length; - extending(h, items, (item) => h.d.push(item), take); + vecExtending(h, start, items, (item) => h.d.push(item), take, size, trusted); rebuildTail(h.d, start, le, ge, lt); return h; } diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index d36d6e346..7f968dd75 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -41,6 +41,26 @@ function satAdd(a: number, b: number): number { return Math.min(a + b, USIZE_MAX); } +/** `a + b` of two upper bounds: `None` if either is, or if it passes `usize::MAX`, as std's `checked_add`. */ +function addUpper(a: number | undefined, b: number | undefined): number | undefined { + if (a === undefined || b === undefined) return undefined; + const sum = a + b; + return sum > USIZE_MAX ? undefined : sum; +} + +/** `Iterator::size_hint`: at least `lower` items, and at most `upper`, if it is known. */ +export type SizeHint = [lower: number, upper: number | undefined]; + +/** The size hint of an iterator that knows it has exactly `n` items. */ +export function exactHint(n: number): SizeHint { + return [n, n]; +} + +/** std's hint of an adaptor that may yield fewer than `it`, and no more: none at least, and `it`'s upper bound. */ +function fewer(it: Iter): SizeHint { + return [0, it.sizeHint()[1]]; +} + /** * What only the iterators std implements these traits for have, which Rust calls only * there: declared, not stubbed, so no bundle carries a stub. @@ -92,13 +112,9 @@ export abstract class Iter implements Iterable { return this; } - /** - * `size_hint`'s lower bound, which std's `String` reserves before it reads chars: exact - * for a range and what adapts one, the only iterators whose bound reaches `isize::MAX`, - * and else 0. - */ - lower(): number { - return 0; + /** `size_hint`, as std's of its kind gives it: `(0, None)` unless it knows better. */ + sizeHint(): SizeHint { + return [0, undefined]; } /** @@ -372,8 +388,63 @@ export function iterBorrow(it: Iter): Iter { return new Borrowed(it); } -/** `Extend::extend` of a `Vec`, which takes `items` as `take` says. */ -export function iterExtend(v: T[], items: Iter, take?: Take): void { +// How std's `Vec` and `VecDeque` reserve for an iterator they collect or extend by, of +// elements `size` bytes each, which panics past what they may hold: a `TrustedLen` one's +// upper bound first, and else, after each item that finds them full, the lower bound and +// one more. Their capacity is not modeled, so one they extend is taken as full, as one +// holding nothing is, and grows as std's would from there. + +/** wasm32's `isize::MAX`, the most bytes std's `Layout` describes. */ +const ISIZE_MAX = 0x7fffffff; + +/** How many `size`-byte elements a `Vec` holds at most: `usize::MAX` of zero-sized ones. */ +function vecMax(size: number): number { + return size === 0 ? USIZE_MAX : Math.floor(ISIZE_MAX / size); +} + +/** + * std's reserve for a `TrustedLen` iterator `it`, in a `Vec` or `VecDeque` holding `len` + * of `size`-byte elements: its upper bound, which panics without one or past what it may + * hold. + */ +export function vecReserveExact(it: Iter, len: number, size: number): void { + const upper = it.sizeHint()[1]; + if (upper === undefined || len + upper > vecMax(size)) panic("capacity overflow"); +} + +/** The capacity of a `Vec` or `VecDeque` holding `len` of `size`-byte elements: full, but for zero-sized ones. */ +export function vecCapacity(len: number, size: number): number { + return size === 0 ? USIZE_MAX : len; +} + +/** + * The capacity a full `Vec` or `VecDeque` of `cap` `size`-byte elements grows to as it + * reserves for the next item of `it`, as std's `RawVec` amortizes it, or a panic past what + * it may hold. + */ +export function vecGrow(it: Iter, cap: number, size: number): number { + const additional = satAdd(it.sizeHint()[0], 1); + const grown = Math.max(cap * 2, cap + additional, size === 1 ? 8 : size <= 1024 ? 4 : 1); + if (grown > vecMax(size)) panic("capacity overflow"); + return grown; +} + +/** + * `Extend::extend` of a `Vec`, which takes `items` as `take` says, and with elements + * `size` bytes each, reserves as std's does for a `trusted`, `TrustedLen`, iterator or any + * other. + */ +export function iterExtend(v: T[], items: Iter, take?: Take, size?: number, trusted = false): void { + if (size !== undefined && !trusted) { + let cap = vecCapacity(v.length, size); + for (let item = items.next(); item !== DONE; item = items.next()) { + if (v.length === cap) cap = vecGrow(items, cap, size); + v.push(item); + } + if (take !== undefined) dispose(items); + return; + } + if (size !== undefined) vecReserveExact(items, v.length, size); if (take === undefined) { const folded = items.folded(); for (let item = folded.next(); item !== DONE; item = folded.next()) v.push(item); @@ -382,8 +453,18 @@ export function iterExtend(v: T[], items: Iter, take?: Take): void { each(items, (item) => v.push(item), take); } -/** `Extend::extend` of a `Vec`. */ -export function iterExtendBytes(v: ByteVec, items: Iter, take?: Take): void { +/** `Extend::extend` of a `Vec`, reserving as `iterExtend` does. */ +export function iterExtendBytes(v: ByteVec, items: Iter, take?: Take, trusted = false): void { + if (!trusted) { + let cap = v.length; + for (let item = items.next(); item !== DONE; item = items.next()) { + if (v.length === cap) cap = vecGrow(items, cap, 1); + byteVecPush(v, item); + } + if (take !== undefined) dispose(items); + return; + } + vecReserveExact(items, v.length, 1); if (take === undefined) { const folded = items.folded(); for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(v, item); @@ -501,22 +582,24 @@ export function iterPeekable(it: Iter, drop?: Drop): Peekable { /** * `flat_map`: `into` makes each of `f`'s results an iterator, as `IntoIterator` does. Its - * source drops once it ends unless it is `fused`, as `fuse` does. + * 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) => U, into?: (value: U) => Iter, fused?: boolean, size?: number): Iter; -export function iterFlatMap(it: Iter, f: (item: T) => U, into?: (value: U) => Iter, fused = false, size?: number): Iter { - return new FlattenIter(new MapIter(it, f), into ?? (itself as (value: U) => Iter), fused, size); +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); } /** * `flatten`: `into` makes each item an iterator, as `IntoIterator` does, `fused` is as - * `flat_map`'s, and `size` is each item's length if it is an array. + * `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?: (value: T) => Iter, fused?: boolean, size?: number): Iter; -export function iterFlatten(it: Iter, into?: (value: T) => Iter, fused = false, size?: number): Iter { - return new FlattenIter(it, into ?? (itself as (value: T) => Iter), fused, size); +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); } // Consumers. Each that takes an iterator by value that `drops` takes it as std's does: by @@ -813,9 +896,19 @@ export function iterIsSortedBy( return sorted; } -/** `collect` into a `Vec`, taking `it` as `take` says. */ -export function iterToArray(it: Iter, take?: Take): T[] { +/** `collect` into a `Vec`, as `iterExtend` of an empty one. */ +export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { const out: T[] = []; + if (size !== undefined && !trusted) { + let cap = vecCapacity(0, size); + for (let item = it.next(); item !== DONE; item = it.next()) { + if (out.length === cap) cap = vecGrow(it, cap, size); + out.push(item); + } + if (take !== undefined) dispose(it); + return out; + } + if (size !== undefined) vecReserveExact(it, 0, size); if (take === undefined) { const folded = it.folded(); for (let item = folded.next(); item !== DONE; item = folded.next()) out.push(item); @@ -825,10 +918,20 @@ export function iterToArray(it: Iter, take?: Take): T[] { return out; } -/** `collect` into a `Vec`, taking `it` as `take` says. */ -export function iterToByteVec(it: Iter, take?: Take): ByteVec { +/** `collect` into a `Vec`, as `iterExtendBytes` of an empty one. */ +export function iterToByteVec(it: Iter, take?: Take, trusted = false): ByteVec { const out = new ByteVec(); - // Its own loop: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. + // Its own loops: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. + if (!trusted) { + let cap = 0; + for (let item = it.next(); item !== DONE; item = it.next()) { + if (out.length === cap) cap = vecGrow(it, cap, 1); + byteVecPush(out, item); + } + if (take !== undefined) dispose(it); + return out; + } + vecReserveExact(it, 0, 1); if (take === undefined) { const folded = it.folded(); for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(out, item); @@ -1067,8 +1170,8 @@ class SliceIter extends Iter implements Disposable { return this.back - this.front; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } [Symbol.dispose](): void { @@ -1120,8 +1223,8 @@ class SliceMutIter extends Iter> { return this.back - this.front; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } override advanceBy(n: number): number { @@ -1194,8 +1297,8 @@ class PartsIter extends Iter { return this.back - this.front; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } override advanceBy(n: number): number { @@ -1240,8 +1343,8 @@ class OptionIter extends Iter implements Disposable { return this.some ? 1 : 0; } - override lower(): number { - return this.len(); + override sizeHint(): SizeHint { + return exactHint(this.len()); } [Symbol.dispose](): void { @@ -1299,8 +1402,8 @@ class SuccessorsIter extends Iter implements Disposable { return item as T; } - override lower(): number { - return this.item === this.none ? 0 : 1; + override sizeHint(): SizeHint { + return this.item === this.none ? [0, 0] : [1, undefined]; } [Symbol.dispose](): void { @@ -1325,8 +1428,8 @@ class Borrowed extends Iter { this.inner = inner; } - override lower(): number { - return this.inner.lower(); + override sizeHint(): SizeHint { + return this.inner.sizeHint(); } next(): T | Done { @@ -1368,8 +1471,8 @@ class MapIter extends Calling U> { super(inner, f); } - override lower(): number { - return this.inner.lower(); + override sizeHint(): SizeHint { + return this.inner.sizeHint(); } next(): U | Done { @@ -1429,6 +1532,10 @@ class FilterIter extends Calling boolean> { return findItem(this.inner, this.f, this.drop); } + override sizeHint(): SizeHint { + return fewer(this.inner); + } + override nextBack(): T | Done { return rfindItem(this.inner, this.f, this.drop); } @@ -1470,6 +1577,10 @@ class FilterMapIter extends Calling U | undefined | Non return DONE; } + override sizeHint(): SizeHint { + return fewer(this.inner); + } + override nextBack(): U | Done { for (let item = this.inner.nextBack(); item !== DONE; item = this.inner.nextBack()) { const mapped = this.f(item); @@ -1497,8 +1608,8 @@ class FilterMapIter extends Calling U | undefined | Non class EnumerateIter extends Adaptor { index = 0; - override lower(): number { - return this.inner.lower(); + override sizeHint(): SizeHint { + return this.inner.sizeHint(); } next(): [number, T] | Done { @@ -1579,8 +1690,12 @@ class ChainIter extends Iter implements Disposable { dispose(b); } - override lower(): number { - return satAdd(this.a?.lower() ?? 0, this.b?.lower() ?? 0); + override sizeHint(): SizeHint { + const { a, b } = this; + if (a === undefined || b === undefined) return a?.sizeHint() ?? b?.sizeHint() ?? [0, 0]; + const [aLower, aUpper] = a.sizeHint(); + const [bLower, bUpper] = b.sizeHint(); + return [satAdd(aLower, bLower), addUpper(aUpper, bUpper)]; } next(): T | Done { @@ -1715,8 +1830,12 @@ class ZipIter extends Iter<[A, B]> implements Disposable { return Math.min(this.a.len(), this.b.len()); } - override lower(): number { - return Math.min(this.a.lower(), this.b.lower()); + /** std's: the shorter side's, where either knows its upper bound. */ + override sizeHint(): SizeHint { + const [aLower, aUpper] = this.a.sizeHint(); + const [bLower, bUpper] = this.b.sizeHint(); + const upper = aUpper === undefined || bUpper === undefined ? (aUpper ?? bUpper) : Math.min(aUpper, bUpper); + return [Math.min(aLower, bLower), upper]; } [Symbol.dispose](): void { @@ -1750,11 +1869,15 @@ class TrustedZipIter extends ZipIter { override len(): number { return this.end - this.index; } + + override sizeHint(): SizeHint { + return exactHint(this.len()); + } } class RevIter extends Adaptor { - override lower(): number { - return this.inner.lower(); + override sizeHint(): SizeHint { + return this.inner.sizeHint(); } next(): T | Done { @@ -1805,8 +1928,9 @@ class SkipIter extends Adaptor { this.drop = drop; } - override lower(): number { - return Math.max(this.inner.lower() - this.n, 0); + override sizeHint(): SizeHint { + const [lower, upper] = this.inner.sizeHint(); + return [Math.max(lower - this.n, 0), upper === undefined ? undefined : Math.max(upper - this.n, 0)]; } next(): T | Done { @@ -1893,8 +2017,10 @@ class TakeIter extends Adaptor { this.drop = drop; } - override lower(): number { - return this.n === 0 ? 0 : Math.min(this.inner.lower(), this.n); + override sizeHint(): SizeHint { + if (this.n === 0) return [0, 0]; + const [lower, upper] = this.inner.sizeHint(); + return [Math.min(lower, this.n), Math.min(upper ?? this.n, this.n)]; } next(): T | Done { @@ -1996,6 +2122,10 @@ class SkipWhileIter extends Calling boolean> { ); } + override sizeHint(): SizeHint { + return fewer(this.inner); + } + /** std's: its first item by `next`, and then its iterator's fold, after which `f` drops. */ override fold(acc: A, f: (acc: A, item: T) => A, release?: () => void): A { if (!this.flag) { @@ -2028,6 +2158,10 @@ class TakeWhileIter extends Calling boolean> { this.drop?.(item); return DONE; } + + override sizeHint(): SizeHint { + return this.flag ? [0, 0] : fewer(this.inner); + } } /** `MapWhile`, which reads on after `f` returns `None` if called again, as std's does. */ @@ -2044,6 +2178,10 @@ class MapWhileIter extends Calling U | undefined | None const item = this.inner.next(); return item === DONE ? DONE : iterFromOption(this.f(item), this.none); } + + override sizeHint(): SizeHint { + return fewer(this.inner); + } } /** `StepBy`, whose items drop by `drop` as its iterator's own `nth` and `nth_back` step over them. */ @@ -2079,8 +2217,9 @@ class StepByIter extends Adaptor { return this.size(this.inner.len()); } - override lower(): number { - return this.size(this.inner.lower()); + override sizeHint(): SizeHint { + const [lower, upper] = this.inner.sizeHint(); + return [this.size(lower), upper === undefined ? undefined : this.size(upper)]; } /** How many of `n` items it yields. */ @@ -2151,8 +2290,8 @@ class StepByIter extends Adaptor { } class InspectIter extends Calling void> { - override lower(): number { - return this.inner.lower(); + override sizeHint(): SizeHint { + return this.inner.sizeHint(); } next(): T | Done { @@ -2203,8 +2342,8 @@ class FuseIter extends Iter implements Disposable { this.fused = fused; } - override lower(): number { - return this.inner?.lower() ?? 0; + override sizeHint(): SizeHint { + return this.inner?.sizeHint() ?? [0, 0]; } /** `item`, dropping its iterator first if it ended there and is not fused. */ @@ -2270,22 +2409,40 @@ class FlattenIter extends Iter implements Disposable { readonly fused: boolean; /** How many items each of its source's has, if each is an array. */ readonly size: number | undefined; + /** Whether each of its source's items makes an iterator of at most one item. */ + readonly oneShot: boolean; front: Iter | undefined; back: Iter | undefined; - constructor(outer: Iter, into: (value: T) => Iter, fused: boolean, size?: number) { + constructor(outer: Iter, into: (value: T) => Iter, fused: boolean, size?: number, oneShot = false) { super(); this.outer = outer; this.into = into; this.fused = fused; this.size = size; + this.oneShot = oneShot; } - /** std's: what its front and back hold, and its source's arrays, if it knows their size. */ - override lower(): number { - const held = satAdd(this.front?.lower() ?? 0, this.back?.lower() ?? 0); - if (this.size === undefined) return held; - return satAdd((this.outer?.lower() ?? 0) * this.size, held); + /** + * std's: what its front and back hold, and its source's items, if it knows how many + * each has. Of items that hold at most one, only its source's, which std never holds + * the iterator of. + */ + override sizeHint(): SizeHint { + const [lower, upper] = this.outer?.sizeHint() ?? [0, 0]; + if (this.oneShot) { + if (this.size === 0) return [0, 0]; + return this.size === 1 ? [lower, upper] : [0, upper]; + } + const [frontLower, frontUpper] = this.front?.sizeHint() ?? [0, 0]; + const [backLower, backUpper] = this.back?.sizeHint() ?? [0, 0]; + const held = satAdd(frontLower, backLower); + const heldUpper = addUpper(frontUpper, backUpper); + if (this.size !== undefined) { + const all = upper === undefined || upper * this.size > USIZE_MAX ? undefined : upper * this.size; + return [satAdd(lower * this.size, held), addUpper(heldUpper, all)]; + } + return [held, lower === 0 && upper === 0 ? heldUpper : undefined]; } /** The source's next item, or `DONE`, which drops it unless it is fused. */ @@ -2458,9 +2615,11 @@ export class Peekable extends Adaptor { } /** std's: none past a peeked end, and one more than its iterator's for a peeked item. */ - override lower(): number { - if (!this.peeked) return this.inner.lower(); - return this.item === DONE ? 0 : satAdd(this.inner.lower(), 1); + override sizeHint(): SizeHint { + if (!this.peeked) return this.inner.sizeHint(); + if (this.item === DONE) return [0, 0]; + const [lower, upper] = this.inner.sizeHint(); + return [satAdd(lower, 1), addUpper(upper, 1)]; } next(): T | Done { @@ -2581,6 +2740,10 @@ class ResultShunt extends Adaptor, U> { this.error = { value: item.error }; return DONE; } + + override sizeHint(): SizeHint { + return this.error === undefined ? fewer(this.inner) : [0, 0]; + } } /** What `iterCollectOption` collects from: values until the first `None`. */ @@ -2595,6 +2758,10 @@ class OptionShunt extends Adaptor { this.none = true; return DONE; } + + override sizeHint(): SizeHint { + return this.none ? [0, 0] : fewer(this.inner); + } } /** `a < b` of two integers of one type, or two booleans. */ @@ -2615,11 +2782,10 @@ function step(n: T, by: number, int: Step | undefined): T | undefined { return over ? undefined : sum; } -/** std's `Step::steps_between` of `a` and `b`, at most `b`, saturating at `usize::MAX`. */ -function stepsBetween(a: T, b: T): number { - if (typeof a === "number" && typeof b === "number") return Math.min(b - a, USIZE_MAX); - const n = intToBig(b as number | Limbs) - intToBig(a as number | Limbs); - return n < USIZE_MAX ? Number(n) : USIZE_MAX; +/** std's `Step::steps_between` of `a` and `b`, at most `b`: `(usize::MAX, None)` past `usize::MAX`. */ +function stepsBetween(a: T, b: T): SizeHint { + const n = typeof a === "number" && typeof b === "number" ? b - a : intToBig(b as number | Limbs) - intToBig(a as number | Limbs); + return n <= USIZE_MAX ? exactHint(Number(n)) : [USIZE_MAX, undefined]; } /** @@ -2677,8 +2843,8 @@ export class Range extends Iter { return lt(this.start, this.end) ? Number(this.end) - Number(this.start) : 0; } - override lower(): number { - return lt(this.start, this.end) ? stepsBetween(this.start, this.end) : 0; + override sizeHint(): SizeHint { + return lt(this.start, this.end) ? stepsBetween(this.start, this.end) : [0, 0]; } } @@ -2735,8 +2901,10 @@ export class RangeInclusive extends Iter { return rangeInclusiveIsEmpty(this) ? 0 : Number(this.hi) - Number(this.lo) + 1; } - override lower(): number { - return rangeInclusiveIsEmpty(this) ? 0 : satAdd(stepsBetween(this.lo, this.hi), 1); + override sizeHint(): SizeHint { + if (rangeInclusiveIsEmpty(this)) return [0, 0]; + const [lower, upper] = stepsBetween(this.lo, this.hi); + return [satAdd(lower, 1), addUpper(upper, 1)]; } /** std's `nth`: `start` moves past the item, wrapping if it overflows, which ends the range. */ @@ -2777,6 +2945,10 @@ class RangeInclusiveFold extends Iter { else r.exhausted = true; return lo; } + + override sizeHint(): SizeHint { + return this.range.sizeHint(); + } } /** `RangeInclusive::start`. */ diff --git a/ts/runtime/rt/str.ts b/ts/runtime/rt/str.ts index 3b375fcaa..fc1371771 100644 --- a/ts/runtime/rt/str.ts +++ b/ts/runtime/rt/str.ts @@ -9,7 +9,7 @@ import { fmtCharDebug, type Place, panic, panicFmt, stringLen } from "../rt.ts"; import { type Bounds, boundsRange } from "./collections.ts"; import type { char, u8, usize } from "./int.ts"; -import { DONE, type Done, Iter, iterForEach, iterSlice } from "./iter.ts"; +import { DONE, type Done, Iter, iterForEach, iterSlice, type SizeHint } from "./iter.ts"; import { drop as dispose } from "./task.ts"; const encoder = /* @__PURE__ */ new TextEncoder(); @@ -121,9 +121,10 @@ class Chars extends Iter { return this.#s.codePointAt(this.#back) as char; } - /** std's: a char per four bytes of what is left. */ - override lower(): number { - return Math.ceil(utf8Len(this.#s, this.#front, this.#back) / 4); + /** std's: a char per four bytes of what is left, and at most one per byte. */ + override sizeHint(): SizeHint { + const bytes = utf8Len(this.#s, this.#front, this.#back); + return [Math.ceil(bytes / 4), bytes]; } /** `as_str`: what is left. */ @@ -470,7 +471,7 @@ export function stringSplitOff(s: string, i: usize): [string, string] { * char, once it reserved the iterator's lower bound, which panics past `isize::MAX`. */ export function stringExtendChars(s: string, it: Iter, drops = false): string { - stringReserve(s, it.lower()); + stringReserve(s, it.sizeHint()[0]); iterForEach( it, (c) => { diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index c75ed2909..521485bb2 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -673,6 +673,7 @@ fn hash_extend<'tcx>( let mut droppers = entry_droppers(b, coll, span); // By `for_each`. droppers.push(super::iter::iter_take(b, iter, true, span)); + droppers.push(hash_max(b, coll, span)); let f = match b.t.std_of(coll) { Some(Std::HashSet) => "hashExtendKeys", _ => "hashExtend", @@ -680,6 +681,51 @@ fn hash_extend<'tcx>( Expr::rt(f, super::iter::tail(vec![target, source], droppers)) } +/// The most entries a hash collection of type `coll` holds on wasm32, past which hashbrown's +/// `reserve` panics: what its table of `(K, V)`, or `(K, ())`, takes as `capacity_to_buckets` +/// and `calculate_layout_for` allow, with 8-byte groups. +fn hash_max<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Expr { + let (size, align) = match super::iter::layout(b, stored(b, coll), span) { + Ok(layout) => layout, + Err(e) => return e, + }; + const GROUP: u64 = 8; + let ctrl_align = align.max(GROUP); + let fits = |cap: u64| -> bool { + if cap == 0 { + return true; + } + let buckets = if cap < 15 { + let cap = cap.max(if size <= 1 { 7 } else { 3 }); + if cap < 4 { + 4 + } else if cap < 8 { + 8 + } else { + 16 + } + } else { + match cap.checked_mul(8).filter(|&n| n <= u64::from(u32::MAX)) { + Some(n) => (n / 7).next_power_of_two(), + None => return false, + } + }; + let len = (size * buckets).div_ceil(ctrl_align) * ctrl_align + buckets + GROUP; + len <= u64::from(i32::MAX as u32) - (ctrl_align - 1) + }; + // The greatest capacity that fits, of which every smaller one does. + let (mut lo, mut hi) = (0, u64::from(u32::MAX)); + while lo < hi { + let mid = lo + (hi - lo).div_ceil(2); + if fits(mid) { + lo = mid; + } else { + hi = mid - 1; + } + } + Expr::lit(lo.to_string()) +} + /// An empty hash collection of type `coll`, which finds its keys as their type needs. fn hash_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Option { let key = arg(coll, 0); @@ -949,7 +995,8 @@ fn btree<'tcx>( } ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; - btree_collect(b, coll, source, iter, span) + let trusted = super::iter::implements(b.t, iter, "TrustedLen"); + btree_collect(b, coll, source, iter, trusted, span) } _ => return None, }; @@ -959,8 +1006,16 @@ fn btree<'tcx>( /// `collect` and `from` into an empty B-tree of type `coll`, from `source`, an iterator of /// type `iter`, which keep the last of equal keys, as std's sorted bulk build does. Of /// entries that drop, std's collects into a `Vec` first, and then drops each but the last -/// of equal keys in the order a stable sort leaves them. -fn btree_collect<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, source: Expr, iter: Ty<'tcx>, span: Span) -> Expr { +/// of equal keys in the order a stable sort leaves them. The `Vec` reserves as for a +/// `TrustedLen` iterator if `trusted`. +fn btree_collect<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + coll: Ty<'tcx>, + source: Expr, + iter: Ty<'tcx>, + trusted: bool, + span: Span, +) -> Expr { let set = b.t.std_of(coll) == Some(Std::BTreeSet); let target = btree_new(b, coll, span); let key = arg(coll, 0); @@ -972,6 +1027,8 @@ fn btree_collect<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, source: Expr, // Into a `Vec` first. let folds = super::iter::implements(b.t, iter, "TrustedLen"); droppers.push(super::iter::iter_take(b, iter, folds, span)); + droppers.push(super::iter::size_of(b, stored(b, coll), span)); + droppers.push(Expr::lit(trusted.to_string())); let f = if set { "btreeExtendKeys" } else { "btreeExtend" }; return Expr::rt(f, super::iter::tail(vec![target, source], droppers)); } @@ -984,7 +1041,7 @@ fn btree_collect<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, source: Expr, ), ); } - let entries = super::iter::to_array(b, source, iter, stored(b, coll), span); + let entries = super::iter::to_array(b, source, iter, stored(b, coll), trusted, span); let droppers = entry_droppers(b, coll, span); let f = if set { "btreeCollectKeys" } else { "btreeCollect" }; Expr::rt(f, super::iter::tail(vec![target, entries], droppers)) @@ -1102,10 +1159,15 @@ fn deque<'tcx>( "From" => deque_new(b, coll, span), _ => values.pop()?, }; - // Of a `TrustedLen` iterator, by `for_each`. - let folds = super::iter::implements(b.t, iter, "TrustedLen"); - let take = super::iter::iter_take(b, iter, folds, span); - Expr::rt("dequeExtend", super::iter::tail(vec![target, source], vec![take])) + // Of a `TrustedLen` iterator, by `for_each`, reserving its upper bound first. + let trusted = super::iter::implements(b.t, iter, "TrustedLen"); + let take = super::iter::iter_take(b, iter, trusted, span); + let reserve = vec![ + take, + super::iter::size_of(b, item, span), + Expr::lit(trusted.to_string()), + ]; + Expr::rt("dequeExtend", super::iter::tail(vec![target, source], reserve)) } _ => return None, }; @@ -1194,19 +1256,24 @@ fn heap<'tcx>( } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; + let trusted = super::iter::implements(b.t, iter, "TrustedLen"); if owner == "From" { - let d = super::iter::to_array(b, source, iter, item, span); + let d = super::iter::to_array(b, source, iter, item, trusted, span); return Some(Expr::rt( "heapFrom", [vec![d], heap_tests(b, item, true, span)].concat(), )); } - // Into its vector, of a `TrustedLen` iterator by `for_each`. - let folds = super::iter::implements(b.t, iter, "TrustedLen"); - let take = super::iter::iter_take(b, iter, folds, span); + // Into its vector, of a `TrustedLen` iterator by `for_each`, reserving as it does. + let take = super::iter::iter_take(b, iter, trusted, span); let mut args = vec![values.pop()?, source]; args.extend(heap_tests(b, item, true, span)); - Expr::rt("heapExtend", super::iter::tail(args, vec![take])) + let reserve = vec![ + take, + super::iter::size_of(b, item, span), + Expr::lit(trusted.to_string()), + ]; + Expr::rt("heapExtend", super::iter::tail(args, reserve)) } _ => return None, }; @@ -1768,19 +1835,27 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp }) } -/// `collect` into a collection of type `ty` from `iter`, an iterator of type `from`. -pub fn collect<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, iter: Expr, from: Ty<'tcx>, span: Span) -> Option { +/// `collect` into a collection of type `ty` from `iter`, an iterator of type `from`, which +/// std's reserves for as it does a `TrustedLen` one if `trusted`. +pub fn collect<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + ty: Ty<'tcx>, + iter: Expr, + from: Ty<'tcx>, + trusted: bool, + span: Span, +) -> Option { let std = b.t.std_of(ty)?; Some(match std { Std::HashMap | Std::HashSet => { let target = hash_new(b, ty, span)?; hash_extend(b, ty, target, iter, from, span) } - Std::BTreeMap | Std::BTreeSet => btree_collect(b, ty, iter, from, span), + Std::BTreeMap | Std::BTreeSet => btree_collect(b, ty, iter, from, trusted, span), // std's collects into a `Vec`, and rebuilds it in place. Std::BinaryHeap => { let item = arg(ty, 0); - let d = super::iter::to_array(b, iter, from, item, span); + let d = super::iter::to_array(b, iter, from, item, trusted, span); Expr::rt("heapFrom", [vec![d], heap_tests(b, item, true, span)].concat()) } // std's collects into a `Vec` first. @@ -1790,9 +1865,14 @@ pub fn collect<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, iter: Expr, from: if !b.t.drops(item) { let folds = super::iter::implements(b.t, from, "TrustedLen"); let take = super::iter::iter_take(b, from, folds, span); - Expr::rt("dequeExtend", super::iter::tail(vec![target, iter], vec![take])) + let reserve = vec![ + take, + super::iter::size_of(b, item, span), + Expr::lit(trusted.to_string()), + ]; + Expr::rt("dequeExtend", super::iter::tail(vec![target, iter], reserve)) } else { - let items = super::iter::to_array(b, iter, from, item, span); + let items = super::iter::to_array(b, iter, from, item, trusted, span); Expr::rt("dequeExtend", vec![target, Expr::rt("iterSlice", vec![items])]) } } diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 55c086758..315d3740f 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -334,7 +334,8 @@ pub fn call<'tcx>( let source = targ(2)?; let iter = iter_of(b.t, source)?; let items = into_iter(b, source, args.pop()?, span)?; - return collect(b, targ(0)?, targ(1)?, items, iter, span); + let trusted = implements(b.t, iter, "TrustedLen"); + return collect(b, targ(0)?, targ(1)?, items, iter, trusted, span); } // `Vec::extend` with an iterator, which it drops once done. @@ -355,13 +356,17 @@ pub fn call<'tcx>( { items = Expr::rt("iterMap", vec![items, copy]); } - let extend = match vec_args.type_at(0).kind() { - ty::Uint(ty::UintTy::U8) => "iterExtendBytes", - _ => "iterExtend", + // Of a `TrustedLen` iterator, by `for_each`, and reserving its upper bound first. + let trusted = implements(b.t, iter, "TrustedLen"); + let take = iter_take(b, iter, trusted, span); + let (extend, reserve) = match vec_args.type_at(0).kind() { + ty::Uint(ty::UintTy::U8) => ("iterExtendBytes", vec![take, Expr::lit(trusted.to_string())]), + _ => { + let size = size_of(b, vec_args.type_at(0), span); + ("iterExtend", vec![take, size, Expr::lit(trusted.to_string())]) + } }; - // Of a `TrustedLen` iterator, by `for_each`. - let take = iter_take(b, iter, implements(b.t, iter, "TrustedLen"), span); - return Some(Expr::rt(extend, tail(vec![v, items], vec![take]))); + return Some(Expr::rt(extend, tail(vec![v, items], reserve))); } let self_ty = match (owner, name) { @@ -469,8 +474,9 @@ pub fn call<'tcx>( let drops = iter_drops(b, self_ty, span); method(name, tail(vec![int.func(op), int.lit(unit)], vec![drops])) } - // `ExactSizeIterator::len` is each iterator's own. + // `ExactSizeIterator::len` and `size_hint` are each iterator's own. "len" => Some(recv.member("len").call(rest)), + "size_hint" => Some(recv.member("sizeHint").call(rest)), "nth" | "find" | "rfind" => { let dropper = b.t.dropper(item, span); method(&camel, tail(rest, [dropper].into_iter().chain(none).collect())) @@ -627,7 +633,8 @@ pub fn call<'tcx>( let into = into_fn(b, targ(1)?, span)?.unwrap_or_else(Expr::undefined); let fused = fused(b, self_ty, Some(targ(2)?)); let size = array_size(b, targ(1)?); - method("flatMap", tail(rest, vec![into, fused, size])) + let one_shot = Expr::lit(implements(b.t, inner, "OneShot").to_string()); + method("flatMap", tail(rest, vec![into, fused, size, one_shot])) } "flatten" => { let inner = iter_of(b.t, item)?; @@ -635,7 +642,8 @@ pub fn call<'tcx>( let into = into_fn(b, item, span)?.unwrap_or_else(Expr::undefined); let fused = fused(b, self_ty, None); let size = array_size(b, item); - method("flatten", tail(Vec::new(), vec![into, fused, size])) + let one_shot = Expr::lit(implements(b.t, inner, "OneShot").to_string()); + method("flatten", tail(Vec::new(), vec![into, fused, size, one_shot])) } "copied" | "cloned" => { let ty::Ref(_, inner, _) = item.kind() else { @@ -663,7 +671,10 @@ pub fn call<'tcx>( (_, None) => method("cloned", Vec::new()), } } - "collect" => collect(b, targ(1)?, item, recv, self_ty, span), + "collect" => { + let trusted = implements(b.t, self_ty, "TrustedLen"); + collect(b, targ(1)?, item, recv, self_ty, trusted, span) + } _ => None, } } @@ -683,6 +694,22 @@ fn undefined(e: &Expr) -> bool { matches!(e, Expr::Lit(l) if l == "undefined") } +/// The size and alignment of a `ty` in bytes on wasm32, by which std's collections of it +/// reserve, or else what stands in for a figure of them: `undefined` over parameters, which +/// only a census's instance, which never runs, has. +pub(super) fn layout<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Result<(u64, u64), Expr> { + match b.t.tcx.layout_of(b.t.typing_env_pub().as_query_input(ty)) { + Ok(layout) => Ok((layout.size.bytes(), layout.align.abi.bytes())), + Err(_) if ty.has_param() => Err(Expr::undefined()), + Err(_) => Err(b.err(span, format!("reserving for `{ty}`, whose layout is unknown"))), + } +} + +/// The size of a `ty` in bytes, as `layout` gives it, by which std's `Vec` of it reserves. +pub(super) fn size_of<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr { + layout(b, ty, span).map_or_else(|e| e, |(size, _)| Expr::lit(size.to_string())) +} + /// Whether an iterator of type `ty`, with `held` beside it, drops and is a `FusedIterator`, /// which std's `fuse` and `flatten` keep once it ends rather than drop: `true` or `false`. fn fused<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, held: Option>) -> Expr { @@ -818,13 +845,15 @@ fn core_trait(tcx: ty::TyCtxt<'_>, name: &str) -> Option { .find(|&tr| tcx.item_name(tr).as_str() == name) } -/// `iter.collect::()` of `item`s, from an iterator of type `from`, which it drops. +/// `iter.collect::()` of `item`s, from an iterator of type `from`, which it drops, and +/// which std's reserves for as it does a `TrustedLen` one if `trusted`. fn collect<'tcx>( b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, item: Ty<'tcx>, iter: Expr, from: Ty<'tcx>, + trusted: bool, span: Span, ) -> Option { let tcx = b.t.tcx; @@ -836,9 +865,12 @@ fn collect<'tcx>( Std::Vec => Some(match args.type_at(0).kind() { ty::Uint(ty::UintTy::U8) => { let take = iter_take(b, from, implements(b.t, from, "TrustedLen"), span); - Expr::rt("iterToByteVec", tail(vec![iter], vec![take])) + Expr::rt( + "iterToByteVec", + tail(vec![iter], vec![take, Expr::lit(trusted.to_string())]), + ) } - _ => to_array(b, iter, from, args.type_at(0), span), + _ => to_array(b, iter, from, args.type_at(0), trusted, span), }), // The values, collected as the `Ok` or `Some` type is, until the first `Err` or `None`. std @ (Std::Result | Std::Option) => { @@ -857,8 +889,9 @@ fn collect<'tcx>( } let value_ty = b.t.ty(value, span); // What it collects from is what `from` yields up to the first `Err` or `None`, which - // std's collects in place of `from`'s source as it would `from`. - let values = collect(b, args.type_at(0), value, Expr::ident("values"), from, span)?; + // std's collects in place of `from`'s source as it would `from`, but never trusts + // the length of. + let values = collect(b, args.type_at(0), value, Expr::ident("values"), from, false, span)?; let param = Param { name: "values".into(), ty: Some(Type::Rt("Iter", vec![value_ty])), @@ -883,7 +916,7 @@ fn collect<'tcx>( _ => string_extend(b, Expr::Str(String::new()), iter, item, from, span), } } - _ => super::collections::collect(b, ty, iter, from, span), + _ => super::collections::collect(b, ty, iter, from, trusted, span), } } @@ -948,17 +981,23 @@ fn drops_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> boo /// `rt.iterToArray` of `iter`, an iterator of type `from`, collected into a `Vec` as /// std's does: by `next` where it collects in place of the `Vec` its items come from, by /// `try_fold`, which drops the closures the iterator holds only with it, where its own -/// `fold` drops them first. +/// `fold` drops them first. It reserves as std's does for a `TrustedLen` iterator if +/// `trusted`. pub(super) fn to_array<'tcx>( b: &mut Body<'_, '_, 'tcx>, iter: Expr, from: Ty<'tcx>, elem: Ty<'tcx>, + trusted: bool, span: Span, ) -> Expr { let folds = implements(b.t, from, "TrustedLen") && !in_place(b.t, from, elem); let take = iter_take(b, from, folds, span); - Expr::rt("iterToArray", tail(vec![iter], vec![take])) + let size = size_of(b, elem, span); + Expr::rt( + "iterToArray", + tail(vec![iter], vec![take, size, Expr::lit(trusted.to_string())]), + ) } /// Whether std's `collect` of an iterator of type `iter` into a `Vec` writes in place