diff --git a/quest/m3/README.md b/quest/m3/README.md index 989c3d6b4..5d1dbe8fd 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -23,7 +23,7 @@ generic std gap is planned here even when moq never calls it. - [Trait objects](/quest/m3/ts-dyn.md) - `dyn Error`, `dyn Iterator`, `dyn Buf`, and `Arc` translate, so a consumer neither rewrites nor binds them - [Placeholders written to a crate's own fmt::Write](/quest/m3/ts-fmt-calls.md) - `write!` with placeholders into a crate's own writer translates, its `write_str` seeing each call std makes - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library -- [An inclusive range folded through an adaptor](/quest/m3/ts-range-fold.md) - a `RangeInclusive` folded through `map`, `filter`, or `rev` ends in core's state, and `by_ref` of one type-checks +- [A zip of TrustedLen iterators folded by its size hint](/quest/m3/ts-zip-fold.md) - `count` and the other folds of a `zip` of `TrustedLen` iterators read only the pairs its size hint holds - [A B-tree's drop order](/quest/m3/ts-btree-drop.md) - dropping a whole `BTreeMap` or `BTreeSet` drops its entries node by node, as std's does - [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 - [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 diff --git a/quest/m3/ts-range-fold.md b/quest/m3/ts-range-fold.md deleted file mode 100644 index c388aecff..000000000 --- a/quest/m3/ts-range-fold.md +++ /dev/null @@ -1,34 +0,0 @@ -# [M] An inclusive range folded through an adaptor - -## Goal - -A `RangeInclusive` borrowed by `by_ref` and drained by a fold through an adaptor (`map`, -`filter`, `rev`, `chain`, `peekable`, `take`, `skip`, ...) ends in core's state, `exhausted` -with `start == end`, where std's adaptor folds the range, proven by a differential test -against native Rust. `for _ in r.by_ref()` over a `RangeInclusive`, then using `r`, type-checks. - -## Plan - -[#179](https://github.com/moq-dev/rust2/pull/179) gave `rt.Iter` a `folded()`, which each -consumer std folds reads through: the iterator itself, but a stepper of core's `try_fold` -for a `RangeInclusive`, and its iterator's for a `&mut` borrow. A per-item method instead -cost up to 58% on `just ts bench`. [#172](https://github.com/moq-dev/rust2/pull/172)'s -per-kind `fold`, which consumers take where the iterator drops, forwards through each -adaptor to the default `fold`, which reads through `folded()`. What remains is each -adaptor where a consumer reads it by `next`: - -- One whose std `try_fold` folds its iterator overrides `folded()` to read its iterator's - `folded()`, sharing its own state (`take`'s count, `peekable`'s peeked item) with it. -- `filter`, `filter_map`, and `skip_while` fold it in `next` too, through `find`, as the - `collect` shunts do through `try_for_each`. -- `rev` needs a back step, as core's `try_rfold` takes it. -- `skip` reads `nth(n - 1)` before it folds, where its `next` reads `nth(n)`. -- `zip` and `step_by` read by `next`, as std's do. -- `collect` and `extend` fold only a `TrustedLen` iterator and read others by `next`. - -`for _ in r.by_ref()` fails `tsc` today (`rt.iterBorrow(r)` is an `Iter`, not the -`rt.RangeInclusive` it is assigned to), found by -[#147](https://github.com/moq-dev/rust2/pull/147): `IntoIterator` for `&mut I` is typed as -a plain iterator. The fixtures drain with `while r.next().is_some()` around it. - -Public API: the translator's output. diff --git a/quest/m3/ts-zip-fold.md b/quest/m3/ts-zip-fold.md new file mode 100644 index 000000000..8008d3fdd --- /dev/null +++ b/quest/m3/ts-zip-fold.md @@ -0,0 +1,19 @@ +# [S] A zip of TrustedLen iterators folded by its size hint + +## Goal + +[rust2-ts](/ts/README.md) folds a `zip` of two `TrustedLen` iterators as std's `SpecFold` +does: `fold`, and what std folds through it (`count`, `last`, `for_each`, `sum`, and a +`TrustedLen` `collect`), reads as many pairs as its size hint's upper bound and no +further, so `r.by_ref().zip(0..n).count()` of a longer `RangeInclusive` leaves `r` read +`n` times, proven by a differential test against native Rust. + +## Plan + +Found by [#301](https://github.com/moq-dev/rust2/pull/301) on 2026-10-30. `rt.ZipIter` +reads `a` once past a shorter `b` in every fold, as std's does only by `try_fold` (`any`, +`find`, `position`) and for iterators that aren't `TrustedLen`. `rt.Iter.folded()` serves +both `fold` and `try_fold`, which agree for every other adaptor, so the zip needs a way to +tell them apart. + +Public API: the translator's output. diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 234596605..b11436959 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -376,7 +376,7 @@ export function iterate(chain: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else if (chain === 2) { putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): boolean => { return (_28 & 1) === 1; - })).length); + }), "next").length); } else if (chain === 3) { putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { return _2 as rt.u32; diff --git a/ts/fixtures/lang/expected/bounds.ts b/ts/fixtures/lang/expected/bounds.ts index 7755943d1..ccb22d0bb 100644 --- a/ts/fixtures/lang/expected/bounds.ts +++ b/ts/fixtures/lang/expected/bounds.ts @@ -247,7 +247,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { 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, undefined, undefined, 1, true); - rt.iterExtendBytes(out, rt.iterRev(rt.btreeRangeKeys(set, range2))); + rt.iterExtendBytes(out, rt.iterRev(rt.btreeRangeKeys(set, range2)), "next"); rt.byteVecPush(out, within$Bound_u8_Bound_u8(set, range2) & 0xff); } else if (_28 === 4) { const empty: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; @@ -285,7 +285,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _263: [rt.RangeBound, rt.RangeBound] = [bound$Key(s, a2), bound$Key(e, b2)]; rt.iterExtendBytes(out, rt.iterMap(rt.btreeRangeKeys(set3, _263, Key.eq$PartialEq, rt.cmpGt(Key.partialCmp$PartialOrd)), (k3: Key.Key): rt.u8 => { return k3._0; - })); + }), "next"); flush(out); const _272: [rt.RangeBound, rt.RangeBound] = [bound$Key(s, a2), bound$Key(e, b2)]; const iter6: rt.Iter<[Key.Key, rt.Place]> = rt.btreeRangeMut(map2, _272, Key.eq$PartialEq, rt.cmpGt(Key.partialCmp$PartialOrd)); @@ -308,7 +308,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _308: [rt.RangeBound<[rt.u8, Key.Key]>, rt.RangeBound<[rt.u8, Key.Key]>] = [bound$u8_Key(s, a3), bound$u8_Key(e, b3)]; rt.iterExtendBytes(out, rt.iterMap(rt.btreeRangeKeys(pairs, _308, rt.eqTuple([rt.same, Key.eq$PartialEq]), rt.cmpGt(rt.cmpTuple([rt.cmp, Key.partialCmp$PartialOrd]))), (_25: [rt.u8, Key.Key]): rt.u8 => { return _25[0]; - })); + }), "next"); flush(out); } flush(out); diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 34a26886c..d1c2b3d54 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); + }), "next", 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/collections.ts b/ts/fixtures/lang/expected/collections.ts index 42b8d5098..4cc8e88ab 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, undefined, undefined, undefined, 4)); + const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _80, true, undefined, undefined, "next", 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, undefined, undefined, 8)); + const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _136, true, undefined, "next", 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, undefined, undefined, undefined, 2)); + const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _238, true, undefined, undefined, "next", 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, undefined, undefined, undefined, 6)); + const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _278, true, undefined, undefined, "next", 6)); while (true) { const _282: [Pair.Pair, Tally.Tally] | rt.Done = iter7.next(); if (_282 === rt.DONE) { @@ -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, undefined, undefined, undefined, 6)); + const iter14: rt.Iter<[Rank.Rank, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Rank.cmp$Ord) as rt.BTreeMap, _486, true, undefined, undefined, "next", 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, undefined, undefined, 1)), undefined, true); + rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _596, true, undefined, "next", 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); @@ -515,7 +515,7 @@ export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, unwrapOr$1j4op5y(_113, 255) & 0xff); } - rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12)), undefined, 2).length & 0xff); + rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12)), "next", 2).length & 0xff); rt.hashRetain(hashed, (v5: rt.u16): boolean => { return rt.u16Rem(v5, 3) !== 0; }); @@ -722,16 +722,16 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi if (_158 === 0) { within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.Range(lo, hi)), (_236: [rt.u8, rt.u8]): rt.u8 => { return _236[0]; - })); + }), "next"); } else if (_158 === 1) { const _167: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u8Step); within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, _167), (_235: [rt.u8, rt.u8]): rt.u8 => { return _235[0]; - })); + }), "next"); } else { within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, { start: lo }), (_234: [rt.u8, rt.u8]): rt.u8 => { return _234[0]; - })); + }), "next"); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(within)); rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); @@ -966,7 +966,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _93[0] ^ _93[1]); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.dequeDrain(q, undefined)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.dequeDrain(q, undefined), "next"))); rt.byteVecPush(out, q.n === 0 ? 1 : 0); const _111: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): Tally.Tally => { return { n: _25 as rt.u16 }; @@ -1021,14 +1021,14 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _198, undefined, 1, true); const _201: rt.usize = rt.usizeRem(a, 4); if (_201 === 0) { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2))); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2)), "next"); } else if (_201 === 1) { const _208: rt.RangeInclusive = new rt.RangeInclusive(a, b2, rt.usizeStep); - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _208)); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _208), "next"); } else if (_201 === 2) { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { end: b2 })); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { end: b2 }), "next"); } else { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a })); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a }), "next"); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(drained2)); rt.iterExtendBytes(out, rt.dequeIter(q2), undefined, true); @@ -1303,7 +1303,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); + }), "next", 16); rt.sliceSortByKey(all, (_22: [rt.u8, string | undefined]): rt.u8 => { return _22[0]; }, rt.lt); @@ -1313,7 +1313,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); + }), "next", 3); rt.sliceSortByKey(all, (_22: [rt.u8, rt.u8 | undefined]): rt.u8 => { return _22[0]; }, rt.lt); @@ -1325,7 +1325,7 @@ export function sorted$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap { return _22[0]; }, rt.lt); @@ -1640,7 +1640,7 @@ export function optionals(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi const args2: rt.Fmt[] = [(f: rt.Formatter) => 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), undefined, 4); + const all: [[rt.u8, boolean], rt.u8 | undefined][] = rt.iterToArray(rt.hashIter(map), "next", 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]]))); @@ -1783,10 +1783,10 @@ export function setOpsOf$Nibble(left: rt.ByteSlice, right: rt.ByteSlice, make: ( if (_111 === rt.DONE) { break; } - putSorted$Nibble(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Nibble(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Nibble(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Nibble(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), undefined, 4), put, out); + putSorted$Nibble(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$Nibble(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$Nibble(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$Nibble(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); putHints$Nibble_Union_Nibble_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); putHints$Nibble_Intersection_Nibble_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); putHints$Nibble_Difference_Nibble_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); @@ -1822,7 +1822,7 @@ export function setOpsOf$Nibble(left: rt.ByteSlice, right: rt.ByteSlice, make: ( if (_175 === rt.DONE) { break; } - putSorted$Nibble(rt.iterToArray(rt.hashKeys(_175), undefined, 4), put, out); + putSorted$Nibble(rt.iterToArray(rt.hashKeys(_175), "next", 4), put, out); } } } @@ -1880,10 +1880,10 @@ export function setOpsOf$Option_u8(left: rt.ByteSlice, right: rt.ByteSlice, make if (_111 === rt.DONE) { break; } - putSorted$Option_u8(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Option_u8(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Option_u8(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Option_u8(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), undefined, 4), put, out); + putSorted$Option_u8(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$Option_u8(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$Option_u8(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$Option_u8(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); putHints$Option_u8_Union_Option_u8_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); putHints$Option_u8_Intersection_Option_u8_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); putHints$Option_u8_Difference_Option_u8_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); @@ -1919,7 +1919,7 @@ export function setOpsOf$Option_u8(left: rt.ByteSlice, right: rt.ByteSlice, make if (_175 === rt.DONE) { break; } - putSorted$Option_u8(rt.iterToArray(rt.hashKeys(_175), undefined, 4), put, out); + putSorted$Option_u8(rt.iterToArray(rt.hashKeys(_175), "next", 4), put, out); } } } @@ -1977,10 +1977,10 @@ export function setOpsOf$Reverse_Option_u8(left: rt.ByteSlice, right: rt.ByteSli if (_111 === rt.DONE) { break; } - putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), undefined, 4), put, out); - putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), undefined, 4), put, out); + putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); putHints$Reverse_Option_u8_Union_Reverse_Option_u8_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); putHints$Reverse_Option_u8_Intersection_Reverse_Option_u8_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); putHints$Reverse_Option_u8_Difference_Reverse_Option_u8_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); @@ -2016,7 +2016,7 @@ export function setOpsOf$Reverse_Option_u8(left: rt.ByteSlice, right: rt.ByteSli if (_175 === rt.DONE) { break; } - putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashKeys(_175), undefined, 4), put, out); + putSorted$Reverse_Option_u8(rt.iterToArray(rt.hashKeys(_175), "next", 4), put, out); } } } @@ -2074,10 +2074,10 @@ export function setOpsOf$u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: if (_111 === rt.DONE) { break; } - putSorted$u8(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), undefined, 4), put, out); - putSorted$u8(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), undefined, 4), put, out); - putSorted$u8(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), undefined, 4), put, out); - putSorted$u8(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), undefined, 4), put, out); + putSorted$u8(rt.iterToArray(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$u8(rt.iterToArray(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$u8(rt.iterToArray(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$u8(rt.iterToArray(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); putHints$u8_Union_u8_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); putHints$u8_Intersection_u8_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); putHints$u8_Difference_u8_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); @@ -2113,7 +2113,7 @@ export function setOpsOf$u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: if (_175 === rt.DONE) { break; } - putSorted$u8(rt.iterToArray(rt.hashKeys(_175), undefined, 4), put, out); + putSorted$u8(rt.iterToArray(rt.hashKeys(_175), "next", 4), put, out); } } } @@ -2171,10 +2171,10 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: if (_111 === rt.DONE) { break; } - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), undefined, 4), put, out); - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), undefined, 4), put, out); - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), undefined, 4), put, out); - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), undefined, 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); putHints$u8s_Union_u8s_RandomState(rt.iterMap(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), 0, out); putHints$u8s_Intersection_u8s_RandomState(rt.iterMap(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), 0, out); putHints$u8s_Difference_u8s_RandomState(rt.iterMap(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), 0, out); @@ -2210,7 +2210,7 @@ export function setOpsOf$u8s(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: if (_175 === rt.DONE) { break; } - putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashKeys(_175), rt.byteSliceFrom), undefined, 4), put, out); + putSorted$u8s(rt.iterToArray(rt.iterMap(rt.hashKeys(_175), rt.byteSliceFrom), "next", 4), put, out); } } } diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index ffee424b6..cccced8be 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -347,6 +347,20 @@ export function map$1httady(self: string[] | undefined, f: (a0: string[]) => str return f(self); } +export function map$1mp7tga(self: rt.i64[] | undefined, f: (a0: rt.i64[]) => rt.usize): rt.usize | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$1c7fhtg(self: rt.ByteVec | undefined, f: (a0: rt.ByteVec) => rt.usize): rt.usize | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function map$0lcwx9x(self: Way.Way | undefined, f: (a0: Way.Way) => boolean): boolean | undefined { if (self === undefined) { return undefined; diff --git a/ts/fixtures/lang/expected/core/result.ts b/ts/fixtures/lang/expected/core/result.ts index bd84b2db7..c138a9321 100644 --- a/ts/fixtures/lang/expected/core/result.ts +++ b/ts/fixtures/lang/expected/core/result.ts @@ -368,6 +368,13 @@ export function map$0zzqmaz(self: rt.Result, rt.Arc, op: (a0: rt.i64[]) => rt.usize): rt.Result { + if (self.ok) { + return rt.Ok(op(self.value)); + } + return rt.ERR; +} + export function map$1qqg34g(self: rt.Result, op: (a0: rt.ByteVec) => rt.ByteVec): rt.Result { if (self.ok) { return rt.Ok(op(self.value)); @@ -375,6 +382,13 @@ export function map$1qqg34g(self: rt.Result, op: (a0: rt.Byt return self; } +export function map$1w3j91w(self: rt.Result, op: (a0: rt.ByteVec) => rt.usize): rt.Result { + if (self.ok) { + return rt.Ok(op(self.value)); + } + return rt.ERR; +} + export function map$0fm1w6u(self: rt.Result, op: (a0: boolean) => rt.Result): rt.Result, rt.ParseBoolError> { if (self.ok) { return rt.Ok(op(self.value)); diff --git a/ts/fixtures/lang/expected/errors.ts b/ts/fixtures/lang/expected/errors.ts index 4aa9574ee..9d10ec4bf 100644 --- a/ts/fixtures/lang/expected/errors.ts +++ b/ts/fixtures/lang/expected/errors.ts @@ -523,13 +523,13 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 12, true), out); pairs$ParseCharError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s3: string): rt.ParseCharError | undefined => { return err$02r96h1(rt.charFromStr(s3)); - }), undefined, 1), out); + }), "next", 1), out); pairs$ParseBoolError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s4: string): rt.ParseBoolError | undefined => { return err$1ujom0k(parse$0vh4cry(s4)); - }), undefined, 0), out); + }), "next", 0), out); pairs$ParseIntError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s5: string): rt.ParseIntError | undefined => { return err$0jf6smd(parse$1fq462u(s5)); - }), undefined, 1), out); + }), "next", 1), out); } } diff --git a/ts/fixtures/lang/expected/folds.ts b/ts/fixtures/lang/expected/folds.ts new file mode 100644 index 000000000..0013d021d --- /dev/null +++ b/ts/fixtures/lang/expected/folds.ts @@ -0,0 +1,856 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { thenSome$0tjggir, thenSome$0d5am30 } from "./core/bool.ts"; +import { unwrapOr$0r2bmpr, map$1mp7tga, map$1c7fhtg } from "./core/option.ts"; +import { map$0d4vpmj, map$1w3j91w } from "./core/result.ts"; +import { put } from "./fmt.ts"; + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_Option_i64(out: rt.ByteVec, v: rt.i64 | undefined, r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.i64Debug), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_Option_i64_Option_i64(out: rt.ByteVec, v: [rt.i64 | undefined, rt.i64 | undefined], r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.i64Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.i64Debug)], f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_Option_i64_Option_usize(out: rt.ByteVec, v: [rt.i64 | undefined, rt.usize | undefined], r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.i64Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_Option_i64_usize(out: rt.ByteVec, v: [rt.i64 | undefined, rt.usize], r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.i64Debug), (f: rt.Formatter) => rt.usizeDebug(v[1], f)], f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_Option_usize(out: rt.ByteVec, v: rt.usize | undefined, r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.usizeDebug), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_Option_usize_i64(out: rt.ByteVec, v: [rt.usize, rt.i64] | undefined, r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, (value: [rt.usize, rt.i64], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.i64Debug(value[1], f)], f)), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_Result_usize_unit(out: rt.ByteVec, v: rt.Result, r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(v, f, rt.usizeDebug, rt.fmtUnit), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_bool(out: rt.ByteVec, v: boolean, r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(v, f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_unit(out: rt.ByteVec, _: undefined, r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$i64_usize(out: rt.ByteVec, v: rt.usize, r: rt.RangeInclusive): void { + const _12: rt.i64 = rt.rangeInclusiveStart(r); + const _14: rt.i64 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDebug(v, f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_Option_u8(out: rt.ByteVec, v: rt.u8 | undefined, r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.u8Debug), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_Option_u8_Option_u8(out: rt.ByteVec, v: [rt.u8 | undefined, rt.u8 | undefined], r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.u8Debug)], f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_Option_u8_Option_usize(out: rt.ByteVec, v: [rt.u8 | undefined, rt.usize | undefined], r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_Option_u8_usize(out: rt.ByteVec, v: [rt.u8 | undefined, rt.usize], r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.u8Debug), (f: rt.Formatter) => rt.usizeDebug(v[1], f)], f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_Option_usize(out: rt.ByteVec, v: rt.usize | undefined, r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.usizeDebug), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_Option_usize_u8(out: rt.ByteVec, v: [rt.usize, rt.u8] | undefined, r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, (value: [rt.usize, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_Result_usize_unit(out: rt.ByteVec, v: rt.Result, r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(v, f, rt.usizeDebug, rt.fmtUnit), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_bool(out: rt.ByteVec, v: boolean, r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(v, f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_unit(out: rt.ByteVec, _: undefined, r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** `r`'s state after `v`, what read it returned. */ +export function state$u8_usize(out: rt.ByteVec, v: rt.usize, r: rt.RangeInclusive): void { + const _12: rt.u8 = rt.rangeInclusiveStart(r); + const _14: rt.u8 = rt.rangeInclusiveEnd(r); + const _16: boolean = rt.rangeInclusiveIsEmpty(r); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDebug(v, f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; + put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +} + +/** + * Each read of empty, single, and full ranges of the integer type `kind` picks, and at + * its limits. + */ +export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { + return unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + }; + const _8: [rt.u8, rt.u8, rt.usize] = [at(0), at(1), rt.usizeRem(at(2) as rt.usize, 6)]; + const a: rt.u8 = _8[0]; + const b: rt.u8 = _8[1]; + const n: rt.usize = _8[2]; + if (rt.u8Rem(kind, 2) === 0) { + const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterSlice([[a, b] as [rt.u8, rt.u8], [a, a] as [rt.u8, rt.u8], [b, a] as [rt.u8, rt.u8], [rt.u8Sub(255, rt.u8Rem(a, 4)), 255] as [rt.u8, rt.u8], [255, 255] as [rt.u8, rt.u8], [0, rt.u8Rem(a, 4)] as [rt.u8, rt.u8]]); + while (true) { + const _38: [rt.u8, rt.u8] | rt.Done = iter.next(); + if (_38 === rt.DONE) { + break; + } + const lo: rt.u8 = _38[0]; + const hi: rt.u8 = _38[1]; + const lo2: rt.u8 = lo; + const hi2: rt.u8 = hi; + const n2: rt.usize = n; + const k: rt.u8 | undefined = rt.iterNth(new rt.RangeInclusive(lo2, hi2, rt.u8Step), n2); + const isK: (a0: rt.u8) => boolean = (x40: rt.u8): boolean => { + return x40 === k; + }; + const below: (a0: rt.u8) => boolean = (x41: rt.u8): boolean => { + if (k === undefined) { + return true; + } + return x41 < k; + }; + const r: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const iter2: rt.RangeInclusive = r; + while (iter2.next() !== rt.DONE) { + } + state$u8_unit(out, undefined, r); + const r2: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const iter3: rt.RangeInclusive = r2; + while (true) { + const _69: rt.u8 | rt.Done = iter3.next(); + if (_69 === rt.DONE) { + break; + } + if (isK(_69)) { + break; + } + } + state$u8_unit(out, undefined, r2); + const r3: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterRfind(r3, isK), r3); + const r4: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterRfind(r4, (_221: rt.u8): boolean => { + return false; + }), r4); + const r5: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterMap(rt.iterBorrow(r5), (x42: rt.u8): rt.u8 => { + return x42; + })), r5); + const r6: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterMap(rt.iterBorrow(r6), (x43: rt.u8): rt.u8 => { + return x43; + })), r6); + const r7: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize(out, rt.iterPosition(rt.iterMap(rt.iterBorrow(r7), (x44: rt.u8): rt.u8 => { + return x44; + }), (x45: rt.u8): boolean => { + return isK(x45); + }), r7); + const r8: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterRfind(rt.iterMap(rt.iterBorrow(r8), (x46: rt.u8): rt.u8 => { + return x46; + }), isK), r8); + const r9: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterFold(rt.iterMap(rt.iterBorrow(r9), (x47: rt.u8): rt.u8 => { + return x47; + }), 0, (n6: rt.usize, _332: rt.u8): rt.usize => { + return rt.usizeAdd(n6, 1); + }), r9); + const r10: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterNth(rt.iterMap(rt.iterBorrow(r10), (x48: rt.u8): rt.u8 => { + return x48; + }), n2), r10); + const r11: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterNthBack(rt.iterMap(rt.iterBorrow(r11), (x49: rt.u8): rt.u8 => { + return x49; + }), n2), r11); + const r12: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r12), (x50: rt.u8): rt.u8 => { + return x50; + })), rt.lt), r12); + const r13: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterMap(rt.iterBorrow(r13), (x51: rt.u8): rt.u8 => { + return x51; + }), undefined, true).length, r13); + const r14: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r14), (_222: rt.u8): undefined => {})), r14); + const r15: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r15), (_223: rt.u8): undefined => {}), (x52: rt.u8): boolean => { + return isK(x52); + }), r15); + const r16: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterInspect(rt.iterBorrow(r16), (_226: rt.u8): undefined => {}), "next").length, r16); + const r17: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _191: rt.RangeInclusive = r17; + const _193: (a0: rt.u8) => boolean = (x53: rt.u8): boolean => { + return !isK(x53); + }; + state$u8_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_191), _193)), r17); + const r18: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r18), isK).next()), r18); + const r19: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r19), isK).nextBack()), r19); + const r20: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterFilter(rt.iterBorrow(r20), (_228: rt.u8): boolean => { + return true; + }), "next").length, r20); + const r21: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _225: rt.RangeInclusive = r21; + const _227: (a0: rt.u8) => rt.u8 | undefined = (x54: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(!isK(x54), x54); + }; + state$u8_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_225), _227)), r21); + const r22: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _235: rt.RangeInclusive = r22; + const _237: (a0: rt.u8) => rt.u8 | undefined = (x55: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(isK(x55), x55); + }; + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_235), _237).next()), r22); + const r23: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _245: rt.RangeInclusive = r23; + const _247: (a0: rt.u8) => rt.u8 | undefined = (x56: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(isK(x56), x56); + }; + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_245), _247).nextBack()), r23); + const r24: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r24))), r24); + const r25: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r25)), (_229: [rt.usize, rt.u8]): boolean => { + return isK(_229[1]); + }), r25); + const r26: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize_u8(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r26))), r26); + const r27: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _278: rt.RangeInclusive = r27; + const _280: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_278), _280)), r27); + const r28: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterChain(new rt.RangeInclusive(hi2, hi2, rt.u8Step), rt.iterBorrow(r28))), r28); + const r29: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _295: rt.RangeInclusive = r29; + const _297: rt.RangeInclusive = new rt.RangeInclusive(hi2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_295), _297), (x58: rt.u8): boolean => { + return isK(x58); + }), r29); + const r30: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _306: rt.RangeInclusive = r30; + const _308: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_306), _308))), r30); + const r31: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r31))), r31); + const r32: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r32)), (x59: rt.u8): boolean => { + return isK(x59); + }), r32); + const r33: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r33)), rt.lt), r33); + const r34: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r34)))), r34); + const r35: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterTake(rt.iterBorrow(r35), n2)), r35); + const r36: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _353: rt.RangeInclusive = r36; + const _355: rt.usize = rt.usizeAdd(n2, 1); + state$u8_Option_u8(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_353), _355), rt.lt), r36); + const r37: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r37), n2)), r37); + const r38: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r38), n2), (x60: rt.u8): rt.u8 => { + return x60; + })), r38); + const r39: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterMin(rt.iterTake(rt.iterBorrow(r39), 4294967295), rt.lt), r39); + const r40: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterTake(rt.iterBorrow(r40), n2))), r40); + const r41: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterSkip(rt.iterBorrow(r41), n2).next()), r41); + const r42: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterSkip(rt.iterBorrow(r42), n2)), r42); + const r43: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterSkip(rt.iterBorrow(r43), n2)), r43); + const r44: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r44), n2), rt.lt), r44); + const r45: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterSkip(rt.iterBorrow(r45), n2), "next").length, r45); + const r46: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r46), below).next()), r46); + const r47: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterSkipWhile(rt.iterBorrow(r47), below)), r47); + const r48: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r48), below)), r48); + const r49: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r49), (_230: rt.u8): boolean => { + return true; + })), r49); + const r50: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterTakeWhile(rt.iterBorrow(r50), below), "next").length, r50); + const r51: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _468: rt.RangeInclusive = r51; + const _470: (a0: rt.u8) => rt.u8 | undefined = (x61: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(below(x61), x61); + }; + state$u8_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_468), _470)), r51); + const r52: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r52), (x62: rt.u8): rt.u8 | undefined => { + return x62; + })), r52); + const r53: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterMapWhile(rt.iterBorrow(r53), (x63: rt.u8): rt.u8 | undefined => { + return x63; + }), "next").length, r53); + const r54: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r54))), r54); + const r55: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r55))), (x64: rt.u8): boolean => { + return isK(x64); + }), r55); + const r56: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r56)); + state$u8_Option_u8_usize(out, [rt.peekablePeek(p), rt.iterCount(p)] as [rt.u8 | undefined, rt.usize], r56); + const r57: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p2: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r57)); + state$u8_Option_u8_Option_u8(out, [rt.peekablePeek(p2), rt.iterLast(rt.iterRev(p2))] as [rt.u8 | undefined, rt.u8 | undefined], r57); + const r58: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p3: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r58)); + state$u8_Option_u8_Option_usize(out, [rt.peekablePeek(p3), rt.iterPosition(p3, (x65: rt.u8): boolean => { + return isK(x65); + })] as [rt.u8 | undefined, rt.usize | undefined], r58); + const r59: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r59))), r59); + const r60: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p4: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r60)); + const iter4: rt.Peekable = p4; + while (true) { + const _563: rt.u8 | rt.Done = iter4.next(); + if (_563 === rt.DONE) { + break; + } + if (isK(_563)) { + break; + } + } + state$u8_Option_u8(out, rt.peekablePeek(p4), r60); + const r61: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r61), (x66: rt.u8): rt.u8 | undefined => { + return x66; + }, (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true)), r61); + const r62: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r62), (x67: rt.u8): rt.u8 | undefined => { + return x67; + }, (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true).next()), r62); + const r63: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _594: rt.RangeInclusive = r63; + const _596: (a0: rt.u8) => rt.RangeInclusive = (x68: rt.u8): rt.RangeInclusive => { + return new rt.RangeInclusive(lo2, x68, rt.u8Step); + }; + state$u8_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_594), _596))), r63); + const r64: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _604: rt.RangeInclusive = r64; + const _606: (a0: rt.u8) => rt.RangeInclusive = (x69: rt.u8): rt.RangeInclusive => { + return new rt.RangeInclusive(x69, hi2, rt.u8Step); + }; + state$u8_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_604), _606), (x70: rt.u8): boolean => { + return isK(x70); + }), r64); + const r65: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r65), (x71: rt.u8): Uint8Array => { + return Uint8Array.of(x71, x71); + }, (value: Uint8Array) => rt.iterSlice(value), false, 2))), r65); + const r66: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _623: rt.RangeInclusive = r66; + const _625: rt.usize = rt.usizeAdd(n2, 1); + state$u8_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_623), _625)), r66); + const r67: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r67), new rt.Range(0, n2)), (_231: [rt.u8, rt.usize]): boolean => { + return false; + }), r67); + const r68: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Result_usize_unit(out, map$1w3j91w(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r68), (x72: rt.u8): rt.Result => { + return rt.Ok(x72); + }), (values: rt.Iter) => rt.iterToByteVec(values)), (v153: rt.ByteVec): rt.usize => { + return v153.length; + }), r68); + const r69: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _649: rt.RangeInclusive = r69; + const _651: (a0: rt.u8) => rt.u8 | undefined = (x73: rt.u8): rt.u8 | undefined => { + if (!isK(x73)) { + return x73; + } + return undefined; + }; + state$u8_Option_usize(out, map$1c7fhtg(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_649), _651), (values: rt.Iter) => rt.iterToByteVec(values)), (v154: rt.ByteVec): rt.usize => { + return v154.length; + }), r69); + const r70: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const v69: rt.ByteVec = new rt.ByteVec(); + const _661: rt.Iter = rt.iterMap(rt.iterBorrow(r70), (x74: rt.u8): rt.u8 => { + return x74; + }); + rt.iterExtendBytes(v69, _661, undefined, true); + state$u8_usize(out, v69.length, r70); + const r71: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const v71: rt.ByteVec = new rt.ByteVec(); + const _672: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r71), (_232: rt.u8): boolean => { + return true; + }); + rt.iterExtendBytes(v71, _672, "next"); + state$u8_usize(out, v71.length, r71); + const lo3: rt.u8 = lo; + const hi3: rt.u8 = hi; + const n3: rt.usize = n; + const k2: rt.u8 | undefined = rt.iterNth(new rt.RangeInclusive(lo3, hi3, rt.u8Step), n3); + const isK2: (a0: rt.u8) => boolean = (x75: rt.u8): boolean => { + return x75 === k2; + }; + const r72: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(r72, isK2), r72); + const r73: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(r73, (_233: rt.u8): boolean => { + return false; + }), r73); + const r74: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterTake(rt.iterBorrow(r74), n3))), r74); + const r75: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(rt.iterTake(rt.iterBorrow(r75), n3), isK2), r75); + const r76: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterSkip(rt.iterBorrow(r76), n3))), r76); + const r77: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(rt.iterSkip(rt.iterBorrow(r77), n3), isK2), r77); + const r78: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize_u8(out, rt.iterLast(rt.iterRev(rt.iterEnumerate(rt.iterBorrow(r78)))), r78); + const r79: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(rt.iterEnumerate(rt.iterBorrow(r79)), (_236: [rt.usize, rt.u8]): boolean => { + return isK2(_236[1]); + }), r79); + } + } else { + const _750: [rt.i64, rt.i64] = [rt.i64Sub(a as rt.i64, 128), rt.i64Sub(b as rt.i64, 128)]; + const a2: rt.i64 = _750[0]; + const b2: rt.i64 = _750[1]; + const low: rt.i64 = rt.i64Add({ hi: -0x80000000, lo: 0 } as rt.i64, rt.u8Rem(at(0), 4) as rt.i64); + const high: rt.i64 = rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, rt.u8Rem(at(1), 4) as rt.i64); + const _775: [rt.i64, rt.i64] = [a2, b2]; + const _776: [rt.i64, rt.i64] = [a2, a2]; + const _777: [rt.i64, rt.i64] = [b2, a2]; + const iter5: rt.Iter<[rt.i64, rt.i64]> = rt.iterSlice([_775, _776, _777, [{ hi: -0x80000000, lo: 0 } as rt.i64, low] as [rt.i64, rt.i64], [{ hi: -0x80000000, lo: 0 } as rt.i64, { hi: -0x80000000, lo: 0 } as rt.i64] as [rt.i64, rt.i64], [high, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64] as [rt.i64, rt.i64]]); + while (true) { + const _782: [rt.i64, rt.i64] | rt.Done = iter5.next(); + if (_782 === rt.DONE) { + break; + } + const _790: [rt.i64, rt.i64, rt.usize] = [_782[0], _782[1], n]; + const lo5: rt.i64 = _790[0]; + const hi5: rt.i64 = _790[1]; + const n4: rt.usize = n; + const k3: rt.i64 | undefined = rt.iterNth(new rt.RangeInclusive(lo5, hi5, rt.i64Step), n4); + const isK3: (a0: rt.i64) => boolean = (x5: rt.i64): boolean => { + return rt.eqOption(rt.i64Eq)(x5, k3); + }; + const below2: (a0: rt.i64) => boolean = (x6: rt.i64): boolean => { + if (k3 === undefined) { + return true; + } + return rt.i64Lt(x6, k3); + }; + const r80: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const iter6: rt.RangeInclusive = r80; + while (iter6.next() !== rt.DONE) { + } + state$i64_unit(out, undefined, r80); + const r81: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const iter7: rt.RangeInclusive = r81; + while (true) { + const _813: rt.i64 | rt.Done = iter7.next(); + if (_813 === rt.DONE) { + break; + } + if (isK3(_813)) { + break; + } + } + state$i64_unit(out, undefined, r81); + const r82: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterRfind(r82, isK3), r82); + const r83: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterRfind(r83, (_2: rt.i64): boolean => { + return false; + }), r83); + const r84: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterMap(rt.iterBorrow(r84), (x7: rt.i64): rt.i64 => { + return x7; + })), r84); + const r85: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterMap(rt.iterBorrow(r85), (x8: rt.i64): rt.i64 => { + return x8; + })), r85); + const r86: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize(out, rt.iterPosition(rt.iterMap(rt.iterBorrow(r86), (x9: rt.i64): rt.i64 => { + return x9; + }), (x10: rt.i64): boolean => { + return isK3(x10); + }), r86); + const r87: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterRfind(rt.iterMap(rt.iterBorrow(r87), (x11: rt.i64): rt.i64 => { + return x11; + }), isK3), r87); + const r88: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterFold(rt.iterMap(rt.iterBorrow(r88), (x12: rt.i64): rt.i64 => { + return x12; + }), 0, (n5: rt.usize, _39: rt.i64): rt.usize => { + return rt.usizeAdd(n5, 1); + }), r88); + const r89: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterNth(rt.iterMap(rt.iterBorrow(r89), (x13: rt.i64): rt.i64 => { + return x13; + }), n4), r89); + const r90: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterNthBack(rt.iterMap(rt.iterBorrow(r90), (x14: rt.i64): rt.i64 => { + return x14; + }), n4), r90); + const r91: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r91), (x15: rt.i64): rt.i64 => { + return x15; + })), rt.lt), r91); + const r92: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterMap(rt.iterBorrow(r92), (x16: rt.i64): rt.i64 => { + return x16; + }), undefined, 8, true).length, r92); + const r93: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r93), (_210: rt.i64): undefined => {})), r93); + const r94: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r94), (_211: rt.i64): undefined => {}), (x17: rt.i64): boolean => { + return isK3(x17); + }), r94); + const r95: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterInspect(rt.iterBorrow(r95), (_212: rt.i64): undefined => {}), "next", 8).length, r95); + const r96: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _935: rt.RangeInclusive = r96; + const _937: (a0: rt.i64) => boolean = (x18: rt.i64): boolean => { + return !isK3(x18); + }; + state$i64_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_935), _937)), r96); + const r97: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r97), isK3).next()), r97); + const r98: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r98), isK3).nextBack()), r98); + const r99: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterFilter(rt.iterBorrow(r99), (_213: rt.i64): boolean => { + return true; + }), "next", 8).length, r99); + const r100: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _969: rt.RangeInclusive = r100; + const _971: (a0: rt.i64) => rt.i64 | undefined = (x19: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(!isK3(x19), x19); + }; + state$i64_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_969), _971)), r100); + const r101: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _979: rt.RangeInclusive = r101; + const _981: (a0: rt.i64) => rt.i64 | undefined = (x20: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(isK3(x20), x20); + }; + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_979), _981).next()), r101); + const r102: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _989: rt.RangeInclusive = r102; + const _991: (a0: rt.i64) => rt.i64 | undefined = (x21: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(isK3(x21), x21); + }; + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_989), _991).nextBack()), r102); + const r103: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r103))), r103); + const r104: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r104)), (_214: [rt.usize, rt.i64]): boolean => { + return isK3(_214[1]); + }), r104); + const r105: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize_i64(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r105))), r105); + const r106: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1022: rt.RangeInclusive = r106; + const _1024: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_1022), _1024)), r106); + const r107: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterChain(new rt.RangeInclusive(hi5, hi5, rt.i64Step), rt.iterBorrow(r107))), r107); + const r108: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1039: rt.RangeInclusive = r108; + const _1041: rt.RangeInclusive = new rt.RangeInclusive(hi5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_1039), _1041), (x23: rt.i64): boolean => { + return isK3(x23); + }), r108); + const r109: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1050: rt.RangeInclusive = r109; + const _1052: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_1050), _1052))), r109); + const r110: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r110))), r110); + const r111: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r111)), (x24: rt.i64): boolean => { + return isK3(x24); + }), r111); + const r112: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r112)), rt.lt), r112); + const r113: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r113)))), r113); + const r114: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterTake(rt.iterBorrow(r114), n4)), r114); + const r115: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1097: rt.RangeInclusive = r115; + const _1099: rt.usize = rt.usizeAdd(n4, 1); + state$i64_Option_i64(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_1097), _1099), rt.lt), r115); + const r116: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r116), n4)), r116); + const r117: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r117), n4), (x25: rt.i64): rt.i64 => { + return x25; + })), r117); + const r118: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMin(rt.iterTake(rt.iterBorrow(r118), 4294967295), rt.lt), r118); + const r119: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterTake(rt.iterBorrow(r119), n4))), r119); + const r120: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterSkip(rt.iterBorrow(r120), n4).next()), r120); + const r121: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterSkip(rt.iterBorrow(r121), n4)), r121); + const r122: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterSkip(rt.iterBorrow(r122), n4)), r122); + const r123: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r123), n4), rt.lt), r123); + const r124: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterSkip(rt.iterBorrow(r124), n4), "next", 8).length, r124); + const r125: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r125), below2).next()), r125); + const r126: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterSkipWhile(rt.iterBorrow(r126), below2)), r126); + const r127: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r127), below2)), r127); + const r128: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r128), (_215: rt.i64): boolean => { + return true; + })), r128); + const r129: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterTakeWhile(rt.iterBorrow(r129), below2), "next", 8).length, r129); + const r130: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1212: rt.RangeInclusive = r130; + const _1214: (a0: rt.i64) => rt.i64 | undefined = (x26: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(below2(x26), x26); + }; + state$i64_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_1212), _1214)), r130); + const r131: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r131), (x27: rt.i64): rt.i64 | undefined => { + return x27; + })), r131); + const r132: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterMapWhile(rt.iterBorrow(r132), (x28: rt.i64): rt.i64 | undefined => { + return x28; + }), "next", 8).length, r132); + const r133: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r133))), r133); + const r134: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r134))), (x29: rt.i64): boolean => { + return isK3(x29); + }), r134); + const r135: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p5: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r135)); + state$i64_Option_i64_usize(out, [rt.peekablePeek(p5), rt.iterCount(p5)] as [rt.i64 | undefined, rt.usize], r135); + const r136: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p6: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r136)); + state$i64_Option_i64_Option_i64(out, [rt.peekablePeek(p6), rt.iterLast(rt.iterRev(p6))] as [rt.i64 | undefined, rt.i64 | undefined], r136); + const r137: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p7: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r137)); + state$i64_Option_i64_Option_usize(out, [rt.peekablePeek(p7), rt.iterPosition(p7, (x30: rt.i64): boolean => { + return isK3(x30); + })] as [rt.i64 | undefined, rt.usize | undefined], r137); + const r138: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r138))), r138); + const r139: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p8: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r139)); + const iter8: rt.Peekable = p8; + while (true) { + const _1307: rt.i64 | rt.Done = iter8.next(); + if (_1307 === rt.DONE) { + break; + } + if (isK3(_1307)) { + break; + } + } + state$i64_Option_i64(out, rt.peekablePeek(p8), r139); + const r140: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r140), (x31: rt.i64): rt.i64 | undefined => { + return x31; + }, (value: rt.i64 | undefined) => rt.iterOption(value), false, undefined, true)), r140); + const r141: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r141), (x32: rt.i64): rt.i64 | undefined => { + return x32; + }, (value: rt.i64 | undefined) => rt.iterOption(value), false, undefined, true).next()), r141); + const r142: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1338: rt.RangeInclusive = r142; + const _1340: (a0: rt.i64) => rt.RangeInclusive = (x33: rt.i64): rt.RangeInclusive => { + return new rt.RangeInclusive(lo5, x33, rt.i64Step); + }; + state$i64_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_1338), _1340))), r142); + const r143: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1348: rt.RangeInclusive = r143; + const _1350: (a0: rt.i64) => rt.RangeInclusive = (x34: rt.i64): rt.RangeInclusive => { + return new rt.RangeInclusive(x34, hi5, rt.i64Step); + }; + state$i64_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_1348), _1350), (x35: rt.i64): boolean => { + return isK3(x35); + }), r143); + const r144: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r144), (x36: rt.i64): rt.i64[] => { + return [x36, x36]; + }, (value: rt.i64[]) => rt.iterSlice(value), false, 2))), r144); + const r145: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1367: rt.RangeInclusive = r145; + const _1369: rt.usize = rt.usizeAdd(n4, 1); + state$i64_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_1367), _1369)), r145); + const r146: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r146), new rt.Range(0, n4)), (_219: [rt.i64, rt.usize]): boolean => { + return false; + }), r146); + const r147: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Result_usize_unit(out, map$0d4vpmj(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r147), (x37: rt.i64): rt.Result => { + return rt.Ok(x37); + }), (values: rt.Iter) => rt.iterToArray(values, undefined, 8)), (v151: rt.i64[]): rt.usize => { + return v151.length; + }), r147); + const r148: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1393: rt.RangeInclusive = r148; + const _1395: (a0: rt.i64) => rt.i64 | undefined = (x38: rt.i64): rt.i64 | undefined => { + if (!isK3(x38)) { + return x38; + } + return undefined; + }; + state$i64_Option_usize(out, map$1mp7tga(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_1393), _1395), (values: rt.Iter) => rt.iterToArray(values, undefined, 8)), (v152: rt.i64[]): rt.usize => { + return v152.length; + }), r148); + const r149: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const v148: rt.i64[] = []; + const _1405: rt.Iter = rt.iterMap(rt.iterBorrow(r149), (x39: rt.i64): rt.i64 => { + return x39; + }); + rt.iterExtend(v148, _1405, undefined, 8, true); + state$i64_usize(out, v148.length, r149); + const r150: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const v150: rt.i64[] = []; + const _1416: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r150), (_220: rt.i64): boolean => { + return true; + }); + rt.iterExtend(v150, _1416, "next", 8); + state$i64_usize(out, v150.length, r150); + } + } +} + +//# sourceMappingURL=folds.ts.map diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index d1f263d5c..8e1d97fd3 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -20,6 +20,7 @@ import { edits, bytes } from "./edits.ts"; import { eqs } from "./errors.ts"; import { floats, formats, parses } from "./floats.ts"; import { ints, strings, derived, written, counts, rounding, panics, wrapped, writes } from "./fmt.ts"; +import { folds } from "./folds.ts"; import { methods } from "./generics.ts"; import { values, random, bytes as hashes_bytes } from "./hashes.ts"; import { hints, reserves } from "./hints.ts"; @@ -186,7 +187,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) => undefined], ["keys::lent_keys", lentKeys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", lentValues as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::singles", singles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", singles_formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", singles_parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_2168: rt.u8, data68: rt.ByteSlice, out69: rt.ByteVec): undefined => { peekedOthers(data68, out69); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", hints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", reserves as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::hints", hints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", reserves as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["folds::folds", folds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index a3c8710ce..1afa2f420 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -2490,30 +2490,30 @@ export function typed$u8_u8_u8_reserves_closure2(kind: rt.u8, data: rt.ByteSlice 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; + len = rt.iterToArray(items, "next", 1100).length; } else if (coll === 1) { const v: Big.Big[] = []; - rt.iterExtend(v, items, undefined, 1100); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { @@ -2528,11 +2528,11 @@ export function fill$Big_Filter_Map_RangeInclusive_u32_typed_closure1_typed_clos 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { return v4.length; }); } else { @@ -2546,7 +2546,7 @@ export function fill$Big_Filter_Map_RangeInclusive_u32_typed_closure1_typed_clos _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); if (_53.ok) { len = _53.value.length; } else { @@ -2560,30 +2560,30 @@ export function fill$Big_Filter_Map_RangeInclusive_u32_typed_closure1_typed_clos 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; + len = rt.iterToArray(items, "next", 1100).length; } else if (coll === 1) { const v: Big.Big[] = []; - rt.iterExtend(v, items, undefined, 1100); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { @@ -2598,11 +2598,11 @@ export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1( 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { return v4.length; }); } else { @@ -2616,7 +2616,7 @@ export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1( _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); if (_53.ok) { len = _53.value.length; } else { @@ -2630,30 +2630,30 @@ export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1( 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; + len = rt.iterToArray(items, "next", 1100).length; } else if (coll === 1) { const v: Big.Big[] = []; - rt.iterExtend(v, items, undefined, 1100); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { @@ -2668,11 +2668,11 @@ export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$ 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { return v4.length; }); } else { @@ -2686,7 +2686,7 @@ export function fill$Big_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$ _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); if (_53.ok) { len = _53.value.length; } else { @@ -2770,30 +2770,30 @@ export function fill$Big_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, item 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; + len = rt.iterToArray(items, "next", 1100).length; } else if (coll === 1) { const v: Big.Big[] = []; - rt.iterExtend(v, items, undefined, 1100); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1100).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.cmpLe(Big.partialCmp$PartialOrd), rt.cmpGe(Big.partialCmp$PartialOrd), rt.cmpLt(Big.partialCmp$PartialOrd), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Big.cmp$Ord) as rt.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Big.hash$Hash_DefaultHasher as (a0: Big.Big, a1: rt.Hasher) => undefined, Big.eq$PartialEq)) as rt.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { @@ -2808,11 +2808,11 @@ export function fill$Big_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Big.cmp$Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)), 255, (v4: Big.Big[]): rt.usize => { return v4.length; }); } else { @@ -2826,7 +2826,7 @@ export function fill$Big_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 1100)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 1100)); if (_53.ok) { len = _53.value.length; } else { @@ -2840,30 +2840,30 @@ export function fill$Big_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, 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; + len = rt.iterToArray(items, "next", 4).length; } else if (coll === 1) { const v: rt.u32[] = []; - rt.iterExtend(v, items, undefined, 4); + rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 4); + rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { @@ -2878,11 +2878,11 @@ export function fill$u32_Filter_Map_RangeInclusive_u32_typed_closure1_typed_clos 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)), 255, (v4: rt.u32[]): rt.usize => { return v4.length; }); } else { @@ -2896,7 +2896,7 @@ export function fill$u32_Filter_Map_RangeInclusive_u32_typed_closure1_typed_clos _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)); if (_53.ok) { len = _53.value.length; } else { @@ -2910,30 +2910,30 @@ export function fill$u32_Filter_Map_RangeInclusive_u32_typed_closure1_typed_clos 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; + len = rt.iterToArray(items, "next", 4).length; } else if (coll === 1) { const v: rt.u32[] = []; - rt.iterExtend(v, items, undefined, 4); + rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 4); + rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { @@ -2948,11 +2948,11 @@ export function fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1( 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)), 255, (v4: rt.u32[]): rt.usize => { return v4.length; }); } else { @@ -2966,7 +2966,7 @@ export function fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1( _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)); if (_53.ok) { len = _53.value.length; } else { @@ -2980,30 +2980,30 @@ export function fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1( 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; + len = rt.iterToArray(items, "next", 4).length; } else if (coll === 1) { const v: rt.u32[] = []; - rt.iterExtend(v, items, undefined, 4); + rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 4); + rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { @@ -3018,11 +3018,11 @@ export function fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$ 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)), 255, (v4: rt.u32[]): rt.usize => { return v4.length; }); } else { @@ -3036,7 +3036,7 @@ export function fill$u32_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$ _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)); if (_53.ok) { len = _53.value.length; } else { @@ -3120,30 +3120,30 @@ export function fill$u32_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, item 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; + len = rt.iterToArray(items, "next", 4).length; } else if (coll === 1) { const v: rt.u32[] = []; - rt.iterExtend(v, items, undefined, 4); + rt.iterExtend(v, items, "next", 4); len = v.length; } else if (coll === 2) { const v2: rt.u32[] = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 4); + rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 4).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 4); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 4), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { @@ -3158,11 +3158,11 @@ export function fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)), 255, (v4: rt.u32[]): rt.usize => { return v4.length; }); } else { @@ -3176,7 +3176,7 @@ export function fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToArray(values, undefined, 4)); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 4)); if (_53.ok) { len = _53.value.length; } else { @@ -3190,30 +3190,30 @@ export function fill$u32_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, 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; + len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { const v: [rt.u64, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 16); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 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) { @@ -3228,11 +3228,11 @@ export function fill$u64_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_c 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -3246,7 +3246,7 @@ export function fill$u64_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_c _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)); if (_53.ok) { len = _53.value.length; } else { @@ -3260,30 +3260,30 @@ export function fill$u64_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_c 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; + len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { const v: [rt.u64, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 16); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 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) { @@ -3298,11 +3298,11 @@ export function fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closur 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -3316,7 +3316,7 @@ export function fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closur _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)); if (_53.ok) { len = _53.value.length; } else { @@ -3330,30 +3330,30 @@ export function fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closur 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; + len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { const v: [rt.u64, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 16); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 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) { @@ -3368,11 +3368,11 @@ export function fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closur 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -3386,7 +3386,7 @@ export function fill$u64_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closur _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)); if (_53.ok) { len = _53.value.length; } else { @@ -3470,30 +3470,30 @@ export function fill$u64_u8_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, i 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; + len = rt.iterToArray(items, "next", 16).length; } else if (coll === 1) { const v: [rt.u64, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 16); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, undefined, 16).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 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) { @@ -3508,11 +3508,11 @@ export function fill$u64_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt. 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)), 255, (v4: [rt.u64, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -3526,7 +3526,7 @@ export function fill$u64_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt. _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, undefined, 16)); + }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToArray(values, "next", 16)); if (_53.ok) { len = _53.value.length; } else { @@ -3540,30 +3540,30 @@ export function fill$u64_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt. 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; + len = rt.iterToByteVec(items, "next").length; } else if (coll === 1) { const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items); + rt.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items); + rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { @@ -3578,11 +3578,11 @@ export function fill$u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closu 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { return v4.length; }); } else { @@ -3596,7 +3596,7 @@ export function fill$u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closu _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values)); + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { @@ -3610,30 +3610,30 @@ export function fill$u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed_closu 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; + len = rt.iterToByteVec(items, "next").length; } else if (coll === 1) { const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items); + rt.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items); + rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { @@ -3648,11 +3648,11 @@ export function fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(c 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { return v4.length; }); } else { @@ -3666,7 +3666,7 @@ export function fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(c _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values)); + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { @@ -3680,30 +3680,30 @@ export function fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1(c 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; + len = rt.iterToByteVec(items, "next").length; } else if (coll === 1) { const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items); + rt.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items); + rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { @@ -3718,11 +3718,11 @@ export function fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { return v4.length; }); } else { @@ -3736,7 +3736,7 @@ export function fill$u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_closure1$2 _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values)); + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { @@ -3820,30 +3820,30 @@ export function fill$u8_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, items 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; + len = rt.iterToByteVec(items, "next").length; } else if (coll === 1) { const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items); + rt.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items); + rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, undefined, 1).n; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, items, "next", 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); + rt.dequeExtend(q, items, "next", 1); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToArray(items, undefined, 1), rt.le, rt.ge, rt.lt).d.length; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 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)); + len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { @@ -3858,11 +3858,11 @@ export function fill$u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, 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)); + len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 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 => { + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { return v4.length; }); } else { @@ -3876,7 +3876,7 @@ export function fill$u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values)); + }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { @@ -3890,30 +3890,30 @@ export function fill$u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, 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; + len = rt.iterToArray(items, "next", 3).length; } else if (coll === 1) { const v: [rt.u8, rt.u8, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 3); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 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; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + 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, "next", 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) { @@ -3928,11 +3928,11 @@ export function fill$u8_u8_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -3946,7 +3946,7 @@ export function fill$u8_u8_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)); if (_53.ok) { len = _53.value.length; } else { @@ -3960,30 +3960,30 @@ export function fill$u8_u8_u8_Filter_Map_RangeInclusive_u32_typed_closure1_typed 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; + len = rt.iterToArray(items, "next", 3).length; } else if (coll === 1) { const v: [rt.u8, rt.u8, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 3); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 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; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + 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, "next", 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) { @@ -3998,11 +3998,11 @@ export function fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_clos 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -4016,7 +4016,7 @@ export function fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_clos _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)); if (_53.ok) { len = _53.value.length; } else { @@ -4030,30 +4030,30 @@ export function fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_clos 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; + len = rt.iterToArray(items, "next", 3).length; } else if (coll === 1) { const v: [rt.u8, rt.u8, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 3); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 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; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + 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, "next", 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) { @@ -4068,11 +4068,11 @@ export function fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_clos 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -4086,7 +4086,7 @@ export function fill$u8_u8_u8_Map_Flatten_IntoIter_RangeInclusive_u32_typed_clos _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)); if (_53.ok) { len = _53.value.length; } else { @@ -4170,30 +4170,30 @@ export function fill$u8_u8_u8_Map_RangeInclusive_u32_typed_closure1(coll: rt.u8, 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; + len = rt.iterToArray(items, "next", 3).length; } else if (coll === 1) { const v: [rt.u8, rt.u8, rt.u8][] = []; - rt.iterExtend(v, items, undefined, 3); + rt.iterExtend(v, items, "next", 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); + rt.iterExtend(v2, items, "next", 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; + len = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>, items, "next", 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); + rt.dequeExtend(q, items, "next", 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; + len = rt.heapFrom(rt.iterToArray(items, "next", 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); + 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])), "next", 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)); + 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, "next", 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) { @@ -4208,11 +4208,11 @@ export function fill$u8_u8_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: r 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)); + 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, "next", 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 => { + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)), 255, (v4: [rt.u8, rt.u8, rt.u8][]): rt.usize => { return v4.length; }); } else { @@ -4226,7 +4226,7 @@ export function fill$u8_u8_u8_Skip_Map_RangeInclusive_u32_typed_closure1(coll: r _0 = rt.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, undefined, 3)); + }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToArray(values, "next", 3)); if (_53.ok) { len = _53.value.length; } else { diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 2b58cb629..8e4ac2078 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -26,11 +26,11 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void return rt.u8Div(_217, 2); }), (b11: rt.u8): boolean => { return rt.u8Rem(b11, 3) !== 0; - })))); + }), "next"))); 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)) { + }), "next", 2)) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_18))); } } else { @@ -69,13 +69,13 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else if (_4 === 3) { const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): boolean => { return _213 !== 0; - })); + }), "next"); const skipped: rt.ByteVec = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): boolean => { return _214 < 128; - })); + }), "next"); const mapped: rt.ByteVec = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u8 | undefined => { return rt.u8CheckedAdd(_215, 64); - })); + }), "next"); rt.byteVecPush(out, taken.length & 0xff); rt.byteVecPush(out, skipped.length & 0xff); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(mapped)); @@ -83,12 +83,12 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const words: rt.ByteVec[] = chunksByZero$ChunksByZero_u8s(data); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words), (w: rt.ByteVec): rt.Iter => { return rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w)))); - })))); + }), "next"))); rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words), (w2: rt.ByteVec): rt.Iter => { return rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w2))), (_212: rt.u8): rt.u8 => { return rt.u8WrappingAdd(_212, 3); }); - })))); + }))), "next"); } else { if (_4 === 5) { const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); @@ -123,7 +123,7 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else { rt.byteVecPush(out, _152); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3), "next"))); } else { const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { const b3: rt.u8 = _2; @@ -150,7 +150,7 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, v2.length & 0xff); rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { return _210 > 128; - })); + }), "next"); } } } @@ -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__, undefined, 2)), 255, (v2: rt.u16[]): rt.u8 => { + }), (values__: rt.Iter) => rt.iterToArray(values__, "next", 2)), 255, (v2: rt.u16[]): rt.u8 => { return v2.length & 0xff; })); } @@ -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), false, undefined, true)))); + }), (value: rt.u8 | undefined) => rt.iterOption(value), false, undefined, true), "next"))); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); @@ -1347,7 +1347,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { n = rt.u8Add(n, 1); return thenSome$0d5am30(n < 4, n); - })))); + }), "next"))); let k: rt.u8 = 0; rt.iterEmpty(); const _70: rt.Iter = rt.iterFromFn((): rt.u8 | undefined => { @@ -1361,7 +1361,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { const first2: rt.u8 | undefined = rt.byteSliceFirst(data); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterSuccessors(first2, (b8: rt.u8): rt.u8 | undefined => { return _83(b8, calls); - }), rt.usizeRem(data.length, 4))))); + }), rt.usizeRem(data.length, 4)), "next"))); rt.byteVecExtendFromSlice(out, rt.byteVecSlice(calls)); rt.byteVecPush(out, rt.iterCount(rt.iterSuccessors(first2, (b9: rt.u8): rt.u8 | undefined => { return _83(b9, calls); @@ -1403,8 +1403,8 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _13); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n3: rt.u8): rt.u64 => { - return rt.u64Div(rt.u64Mul(n3 as rt.u64, 1000), 7); + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, (it: Countdown.Countdown) => Countdown.next$Iterator(it)), (n4: rt.u8): rt.u64 => { + return rt.u64Div(rt.u64Mul(n4 as rt.u64, 1000), 7); }), rt.u64Add, 0)))); const down: Countdown.Countdown = { left, step }; while (true) { @@ -1418,11 +1418,24 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.byteVecPush(out, down.left); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(rt.byteSliceView(data)) }, (it: Evens.Evens) => Evens.next$Iterator(it))))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(rt.byteSliceView(data)) }, (it: Evens.Evens) => Evens.next$Iterator(it)), "next"))); const byRef: Evens.Evens = { inner: rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.min(data.length, 1)))) }; - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2)))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it)), 2), "next"))); + const iter2: Evens.Evens = byRef; + while (true) { + const _60: rt.u8 | rt.Done = Evens.next$Iterator(iter2); + if (_60 === rt.DONE) { + break; + } + const n3: rt.u8 = _60; + if (!(rt.u8Rem(n3, 4) === 0)) { + rt.byteVecPush(out, n3); + } else { + break; + } + } rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, (it: Evens.Evens) => Evens.next$Iterator(it))) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(new Halving.Halving(left), (it: Halving.Halving) => Halving.next$Iterator_u8(it))))); + rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(new Halving.Halving(left), (it: Halving.Halving) => Halving.next$Iterator_u8(it)), "next"))); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving(rt.u64Mul(left as rt.u64, 4294967297)), (it: Halving.Halving) => Halving.next$Iterator_u64(it)), rt.u64Add, 0)))); } diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 858d8e41e..34aa07614 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -818,7 +818,7 @@ export function places(data: rt.ByteSlice, out: rt.ByteVec): void { return 0; }); _203.v = rt.u8Add(_203.v, 2); - rt.iterExtendBytes(out, rt.iterChain(rt.btreeValues(touchy), rt.hashValues(hashy))); + rt.iterExtendBytes(out, rt.iterChain(rt.btreeValues(touchy), rt.hashValues(hashy)), "next"); const c2: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, 0), (): rt.usize => { return 0; }); @@ -1093,7 +1093,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void key[0] = key[0] ^ 16; rt.byteVecPush(out, rt.hashContains(map, rt.byteSliceView(rt.byteSliceFrom(key))) ? 1 : 0); } - const lent: rt.ByteSlice[] = rt.iterToArray(rt.iterMap(rt.hashKeys(map), rt.byteSliceFrom), undefined, 4); + const lent: rt.ByteSlice[] = rt.iterToArray(rt.iterMap(rt.hashKeys(map), rt.byteSliceFrom), "next", 4); rt.sliceSort(lent, rt.cmpLt(rt.cmpBytes)); for (const k of lent) { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(k.data[k.start], k.data[k.start + 1], rt.hashIndex(map, rt.byteSliceView(k)), rt.hashContains(map, rt.byteSliceView(k)) ? 1 : 0, rt.eqBytes(k, rt.byteSliceFrom(probe)) ? 1 : 0, rt.cmpBytes(k, rt.byteSliceFrom(probe)) === -1 ? 1 : 0)), undefined, true); @@ -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), undefined, 2); + const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); rt.sliceSort(members, rt.cmpLt(rt.cmpBytes)); const iter8: rt.Iter = rt.iterMap(rt.iterSlice(members), rt.byteSliceFrom); while (true) { @@ -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, undefined, undefined, undefined, 58720256)), undefined, 4); + 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)), "next", 4); rt.sliceSort(lens, rt.cmpLt(rt.cmpBytes)); for (const _559 of lens) { rt.byteVecPush(out, _559.length & 0xff); @@ -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), undefined, 2); + const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashValues(map), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); rt.sliceSort(values, rt.cmpLt(rt.cmpBytes)); const iter4: rt.Iter = rt.iterMap(rt.iterSlice(values), rt.byteSliceFrom); while (true) { diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index 72c499688..964959ddd 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -360,13 +360,13 @@ 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), undefined, 2)), (_28: rt.u8 | undefined): rt.u8 => { + }, rt.None), "next", 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)), undefined, 2)), (_211: rt.u8 | undefined): rt.u8 => { + }, rt.None)), "next", 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 => { @@ -383,7 +383,7 @@ 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), undefined, 2); + }, rt.None), "next", 2); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(whiles), (_215: rt.u8 | undefined): rt.u8 => { return code(_215); }), undefined, true); @@ -402,7 +402,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.None; }, rt.None); - const first: Array = rt.iterToArray(rt.iterBorrow(made_), undefined, 2); + const first: Array = rt.iterToArray(rt.iterBorrow(made_), "next", 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); @@ -428,7 +428,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { return pick(_84); } return rt.None; - }, undefined, rt.None), undefined, 2)), (_222: rt.u8 | undefined): rt.u8 => { + }, undefined, rt.None), "next", 2)), (_222: rt.u8 | undefined): rt.u8 => { return code(_222); }), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen)), undefined, true); diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index 7f3a577f8..0d78f5a0f 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -392,7 +392,7 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { }), _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); + }), "next", 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]))); @@ -450,7 +450,7 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, requeue(q, map, _519) & 0xff); } rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); - rt.iterExtendBytes(out, rt.hashValues(map)); + rt.iterExtendBytes(out, rt.hashValues(map), "next"); const weak: rt.Weak = new rt.Weak(); relink(weak, two); rt.byteVecPush(out, mapOr$1q3ff8g(rt.weakUpgrade(weak), 238, (a3: rt.Arc): rt.u8 => { diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index 4a5b4984b..e81b6eb54 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -323,7 +323,7 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { } else { rt.iterExtendBytes(out, rt.iterMap(rt.heapIter(heap), (x: Item.Item): rt.u8 => { return x.tag; - })); + }), "next"); 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)), undefined, true); @@ -407,10 +407,10 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { }, rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(copy.d), (s2: string): rt.Iter => { return rt.strBytes(s2); - })); + }), "next"); rt.iterExtendBytes(out, rt.iterMap(rt.heapIter(strings), (s3: string): rt.u8 => { return rt.stringLen(s3) & 0xff; - })); + }), "next"); const pairs: rt.BinaryHeap<[rt.u8, rt.u8]> = rt.heapNew() as rt.BinaryHeap<[rt.u8, rt.u8]>; const _73: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [rt.u8, rt.u8] => { const b5: rt.u8 = _24; diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 7e599627d..7b861136b 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -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, undefined, undefined, undefined, 8)), 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, "next", 8)), rt.btreeIter(tree)); while (true) { const _264: [rt.u8, rt.u32] | rt.Done = iter6.next(); if (_264 === rt.DONE) { @@ -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); + }), "next", 4); })(); return held.length === 0; }) as rt.u32))); @@ -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)); + }), "next", 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, undefined, undefined, undefined, 8)); + const iter29: rt.Iter<[rt.u8, rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _486, true, undefined, undefined, "next", 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, undefined, undefined, undefined, 8)); + 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, "next", 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, undefined, undefined, undefined, 3)); + 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, "next", 3)); while (true) { const _564: [rt.u8, [rt.u8, rt.u8]] | rt.Done = iter34.next(); if (_564 === rt.DONE) { diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index 1ee92426e..d9797357d 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)) { + }), "next", 4)) { putOffset(out, _190); } break b0; @@ -356,7 +356,7 @@ 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, "/"), undefined, 8); + const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), "next", 8); put(out, parts.join(p)); put(out, rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (part3: string): string => { return part3; @@ -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), undefined, 4); - const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), undefined, 8); + const chars: rt.char[] = rt.iterToArray(rt.strChars(s), "next", 4); + const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), "next", 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); diff --git a/ts/fixtures/lang/src/folds.rs b/ts/fixtures/lang/src/folds.rs new file mode 100644 index 000000000..fde6e2c4c --- /dev/null +++ b/ts/fixtures/lang/src/folds.rs @@ -0,0 +1,227 @@ +//! An inclusive range borrowed by `by_ref` and read through each of std's adaptors and +//! consumers, after which it is printed: its bounds, whether it is empty, and its `Debug`, +//! which says whether it is exhausted. Where std's adaptor folds the range, as `try_fold` +//! and `try_rfold` step it, `start` stops at `end`, exhausted; where it reads by `next`, +//! `start` passes `end`, and only wrapping exhausts it. + +use std::fmt::Debug; +use std::ops::RangeInclusive; + +use crate::fmt::put; + +/// `r`'s state after `v`, what read it returned. +fn state(out: &mut Vec, v: impl Debug, r: &RangeInclusive) { + put( + out, + &format!("{v:?} {:?} {:?} {} {r:?}", r.start(), r.end(), r.is_empty()), + ); +} + +/// Each read of `$lo..=$hi`, a fresh range of each, stopping early at `$k`, the item +/// `$n` past the start, if any, of `$t`s. +macro_rules! folds { + ($out:ident, $t:ty, $lo:expr, $hi:expr, $n:expr) => {{ + let (lo, hi, n): ($t, $t, usize) = ($lo, $hi, $n); + let k = (lo..=hi).nth(n); + let is_k = |x: &$t| Some(*x) == k; + let below = |x: &$t| match k { + Some(k) => *x < k, + None => true, + }; + macro_rules! read { + (|$r:ident| $e:expr) => {{ + let mut $r = lo..=hi; + let v = $e; + state($out, v, &$r); + }}; + } + // `for` reads by `next`, as does a `break` out of it. + read!(|r| for _ in r.by_ref() {}); + read!(|r| { + for x in r.by_ref() { + if is_k(&x) { + break; + } + } + }); + // The range's own folds, read from the back too. + read!(|r| r.rfind(is_k)); + read!(|r| r.by_ref().rfind(|_| false)); + // `map` and `inspect` fold their iterator, and so do the `fold`s through them. + read!(|r| r.by_ref().map(|x| x).count()); + read!(|r| r.by_ref().map(|x| x).last()); + read!(|r| r.by_ref().map(|x| x).position(|x| is_k(&x))); + read!(|r| r.by_ref().map(|x| x).rfind(is_k)); + read!(|r| r.by_ref().map(|x| x).fold(0usize, |n, _| n + 1)); + // `nth` and `nth_back` advance it by `advance_by`, which folds. + read!(|r| r.by_ref().map(|x| x).nth(n)); + read!(|r| r.by_ref().map(|x| x).nth_back(n)); + read!(|r| r.by_ref().map(|x| x).rev().max()); + read!(|r| r.by_ref().map(|x| x).collect::>().len()); + read!(|r| r.by_ref().inspect(|_| {}).count()); + read!(|r| r.by_ref().inspect(|_| {}).any(|x| is_k(&x))); + // Not `TrustedLen`, so `collect` reads it by `next`. + read!(|r| r.by_ref().inspect(|_| {}).collect::>().len()); + // `filter` and `filter_map` fold it in `next` too, through `find` and `find_map`. + read!(|r| r.by_ref().filter(|x| !is_k(x)).count()); + read!(|r| r.by_ref().filter(is_k).next()); + read!(|r| r.by_ref().filter(is_k).next_back()); + read!(|r| r.by_ref().filter(|_| true).collect::>().len()); + read!(|r| r.by_ref().filter_map(|x| (!is_k(&x)).then_some(x)).count()); + read!(|r| r.by_ref().filter_map(|x| is_k(&x).then_some(x)).next()); + read!(|r| r.by_ref().filter_map(|x| is_k(&x).then_some(x)).next_back()); + // `enumerate` counts as it folds. + read!(|r| r.by_ref().enumerate().count()); + read!(|r| r.by_ref().enumerate().position(|(_, x)| is_k(&x))); + read!(|r| r.by_ref().enumerate().last()); + // `chain` folds each in turn. + read!(|r| r.by_ref().chain(lo..=lo).count()); + read!(|r| (hi..=hi).chain(r.by_ref()).last()); + read!(|r| r.by_ref().chain(hi..=hi).any(|x| is_k(&x))); + read!(|r| r.by_ref().chain(lo..=lo).rev().last()); + // `rev` folds it from the back. + read!(|r| r.by_ref().rev().count()); + read!(|r| r.by_ref().rev().position(|x| is_k(&x))); + read!(|r| r.by_ref().rev().min()); + read!(|r| r.by_ref().rev().rev().last()); + // `take` folds only up to its limit, and so does its `count`, by `advance_by`. + read!(|r| r.by_ref().take(n).last()); + read!(|r| r.by_ref().take(n + 1).max()); + read!(|r| r.by_ref().take(n).count()); + read!(|r| r.by_ref().take(n).map(|x| x).count()); + read!(|r| r.by_ref().take(usize::MAX).min()); + read!(|r| r.by_ref().take(n).enumerate().count()); + // `skip` passes what it skips by `nth`, one short where it then folds. + read!(|r| r.by_ref().skip(n).next()); + read!(|r| r.by_ref().skip(n).count()); + read!(|r| r.by_ref().skip(n).last()); + read!(|r| r.by_ref().skip(n).max()); + read!(|r| r.by_ref().skip(n).collect::>().len()); + // `skip_while` finds its first by `find`; `take_while` and `map_while` fold. + read!(|r| r.by_ref().skip_while(below).next()); + read!(|r| r.by_ref().skip_while(below).count()); + read!(|r| r.by_ref().take_while(below).count()); + read!(|r| r.by_ref().take_while(|_| true).last()); + read!(|r| r.by_ref().take_while(below).collect::>().len()); + read!(|r| r.by_ref().map_while(|x| below(&x).then_some(x)).count()); + read!(|r| r.by_ref().map_while(|x| Some(x)).last()); + read!(|r| r.by_ref().map_while(|x| Some(x)).collect::>().len()); + // `fuse` and `peekable` fold their iterator, `peekable` after what it peeked. + read!(|r| r.by_ref().fuse().count()); + read!(|r| r.by_ref().fuse().rev().any(|x| is_k(&x))); + read!(|r| { + let mut p = r.by_ref().peekable(); + let peeked = p.peek().copied(); + (peeked, p.count()) + }); + read!(|r| { + let mut p = r.by_ref().peekable(); + let peeked = p.peek().copied(); + (peeked, p.rev().last()) + }); + read!(|r| { + let mut p = r.by_ref().peekable(); + let peeked = p.peek().copied(); + (peeked, p.position(|x| is_k(&x))) + }); + read!(|r| r.by_ref().peekable().last()); + // `for` over a `&mut` to a `Peekable`, which then peeks on from where it stopped. + read!(|r| { + let mut p = r.by_ref().peekable(); + for x in p.by_ref() { + if is_k(&x) { + break; + } + } + p.peek().copied() + }); + // `flat_map` and `flatten` fold their source, and each iterator it makes. + read!(|r| r.by_ref().flat_map(|x| Some(x)).count()); + read!(|r| r.by_ref().flat_map(|x| Some(x)).next()); + read!(|r| r.by_ref().map(|x| lo..=x).flatten().count()); + read!(|r| r.by_ref().flat_map(|x| x..=hi).position(|x| is_k(&x))); + read!(|r| r.by_ref().flat_map(|x| [x, x]).rev().last()); + // `step_by` and `zip` read it by `nth` and `next`, as std's do. + read!(|r| r.by_ref().step_by(n + 1).count()); + read!(|r| r.by_ref().zip(0..n).any(|_| false)); + // Collected as `Result`s, read by `try_fold` until the first error. + read!(|r| r.by_ref().map(|x| Ok::<$t, ()>(x)).collect::, _>>().map(|v| v.len())); + read!(|r| { + let items = r.by_ref().map(|x| if is_k(&x) { None } else { Some(x) }); + items.collect::>>().map(|v| v.len()) + }); + // `extend` folds a `TrustedLen` iterator and reads others by `next`. + read!(|r| { + let mut v = Vec::new(); + v.extend(r.by_ref().map(|x| x)); + v.len() + }); + read!(|r| { + let mut v = Vec::new(); + v.extend(r.by_ref().take_while(|_| true)); + v.len() + }); + }}; +} + +/// What only a range of a type with an `ExactSizeIterator` can do: `take` and `skip` +/// from the back, `rposition`, and `enumerate` from the back. +macro_rules! exact { + ($out:ident, $lo:expr, $hi:expr, $n:expr) => {{ + let (lo, hi, n): (u8, u8, usize) = ($lo, $hi, $n); + let k = (lo..=hi).nth(n); + let is_k = |x: u8| Some(x) == k; + macro_rules! read { + (|$r:ident| $e:expr) => {{ + let mut $r = lo..=hi; + let v = $e; + state($out, v, &$r); + }}; + } + read!(|r| r.rposition(is_k)); + read!(|r| r.by_ref().rposition(|_| false)); + read!(|r| r.by_ref().take(n).rev().last()); + read!(|r| r.by_ref().take(n).rposition(is_k)); + read!(|r| r.by_ref().skip(n).rev().last()); + read!(|r| r.by_ref().skip(n).rposition(is_k)); + read!(|r| r.by_ref().enumerate().rev().last()); + read!(|r| r.by_ref().enumerate().rposition(|(_, x)| is_k(x))); + }}; +} + +/// Each read of empty, single, and full ranges of the integer type `kind` picks, and at +/// its limits. +pub fn folds(kind: u8, data: &[u8], out: &mut Vec) { + let at = |i: usize| data.get(i).copied().unwrap_or(0); + let (a, b, n) = (at(0), at(1), at(2) as usize % 6); + match kind % 2 { + 0 => { + for (lo, hi) in [ + (a, b), + (a, a), + (b, a), + (u8::MAX - a % 4, u8::MAX), + (u8::MAX, u8::MAX), + (0, a % 4), + ] { + folds!(out, u8, lo, hi, n); + exact!(out, lo, hi, n); + } + } + _ => { + let (a, b) = (a as i64 - 128, b as i64 - 128); + let low = i64::MIN + (at(0) % 4) as i64; + let high = i64::MAX - (at(1) % 4) as i64; + for (lo, hi) in [ + (a, b), + (a, a), + (b, a), + (i64::MIN, low), + (i64::MIN, i64::MIN), + (high, i64::MAX), + ] { + folds!(out, i64, lo, hi, n); + } + } + } +} diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 553f30dd6..ef4c6a308 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, hints, 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, folds, 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 @@ -164,6 +164,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("hints::hints", hints::hints), ("hints::reserves", hints::reserves), ("collections::set_ops", collections::set_ops), + ("folds::folds", folds::folds), ] } diff --git a/ts/fixtures/lang/src/iters.rs b/ts/fixtures/lang/src/iters.rs index b608bf915..09e4f6193 100644 --- a/ts/fixtures/lang/src/iters.rs +++ b/ts/fixtures/lang/src/iters.rs @@ -832,6 +832,13 @@ pub fn own(data: &[u8], out: &mut Vec) { }; let firsts: Vec = by_ref.by_ref().take(2).collect(); out.extend_from_slice(&firsts); + // `for` over a `&mut` to one, which reads on from where it stopped. + for n in by_ref.by_ref() { + if n % 4 == 0 { + break; + } + out.push(n); + } out.push(by_ref.count() as u8); // Two instances of one generic iterator, each with its own `next` on one class. let halves: Vec = Halving { value: left }.collect(); diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 21d2eae31..9abb671a8 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -12,8 +12,9 @@ //! `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`, the equality of `Result`s and std's errors, iterators' -//! size hints, and the capacity overflows collections reserving by them panic with. +//! the crate's own `RangeBounds`, the equality of `Result`s and std's errors, inclusive +//! ranges read through each adaptor, 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. @@ -37,6 +38,7 @@ mod edits; mod errors; mod floats; mod fmt; +mod folds; mod generics; pub mod harness; mod hashes; diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 7f968dd75..5ec0fe41a 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -15,7 +15,8 @@ // takes the iterator by value, which drops it as std's does. Each kind's `nth`, // `nth_back`, and `advance_by` are its own, as std's are, reading and dropping what they // skip in its order. A consumer std folds reads what `folded` returns, which steps -// an inclusive range as its `try_fold` does. Where std's `count` and `last` drop items in +// an inclusive range as its `try_fold` does, and by `nextBack` as its `try_rfold` does, +// as does each adaptor whose std's folds its iterator. Where std's `count` and `last` drop items in // an order each kind of iterator has its own, the `owned` functions follow it, dispatching // on the kind, so a bundle that never drops an item carries none of it. @@ -77,10 +78,14 @@ export abstract class Iter implements Iterable { /** The next item, or `DONE`. */ abstract next(): T | Done; - /** `advance_by`: skip up to `n` items, each dropped by `drop`, and return how many it fell short. */ + /** + * `advance_by`: skip up to `n` items, each dropped by `drop`, and return how many it fell + * short. std's folds it, as `folded` steps it. + */ advanceBy(n: number, drop?: Drop): number { + const folded = this.folded(); for (let i = 0; i < n; i++) { - const item = this.next(); + const item = folded.next(); if (item === DONE) return n - i; drop?.(item); } @@ -89,8 +94,9 @@ export abstract class Iter implements Iterable { /** `advance_back_by`, from the back. */ advanceBackBy(n: number, drop?: Drop): number { + const folded = this.folded(); for (let i = 0; i < n; i++) { - const item = this.nextBack(); + const item = folded.nextBack(); if (item === DONE) return n - i; drop?.(item); } @@ -107,7 +113,10 @@ export abstract class Iter implements Iterable { return this.advanceBackBy(n, drop) === 0 ? this.nextBack() : DONE; } - /** What std's `try_fold` reads it by: itself, but for an inclusive range, which steps its own way. */ + /** + * What std's `try_fold` reads it by, and `try_rfold` by `nextBack`: itself, but for an + * inclusive range, which steps its own way, and an adaptor that folds one. + */ folded(): Iter { return this; } @@ -138,13 +147,13 @@ export abstract class Iter implements Iterable { } /** - * std's default `fold`, or `rfold` if `back`: each item as `folded` steps it, or by - * `next_back`, and then `release` and `it`. + * std's default `fold`, or `rfold` if `back`: each item as `folded` steps it, from the + * back if `back`, and then `release` and `it`. */ function foldBy(it: Iter, back: boolean, acc: A, f: (acc: A, item: T) => A, release?: () => void): A { const folded = it.folded(); for (;;) { - const item = back ? it.nextBack() : folded.next(); + const item = back ? folded.nextBack() : folded.next(); if (item === DONE) break; acc = f(acc, item); } @@ -221,6 +230,26 @@ abstract class Calling extends Adaptor { } } +/** An adaptor folded, whose `next` and `nextBack` are `front` and `back`, which share its state. */ +class Folded extends Iter { + readonly front: () => T | Done; + readonly back: () => T | Done; + + constructor(front: () => T | Done, back: () => T | Done) { + super(); + this.front = front; + this.back = back; + } + + next(): T | Done { + return this.front(); + } + + override nextBack(): T | Done { + return this.back(); + } +} + /** The item `next` returned, as an `Option`. */ export function iterToOption(item: T | Done): T | undefined; export function iterToOption(item: T | Done, none: None): T | None; @@ -607,8 +636,9 @@ export function iterFlatten(it: Iter, into?: (value: T) => Iter, fus // says, and else by `next`, dropping it once done. /** - * How a consumer takes an iterator by value that drops, where std's may either way: by - * `next`, as std's does one it can't trust the length of, or by its own `fold`. + * How a consumer takes an iterator by value, where std's may either way: by `next`, as + * std's does one it can't trust the length of, or by its own `fold`, which drops what it + * holds. Without either, it drops nothing, and std's folds it. */ export type Take = "next" | "fold"; @@ -679,9 +709,10 @@ function findItem(it: Iter, f: (item: T) => boolean, drop?: Drop): T | return DONE; } -/** `rfind`, as `next_back` returns it. */ +/** `rfind`, as `next_back` returns it, as `try_rfold` steps it. */ function rfindItem(it: Iter, f: (item: T) => boolean, drop?: Drop): T | Done { - for (let item = it.nextBack(); item !== DONE; item = it.nextBack()) { + const folded = it.folded(); + for (let item = folded.nextBack(); item !== DONE; item = folded.nextBack()) { if (f(item)) return item; drop?.(item); } @@ -717,7 +748,8 @@ export function iterRfind(it: Iter, f: (item: T) => boolean, drop?: Drop(it: Iter, f: (item: T) => boolean): number | undefined { let i = it.len(); - for (let item = it.nextBack(); item !== DONE; item = it.nextBack()) { + const folded = it.folded(); + for (let item = folded.nextBack(); item !== DONE; item = folded.nextBack()) { i--; if (f(item)) return i; } @@ -1489,6 +1521,12 @@ class MapIter extends Calling U> { return this.inner.len(); } + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + return new MapIter(inner, this.f); + } + /** std's: `inner`'s, by a closure that drops `release`'s and then `f`. */ override fold(acc: A, g: (acc: A, item: U) => A, release?: () => void): A { return this.inner.fold(acc, mapFold(this.f, g), then(release, this.take())); @@ -1569,8 +1607,10 @@ class FilterMapIter extends Calling U | undefined | Non this.none = none; } + /** std's, by `find_map`, which folds its iterator. */ next(): U | Done { - for (let item = this.inner.next(); item !== DONE; item = this.inner.next()) { + const inner = this.inner.folded(); + for (let item = inner.next(); item !== DONE; item = inner.next()) { const mapped = this.f(item); if (mapped !== this.none) return mapped as U; } @@ -1582,7 +1622,8 @@ class FilterMapIter extends Calling U | undefined | Non } override nextBack(): U | Done { - for (let item = this.inner.nextBack(); item !== DONE; item = this.inner.nextBack()) { + const inner = this.inner.folded(); + for (let item = inner.nextBack(); item !== DONE; item = inner.nextBack()) { const mapped = this.f(item); if (mapped !== this.none) return mapped as U; } @@ -1651,6 +1692,21 @@ class EnumerateIter extends Adaptor { return item === DONE ? DONE : [this.index + this.inner.len(), item]; } + /** std's: its iterator folded, counting each item as it goes, and from the back from its length. */ + override folded(): Iter<[number, T]> { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + const front = (): [number, T] | Done => { + const item = inner.next(); + return item === DONE ? DONE : [this.index++, item]; + }; + const back = (): [number, T] | Done => { + const item = inner.nextBack(); + return item === DONE ? DONE : [this.index + this.inner.len(), item]; + }; + return new Folded(front, back); + } + override fold(acc: A, g: (acc: A, item: [number, T]) => A, release?: () => void): A { let i = this.index; return this.inner.fold(acc, (acc, item) => g(acc, [i++, item]), release); @@ -1721,6 +1777,30 @@ class ChainIter extends Iter implements Disposable { this.endB(); } + /** std's: each folded in turn, the first dropped once it ends. */ + override folded(): Iter { + const a = this.a?.folded(); + const b = this.b?.folded(); + if (a === this.a && b === this.b) return this; + const front = (): T | Done => { + if (this.a !== undefined) { + const item = a!.next(); + if (item !== DONE) return item; + this.endA(); + } + return this.b === undefined ? DONE : b!.next(); + }; + const back = (): T | Done => { + if (this.b !== undefined) { + const item = b!.nextBack(); + if (item !== DONE) return item; + this.endB(); + } + return this.a === undefined ? DONE : a!.nextBack(); + }; + return new Folded(front, back); + } + override advanceBy(n: number, drop?: Drop): number { if (this.a !== undefined) { n = this.a.advanceBy(n, drop); @@ -1908,6 +1988,12 @@ class RevIter extends Adaptor { return this.inner.nth(n, drop); } + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + return new RevIter(inner); + } + override fold(acc: A, f: (acc: A, item: T) => A, release?: () => void): A { return this.inner.rfold(acc, f, release); } @@ -1981,6 +2067,26 @@ class SkipIter extends Adaptor { return this.inner.nth(n, drop); } + /** + * std's: past what it skips by `nth`, one short of where `next` reads, then its iterator + * folded, and from the back, its iterator folded down to what it skips. + */ + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + const front = (): T | Done => { + if (this.n > 0) { + const n = this.n; + this.n = 0; + const item = this.inner.nth(n - 1, this.drop); + if (item === DONE) return DONE; + this.drop?.(item); + } + return inner.next(); + }; + return new Folded(front, () => (this.len() > 0 ? inner.nextBack() : DONE)); + } + /** std's: past what it skips by `nth`, and then its iterator's own. */ override fold(acc: A, f: (acc: A, item: T) => A, release?: () => void): A { if (this.n > 0) { @@ -2047,6 +2153,32 @@ class TakeIter extends Adaptor { return n - advanced; } + /** + * std's: its iterator folded, counting each item it reads against the limit, and from + * the back, past what it holds beyond the limit by `nth_back`, folded without counting. + */ + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + const front = (): T | Done => { + if (this.n === 0) return DONE; + const item = inner.next(); + if (item !== DONE) this.n--; + return item; + }; + const back = (): T | Done => { + if (this.n === 0) return DONE; + const len = this.inner.len(); + if (len > this.n) { + const item = this.inner.nthBack(len - this.n - 1, this.drop); + if (item === DONE) return DONE; + this.drop?.(item); + } + return inner.nextBack(); + }; + return new Folded(front, back); + } + /** std's: its iterator advanced from the back past the limit and `n` more, in one step. */ override advanceBackBy(n: number, drop?: Drop): number { const trim = Math.max(this.inner.len() - this.n, 0); @@ -2150,8 +2282,19 @@ class TakeWhileIter extends Calling boolean> { } next(): T | Done { + return this.from(this.inner); + } + + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + return new FromNext(inner, (inner) => this.from(inner)); + } + + /** The next item of `inner`, its iterator or that folded, while `f` holds of each. */ + private from(inner: Iter): T | Done { if (this.flag) return DONE; - const item = this.inner.next(); + const item = inner.next(); if (item === DONE) return DONE; if (this.f(item)) return item; this.flag = true; @@ -2179,6 +2322,12 @@ class MapWhileIter extends Calling U | undefined | None return item === DONE ? DONE : iterFromOption(this.f(item), this.none); } + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + return new MapWhileIter(inner, this.f, this.none); + } + override sizeHint(): SizeHint { return fewer(this.inner); } @@ -2312,6 +2461,12 @@ class InspectIter extends Calling void> { return this.inner.len(); } + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + return new InspectIter(inner, this.f); + } + /** std's: `inner`'s, by a closure that drops `f` and then `release`'s. */ override fold(acc: A, g: (acc: A, item: T) => A, release?: () => void): A { return this.inner.fold(acc, this.inspectFold(g), then(this.take(), release)); @@ -2378,6 +2533,15 @@ class FuseIter extends Iter implements Disposable { return this.inner === undefined ? DONE : this.clear(this.inner.nth(n, drop)); } + /** std's: its iterator folded, dropped once it ends unless it is fused. */ + override folded(): Iter { + const inner = this.inner?.folded(); + if (inner === this.inner) return this; + const front = () => (this.inner === undefined ? DONE : this.clear(inner!.next())); + const back = () => (this.inner === undefined ? DONE : this.clear(inner!.nextBack())); + return new Folded(front, back); + } + override nthBack(n: number, drop?: Drop): T | Done { return this.inner === undefined ? DONE : this.clear(this.inner.nthBack(n, drop)); } @@ -2525,6 +2689,14 @@ class FlattenIter extends Iter implements Disposable { dispose(back); } + /** Its fold's view, which each fold starts anew. */ + private view: FlattenFold | undefined; + + override folded(): Iter { + this.view ??= new FlattenFold(this); + return this.view.reset(); + } + override fold(acc: A, f: (acc: A, item: V) => A, release?: () => void): A { return flattenFold(this, false, acc, (acc, inner) => inner.fold(acc, f), release); } @@ -2534,9 +2706,9 @@ class FlattenIter extends Iter implements Disposable { } /** - * std's, by `try_fold`: each iterator in turn advanced by its own `advance_by`, one - * that falls short dropped only as the next replaces it, and the source dropped once - * it ends unless it is fused. + * std's, by `try_fold`: each iterator in turn advanced by its own `advance_by`, of its + * source folded, one that falls short dropped only as the next replaces it, and the + * source dropped once it ends unless it is fused. */ override advanceBy(n: number, drop?: Drop): number { if (this.front !== undefined) { @@ -2546,7 +2718,8 @@ class FlattenIter extends Iter implements Disposable { this.setFront(undefined); const outer = this.outer; if (outer !== undefined) { - for (let inner = outer.next(); inner !== DONE; inner = outer.next()) { + const source = outer.folded(); + for (let inner = source.next(); inner !== DONE; inner = source.next()) { const front = this.into(inner); this.setFront(front); n = front.advanceBy(n, drop); @@ -2574,7 +2747,8 @@ class FlattenIter extends Iter implements Disposable { this.setBack(undefined); const outer = this.outer; if (outer !== undefined) { - for (let inner = outer.nextBack(); inner !== DONE; inner = outer.nextBack()) { + const source = outer.folded(); + for (let inner = source.nextBack(); inner !== DONE; inner = source.nextBack()) { const back = this.into(inner); this.setBack(back); n = back.advanceBackBy(n, drop); @@ -2595,6 +2769,79 @@ class FlattenIter extends Iter implements Disposable { } } +/** + * A flatten as std's `try_fold` reads it, or `try_rfold` from the back: the iterator it + * holds at that end folded, which then drops, then its source folded, each iterator it + * makes held and folded in turn, dropping the one before, and then the other end's, which + * drops once it ends. The source drops once it ends unless it is fused. + */ +class FlattenFold extends Iter { + readonly of: FlattenIter; + /** At its own end, then its source's, then the other end. */ + private phase = 0; + private source: Iter | undefined; + /** The iterator it reads, and that folded. */ + private held: Iter | undefined; + private reading: Iter | undefined; + + constructor(of: FlattenIter) { + super(); + this.of = of; + } + + /** Itself, at the start of a fold. */ + reset(): this { + this.phase = 0; + this.source = this.of.outer?.folded(); + this.held = this.reading = undefined; + return this; + } + + next(): V | Done { + return this.step(false); + } + + override nextBack(): V | Done { + return this.step(true); + } + + private step(back: boolean): V | Done { + const of = this.of; + for (;;) { + const it = back !== (this.phase === 2) ? of.back : of.front; + if (it !== undefined) { + if (it !== this.held) [this.held, this.reading] = [it, it.folded()]; + const item = back ? this.reading!.nextBack() : this.reading!.next(); + if (item !== DONE) return item; + } + if (this.phase === 2) { + this.hold(back, undefined, true); + return DONE; + } + if (this.phase === 1) { + const outer = of.outer; + const value = outer === undefined ? DONE : back ? this.source!.nextBack() : this.source!.next(); + if (value !== DONE) { + this.hold(back, of.into(value), false); + continue; + } + if (outer !== undefined && !of.fused) { + of.outer = undefined; + dispose(outer); + } + } + this.hold(back, undefined, false); + this.phase++; + } + } + + /** Hold `it` at the end it folds from, from the back if `back`, or at the other. */ + private hold(back: boolean, it: Iter | undefined, other: boolean): void { + if (back !== other) this.of.setBack(it); + else this.of.setFront(it); + } +} + /** `Peekable`, which drops the item it peeked by `drop`. */ export class Peekable extends Adaptor { peeked = false; @@ -2649,6 +2896,23 @@ export class Peekable extends Adaptor { if (item !== DONE) this.drop?.(item); } + /** + * std's: the item it peeked, or none past a peeked end, and then its iterator folded; from + * the back, its iterator folded and then the item it peeked, which it holds until then. + */ + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + const front = () => (this.peeked ? this.take() : inner.next()); + const back = (): T | Done => { + if (!this.peeked) return inner.nextBack(); + if (this.item === DONE) return this.take(); + const item = inner.nextBack(); + return item !== DONE ? item : this.take(); + }; + return new Folded(front, back); + } + /** std's: the item it peeked, and then its iterator's fold. */ override fold(acc: A, f: (acc: A, item: T) => A, release?: () => void): A { if (this.peeked) { @@ -2732,9 +2996,10 @@ export function peekableNextIfEq(p: Peekable, expected: U, eq: (a: T, b class ResultShunt extends Adaptor, U> { error: { value: E } | undefined; + /** std's, by `try_for_each`, which folds its iterator. */ next(): U | Done { if (this.error !== undefined) return DONE; - const item = this.inner.next(); + const item = this.inner.folded().next(); if (item === DONE) return DONE; if (item.ok) return item.value; this.error = { value: item.error }; @@ -2752,7 +3017,7 @@ class OptionShunt extends Adaptor { next(): U | Done { if (this.none) return DONE; - const item = this.inner.next(); + const item = this.inner.folded().next(); if (item === DONE) return DONE; if (item !== undefined) return item; this.none = true; @@ -2928,7 +3193,10 @@ export class RangeInclusive extends Iter { } } -/** An inclusive range as std's `try_fold` steps it: `start` stops at `end`, which exhausts it, so it never wraps. */ +/** + * An inclusive range as std's `try_fold` steps it, and `try_rfold` from the back: `start` + * or `end` stops at the other, which exhausts it, so it never wraps. + */ class RangeInclusiveFold extends Iter { readonly range: RangeInclusive; @@ -2946,6 +3214,15 @@ class RangeInclusiveFold extends Iter { return lo; } + override nextBack(): T | Done { + const r = this.range; + if (rangeInclusiveIsEmpty(r)) return DONE; + const hi = r.hi; + if (lt(r.lo, hi)) r.hi = step(hi, -1, r.int)!; + else r.exhausted = true; + return hi; + } + override sizeHint(): SizeHint { return this.range.sizeHint(); } diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 315d3740f..fa583f9a2 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -302,6 +302,13 @@ pub fn call<'tcx>( } // A `&mut` to a `&mut` iterator is itself, an `rt.Place` that each use reads through. ("IntoIterator", "into_iter") if through_mut(targ(0)?) => return args.pop(), + // So is a `&mut` iterator, which what takes it by value borrows as it does. + ("IntoIterator", "into_iter") + if targ(0)?.ref_mutability() == Some(ty::Mutability::Mut) && b.t.iter_item(targ(0)?).is_some() => + { + not_bound(b, targ(0)?, span); + return args.pop(); + } ("IntoIterator", "into_iter") => { let value = args.pop()?; return into_iter(b, targ(0)?, value, span); @@ -956,13 +963,14 @@ pub(super) fn iter_drops<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: S } } -/// How a runtime function takes an iterator of type `ty` by value, as `rt.Take` says: by its -/// own `fold` where std's `folds` it, else by `next`, or `undefined` for one that drops -/// nothing. +/// How a runtime function takes an iterator of type `ty` by value, as `rt.Take` says: by +/// `next` unless std's `folds` it, and then by its own `fold`, or `undefined` for one that +/// drops nothing, which it reads as `folded` steps it. pub(super) fn iter_take<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, folds: bool, span: Span) -> Expr { - match drops_iter(b, ty, span) { - true => Expr::Str(if folds { "fold" } else { "next" }.into()), - false => Expr::undefined(), + match (drops_iter(b, ty, span), folds) { + (_, false) => Expr::Str("next".into()), + (true, true) => Expr::Str("fold".into()), + (false, true) => Expr::undefined(), } }