From 877181511fddbea3a515eb5ca621823ec0fde8eb Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 11:55:25 -0700 Subject: [PATCH 1/6] chore(quest): claim quest/m3/ts-range-fold.md Quest-Claim: b14ca40bfe2de79e From c683d6b260b944e440b8a2dfec03731a46674b13 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:25:29 -0700 Subject: [PATCH 2/6] fix(ts): fold an inclusive range through std's adaptors as core does A RangeInclusive borrowed by by_ref and folded through map, filter, rev, chain, peekable, take, skip, and the other adaptors whose std's folds their iterator now ends exhausted with start == end, as core's try_fold and try_rfold leave it. IntoIterator::into_iter of a &mut iterator is the reference itself, so for over r.by_ref() type-checks. Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 2 +- quest/m3/ts-range-fold.md | 34 - quest/m3/ts-zip-fold.md | 23 + ts/fixtures/codec/expected/bench.ts | 2 +- ts/fixtures/lang/expected/bounds.ts | 6 +- ts/fixtures/lang/expected/chars.ts | 2 +- ts/fixtures/lang/expected/collections.ts | 38 +- ts/fixtures/lang/expected/core/option.ts | 14 + ts/fixtures/lang/expected/core/result.ts | 14 + ts/fixtures/lang/expected/errors.ts | 6 +- ts/fixtures/lang/expected/folds.ts | 840 +++++++++++++++++++++++ ts/fixtures/lang/expected/harness.ts | 3 +- ts/fixtures/lang/expected/iters.ts | 49 +- ts/fixtures/lang/expected/keys.ts | 10 +- ts/fixtures/lang/expected/nested.ts | 10 +- ts/fixtures/lang/expected/objects.ts | 4 +- ts/fixtures/lang/expected/orders.ts | 6 +- ts/fixtures/lang/expected/refs.ts | 12 +- ts/fixtures/lang/expected/strs.ts | 8 +- ts/fixtures/lang/src/folds.rs | 224 ++++++ ts/fixtures/lang/src/harness.rs | 5 +- ts/fixtures/lang/src/iters.rs | 7 + ts/fixtures/lang/src/lib.rs | 3 +- ts/runtime/rt/iter.ts | 339 +++++++-- ts/src/lower/iter.rs | 20 +- 25 files changed, 1515 insertions(+), 166 deletions(-) delete mode 100644 quest/m3/ts-range-fold.md create mode 100644 quest/m3/ts-zip-fold.md create mode 100644 ts/fixtures/lang/expected/folds.ts create mode 100644 ts/fixtures/lang/src/folds.rs diff --git a/quest/m3/README.md b/quest/m3/README.md index d9aba5578..e393e962b 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 - [Binding gaps](/quest/m3/ts-bind-gaps.md) - bound types as keys, unit returns checked, renamed dependencies - [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 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..2f7338e89 --- /dev/null +++ b/quest/m3/ts-zip-fold.md @@ -0,0 +1,23 @@ +# [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. + +## Related + +- [Size hints of std's iterators](/quest/m3/ts-size-hints.md) - the upper bound std's fold reads diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 2539171df..76deca557 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 e3eb8e462..702fa8ee1 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)); 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); - 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 992e07504..82a9d5a60 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); - })); + }), "next"); 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 a71883d6b..5fc65280f 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -102,7 +102,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _80: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map), (_231: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { return [_231[0], _231[1]] as [rt.u8, rt.u16]; }); - const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _80, true)); + const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _80, true, undefined, undefined, "next")); while (true) { const _86: [rt.u8, rt.u16] | rt.Done = iter2.next(); if (_86 === rt.DONE) { @@ -134,7 +134,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } } const _136: rt.Iter = rt.hashKeys(map2); - const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _136, true)); + const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _136, true, undefined, "next")); while (true) { const _142: rt.u64 | rt.Done = iter4.next(); if (_142 === rt.DONE) { @@ -189,7 +189,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _238: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.hashIter(map3), (_212: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { return [_212[0]._0, _212[1]] as [rt.u8, rt.u8]; }); - const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _238, true)); + const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _238, true, undefined, undefined, "next")); while (true) { const _243: [rt.u8, rt.u8] | rt.Done = iter6.next(); if (_243 === rt.DONE) { @@ -213,7 +213,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, before.n & 0xff); rt.byteVecPush(out, rt.hashIndex(pairs, key).n & 0xff); const _278: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.hashIter(pairs); - const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _278, true)); + const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$Ord) as rt.BTreeMap, _278, true, undefined, undefined, "next")); 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)); + 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")); while (true) { const _492: [Rank.Rank, rt.u16] | rt.Done = iter14.next(); if (_492 === rt.DONE) { @@ -416,7 +416,7 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _596: rt.Iter = rt.iterMap(rt.hashKeys(clashes), (k8: Clash.Clash): rt.u8 => { return k8._0; }); - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _596, true))); + rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _596, true, undefined, "next"))); const copy3: rt.HashMap = rt.hashClone(clashes, undefined, copy$Tally); rt.byteVecPush(out, rt.hashLen(copy3) & 0xff); rt.byteVecPush(out, rt.hashContains(copy3, { _0: 1 }) ? 1 : 0); @@ -486,7 +486,7 @@ export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, unwrapOr$1j4op5y(rt.btreeFirstKey(sorted), 255) & 0xff); rt.byteVecPush(out, unwrapOr$1j4op5y(rt.btreeFirstKey(sorted, true), 255) & 0xff); - rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12))).length & 0xff); + rt.byteVecPush(out, rt.iterToArray(rt.btreeRangeKeys(sorted, new rt.Range(4, 12)), "next").length & 0xff); rt.hashRetain(hashed, (v3: rt.u16): boolean => { return rt.u16Rem(v3, 3) !== 0; }); @@ -665,16 +665,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)); @@ -904,7 +904,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } rt.byteVecPush(out, _83[0] ^ _83[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 _101: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tally.Tally => { return { n: _2 as rt.u16 }; @@ -946,14 +946,14 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { const q2: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, _171); const _174: rt.usize = rt.usizeRem(a, 4); if (_174 === 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 (_174 === 1) { const _181: rt.RangeInclusive = new rt.RangeInclusive(a, b2, rt.usizeStep); - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _181)); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _181), "next"); } else if (_174 === 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)); @@ -1228,7 +1228,7 @@ export function getMut$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap): [rt.u8, string | undefined][] { const all: [rt.u8, string | undefined][] = rt.iterToArray(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, string | undefined]): [rt.u8, string | undefined] => { return [_2[0], clone$14nprly(_2[1])] as [rt.u8, string | undefined]; - })); + }), "next"); rt.sliceSortByKey(all, (_22: [rt.u8, string | undefined]): rt.u8 => { return _22[0]; }, rt.lt); @@ -1238,7 +1238,7 @@ export function sorted$OptionMap_Option_String_HashMap_u8_Option_String(self: rt export function sorted$OptionMap_Option_u8_HashMap_u8_Option_u8(self: rt.HashMap): [rt.u8, rt.u8 | undefined][] { const all: [rt.u8, rt.u8 | undefined][] = rt.iterToArray(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, rt.u8 | undefined]): [rt.u8, rt.u8 | undefined] => { return [_2[0], _2[1]] as [rt.u8, rt.u8 | undefined]; - })); + }), "next"); rt.sliceSortByKey(all, (_22: [rt.u8, rt.u8 | undefined]): rt.u8 => { return _22[0]; }, rt.lt); @@ -1250,7 +1250,7 @@ export function sorted$OptionMap_unit_HashMap_u8_unit(self: rt.HashMap { return _22[0]; }, rt.lt); @@ -1565,7 +1565,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)); + const all: [[rt.u8, boolean], rt.u8 | undefined][] = rt.iterToArray(rt.hashIter(map), "next"); rt.sliceSort(all, rt.cmpLt(rt.cmpTuple([rt.cmpTuple([rt.cmp, rt.cmp]), rt.cmpOption(rt.cmp)]))); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(all, f, (value: [[rt.u8, boolean], rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0][0], f), (f: rt.Formatter) => rt.fmtBool(value[0][1], f)], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 006e0a6e6..2a92d4880 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -317,6 +317,20 @@ export function map$11y9s7r(self: slices_Pair.Pair[] | undefined, f: (a0: slices 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 d88a3e060..49b508fbb 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 5c9e37182..4637b8c59 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 { })), out); pairs$ParseCharError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s3: string): rt.ParseCharError | undefined => { return err$02r96h1(rt.charFromStr(s3)); - })), out); + }), "next"), out); pairs$ParseBoolError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s4: string): rt.ParseBoolError | undefined => { return err$1ujom0k(parse$0vh4cry(s4)); - })), out); + }), "next"), out); pairs$ParseIntError(rt.iterToArray(rt.iterFilterMap(rt.iterSlice(all), (s5: string): rt.ParseIntError | undefined => { return err$0jf6smd(parse$1fq462u(s5)); - })), out); + }), "next"), out); } } diff --git a/ts/fixtures/lang/expected/folds.ts b/ts/fixtures/lang/expected/folds.ts new file mode 100644 index 000000000..e89a3374e --- /dev/null +++ b/ts/fixtures/lang/expected/folds.ts @@ -0,0 +1,840 @@ +// 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 = (x38: rt.u8): boolean => { + return x38 === k; + }; + const below: (a0: rt.u8) => boolean = (x39: rt.u8): boolean => { + if (k === undefined) { + return true; + } + return x39 < 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, (_222: 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), (x40: rt.u8): rt.u8 => { + return x40; + })), r5); + const r6: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterMap(rt.iterBorrow(r6), (x41: rt.u8): rt.u8 => { + return x41; + })), r6); + const r7: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize(out, rt.iterPosition(rt.iterMap(rt.iterBorrow(r7), (x42: rt.u8): rt.u8 => { + return x42; + }), (x43: rt.u8): boolean => { + return isK(x43); + }), r7); + const r8: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterRfind(rt.iterMap(rt.iterBorrow(r8), (x44: rt.u8): rt.u8 => { + return x44; + }), isK), r8); + const r9: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterFold(rt.iterMap(rt.iterBorrow(r9), (x45: rt.u8): rt.u8 => { + return x45; + }), 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.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r10), (x46: rt.u8): rt.u8 => { + return x46; + })), rt.lt), r10); + const r11: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterMap(rt.iterBorrow(r11), (x47: rt.u8): rt.u8 => { + return x47; + })).length, r11); + const r12: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r12), (_223: rt.u8): void => {})), r12); + const r13: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r13), (_224: rt.u8): void => {}), (x48: rt.u8): boolean => { + return isK(x48); + }), r13); + const r14: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterInspect(rt.iterBorrow(r14), (_225: rt.u8): void => {}), "next").length, r14); + const r15: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _175: rt.RangeInclusive = r15; + const _177: (a0: rt.u8) => boolean = (x49: rt.u8): boolean => { + return !isK(x49); + }; + state$u8_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_175), _177)), r15); + const r16: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r16), isK).next()), r16); + const r17: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r17), isK).nextBack()), r17); + const r18: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterFilter(rt.iterBorrow(r18), (_226: rt.u8): boolean => { + return true; + }), "next").length, r18); + const r19: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _209: rt.RangeInclusive = r19; + const _211: (a0: rt.u8) => rt.u8 | undefined = (x50: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(!isK(x50), x50); + }; + state$u8_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_209), _211)), r19); + const r20: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _219: rt.RangeInclusive = r20; + const _221: (a0: rt.u8) => rt.u8 | undefined = (x51: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(isK(x51), x51); + }; + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_219), _221).next()), r20); + const r21: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _229: rt.RangeInclusive = r21; + const _231: (a0: rt.u8) => rt.u8 | undefined = (x52: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(isK(x52), x52); + }; + state$u8_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_229), _231).nextBack()), r21); + const r22: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r22))), r22); + const r23: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r23)), (_227: [rt.usize, rt.u8]): boolean => { + return isK(_227[1]); + }), r23); + const r24: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize_u8(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r24))), r24); + const r25: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _262: rt.RangeInclusive = r25; + const _264: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_262), _264)), r25); + const r26: 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(r26))), r26); + const r27: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _279: rt.RangeInclusive = r27; + const _281: rt.RangeInclusive = new rt.RangeInclusive(hi2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_279), _281), (x54: rt.u8): boolean => { + return isK(x54); + }), r27); + const r28: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _290: rt.RangeInclusive = r28; + const _292: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_290), _292))), r28); + const r29: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r29))), r29); + const r30: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r30)), (x55: rt.u8): boolean => { + return isK(x55); + }), r30); + const r31: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r31)), rt.lt), r31); + const r32: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r32)))), r32); + const r33: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterTake(rt.iterBorrow(r33), n2)), r33); + const r34: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _337: rt.RangeInclusive = r34; + const _339: rt.usize = rt.usizeAdd(n2, 1); + state$u8_Option_u8(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_337), _339), rt.lt), r34); + const r35: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r35), n2)), r35); + const r36: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r36), n2), (x56: rt.u8): rt.u8 => { + return x56; + })), r36); + const r37: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterMin(rt.iterTake(rt.iterBorrow(r37), 4294967295), rt.lt), r37); + const r38: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterTake(rt.iterBorrow(r38), n2))), r38); + const r39: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterSkip(rt.iterBorrow(r39), n2).next()), r39); + const r40: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterSkip(rt.iterBorrow(r40), n2)), r40); + const r41: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterSkip(rt.iterBorrow(r41), n2)), r41); + const r42: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r42), n2), rt.lt), r42); + const r43: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterSkip(rt.iterBorrow(r43), n2), "next").length, r43); + const r44: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r44), below).next()), r44); + const r45: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterSkipWhile(rt.iterBorrow(r45), below)), r45); + const r46: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r46), below)), r46); + const r47: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r47), (_230: rt.u8): boolean => { + return true; + })), r47); + const r48: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterTakeWhile(rt.iterBorrow(r48), below), "next").length, r48); + const r49: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _452: rt.RangeInclusive = r49; + const _454: (a0: rt.u8) => rt.u8 | undefined = (x57: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(below(x57), x57); + }; + state$u8_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_452), _454)), r49); + const r50: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r50), (x58: rt.u8): rt.u8 | undefined => { + return x58; + })), r50); + const r51: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterToByteVec(rt.iterMapWhile(rt.iterBorrow(r51), (x59: rt.u8): rt.u8 | undefined => { + return x59; + }), "next").length, r51); + const r52: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r52))), r52); + const r53: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r53))), (x60: rt.u8): boolean => { + return isK(x60); + }), r53); + const r54: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r54)); + state$u8_Option_u8_usize(out, [rt.peekablePeek(p), rt.iterCount(p)] as [rt.u8 | undefined, rt.usize], r54); + const r55: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p2: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r55)); + state$u8_Option_u8_Option_u8(out, [rt.peekablePeek(p2), rt.iterLast(rt.iterRev(p2))] as [rt.u8 | undefined, rt.u8 | undefined], r55); + const r56: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p3: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r56)); + state$u8_Option_u8_Option_usize(out, [rt.peekablePeek(p3), rt.iterPosition(p3, (x61: rt.u8): boolean => { + return isK(x61); + })] as [rt.u8 | undefined, rt.usize | undefined], r56); + const r57: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r57))), r57); + const r58: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const p4: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r58)); + const iter4: rt.Peekable = p4; + while (true) { + const _547: rt.u8 | rt.Done = iter4.next(); + if (_547 === rt.DONE) { + break; + } + if (isK(_547)) { + break; + } + } + state$u8_Option_u8(out, rt.peekablePeek(p4), r58); + const r59: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r59), (x62: rt.u8): rt.u8 | undefined => { + return x62; + }, (value: rt.u8 | undefined) => rt.iterOption(value))), r59); + const r60: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r60), (x63: rt.u8): rt.u8 | undefined => { + return x63; + }, (value: rt.u8 | undefined) => rt.iterOption(value)).next()), r60); + const r61: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _578: rt.RangeInclusive = r61; + const _580: (a0: rt.u8) => rt.RangeInclusive = (x64: rt.u8): rt.RangeInclusive => { + return new rt.RangeInclusive(lo2, x64, rt.u8Step); + }; + state$u8_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_578), _580))), r61); + const r62: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _588: rt.RangeInclusive = r62; + const _590: (a0: rt.u8) => rt.RangeInclusive = (x65: rt.u8): rt.RangeInclusive => { + return new rt.RangeInclusive(x65, hi2, rt.u8Step); + }; + state$u8_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_588), _590), (x66: rt.u8): boolean => { + return isK(x66); + }), r62); + const r63: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r63), (x67: rt.u8): Uint8Array => { + return Uint8Array.of(x67, x67); + }, (value: Uint8Array) => rt.iterSlice(value), false, 2))), r63); + const r64: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _607: rt.RangeInclusive = r64; + const _609: rt.usize = rt.usizeAdd(n2, 1); + state$u8_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_607), _609)), r64); + const r65: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r65), new rt.Range(0, n2)), (_232: [rt.u8, rt.usize]): boolean => { + return false; + }), r65); + const r66: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + state$u8_Result_usize_unit(out, map$1w3j91w(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r66), (x68: rt.u8): rt.Result => { + return rt.Ok(x68); + }), (values: rt.Iter) => rt.iterToByteVec(values)), (v149: rt.ByteVec): rt.usize => { + return v149.length; + }), r66); + const r67: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const _633: rt.RangeInclusive = r67; + const _635: (a0: rt.u8) => rt.u8 | undefined = (x69: rt.u8): rt.u8 | undefined => { + if (!isK(x69)) { + return x69; + } + return undefined; + }; + state$u8_Option_usize(out, map$1c7fhtg(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_633), _635), (values: rt.Iter) => rt.iterToByteVec(values)), (v150: rt.ByteVec): rt.usize => { + return v150.length; + }), r67); + const r68: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const v67: rt.ByteVec = new rt.ByteVec(); + const _645: rt.Iter = rt.iterMap(rt.iterBorrow(r68), (x70: rt.u8): rt.u8 => { + return x70; + }); + rt.iterExtendBytes(v67, _645); + state$u8_usize(out, v67.length, r68); + const r69: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); + const v69: rt.ByteVec = new rt.ByteVec(); + const _656: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r69), (_233: rt.u8): boolean => { + return true; + }); + rt.iterExtendBytes(v69, _656, "next"); + state$u8_usize(out, v69.length, r69); + 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 = (x71: rt.u8): boolean => { + return x71 === k2; + }; + const r70: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(r70, isK2), r70); + const r71: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(r71, (_234: rt.u8): boolean => { + return false; + }), r71); + const r72: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterTake(rt.iterBorrow(r72), n3))), r72); + const r73: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(rt.iterTake(rt.iterBorrow(r73), n3), isK2), r73); + const r74: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterSkip(rt.iterBorrow(r74), n3))), r74); + const r75: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(rt.iterSkip(rt.iterBorrow(r75), n3), isK2), r75); + const r76: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize_u8(out, rt.iterLast(rt.iterRev(rt.iterEnumerate(rt.iterBorrow(r76)))), r76); + const r77: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); + state$u8_Option_usize(out, rt.iterRposition(rt.iterEnumerate(rt.iterBorrow(r77)), (_235: [rt.usize, rt.u8]): boolean => { + return isK2(_235[1]); + }), r77); + } + } else { + const _734: [rt.i64, rt.i64] = [rt.i64Sub(a as rt.i64, 128), rt.i64Sub(b as rt.i64, 128)]; + const a2: rt.i64 = _734[0]; + const b2: rt.i64 = _734[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 _759: [rt.i64, rt.i64] = [a2, b2]; + const _760: [rt.i64, rt.i64] = [a2, a2]; + const _761: [rt.i64, rt.i64] = [b2, a2]; + const iter5: rt.Iter<[rt.i64, rt.i64]> = rt.iterSlice([_759, _760, _761, [{ 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 _766: [rt.i64, rt.i64] | rt.Done = iter5.next(); + if (_766 === rt.DONE) { + break; + } + const _774: [rt.i64, rt.i64, rt.usize] = [_766[0], _766[1], n]; + const lo5: rt.i64 = _774[0]; + const hi5: rt.i64 = _774[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 r78: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const iter6: rt.RangeInclusive = r78; + while (iter6.next() !== rt.DONE) { + } + state$i64_unit(out, undefined, r78); + const r79: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const iter7: rt.RangeInclusive = r79; + while (true) { + const _797: rt.i64 | rt.Done = iter7.next(); + if (_797 === rt.DONE) { + break; + } + if (isK3(_797)) { + break; + } + } + state$i64_unit(out, undefined, r79); + const r80: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterRfind(r80, isK3), r80); + const r81: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterRfind(r81, (_2: rt.i64): boolean => { + return false; + }), r81); + const r82: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterMap(rt.iterBorrow(r82), (x7: rt.i64): rt.i64 => { + return x7; + })), r82); + const r83: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterMap(rt.iterBorrow(r83), (x8: rt.i64): rt.i64 => { + return x8; + })), r83); + const r84: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize(out, rt.iterPosition(rt.iterMap(rt.iterBorrow(r84), (x9: rt.i64): rt.i64 => { + return x9; + }), (x10: rt.i64): boolean => { + return isK3(x10); + }), r84); + const r85: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterRfind(rt.iterMap(rt.iterBorrow(r85), (x11: rt.i64): rt.i64 => { + return x11; + }), isK3), r85); + const r86: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterFold(rt.iterMap(rt.iterBorrow(r86), (x12: rt.i64): rt.i64 => { + return x12; + }), 0, (n5: rt.usize, _39: rt.i64): rt.usize => { + return rt.usizeAdd(n5, 1); + }), r86); + const r87: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r87), (x13: rt.i64): rt.i64 => { + return x13; + })), rt.lt), r87); + const r88: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterMap(rt.iterBorrow(r88), (x14: rt.i64): rt.i64 => { + return x14; + })).length, r88); + const r89: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r89), (_210: rt.i64): void => {})), r89); + const r90: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r90), (_212: rt.i64): void => {}), (x15: rt.i64): boolean => { + return isK3(x15); + }), r90); + const r91: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterInspect(rt.iterBorrow(r91), (_213: rt.i64): void => {}), "next").length, r91); + const r92: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _903: rt.RangeInclusive = r92; + const _905: (a0: rt.i64) => boolean = (x16: rt.i64): boolean => { + return !isK3(x16); + }; + state$i64_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_903), _905)), r92); + const r93: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r93), isK3).next()), r93); + const r94: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r94), isK3).nextBack()), r94); + const r95: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterFilter(rt.iterBorrow(r95), (_214: rt.i64): boolean => { + return true; + }), "next").length, r95); + const r96: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _937: rt.RangeInclusive = r96; + const _939: (a0: rt.i64) => rt.i64 | undefined = (x17: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(!isK3(x17), x17); + }; + state$i64_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_937), _939)), r96); + const r97: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _947: rt.RangeInclusive = r97; + const _949: (a0: rt.i64) => rt.i64 | undefined = (x18: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(isK3(x18), x18); + }; + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_947), _949).next()), r97); + const r98: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _957: rt.RangeInclusive = r98; + const _959: (a0: rt.i64) => rt.i64 | undefined = (x19: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(isK3(x19), x19); + }; + state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_957), _959).nextBack()), r98); + const r99: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r99))), r99); + const r100: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r100)), (_215: [rt.usize, rt.i64]): boolean => { + return isK3(_215[1]); + }), r100); + const r101: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize_i64(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r101))), r101); + const r102: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _990: rt.RangeInclusive = r102; + const _992: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_990), _992)), r102); + const r103: 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(r103))), r103); + const r104: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1007: rt.RangeInclusive = r104; + const _1009: rt.RangeInclusive = new rt.RangeInclusive(hi5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_1007), _1009), (x21: rt.i64): boolean => { + return isK3(x21); + }), r104); + const r105: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1018: rt.RangeInclusive = r105; + const _1020: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_1018), _1020))), r105); + const r106: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r106))), r106); + const r107: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r107)), (x22: rt.i64): boolean => { + return isK3(x22); + }), r107); + const r108: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r108)), rt.lt), r108); + const r109: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r109)))), r109); + const r110: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterTake(rt.iterBorrow(r110), n4)), r110); + const r111: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1065: rt.RangeInclusive = r111; + const _1067: rt.usize = rt.usizeAdd(n4, 1); + state$i64_Option_i64(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_1065), _1067), rt.lt), r111); + const r112: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r112), n4)), r112); + const r113: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r113), n4), (x23: rt.i64): rt.i64 => { + return x23; + })), r113); + const r114: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMin(rt.iterTake(rt.iterBorrow(r114), 4294967295), rt.lt), r114); + const r115: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterTake(rt.iterBorrow(r115), n4))), r115); + const r116: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterSkip(rt.iterBorrow(r116), n4).next()), r116); + const r117: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterSkip(rt.iterBorrow(r117), n4)), r117); + const r118: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterSkip(rt.iterBorrow(r118), n4)), r118); + const r119: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r119), n4), rt.lt), r119); + const r120: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterSkip(rt.iterBorrow(r120), n4), "next").length, r120); + const r121: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r121), below2).next()), r121); + const r122: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterSkipWhile(rt.iterBorrow(r122), below2)), r122); + const r123: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r123), below2)), r123); + const r124: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r124), (_216: rt.i64): boolean => { + return true; + })), r124); + const r125: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterTakeWhile(rt.iterBorrow(r125), below2), "next").length, r125); + const r126: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1180: rt.RangeInclusive = r126; + const _1182: (a0: rt.i64) => rt.i64 | undefined = (x24: rt.i64): rt.i64 | undefined => { + return thenSome$0tjggir(below2(x24), x24); + }; + state$i64_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_1180), _1182)), r126); + const r127: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r127), (x25: rt.i64): rt.i64 | undefined => { + return x25; + })), r127); + const r128: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterToArray(rt.iterMapWhile(rt.iterBorrow(r128), (x26: rt.i64): rt.i64 | undefined => { + return x26; + }), "next").length, r128); + const r129: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r129))), r129); + const r130: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r130))), (x27: rt.i64): boolean => { + return isK3(x27); + }), r130); + const r131: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p5: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r131)); + state$i64_Option_i64_usize(out, [rt.peekablePeek(p5), rt.iterCount(p5)] as [rt.i64 | undefined, rt.usize], r131); + const r132: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p6: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r132)); + state$i64_Option_i64_Option_i64(out, [rt.peekablePeek(p6), rt.iterLast(rt.iterRev(p6))] as [rt.i64 | undefined, rt.i64 | undefined], r132); + const r133: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p7: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r133)); + state$i64_Option_i64_Option_usize(out, [rt.peekablePeek(p7), rt.iterPosition(p7, (x28: rt.i64): boolean => { + return isK3(x28); + })] as [rt.i64 | undefined, rt.usize | undefined], r133); + const r134: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r134))), r134); + const r135: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const p8: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r135)); + const iter8: rt.Peekable = p8; + while (true) { + const _1275: rt.i64 | rt.Done = iter8.next(); + if (_1275 === rt.DONE) { + break; + } + if (isK3(_1275)) { + break; + } + } + state$i64_Option_i64(out, rt.peekablePeek(p8), r135); + const r136: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r136), (x29: rt.i64): rt.i64 | undefined => { + return x29; + }, (value: rt.i64 | undefined) => rt.iterOption(value))), r136); + const r137: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r137), (x30: rt.i64): rt.i64 | undefined => { + return x30; + }, (value: rt.i64 | undefined) => rt.iterOption(value)).next()), r137); + const r138: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1306: rt.RangeInclusive = r138; + const _1308: (a0: rt.i64) => rt.RangeInclusive = (x31: rt.i64): rt.RangeInclusive => { + return new rt.RangeInclusive(lo5, x31, rt.i64Step); + }; + state$i64_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_1306), _1308))), r138); + const r139: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1316: rt.RangeInclusive = r139; + const _1318: (a0: rt.i64) => rt.RangeInclusive = (x32: rt.i64): rt.RangeInclusive => { + return new rt.RangeInclusive(x32, hi5, rt.i64Step); + }; + state$i64_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_1316), _1318), (x33: rt.i64): boolean => { + return isK3(x33); + }), r139); + const r140: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r140), (x34: rt.i64): rt.i64[] => { + return [x34, x34]; + }, (value: rt.i64[]) => rt.iterSlice(value), false, 2))), r140); + const r141: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1335: rt.RangeInclusive = r141; + const _1337: rt.usize = rt.usizeAdd(n4, 1); + state$i64_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_1335), _1337)), r141); + const r142: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r142), new rt.Range(0, n4)), (_217: [rt.i64, rt.usize]): boolean => { + return false; + }), r142); + const r143: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + state$i64_Result_usize_unit(out, map$0d4vpmj(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r143), (x35: rt.i64): rt.Result => { + return rt.Ok(x35); + }), (values: rt.Iter) => rt.iterToArray(values)), (v147: rt.i64[]): rt.usize => { + return v147.length; + }), r143); + const r144: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const _1361: rt.RangeInclusive = r144; + const _1363: (a0: rt.i64) => rt.i64 | undefined = (x36: rt.i64): rt.i64 | undefined => { + if (!isK3(x36)) { + return x36; + } + return undefined; + }; + state$i64_Option_usize(out, map$1mp7tga(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_1361), _1363), (values: rt.Iter) => rt.iterToArray(values)), (v148: rt.i64[]): rt.usize => { + return v148.length; + }), r144); + const r145: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const v144: rt.i64[] = []; + const _1373: rt.Iter = rt.iterMap(rt.iterBorrow(r145), (x37: rt.i64): rt.i64 => { + return x37; + }); + rt.iterExtend(v144, _1373); + state$i64_usize(out, v144.length, r145); + const r146: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); + const v146: rt.i64[] = []; + const _1384: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r146), (_220: rt.i64): boolean => { + return true; + }); + rt.iterExtend(v146, _1384, "next"); + state$i64_usize(out, v146.length, r146); + } + } +} + +//# sourceMappingURL=folds.ts.map diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 0801da818..b0e7cae0d 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 { holds } from "./holds.ts"; @@ -183,7 +184,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) asSlices(data66, out67); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["ints::widenings", widenings] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["shapes::uninhabited", (_2167: rt.u8, data67: rt.ByteSlice, out68: rt.ByteVec): void => { uninhabited(data67, out68); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::lent_keys", lentKeys] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::lent_values", lentValues] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::singles", singles] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::formats", singles_formats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::parses", singles_parses] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::lent_keys", lentKeys] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["keys::lent_values", lentValues] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::singles", singles] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::formats", singles_formats] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["singles::parses", singles_parses] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["folds::folds", folds] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 8a1aa1707..8e8eb8e73 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -25,11 +25,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)); - }))) { + }), "next")) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_18))); } } else { @@ -68,13 +68,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)); @@ -82,12 +82,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))); @@ -122,7 +122,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; @@ -149,7 +149,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"); } } } @@ -302,7 +302,7 @@ export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi }), (_29: rt.u8): rt.u16 | undefined => { const b5: rt.u8 = _29; return thenSome$0b23a33(b5 !== 32, b5 as rt.u16); - }), (values__: rt.Iter) => rt.iterToArray(values__)), 255, (v2: rt.u16[]): rt.u8 => { + }), (values__: rt.Iter) => rt.iterToArray(values__, "next")), 255, (v2: rt.u16[]): rt.u8 => { return v2.length & 0xff; })); } @@ -1105,7 +1105,7 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { return b6; } return undefined; - }), (value: rt.u8 | undefined) => rt.iterOption(value))))); + }), (value: rt.u8 | undefined) => rt.iterOption(value)), "next"))); rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all), (o: rt.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); @@ -1131,7 +1131,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 => { @@ -1145,7 +1145,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); @@ -1187,8 +1187,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) { @@ -1202,11 +1202,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 72b125e12..8ee26f408 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)); + const lent: rt.ByteSlice[] = rt.iterToArray(rt.iterMap(rt.hashKeys(map), rt.byteSliceFrom), "next"); 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))); @@ -1215,7 +1215,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_294 !== undefined) { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.entryKey(_294))); } - const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray)); + const members: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next"); 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))); + const lens: rt.ByteVec[] = rt.iterToArray(rt.hashKeys(rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _548)), "next"); 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)); + const values: Uint8Array[] = rt.iterToArray(rt.iterCopied(rt.iterMap(rt.hashValues(map), rt.byteSliceFrom), rt.byteSliceToArray), "next"); 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 fcca1ef55..0a0521de1 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -356,13 +356,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))), (_28: rt.u8 | undefined): rt.u8 => { + }, rt.None), "next")), (_28: rt.u8 | undefined): rt.u8 => { return code(_28); })); rt.byteVecPush(out, called); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToArray(rt.iterRev(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): rt.u8 | undefined | rt.None => { return pick(_210); - }, rt.None)))), (_211: rt.u8 | undefined): rt.u8 => { + }, rt.None)), "next")), (_211: rt.u8 | undefined): rt.u8 => { return code(_211); })); rt.byteVecPush(out, rt.iterFold(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): rt.u8 | undefined | rt.None => { @@ -379,7 +379,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)); + }, rt.None), "next"); rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(whiles), (_215: rt.u8 | undefined): rt.u8 => { return code(_215); })); @@ -398,7 +398,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.None; }, rt.None); - const first: Array = rt.iterToArray(rt.iterBorrow(made_)); + const first: Array = rt.iterToArray(rt.iterBorrow(made_), "next"); 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); @@ -424,7 +424,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { return pick(_84); } return rt.None; - }, undefined, rt.None))), (_222: rt.u8 | undefined): rt.u8 => { + }, undefined, rt.None), "next")), (_222: rt.u8 | undefined): rt.u8 => { return code(_222); })); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen))); diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index 1bb1036ae..2f9974e2c 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]; - })); + }), "next"); 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)); - 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 5b947534d..b2f0c94c7 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))); @@ -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 aed6f6b84..7fc74b1b3 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)), 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")), 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); - })); + }), "next"); })(); 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; - }))); + }), "next")); while (true) { const _120: rt.Place | rt.Done = iter5.next(); if (_120 === rt.DONE) { @@ -966,7 +966,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { _480.v = rt.u32Mul(_480.v, 3); } const _486: rt.Iter<[rt.u8, rt.u32]> = rt.hashIter(scalars); - const iter29: rt.Iter<[rt.u8, rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _486, true)); + const iter29: rt.Iter<[rt.u8, rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _486, true, undefined, undefined, "next")); while (true) { const _490: [rt.u8, rt.u32] | rt.Done = iter29.next(); if (_490 === rt.DONE) { @@ -1007,7 +1007,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { return k6[1] === 0; }); const _541: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.hashIter(paired); - const iter33: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u32>, _541, true)); + const iter33: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpTuple([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u32>, _541, true, undefined, undefined, "next")); while (true) { const _545: [[rt.u8, rt.u8], rt.u32] | rt.Done = iter33.next(); if (_545 === rt.DONE) { @@ -1020,7 +1020,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x3))); } const _560: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.hashIter(hash); - const iter34: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true)); + const iter34: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, "next")); 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 a51a77d1b..d6315e93d 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]; - }))) { + }), "next")) { 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, "/")); + const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), "next"); 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)); - const parts: string[] = rt.iterToArray(rt.strSplit(s, "/")); + const chars: rt.char[] = rt.iterToArray(rt.strChars(s), "next"); + const parts: string[] = rt.iterToArray(rt.strSplit(s, "/"), "next"); 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..ecb718fec --- /dev/null +++ b/ts/fixtures/lang/src/folds.rs @@ -0,0 +1,224 @@ +//! 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)); + 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 696245eec..498077999 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -3,8 +3,8 @@ use crate::{ arrays, atomics, borrows, bounds, captures, cells, chars, chunks, collections, combinators, counts, cows, defaults, - durations, dyns, edits, errors, floats, fmt, generics, hashes, holds, ints, iters, keys, locals, locks, nested, - objects, orders, pointers, refs, shapes, singles, slices, splits, statics, strs, utf8, wrappers, + durations, dyns, edits, errors, floats, fmt, folds, generics, hashes, 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 @@ -160,6 +160,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("singles::singles", singles::singles), ("singles::formats", singles::formats), ("singles::parses", singles::parses), + ("folds::folds", folds::folds), ] } diff --git a/ts/fixtures/lang/src/iters.rs b/ts/fixtures/lang/src/iters.rs index 21d6133d8..6debb5773 100644 --- a/ts/fixtures/lang/src/iters.rs +++ b/ts/fixtures/lang/src/iters.rs @@ -726,6 +726,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 0edc66b9a..042a49074 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -12,7 +12,7 @@ //! `Hash` writes into `DefaultHasher` and `RandomState`, slices' `windows` and chunks, //! mutable ones written through, their parts by inclusive and checked ranges and by fixed //! size, `Vec::drain`, the order, equality, and hashes of bytes, ranges of `Bound`s and of -//! the crate's own `RangeBounds`, and the equality of `Result`s and std's errors. +//! the crate's own `RangeBounds`, inclusive ranges read through each adaptor, and the equality of `Result`s and std's errors. //! //! `harness::run` is the entry point both sides of the differential test run, and //! `fmt::Fault` an error only `caller.ts` prints. @@ -36,6 +36,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 e345db733..6fe75d3a1 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. @@ -57,10 +58,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); } @@ -69,8 +74,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); } @@ -87,7 +93,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; } @@ -122,13 +131,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); } @@ -205,6 +214,35 @@ abstract class Calling extends Adaptor { } } +/** + * `a` folded: `a` itself where its iterator folds as `next` reads it, or else `view` of + * its iterator folded. + */ +function foldedBy(a: Adaptor, view: (inner: Iter) => Iter): Iter { + const inner = a.inner.folded(); + return inner === a.inner ? a : view(inner); +} + +/** 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; @@ -374,22 +412,24 @@ export function iterBorrow(it: Iter): Iter { /** `Extend::extend` of a `Vec`, which takes `items` as `take` says. */ export function iterExtend(v: T[], items: Iter, take?: Take): void { - if (take === undefined) { - const folded = items.folded(); - for (let item = folded.next(); item !== DONE; item = folded.next()) v.push(item); + if (take === "fold") { + items.fold(undefined, (_, item) => void v.push(item)); return; } - each(items, (item) => v.push(item), take); + const read = reader(items, take); + for (let item = read.next(); item !== DONE; item = read.next()) v.push(item); + if (take === "next") dispose(items); } /** `Extend::extend` of a `Vec`. */ export function iterExtendBytes(v: ByteVec, items: Iter, take?: Take): void { - if (take === undefined) { - const folded = items.folded(); - for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(v, item); + if (take === "fold") { + items.fold(undefined, (_, item) => byteVecPush(v, item)); return; } - each(items, (item) => byteVecPush(v, item), take); + const read = reader(items, take); + for (let item = read.next(); item !== DONE; item = read.next()) byteVecPush(v, item); + if (take === "next") dispose(items); } // Adaptors @@ -524,20 +564,18 @@ 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"; -/** `it`, taken as `take` says: `f` of each item, and then it dropped. */ -function each(it: Iter, f: (item: T) => void, take: Take | undefined): void { - if (take === "fold") { - it.fold(undefined, (_, item) => f(item)); - return; - } - consumed(it, () => { - for (let item = it.next(); item !== DONE; item = it.next()) f(item); - }); +/** + * What a consumer reads `it` by, unless it takes it by its own `fold`: by `next` as `take` + * says, after which it drops, or else as `folded` steps it. + */ +function reader(it: Iter, take: Take | undefined): Iter { + return take === "next" ? it : it.folded(); } /** `Iterator::count` of an iterator that drops nothing. */ @@ -596,9 +634,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); } @@ -634,7 +673,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; } @@ -816,12 +856,7 @@ export function iterIsSortedBy( /** `collect` into a `Vec`, taking `it` as `take` says. */ export function iterToArray(it: Iter, take?: Take): T[] { const out: T[] = []; - if (take === undefined) { - const folded = it.folded(); - for (let item = folded.next(); item !== DONE; item = folded.next()) out.push(item); - return out; - } - each(it, (item) => out.push(item), take); + iterExtend(out, it, take); return out; } @@ -829,12 +864,13 @@ export function iterToArray(it: Iter, take?: Take): T[] { export function iterToByteVec(it: Iter, take?: Take): ByteVec { const out = new ByteVec(); // Its own loop: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. - if (take === undefined) { - const folded = it.folded(); - for (let item = folded.next(); item !== DONE; item = folded.next()) byteVecPush(out, item); + if (take === "fold") { + it.fold(undefined, (_, item) => byteVecPush(out, item)); return out; } - each(it, (item) => byteVecPush(out, item), take); + const read = reader(it, take); + for (let item = read.next(); item !== DONE; item = read.next()) byteVecPush(out, item); + if (take === "next") dispose(it); return out; } @@ -1386,6 +1422,10 @@ class MapIter extends Calling U> { return this.inner.len(); } + override folded(): Iter { + return foldedBy(this, (inner) => 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())); @@ -1462,8 +1502,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; } @@ -1471,7 +1513,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; } @@ -1540,6 +1583,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]> { + return foldedBy(this, (inner) => { + 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); @@ -1606,6 +1664,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); @@ -1785,6 +1867,10 @@ class RevIter extends Adaptor { return this.inner.nth(n, drop); } + override folded(): Iter { + return foldedBy(this, (inner) => new RevIter(inner)); + } + override fold(acc: A, f: (acc: A, item: T) => A, release?: () => void): A { return this.inner.rfold(acc, f, release); } @@ -1857,6 +1943,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 { + return foldedBy(this, (inner) => { + 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) { @@ -1921,6 +2027,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 { + return foldedBy(this, (inner) => { + 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); @@ -2020,8 +2152,17 @@ class TakeWhileIter extends Calling boolean> { } next(): T | Done { + return this.from(this.inner); + } + + override folded(): Iter { + return foldedBy(this, (inner) => 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; @@ -2044,6 +2185,10 @@ class MapWhileIter extends Calling U | undefined | None const item = this.inner.next(); return item === DONE ? DONE : iterFromOption(this.f(item), this.none); } + + override folded(): Iter { + return foldedBy(this, (inner) => new MapWhileIter(inner, this.f, this.none)); + } } /** `StepBy`, whose items drop by `drop` as its iterator's own `nth` and `nth_back` step over them. */ @@ -2173,6 +2318,10 @@ class InspectIter extends Calling void> { return this.inner.len(); } + override folded(): Iter { + return foldedBy(this, (inner) => 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)); @@ -2239,6 +2388,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)); } @@ -2368,6 +2526,53 @@ class FlattenIter extends Iter implements Disposable { dispose(back); } + override folded(): Iter { + return new Folded(this.stepper(false), this.stepper(true)); + } + + /** + * A step of std's `try_fold`, or `try_rfold` if `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. + */ + private stepper(back: boolean): () => V | Done { + const source = this.outer?.folded(); + const hold = (it: Iter | undefined, other: boolean) => (back !== other ? this.setBack(it) : this.setFront(it)); + // At its own end, then its source's, then the other end. + let phase = 0; + let held: Iter | undefined; + let folded: Iter | undefined; + return () => { + for (;;) { + const it = back !== (phase === 2) ? this.back : this.front; + if (it !== undefined) { + if (it !== held) [held, folded] = [it, it.folded()]; + const item = back ? folded!.nextBack() : folded!.next(); + if (item !== DONE) return item; + } + if (phase === 2) { + hold(undefined, true); + return DONE; + } + if (phase === 1) { + const outer = this.outer; + const value = outer === undefined ? DONE : back ? source!.nextBack() : source!.next(); + if (value !== DONE) { + hold(this.into(value), false); + continue; + } + if (outer !== undefined && !this.fused) { + this.outer = undefined; + dispose(outer); + } + } + hold(undefined, false); + phase++; + } + }; + } + 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); } @@ -2377,9 +2582,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) { @@ -2389,7 +2594,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); @@ -2417,7 +2623,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); @@ -2490,6 +2697,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 { + return foldedBy(this, (inner) => { + 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) { @@ -2573,9 +2797,10 @@ export function peekableNextIfEq(p: Peekable, expected: T, eq: (a: T, b: T 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 }; @@ -2589,7 +2814,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; @@ -2760,7 +2985,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; @@ -2777,6 +3005,15 @@ class RangeInclusiveFold extends Iter { else r.exhausted = true; 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; + } } /** `RangeInclusive::start`. */ diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index b10349560..f592c7836 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); @@ -907,13 +914,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(), } } From eddd6df9028e99fe27f25e2893b6146158c20617 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 12:48:16 -0700 Subject: [PATCH 3/6] test(ts): cover nth and nth_back of a borrowed range through map Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/folds.ts | 812 +++++++++++++++-------------- ts/fixtures/lang/src/folds.rs | 3 + 2 files changed, 417 insertions(+), 398 deletions(-) diff --git a/ts/fixtures/lang/expected/folds.ts b/ts/fixtures/lang/expected/folds.ts index e89a3374e..7d4503c18 100644 --- a/ts/fixtures/lang/expected/folds.ts +++ b/ts/fixtures/lang/expected/folds.ts @@ -211,14 +211,14 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { 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 = (x38: rt.u8): boolean => { - return x38 === k; + const isK: (a0: rt.u8) => boolean = (x40: rt.u8): boolean => { + return x40 === k; }; - const below: (a0: rt.u8) => boolean = (x39: rt.u8): boolean => { + const below: (a0: rt.u8) => boolean = (x41: rt.u8): boolean => { if (k === undefined) { return true; } - return x39 < k; + return x41 < k; }; const r: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); const iter2: rt.RangeInclusive = r; @@ -240,310 +240,318 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { 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, (_222: rt.u8): boolean => { + 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), (x40: rt.u8): rt.u8 => { - return x40; + 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), (x41: rt.u8): rt.u8 => { - return x41; + 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), (x42: rt.u8): rt.u8 => { - return x42; - }), (x43: rt.u8): boolean => { - return isK(x43); + 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), (x44: rt.u8): rt.u8 => { - return x44; + 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), (x45: rt.u8): rt.u8 => { - return x45; + 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.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r10), (x46: rt.u8): rt.u8 => { - return x46; - })), rt.lt), r10); + 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_usize(out, rt.iterToByteVec(rt.iterMap(rt.iterBorrow(r11), (x47: rt.u8): rt.u8 => { - return x47; - })).length, r11); + 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_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r12), (_223: rt.u8): void => {})), r12); + 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_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r13), (_224: rt.u8): void => {}), (x48: rt.u8): boolean => { - return isK(x48); - }), r13); + state$u8_usize(out, rt.iterToByteVec(rt.iterMap(rt.iterBorrow(r13), (x51: rt.u8): rt.u8 => { + return x51; + })).length, r13); const r14: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterInspect(rt.iterBorrow(r14), (_225: rt.u8): void => {}), "next").length, r14); + state$u8_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r14), (_222: rt.u8): void => {})), r14); const r15: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _175: rt.RangeInclusive = r15; - const _177: (a0: rt.u8) => boolean = (x49: rt.u8): boolean => { - return !isK(x49); - }; - state$u8_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_175), _177)), r15); + state$u8_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r15), (_223: rt.u8): void => {}), (x52: rt.u8): boolean => { + return isK(x52); + }), r15); const r16: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r16), isK).next()), r16); + state$u8_usize(out, rt.iterToByteVec(rt.iterInspect(rt.iterBorrow(r16), (_226: rt.u8): void => {}), "next").length, r16); const r17: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r17), isK).nextBack()), r17); + 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_usize(out, rt.iterToByteVec(rt.iterFilter(rt.iterBorrow(r18), (_226: rt.u8): boolean => { - return true; - }), "next").length, r18); + 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); - const _209: rt.RangeInclusive = r19; - const _211: (a0: rt.u8) => rt.u8 | undefined = (x50: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(!isK(x50), x50); - }; - state$u8_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_209), _211)), r19); + 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); - const _219: rt.RangeInclusive = r20; - const _221: (a0: rt.u8) => rt.u8 | undefined = (x51: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(isK(x51), x51); - }; - state$u8_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_219), _221).next()), r20); + 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 _229: rt.RangeInclusive = r21; - const _231: (a0: rt.u8) => rt.u8 | undefined = (x52: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(isK(x52), x52); + 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_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_229), _231).nextBack()), r21); + state$u8_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_225), _227)), r21); const r22: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r22))), r22); + 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); - state$u8_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r23)), (_227: [rt.usize, rt.u8]): boolean => { - return isK(_227[1]); - }), r23); + 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_Option_usize_u8(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r24))), r24); + state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r24))), r24); const r25: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _262: rt.RangeInclusive = r25; - const _264: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_262), _264)), r25); + 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_u8(out, rt.iterLast(rt.iterChain(new rt.RangeInclusive(hi2, hi2, rt.u8Step), rt.iterBorrow(r26))), r26); + 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 _279: rt.RangeInclusive = r27; - const _281: rt.RangeInclusive = new rt.RangeInclusive(hi2, hi2, rt.u8Step); - state$u8_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_279), _281), (x54: rt.u8): boolean => { - return isK(x54); - }), r27); + 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); - const _290: rt.RangeInclusive = r28; - const _292: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_290), _292))), r28); + 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); - state$u8_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r29))), r29); + 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); - state$u8_Option_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r30)), (x55: rt.u8): boolean => { - return isK(x55); - }), r30); + 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_Option_u8(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r31)), rt.lt), r31); + 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_u8(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r32)))), r32); + 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.iterLast(rt.iterTake(rt.iterBorrow(r33), n2)), r33); + 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); - const _337: rt.RangeInclusive = r34; - const _339: rt.usize = rt.usizeAdd(n2, 1); - state$u8_Option_u8(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_337), _339), rt.lt), r34); + 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_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r35), n2)), r35); + 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); - state$u8_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r36), n2), (x56: rt.u8): rt.u8 => { - return x56; - })), r36); + 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_Option_u8(out, rt.iterMin(rt.iterTake(rt.iterBorrow(r37), 4294967295), rt.lt), r37); + 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.iterEnumerate(rt.iterTake(rt.iterBorrow(r38), n2))), r38); + 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.iterToOption(rt.iterSkip(rt.iterBorrow(r39), n2).next()), r39); + 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.iterSkip(rt.iterBorrow(r40), n2)), r40); + 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.iterLast(rt.iterSkip(rt.iterBorrow(r41), n2)), r41); + 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_Option_u8(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r42), n2), rt.lt), r42); + 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_usize(out, rt.iterToByteVec(rt.iterSkip(rt.iterBorrow(r43), n2), "next").length, r43); + 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.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r44), below).next()), r44); + 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.iterCount(rt.iterSkipWhile(rt.iterBorrow(r45), below)), r45); + 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_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r46), below)), r46); + 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_Option_u8(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r47), (_230: rt.u8): boolean => { - return true; - })), r47); + 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.iterToByteVec(rt.iterTakeWhile(rt.iterBorrow(r48), below), "next").length, r48); + state$u8_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r48), below)), r48); const r49: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _452: rt.RangeInclusive = r49; - const _454: (a0: rt.u8) => rt.u8 | undefined = (x57: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(below(x57), x57); - }; - state$u8_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_452), _454)), r49); + 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_Option_u8(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r50), (x58: rt.u8): rt.u8 | undefined => { - return x58; - })), r50); + 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); - state$u8_usize(out, rt.iterToByteVec(rt.iterMapWhile(rt.iterBorrow(r51), (x59: rt.u8): rt.u8 | undefined => { - return x59; - }), "next").length, r51); + 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_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r52))), r52); + 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_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r53))), (x60: rt.u8): boolean => { - return isK(x60); - }), r53); + 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); - const p: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r54)); - state$u8_Option_u8_usize(out, [rt.peekablePeek(p), rt.iterCount(p)] as [rt.u8 | undefined, rt.usize], r54); + state$u8_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r54))), r54); const r55: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const p2: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r55)); - state$u8_Option_u8_Option_u8(out, [rt.peekablePeek(p2), rt.iterLast(rt.iterRev(p2))] as [rt.u8 | undefined, rt.u8 | undefined], r55); + 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 p3: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r56)); - state$u8_Option_u8_Option_usize(out, [rt.peekablePeek(p3), rt.iterPosition(p3, (x61: rt.u8): boolean => { - return isK(x61); - })] as [rt.u8 | undefined, rt.usize | undefined], r56); + 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); - state$u8_Option_u8(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r57))), r57); + 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 p4: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r58)); + 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 _547: rt.u8 | rt.Done = iter4.next(); - if (_547 === rt.DONE) { + const _563: rt.u8 | rt.Done = iter4.next(); + if (_563 === rt.DONE) { break; } - if (isK(_547)) { + if (isK(_563)) { break; } } - state$u8_Option_u8(out, rt.peekablePeek(p4), r58); - const r59: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r59), (x62: rt.u8): rt.u8 | undefined => { - return x62; - }, (value: rt.u8 | undefined) => rt.iterOption(value))), r59); - const r60: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r60), (x63: rt.u8): rt.u8 | undefined => { - return x63; - }, (value: rt.u8 | undefined) => rt.iterOption(value)).next()), r60); + state$u8_Option_u8(out, rt.peekablePeek(p4), r60); const r61: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _578: rt.RangeInclusive = r61; - const _580: (a0: rt.u8) => rt.RangeInclusive = (x64: rt.u8): rt.RangeInclusive => { - return new rt.RangeInclusive(lo2, x64, rt.u8Step); - }; - state$u8_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_578), _580))), r61); + 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))), r61); const r62: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _588: rt.RangeInclusive = r62; - const _590: (a0: rt.u8) => rt.RangeInclusive = (x65: rt.u8): rt.RangeInclusive => { - return new rt.RangeInclusive(x65, hi2, rt.u8Step); - }; - state$u8_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_588), _590), (x66: rt.u8): boolean => { - return isK(x66); - }), r62); + 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)).next()), r62); const r63: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r63), (x67: rt.u8): Uint8Array => { - return Uint8Array.of(x67, x67); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2))), r63); + 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 _607: rt.RangeInclusive = r64; - const _609: rt.usize = rt.usizeAdd(n2, 1); - state$u8_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_607), _609)), r64); + 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_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r65), new rt.Range(0, n2)), (_232: [rt.u8, rt.usize]): boolean => { - return false; - }), r65); + 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); - state$u8_Result_usize_unit(out, map$1w3j91w(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r66), (x68: rt.u8): rt.Result => { - return rt.Ok(x68); - }), (values: rt.Iter) => rt.iterToByteVec(values)), (v149: rt.ByteVec): rt.usize => { - return v149.length; - }), r66); + 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); - const _633: rt.RangeInclusive = r67; - const _635: (a0: rt.u8) => rt.u8 | undefined = (x69: rt.u8): rt.u8 | undefined => { - if (!isK(x69)) { - return x69; - } - return undefined; - }; - state$u8_Option_usize(out, map$1c7fhtg(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_633), _635), (values: rt.Iter) => rt.iterToByteVec(values)), (v150: rt.ByteVec): rt.usize => { - return v150.length; + 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); - const v67: rt.ByteVec = new rt.ByteVec(); - const _645: rt.Iter = rt.iterMap(rt.iterBorrow(r68), (x70: rt.u8): rt.u8 => { - return x70; - }); - rt.iterExtendBytes(v67, _645); - state$u8_usize(out, v67.length, r68); + 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 _656: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r69), (_233: rt.u8): boolean => { + const _661: rt.Iter = rt.iterMap(rt.iterBorrow(r70), (x74: rt.u8): rt.u8 => { + return x74; + }); + rt.iterExtendBytes(v69, _661); + 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(v69, _656, "next"); - state$u8_usize(out, v69.length, r69); + 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 = (x71: rt.u8): boolean => { - return x71 === k2; + const isK2: (a0: rt.u8) => boolean = (x75: rt.u8): boolean => { + return x75 === k2; }; - const r70: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_usize(out, rt.iterRposition(r70, isK2), r70); - const r71: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_usize(out, rt.iterRposition(r71, (_234: rt.u8): boolean => { - return false; - }), r71); const r72: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterTake(rt.iterBorrow(r72), n3))), r72); + 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(rt.iterTake(rt.iterBorrow(r73), n3), isK2), r73); + 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.iterSkip(rt.iterBorrow(r74), n3))), r74); + 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.iterSkip(rt.iterBorrow(r75), n3), isK2), r75); + 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_usize_u8(out, rt.iterLast(rt.iterRev(rt.iterEnumerate(rt.iterBorrow(r76)))), r76); + 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.iterEnumerate(rt.iterBorrow(r77)), (_235: [rt.usize, rt.u8]): boolean => { - return isK2(_235[1]); - }), r77); + 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 _734: [rt.i64, rt.i64] = [rt.i64Sub(a as rt.i64, 128), rt.i64Sub(b as rt.i64, 128)]; - const a2: rt.i64 = _734[0]; - const b2: rt.i64 = _734[1]; + 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 _759: [rt.i64, rt.i64] = [a2, b2]; - const _760: [rt.i64, rt.i64] = [a2, a2]; - const _761: [rt.i64, rt.i64] = [b2, a2]; - const iter5: rt.Iter<[rt.i64, rt.i64]> = rt.iterSlice([_759, _760, _761, [{ 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]]); + 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 _766: [rt.i64, rt.i64] | rt.Done = iter5.next(); - if (_766 === rt.DONE) { + const _782: [rt.i64, rt.i64] | rt.Done = iter5.next(); + if (_782 === rt.DONE) { break; } - const _774: [rt.i64, rt.i64, rt.usize] = [_766[0], _766[1], n]; - const lo5: rt.i64 = _774[0]; - const hi5: rt.i64 = _774[1]; + 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 => { @@ -555,284 +563,292 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } return rt.i64Lt(x6, k3); }; - const r78: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const iter6: rt.RangeInclusive = r78; + 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, r78); - const r79: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const iter7: rt.RangeInclusive = r79; + 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 _797: rt.i64 | rt.Done = iter7.next(); - if (_797 === rt.DONE) { + const _813: rt.i64 | rt.Done = iter7.next(); + if (_813 === rt.DONE) { break; } - if (isK3(_797)) { + if (isK3(_813)) { break; } } - state$i64_unit(out, undefined, r79); - const r80: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterRfind(r80, isK3), r80); - const r81: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterRfind(r81, (_2: rt.i64): boolean => { - return false; - }), r81); + state$i64_unit(out, undefined, r81); const r82: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterMap(rt.iterBorrow(r82), (x7: rt.i64): rt.i64 => { - return x7; - })), r82); + 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.iterLast(rt.iterMap(rt.iterBorrow(r83), (x8: rt.i64): rt.i64 => { - return x8; - })), r83); + 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_Option_usize(out, rt.iterPosition(rt.iterMap(rt.iterBorrow(r84), (x9: rt.i64): rt.i64 => { + 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); - }), r84); - const r85: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterRfind(rt.iterMap(rt.iterBorrow(r85), (x11: rt.i64): rt.i64 => { + }), 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), r85); - const r86: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterFold(rt.iterMap(rt.iterBorrow(r86), (x12: rt.i64): rt.i64 => { + }), 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); - }), r86); - const r87: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r87), (x13: rt.i64): rt.i64 => { - return x13; - })), rt.lt), r87); - const r88: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToArray(rt.iterMap(rt.iterBorrow(r88), (x14: rt.i64): rt.i64 => { - return x14; - })).length, r88); + }), r88); const r89: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r89), (_210: rt.i64): void => {})), r89); + 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_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r90), (_212: rt.i64): void => {}), (x15: rt.i64): boolean => { - return isK3(x15); - }), r90); + 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_usize(out, rt.iterToArray(rt.iterInspect(rt.iterBorrow(r91), (_213: rt.i64): void => {}), "next").length, r91); + 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); - const _903: rt.RangeInclusive = r92; - const _905: (a0: rt.i64) => boolean = (x16: rt.i64): boolean => { - return !isK3(x16); - }; - state$i64_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_903), _905)), r92); + state$i64_usize(out, rt.iterToArray(rt.iterMap(rt.iterBorrow(r92), (x16: rt.i64): rt.i64 => { + return x16; + })).length, r92); const r93: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r93), isK3).next()), r93); + state$i64_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r93), (_210: rt.i64): void => {})), r93); const r94: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r94), isK3).nextBack()), r94); + state$i64_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r94), (_211: rt.i64): void => {}), (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.iterFilter(rt.iterBorrow(r95), (_214: rt.i64): boolean => { - return true; - }), "next").length, r95); + state$i64_usize(out, rt.iterToArray(rt.iterInspect(rt.iterBorrow(r95), (_212: rt.i64): void => {}), "next").length, r95); const r96: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _937: rt.RangeInclusive = r96; - const _939: (a0: rt.i64) => rt.i64 | undefined = (x17: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(!isK3(x17), x17); + 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.iterFilterMap(rt.iterBorrow(_937), _939)), r96); + state$i64_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_935), _937)), r96); const r97: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _947: rt.RangeInclusive = r97; - const _949: (a0: rt.i64) => rt.i64 | undefined = (x18: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(isK3(x18), x18); - }; - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_947), _949).next()), r97); + 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); - const _957: rt.RangeInclusive = r98; - const _959: (a0: rt.i64) => rt.i64 | undefined = (x19: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(isK3(x19), x19); - }; - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_957), _959).nextBack()), r98); + 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.iterCount(rt.iterEnumerate(rt.iterBorrow(r99))), r99); + state$i64_usize(out, rt.iterToArray(rt.iterFilter(rt.iterBorrow(r99), (_213: rt.i64): boolean => { + return true; + }), "next").length, r99); const r100: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r100)), (_215: [rt.usize, rt.i64]): boolean => { - return isK3(_215[1]); - }), r100); + 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); - state$i64_Option_usize_i64(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r101))), r101); + 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 _990: rt.RangeInclusive = r102; - const _992: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_990), _992)), r102); + 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_Option_i64(out, rt.iterLast(rt.iterChain(new rt.RangeInclusive(hi5, hi5, rt.i64Step), rt.iterBorrow(r103))), r103); + state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r103))), r103); const r104: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1007: rt.RangeInclusive = r104; - const _1009: rt.RangeInclusive = new rt.RangeInclusive(hi5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_1007), _1009), (x21: rt.i64): boolean => { - return isK3(x21); + 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); - const _1018: rt.RangeInclusive = r105; - const _1020: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_1018), _1020))), r105); + 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); - state$i64_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r106))), r106); + 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_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r107)), (x22: rt.i64): boolean => { - return isK3(x22); - }), r107); + 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); - state$i64_Option_i64(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r108)), rt.lt), r108); + 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); - state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r109)))), r109); + 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_Option_i64(out, rt.iterLast(rt.iterTake(rt.iterBorrow(r110), n4)), r110); + state$i64_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r110))), r110); const r111: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1065: rt.RangeInclusive = r111; - const _1067: rt.usize = rt.usizeAdd(n4, 1); - state$i64_Option_i64(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_1065), _1067), rt.lt), r111); + 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_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r112), n4)), r112); + 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_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r113), n4), (x23: rt.i64): rt.i64 => { - return x23; - })), r113); + 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.iterMin(rt.iterTake(rt.iterBorrow(r114), 4294967295), rt.lt), r114); + 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); - state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterTake(rt.iterBorrow(r115), n4))), r115); + 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_Option_i64(out, rt.iterToOption(rt.iterSkip(rt.iterBorrow(r116), n4).next()), r116); + 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.iterSkip(rt.iterBorrow(r117), n4)), r117); + 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.iterLast(rt.iterSkip(rt.iterBorrow(r118), n4)), r118); + 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_Option_i64(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r119), n4), rt.lt), r119); + 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_usize(out, rt.iterToArray(rt.iterSkip(rt.iterBorrow(r120), n4), "next").length, r120); + 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_Option_i64(out, rt.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r121), below2).next()), r121); + 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_usize(out, rt.iterCount(rt.iterSkipWhile(rt.iterBorrow(r122), below2)), r122); + 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_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r123), below2)), r123); + 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_Option_i64(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r124), (_216: rt.i64): boolean => { - return true; - })), r124); + state$i64_usize(out, rt.iterToArray(rt.iterSkip(rt.iterBorrow(r124), n4), "next").length, r124); const r125: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToArray(rt.iterTakeWhile(rt.iterBorrow(r125), below2), "next").length, r125); + 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); - const _1180: rt.RangeInclusive = r126; - const _1182: (a0: rt.i64) => rt.i64 | undefined = (x24: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(below2(x24), x24); - }; - state$i64_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_1180), _1182)), r126); + 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_Option_i64(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r127), (x25: rt.i64): rt.i64 | undefined => { - return x25; - })), r127); + 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_usize(out, rt.iterToArray(rt.iterMapWhile(rt.iterBorrow(r128), (x26: rt.i64): rt.i64 | undefined => { - return x26; - }), "next").length, r128); + 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.iterCount(rt.iterFuse(rt.iterBorrow(r129))), r129); + state$i64_usize(out, rt.iterToArray(rt.iterTakeWhile(rt.iterBorrow(r129), below2), "next").length, r129); const r130: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r130))), (x27: rt.i64): boolean => { - return isK3(x27); - }), r130); + 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); - const p5: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r131)); - state$i64_Option_i64_usize(out, [rt.peekablePeek(p5), rt.iterCount(p5)] as [rt.i64 | undefined, rt.usize], r131); + 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); - const p6: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r132)); - state$i64_Option_i64_Option_i64(out, [rt.peekablePeek(p6), rt.iterLast(rt.iterRev(p6))] as [rt.i64 | undefined, rt.i64 | undefined], r132); + state$i64_usize(out, rt.iterToArray(rt.iterMapWhile(rt.iterBorrow(r132), (x28: rt.i64): rt.i64 | undefined => { + return x28; + }), "next").length, r132); const r133: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const p7: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r133)); - state$i64_Option_i64_Option_usize(out, [rt.peekablePeek(p7), rt.iterPosition(p7, (x28: rt.i64): boolean => { - return isK3(x28); - })] as [rt.i64 | undefined, rt.usize | undefined], r133); + 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_Option_i64(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r134))), r134); + 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 p8: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r135)); + 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 _1275: rt.i64 | rt.Done = iter8.next(); - if (_1275 === rt.DONE) { + const _1307: rt.i64 | rt.Done = iter8.next(); + if (_1307 === rt.DONE) { break; } - if (isK3(_1275)) { + if (isK3(_1307)) { break; } } - state$i64_Option_i64(out, rt.peekablePeek(p8), r135); - const r136: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r136), (x29: rt.i64): rt.i64 | undefined => { - return x29; - }, (value: rt.i64 | undefined) => rt.iterOption(value))), r136); - const r137: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r137), (x30: rt.i64): rt.i64 | undefined => { - return x30; - }, (value: rt.i64 | undefined) => rt.iterOption(value)).next()), r137); - const r138: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1306: rt.RangeInclusive = r138; - const _1308: (a0: rt.i64) => rt.RangeInclusive = (x31: rt.i64): rt.RangeInclusive => { - return new rt.RangeInclusive(lo5, x31, rt.i64Step); - }; - state$i64_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_1306), _1308))), r138); - const r139: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1316: rt.RangeInclusive = r139; - const _1318: (a0: rt.i64) => rt.RangeInclusive = (x32: rt.i64): rt.RangeInclusive => { - return new rt.RangeInclusive(x32, hi5, rt.i64Step); - }; - state$i64_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_1316), _1318), (x33: rt.i64): boolean => { - return isK3(x33); - }), r139); + state$i64_Option_i64(out, rt.peekablePeek(p8), r139); const r140: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r140), (x34: rt.i64): rt.i64[] => { - return [x34, x34]; - }, (value: rt.i64[]) => rt.iterSlice(value), false, 2))), r140); + 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))), r140); const r141: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1335: rt.RangeInclusive = r141; - const _1337: rt.usize = rt.usizeAdd(n4, 1); - state$i64_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_1335), _1337)), r141); + 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)).next()), r141); const r142: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r142), new rt.Range(0, n4)), (_217: [rt.i64, rt.usize]): boolean => { - return false; - }), r142); + 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); - state$i64_Result_usize_unit(out, map$0d4vpmj(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r143), (x35: rt.i64): rt.Result => { - return rt.Ok(x35); - }), (values: rt.Iter) => rt.iterToArray(values)), (v147: rt.i64[]): rt.usize => { - return v147.length; + 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); - const _1361: rt.RangeInclusive = r144; - const _1363: (a0: rt.i64) => rt.i64 | undefined = (x36: rt.i64): rt.i64 | undefined => { - if (!isK3(x36)) { - return x36; + 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)), (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(_1361), _1363), (values: rt.Iter) => rt.iterToArray(values)), (v148: rt.i64[]): rt.usize => { - return v148.length; - }), r144); - const r145: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const v144: rt.i64[] = []; - const _1373: rt.Iter = rt.iterMap(rt.iterBorrow(r145), (x37: rt.i64): rt.i64 => { - return x37; + state$i64_Option_usize(out, map$1mp7tga(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_1393), _1395), (values: rt.Iter) => rt.iterToArray(values)), (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(v144, _1373); - state$i64_usize(out, v144.length, r145); - const r146: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const v146: rt.i64[] = []; - const _1384: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r146), (_220: rt.i64): boolean => { + rt.iterExtend(v148, _1405); + 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(v146, _1384, "next"); - state$i64_usize(out, v146.length, r146); + rt.iterExtend(v150, _1416, "next"); + state$i64_usize(out, v150.length, r150); } } } diff --git a/ts/fixtures/lang/src/folds.rs b/ts/fixtures/lang/src/folds.rs index ecb718fec..fde6e2c4c 100644 --- a/ts/fixtures/lang/src/folds.rs +++ b/ts/fixtures/lang/src/folds.rs @@ -53,6 +53,9 @@ macro_rules! folds { 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()); From 5cf8bd9524a41348a1308f4f3472f543dab5ab0a Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 13:38:40 -0700 Subject: [PATCH 4/6] perf(ts): make an adaptor's folded view only where its iterator folds folded() allocated a closure on every call, which filter's next makes once per item, so iter/map-filter-count took twice as long in Bun. Each adaptor now checks its iterator inline, and a flatten reuses one view, which each fold resets. Co-Authored-By: Claude Opus 5.5 --- ts/runtime/rt/iter.ts | 257 ++++++++++++++++++++++++------------------ 1 file changed, 146 insertions(+), 111 deletions(-) diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 97c50ea57..1a52a8cfa 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -214,15 +214,6 @@ abstract class Calling extends Adaptor { } } -/** - * `a` folded: `a` itself where its iterator folds as `next` reads it, or else `view` of - * its iterator folded. - */ -function foldedBy(a: Adaptor, view: (inner: Iter) => Iter): Iter { - const inner = a.inner.folded(); - return inner === a.inner ? a : view(inner); -} - /** An adaptor folded, whose `next` and `nextBack` are `front` and `back`, which share its state. */ class Folded extends Iter { readonly front: () => T | Done; @@ -1423,7 +1414,9 @@ class MapIter extends Calling U> { } override folded(): Iter { - return foldedBy(this, (inner) => new MapIter(inner, this.f)); + 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`. */ @@ -1585,17 +1578,17 @@ class EnumerateIter extends Adaptor { /** std's: its iterator folded, counting each item as it goes, and from the back from its length. */ override folded(): Iter<[number, T]> { - return foldedBy(this, (inner) => { - 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); - }); + 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 { @@ -1868,7 +1861,9 @@ class RevIter extends Adaptor { } override folded(): Iter { - return foldedBy(this, (inner) => new RevIter(inner)); + 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 { @@ -1948,19 +1943,19 @@ class SkipIter extends Adaptor { * folded, and from the back, its iterator folded down to what it skips. */ override folded(): Iter { - return foldedBy(this, (inner) => { - 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)); - }); + 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. */ @@ -2032,25 +2027,25 @@ class TakeIter extends Adaptor { * the back, past what it holds beyond the limit by `nth_back`, folded without counting. */ override folded(): Iter { - return foldedBy(this, (inner) => { - 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); - }); + 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. */ @@ -2156,7 +2151,9 @@ class TakeWhileIter extends Calling boolean> { } override folded(): Iter { - return foldedBy(this, (inner) => new FromNext(inner, (inner) => this.from(inner))); + 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. */ @@ -2187,7 +2184,9 @@ class MapWhileIter extends Calling U | undefined | None } override folded(): Iter { - return foldedBy(this, (inner) => new MapWhileIter(inner, this.f, this.none)); + const inner = this.inner.folded(); + if (inner === this.inner) return this; + return new MapWhileIter(inner, this.f, this.none); } } @@ -2319,7 +2318,9 @@ class InspectIter extends Calling void> { } override folded(): Iter { - return foldedBy(this, (inner) => new InspectIter(inner, this.f)); + 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. */ @@ -2526,51 +2527,12 @@ class FlattenIter extends Iter implements Disposable { dispose(back); } - override folded(): Iter { - return new Folded(this.stepper(false), this.stepper(true)); - } + /** Its fold's view, which each fold starts anew. */ + private view: FlattenFold | undefined; - /** - * A step of std's `try_fold`, or `try_rfold` if `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. - */ - private stepper(back: boolean): () => V | Done { - const source = this.outer?.folded(); - const hold = (it: Iter | undefined, other: boolean) => (back !== other ? this.setBack(it) : this.setFront(it)); - // At its own end, then its source's, then the other end. - let phase = 0; - let held: Iter | undefined; - let folded: Iter | undefined; - return () => { - for (;;) { - const it = back !== (phase === 2) ? this.back : this.front; - if (it !== undefined) { - if (it !== held) [held, folded] = [it, it.folded()]; - const item = back ? folded!.nextBack() : folded!.next(); - if (item !== DONE) return item; - } - if (phase === 2) { - hold(undefined, true); - return DONE; - } - if (phase === 1) { - const outer = this.outer; - const value = outer === undefined ? DONE : back ? source!.nextBack() : source!.next(); - if (value !== DONE) { - hold(this.into(value), false); - continue; - } - if (outer !== undefined && !this.fused) { - this.outer = undefined; - dispose(outer); - } - } - hold(undefined, false); - phase++; - } - }; + 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 { @@ -2645,6 +2607,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; @@ -2702,16 +2737,16 @@ export class Peekable extends Adaptor { * the back, its iterator folded and then the item it peeked, which it holds until then. */ override folded(): Iter { - return foldedBy(this, (inner) => { - 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); - }); + 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. */ From 614ff2cded0a5b665c76fb0b5c6d807ec1940f29 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:18:05 -0700 Subject: [PATCH 5/6] quest: drop the zip-fold quest's link to the finished size-hints quest Co-Authored-By: Claude Opus 5.5 --- quest/m3/ts-zip-fold.md | 4 ---- 1 file changed, 4 deletions(-) diff --git a/quest/m3/ts-zip-fold.md b/quest/m3/ts-zip-fold.md index 2f7338e89..8008d3fdd 100644 --- a/quest/m3/ts-zip-fold.md +++ b/quest/m3/ts-zip-fold.md @@ -17,7 +17,3 @@ both `fold` and `try_fold`, which agree for every other adaptor, so the zip need tell them apart. Public API: the translator's output. - -## Related - -- [Size hints of std's iterators](/quest/m3/ts-size-hints.md) - the upper bound std's fold reads From 0f1b99a1789681c27849a6f5e5872783a24d9aa6 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:28:21 -0700 Subject: [PATCH 6/6] test(ts): regenerate the collections snapshot after merging main Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/expected/collections.ts | 88 ++++++++++++------------ 1 file changed, 44 insertions(+), 44 deletions(-) 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); } } }