diff --git a/quest/m3/README.md b/quest/m3/README.md index d9eb2d05a..5e8d66f64 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -25,7 +25,6 @@ generic std gap is planned here even when moq never calls it. - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library - [Drop order in std's folds and iterators](/quest/m3/ts-drop-order.md) - the values that drop still refused in std's consumers and collects drop as std's do - [A slice of one value behind any &mut](/quest/m3/ts-slice-of-one.md) - `slice::from_mut` and `array::from_mut` of a `&mut u8`, or of an object no place names, translate -- [std's calls of a closure that have no mapping](/quest/m3/ts-closure-calls.md) - `try_fold`, `partition`, `repeat_with`, `sort_by_cached_key`, and `LazyCell::new` translate, dropping what their closures own as std's do - [A function pointer or a boxed closure as a string pattern](/quest/m3/ts-fn-patterns.md) - `s.split(p)` of a `fn(char) -> bool` or a `Box bool>` translates, dropping a box it owns where std does - [std's char methods that have no mapping](/quest/m3/ts-char-methods.md) - `is_alphabetic`, `to_lowercase`, `len_utf8`, the escapes, and the rest of `char` translate, called or as values, by std's Unicode version - [Waiting: a slice object for a mutable part of other values](/quest/m3/ts-slice-object.md) - waits on a moq profile showing the `Proxy` view's traps matter, then decides on an `rt.ByteSlice`-like form diff --git a/quest/m3/ts-closure-calls.md b/quest/m3/ts-closure-calls.md deleted file mode 100644 index 80d5ebd2d..000000000 --- a/quest/m3/ts-closure-calls.md +++ /dev/null @@ -1,25 +0,0 @@ -# [M] std's calls of a closure that have no mapping - -## Goal - -[rust2-ts](/ts/README.md) translates std's functions that take a closure and are refused -as "unsupported call" whatever the closure holds, each calling it and dropping what it -owns as std's does, proven by the task fixture's differential tests against native Rust. - -## Plan - -Found probing std's consumers for [drop order](/quest/m3/ts-drop-order.md) in -[#438](https://github.com/moq-dev/rust2/pull/438). Of a closure that owns nothing, each of -these is refused today: - -- `Iterator::try_fold`, `try_for_each`, and `partition`. `rt.iterTryRfold` already folds - from the back as `try_rfold` does, breaking by an `Option`, `Result`, or `ControlFlow`. -- `iter::repeat_with`, and `Iterator::scan` of a state JS copies, which is refused as a - `&mut` its mapping would copy. -- `slice::sort_by_cached_key`. -- `LazyCell::new`, `Cell::update`, and `RefCell::replace_with` of a value JS copies. - -Each `rt.Iter` has a `fold` and `rfold` that drop what it holds where std's do: a consumer -that takes the iterator by value builds on them, as `rt.iterFold` does. - -Public API: the translator's output, and the runtime's functions each needs. diff --git a/ts/README.md b/ts/README.md index 69d85eecd..42d86b342 100644 --- a/ts/README.md +++ b/ts/README.md @@ -134,11 +134,11 @@ crate translation reaches is refused, and so are two versions of one crate it re | a type's function | a function of the type's module, taking `self` first: `Decoder.slice(dec, 4)` after `import * as Decoder` | | `Arc`, `Rc`, `Weak`, `Mutex` | `rt.Arc` for either, with its strong and weak counts, and `new_cyclic`'s `Weak` upgrading only once its value is made, `get_mut` lending its value only while no other `Arc` or `Weak` shares it, `make_mut` cloning it into a new `rt.Arc` while another `Arc` shares it, or moving it there while only `Weak`s do, which then dangle, and `into_inner` giving it only from the last strong `Arc`, after which its `Weak`s no longer upgrade; `rt.Weak`, counted in its `rt.Arc` until it drops, and of no `Arc` once made by `Weak::new`; `rt.Mutex`, its own guard, which a lock gives as `Ok` and the guard's drop unlocks: locking it again while held panics and `try_lock` gives `WouldBlock`, as wasm32's do, and a guard's `map` and `filter_map` make `rt.MutexMap`s, each where the part it lends is, which hold the mutex locked until they drop, and a panic aborts, so nothing poisons it and `thread::panicking` is `false`; a `Mutex`'s, a `RefCell`'s, and an `RwLock`'s `into_inner` gives its value and `get_mut` lends it, or an `rt.Place` of it where JS copies it | | `PoisonError`, `TryLockError` | the `T` it holds; `rt.TryLockError`, tagged as `Bound` is | -| `Cell`, `UnsafeCell`, `RefCell`, `RwLock` | `rt.Cell`, the place holding its value in `v`, for either of the first two: `UnsafeCell::get`'s pointer is the cell where it is an `rt.Place`, and otherwise the object in `v`, refused where the crate may put another cell or object in its place; `rt.RefCell` for either of the others, its own guard, counting its borrows: borrowing it while that conflicts panics as `RefCell`'s does, and locking it so aborts as wasm32's `RwLock` does; `try_borrow` and `try_borrow_mut` fail with `rt.BorrowError` and `rt.BorrowMutError` instead, a clone borrows the cell, `Ref::clone` counts another borrow of it, and a guard's `map`, `filter_map`, `try_map`, and `map_split`, an `RwLock` guard's included, make `rt.RefMap`s, each where a part it lends is, which a write through a mapped `RefMut` reaches in place, sharing the cell's borrow until the last drops; `RwLockWriteGuard::downgrade` keeps the lock as one read, and `Ref::leak` and `RefMut::leak` keep the borrow until `RefCell::undo_leak` ends it; refused for a part of a sized type JS can't write in place, such as a binding's | +| `Cell`, `UnsafeCell`, `RefCell`, `RwLock` | `rt.Cell`, the place holding its value in `v`, for either of the first two: `UnsafeCell::get`'s pointer is the cell where it is an `rt.Place`, and otherwise the object in `v`, refused where the crate may put another cell or object in its place; `rt.RefCell` for either of the others, its own guard, counting its borrows: borrowing it while that conflicts panics as `RefCell`'s does, and locking it so aborts as wasm32's `RwLock` does; `try_borrow` and `try_borrow_mut` fail with `rt.BorrowError` and `rt.BorrowMutError` instead, a clone borrows the cell, `Ref::clone` counts another borrow of it, and a guard's `map`, `filter_map`, `try_map`, and `map_split`, an `RwLock` guard's included, make `rt.RefMap`s, each where a part it lends is, which a write through a mapped `RefMut` reaches in place, sharing the cell's borrow until the last drops; `RwLockWriteGuard::downgrade` keeps the lock as one read, and `Ref::leak` and `RefMut::leak` keep the borrow until `RefCell::undo_leak` ends it; `Cell::update` calls its function on a copy, and `RefCell::replace_with` on the value, borrowed as `borrow_mut` does, or its place where JS copies it; refused for a part of a sized type JS can't write in place, such as a binding's | | `thread_local!`, `LocalKey` | an `rt.LocalKey`, a module's value, which makes its value on first use from the `const` or the expression and never drops it, as wasm32's do; `with` calls its function on that value, `try_with` never fails, the `Cell` and `RefCell` helpers lower from std, and a `RefCell` key's `set` and `with_borrow_mut` borrow it as `borrow_mut` does | | `OnceCell`, `OnceLock` | `rt.OnceCell` and `rt.OnceLock`, holding the `Option` in `v`, which is the place `get_mut` lends where JS copies the value; a `OnceLock` initialized from within its own initialization panics, as wasm32's does, and `get_or_try_init`'s error leaves either empty | | `Once`, `OnceState` | `rt.Once`, an `rt.OnceLock` that holds `true` once `call_once` or `call_once_force` ran its function, and panics as wasm32's does if run again from within it; `rt.OnceState`, that `Once`, which a panic never poisons, as it aborts | -| `LazyCell`, `LazyLock` in a `static` or `const` | `rt.LazyCell` and `rt.LazyLock`, which run their function on the first `force` or `Deref`, once; forced from within it, either panics as std's does | +| `LazyCell`, `LazyLock` | `rt.LazyCell` and `rt.LazyLock`, which run their function on the first `force` or `Deref`, once, and drop it then, or with the cell if it never ran; forced from within it, either panics as std's does | | `AtomicU32` and the others of `bool` and integers, `AtomicPtr` | `rt.Atomic`, the `rt.Place` of its value; an `atomic::Ordering` is its discriminant, and one an operation can't take panics as std's does. An `AtomicPtr` compares pointers only to what JS keeps as an object or bytes, as raw pointers do | | `async fn` | a function returning `rt.Future`: a class of its own, its coroutine's state machine | | async closure | a closure returning the future of each call, with what makes the future of a call that consumes it if it owns a value that drops and `Fn` or `FnMut` call it | @@ -463,8 +463,10 @@ map's `drain` does, drops those it still holds by `[Symbol.dispose]`, an adaptor what it skips or rejects, and a consumer that takes an iterator by value drops it: through each `rt.Iter`'s own `fold` where std's folds, which drops each adaptor's closure as its fold ends, before what it wraps, as std's does. The crate's own `fold` is given that -closure as a `Box`, which drops it where its body does. A `try_rfold` drops its -closure as it returns, leaving what the iterator holds to drop with it. A `Vec`'s `drain` leaves the vector +closure as a `Box`, which drops it where its body does. `try_fold`, `try_rfold`, +and `try_for_each` drop their closure as they return, leaving what the iterator holds to drop +with it. `scan` hands its closure its state, or the state's place where JS copies it, and +drops the state after the closure, as std's fields drop. A `Vec`'s `drain` leaves the vector what precedes its range until it drops, then drops what it still holds and moves the tail back, so one never dropped, as `mem::forget` leaves it, leaks the rest, as std's does. @@ -871,7 +873,8 @@ they need. `Freeze` and `Copy`, so each calls the comparator in std's order and leaves equal elements where std's does: JS's `sort` moves `undefined`, a `None`, to the end without comparing it, and each engine orders its comparisons differently. A byte slice's sorts - by its own `Ord` are its typed array's, whose order nothing observes. + by its own `Ord` are its typed array's, whose order nothing observes. `sort_by_cached_key` + sorts its keys paired with their indexes by that `sort_unstable`. - A `BinaryHeap` is std's heap in an array, with std's sifts ported to the runtime: std's move elements through raw pointers into its `Vec`, which no body of std's lowers through, and the sifts decide which `PartialOrd` tests run and which of equal elements @@ -919,13 +922,13 @@ that drops given to a std function that keeps it other than in an iterator or a `poll_fn`, or whose mapping doesn't drop it where std's does, and values that drop in some iterators ([drop order](/quest/m3/ts-drop-order.md)), a `Cow` of other than `str` or a slice, a std function without a mapping of its own that makes or reads an `Option` whose `None` is -`rt.None`, as `Iterator::scan` of `Option`s does, an `Option` of an `Option` of `()` or another +`rt.None`, an `Option` of an `Option` of `()` or another `Option`, an instance of a generic type whose field is an `Option` of a type parameter that can be `undefined`, a `String`'s `capacity`, looking up a key by another type it borrows as through the crate's own `Borrow`, a `&mut` to a value JS copies that std makes, other than a map's, or hands a closure, as `iter_mut` and `and_modify` do, one into a `Result`'s payload passed on or kept, the adaptors -without a mapping in `src/lower/iter.rs` (such as `partition`), an +without a mapping in `src/lower/iter.rs` (such as nightly's `intersperse`), an own `impl Iterator` or `DoubleEndedIterator` that overrides a provided method other than those, such as `find` or `for_each`, or whose own `fold` or `rfold` tells its accumulator or closure apart from another, by an `Option` or a `Poll` of it, a call or constant generic over it diff --git a/ts/fixtures/lang/ends/expected/core/bool.ts b/ts/fixtures/lang/ends/expected/core/bool.ts index 17d957542..5fdee27e3 100644 --- a/ts/fixtures/lang/ends/expected/core/bool.ts +++ b/ts/fixtures/lang/ends/expected/core/bool.ts @@ -9,4 +9,12 @@ export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { return t; } +export function then$19svsql(self: boolean, f: () => undefined): undefined | rt.None { + if (!self) { + return rt.None; + } + f(); + return undefined; +} + //# sourceMappingURL=bool.ts.map diff --git a/ts/fixtures/lang/ends/expected/ends.ts b/ts/fixtures/lang/ends/expected/ends.ts index 378cbacdc..80c633d2a 100644 --- a/ts/fixtures/lang/ends/expected/ends.ts +++ b/ts/fixtures/lang/ends/expected/ends.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rt from "./rt.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; +import { thenSome$0d5am30, then$19svsql } from "./core/bool.ts"; import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1sj2ls1 as option_map$1sj2ls1, map$05nbzug as option_map$05nbzug, mapOr$02k4ito as option_mapOr$02k4ito, or$1loyskh as option_or$1loyskh } from "./core/option.ts"; import * as Counted from "./ends.Counted.ts"; import * as Flicker from "./ends.Flicker.ts"; @@ -601,86 +601,133 @@ export function consumed$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, out: rt * fold panics past `k` items, with what was logged so far. */ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - let _27!: Uint8Array; - let _38!: Uint8Array; - let _53!: Uint8Array; + let _50!: Uint8Array; + let r3!: rt.Result; + let _66!: Uint8Array; + let _84!: rt.u8 | undefined; + let _99!: Uint8Array; const k8: rt.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 1, (a12: rt.u8, b13: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a12, 3) ^ b13; + rt.byteVecPush(out, rt.iterFold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a16, 3) ^ b22; }, true)); } else if (pick === 1) { const _10: Overrides.Overrides = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a11: rt.u8, b12: rt.u8): rt.u8 => { + const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { if (!(k < 15)) { - if (!(b12 !== 2)) { + if (!(b21 !== 2)) { const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b12, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a11, 3) ^ b12; + return rt.u8WrappingMul(a15, 3) ^ b21; }; rt.byteVecPush(out, rt.iterRfold(rt.iterBox(rt.iterFrom(_10, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 1, _11, true)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 2) === 0)) { - const r: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), undefined as rt.u8 | undefined, (a10: rt.u8 | undefined, b11: rt.u8): rt.u8 | undefined | rt.None => { - const _410: rt.u8 = rt.u8Rem(b11, 3); - if (_410 === 0) { - return rt.None; - } - if (_410 === 1) { - return undefined; + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 2)) { + if (!(rt.usizeRem(k, 4) === 3)) { + const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { + const _416: rt.u8 = rt.u8Rem(b20, 3); + if (_416 === 0) { + return rt.None; + } + if (_416 === 1) { + return undefined; + } + return option_or$1loyskh(a14, b20); + }, true, undefined, rt.None); + if (r2 === rt.None) { + _50 = Uint8Array.of(1, 0); + } else { + _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + } + rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); + rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), "next"); + } else { + const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { + return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { + rt.byteVecPush(out, b19); + }); + }; + rt.byteVecPush(out, rt.iterTryForEach(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); + rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), "next"); } - return option_or$1loyskh(a10, b11); - }, true, undefined, rt.None); - if (r === rt.None) { - _27 = Uint8Array.of(1, 0); } else { - _27 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r, 255)); + const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + }; + put(out, rt.iterTryFold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 0, _29, true)); + rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), "next"); } - rt.iterExtendBytes(out, rt.iterSlice(_27), undefined, true); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), "next"); } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a9: rt.u8, b10: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b10 !== k8, a9 ^ b10); + const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b17 !== k8, a12 ^ b17); }; put(out, rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 0, _19, true)); rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), "next"); } } else if (pick === 3) { - const _35: (a0: rt.u8, a1: rt.u8) => rt.Result = (a8: rt.u8, b9: rt.u8): rt.Result => { - if (!(rt.u8Rem(b9, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a8 ^ b9); - } - return rt.Err(b9); - }; - const r2: rt.Result = rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 0, _35); - if (r2.ok) { - _38 = Uint8Array.of(0, r2.value); + if (rt.usizeRem(k, 2) === 0) { + const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { + if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a11 ^ b16); + } + return rt.Err(b16); + }; + r3 = rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 0, _60); } else { - _38 = Uint8Array.of(1, r2.error); + const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { + if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a10 ^ b15); + } + return rt.Err(b15); + }; + r3 = rt.iterTryFold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 0, _63); } - rt.iterExtendBytes(out, rt.iterSlice(_38), undefined, true); + if (r3.ok) { + _66 = Uint8Array.of(0, r3.value); + } else { + _66 = Uint8Array.of(1, r3.error); + } + rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); put(out, rt.iterToOption(Overrides.next$iter_Iterator(it))); } else if (pick === 4) { - const r3: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), 0, (a7: rt.u8, b8: rt.u8): rt.Result => { - if (!(b8 > k8)) { - return rt.Ok(a7 ^ b8); + if (!(rt.usizeRem(k, 2) === 1)) { + const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(b14 > k8)) { + return rt.Ok(a9 ^ b14); + } + return rt.Err(b14); + }); + if (r5.ok) { + _99 = Uint8Array.of(0, r5.value); + } else { + _99 = Uint8Array.of(1, r5.error); } - return rt.Err(b8); - }); - if (r3.ok) { - _53 = Uint8Array.of(0, r3.value); + rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); + rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })).len() & 0xff); } else { - _53 = Uint8Array.of(1, r3.error); + const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), (b13: rt.u8): rt.Result => { + if (!(b13 > rt.u8Div(k8, 2))) { + rt.byteVecPush(out, b13); + return rt.OK; + } + return rt.Err(b13); + }); + if (r4.ok) { + _84 = undefined; + } else { + _84 = r4.error; + } + put(out, _84); + rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })).len() & 0xff); } - rt.iterExtendBytes(out, rt.iterSlice(_53), undefined, true); - rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })).len() & 0xff); } else if (pick === 5) { if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), (b7: rt.u8): rt.u8 => { - return b7 ^ 1; + rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), (b12: rt.u8): rt.u8 => { + return b12 ^ 1; })) & 0xff); } else { rt.byteVecPush(out, rt.ownedCount(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))) & 0xff); @@ -692,10 +739,22 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r put(out, rt.ownedLast(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), (b6: rt.u8): undefined => { - rt.byteVecPush(out, b6); - }, true); + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 1)) { + const _140: Overrides.Overrides = it; + const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { + return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + }; + const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterBox(rt.iterFrom(_140, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart(), true); + const a4: rt.ByteVec = _139[0]; + const b4: rt.ByteVec = _139[1]; + putVec(out, a4); + putVec(out, b4); + } else { + rt.iterForEach(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), (b10: rt.u8): undefined => { + rt.byteVecPush(out, b10); + }, true); + } } else { rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), (a0: rt.u8): rt.u32 => { return a0 as rt.u32; @@ -703,8 +762,8 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r } } else if (pick === 8) { if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), (b5: rt.u8): rt.u8 => { - return rt.u8Rem(b5, 3); + put(out, rt.iterMinByKey(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), (b9: rt.u8): rt.u8 => { + return rt.u8Rem(b9, 3); }, rt.lt, true)); } else { put(out, rt.iterMax(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), rt.lt, true)); @@ -717,39 +776,53 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r } } else if (pick === 10) { if (!(rt.usizeRem(k, 2) === 0)) { - const _118: Overrides.Overrides = it; - const _119: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.ownedLast(rt.iterSkip(rt.iterBox(rt.iterFrom(_118, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _119))); + const _175: Overrides.Overrides = it; + const _176: rt.usize = rt.usizeDiv(k, 2); + put(out, rt.ownedLast(rt.iterSkip(rt.iterBox(rt.iterFrom(_175, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _176))); } else { - const _113: Overrides.Overrides = it; - const _114: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterBox(rt.iterFrom(_113, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _114)) & 0xff); + const _170: Overrides.Overrides = it; + const _171: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterBox(rt.iterFrom(_170, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _171)) & 0xff); } } else if (pick === 11) { - const _121: rt.usize = rt.usizeRem(k, 4); - if (_121 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))), 1, (a6: rt.u8, b4: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a6, 5) ^ b4; + const _178: rt.usize = rt.usizeRem(k, 4); + if (_178 === 0) { + rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a8, 5) ^ b8; }, true)); - } else if (_121 === 1) { + } else if (_178 === 1) { put(out, rt.iterNth(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))), rt.usizeDiv(k, 4))); - } else if (_121 === 2) { + } else if (_178 === 2) { put(out, rt.ownedLast(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))), 1, (a5: rt.u8, b3: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a5, 5) ^ b3; + rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a7, 5) ^ b7; }, true)); } } else if (pick === 12) { - const _139: Overrides.Overrides = it; - const _140: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterBox(rt.iterFrom(_139, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _140); + const _196: Overrides.Overrides = it; + const _197: rt.usize = rt.usizeDiv(k, 2); + const skip: rt.Iter = rt.iterSkip(rt.iterBox(rt.iterFrom(_196, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _197); put(out, rt.iterToOption(skip.next())); put(out, rt.iterToOption(skip.nextBack())); } else if (pick === 13) { - const _150: Overrides.Overrides = it; - const _151: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterBox(rt.iterFrom(_150, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _151), "next")); + if (!(rt.usizeRem(k, 2) === 0)) { + const _216: Overrides.Overrides = it; + const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + s.v = s.v ^ b5; + return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + }; + const scan: rt.Iter = rt.iterScan(rt.iterBox(rt.iterFrom(_216, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 0, _217, true); + putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); + put(out, rt.iterToOption(scan.next())); + rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + return a6 ^ b6; + }, true)); + } else { + const _210: Overrides.Overrides = it; + const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); + putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterBox(rt.iterFrom(_210, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), _211), "next")); + } } else if (pick === 14) { if (!(rt.usizeRem(k, 2) === 0)) { const peek: rt.Peekable = rt.iterPeekable(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))); @@ -759,9 +832,9 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r put(out, rt.ownedLast(rt.iterFuse(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }))))); } } else { - const _175: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), _175), 0, (a4: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a4, 1); + const _249: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { + return rt.u8Add(a5, 1); })); put(out, rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))))); rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })).len() & 0xff); @@ -774,86 +847,133 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r * fold panics past `k` items, with what was logged so far. */ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: rt.Iter, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - let _27!: Uint8Array; - let _38!: Uint8Array; - let _53!: Uint8Array; + let _50!: Uint8Array; + let r3!: rt.Result; + let _66!: Uint8Array; + let _84!: rt.u8 | undefined; + let _99!: Uint8Array; const k8: rt.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterBox(it), 1, (a12: rt.u8, b13: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a12, 3) ^ b13; + rt.byteVecPush(out, rt.iterFold(rt.iterBox(it), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a16, 3) ^ b22; }, true)); } else if (pick === 1) { const _10: rt.Iter = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a11: rt.u8, b12: rt.u8): rt.u8 => { + const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { if (!(k < 15)) { - if (!(b12 !== 2)) { + if (!(b21 !== 2)) { const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b12, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a11, 3) ^ b12; + return rt.u8WrappingMul(a15, 3) ^ b21; }; rt.byteVecPush(out, rt.iterRfold(rt.iterBox(_10), 1, _11, true)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 2) === 0)) { - const r: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterBox(it), undefined as rt.u8 | undefined, (a10: rt.u8 | undefined, b11: rt.u8): rt.u8 | undefined | rt.None => { - const _410: rt.u8 = rt.u8Rem(b11, 3); - if (_410 === 0) { - return rt.None; - } - if (_410 === 1) { - return undefined; + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 2)) { + if (!(rt.usizeRem(k, 4) === 3)) { + const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterBox(it), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { + const _416: rt.u8 = rt.u8Rem(b20, 3); + if (_416 === 0) { + return rt.None; + } + if (_416 === 1) { + return undefined; + } + return option_or$1loyskh(a14, b20); + }, true, undefined, rt.None); + if (r2 === rt.None) { + _50 = Uint8Array.of(1, 0); + } else { + _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + } + rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); + rt.iterExtendBytes(out, rt.iterBox(it), "next"); + } else { + const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { + return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { + rt.byteVecPush(out, b19); + }); + }; + rt.byteVecPush(out, rt.iterTryForEach(rt.iterBox(it), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); + rt.iterExtendBytes(out, rt.iterBox(it), "next"); } - return option_or$1loyskh(a10, b11); - }, true, undefined, rt.None); - if (r === rt.None) { - _27 = Uint8Array.of(1, 0); } else { - _27 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r, 255)); + const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + }; + put(out, rt.iterTryFold(rt.iterBox(it), 0, _29, true)); + rt.iterExtendBytes(out, rt.iterBox(it), "next"); } - rt.iterExtendBytes(out, rt.iterSlice(_27), undefined, true); - rt.iterExtendBytes(out, rt.iterBox(it), "next"); } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a9: rt.u8, b10: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b10 !== k8, a9 ^ b10); + const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b17 !== k8, a12 ^ b17); }; put(out, rt.iterTryRfold(rt.iterBox(it), 0, _19, true)); rt.iterExtendBytes(out, rt.iterBox(it), "next"); } } else if (pick === 3) { - const _35: (a0: rt.u8, a1: rt.u8) => rt.Result = (a8: rt.u8, b9: rt.u8): rt.Result => { - if (!(rt.u8Rem(b9, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a8 ^ b9); - } - return rt.Err(b9); - }; - const r2: rt.Result = rt.iterTryRfold(rt.iterBox(it), 0, _35); - if (r2.ok) { - _38 = Uint8Array.of(0, r2.value); + if (rt.usizeRem(k, 2) === 0) { + const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { + if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a11 ^ b16); + } + return rt.Err(b16); + }; + r3 = rt.iterTryRfold(rt.iterBox(it), 0, _60); + } else { + const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { + if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a10 ^ b15); + } + return rt.Err(b15); + }; + r3 = rt.iterTryFold(rt.iterBox(it), 0, _63); + } + if (r3.ok) { + _66 = Uint8Array.of(0, r3.value); } else { - _38 = Uint8Array.of(1, r2.error); + _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_38), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); put(out, rt.iterToOption(it.next())); } else if (pick === 4) { - const r3: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it)))), 0, (a7: rt.u8, b8: rt.u8): rt.Result => { - if (!(b8 > k8)) { - return rt.Ok(a7 ^ b8); + if (!(rt.usizeRem(k, 2) === 1)) { + const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it)))), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(b14 > k8)) { + return rt.Ok(a9 ^ b14); + } + return rt.Err(b14); + }); + if (r5.ok) { + _99 = Uint8Array.of(0, r5.value); + } else { + _99 = Uint8Array.of(1, r5.error); } - return rt.Err(b8); - }); - if (r3.ok) { - _53 = Uint8Array.of(0, r3.value); + rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); + rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); } else { - _53 = Uint8Array.of(1, r3.error); + const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it)))), (b13: rt.u8): rt.Result => { + if (!(b13 > rt.u8Div(k8, 2))) { + rt.byteVecPush(out, b13); + return rt.OK; + } + return rt.Err(b13); + }); + if (r4.ok) { + _84 = undefined; + } else { + _84 = r4.error; + } + put(out, _84); + rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); } - rt.iterExtendBytes(out, rt.iterSlice(_53), undefined, true); - rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); } else if (pick === 5) { if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterBox(it), (b7: rt.u8): rt.u8 => { - return b7 ^ 1; + rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterBox(it), (b12: rt.u8): rt.u8 => { + return b12 ^ 1; })) & 0xff); } else { rt.byteVecPush(out, rt.ownedCount(rt.iterBox(it)) & 0xff); @@ -865,10 +985,22 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: put(out, rt.ownedLast(rt.iterBox(it))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterBox(it), (b6: rt.u8): undefined => { - rt.byteVecPush(out, b6); - }, true); + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 1)) { + const _140: rt.Iter = it; + const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { + return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + }; + const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterBox(_140), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart(), true); + const a4: rt.ByteVec = _139[0]; + const b4: rt.ByteVec = _139[1]; + putVec(out, a4); + putVec(out, b4); + } else { + rt.iterForEach(rt.iterBox(it), (b10: rt.u8): undefined => { + rt.byteVecPush(out, b10); + }, true); + } } else { rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterBox(it), (a0: rt.u8): rt.u32 => { return a0 as rt.u32; @@ -876,8 +1008,8 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: } } else if (pick === 8) { if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterBox(it), (b5: rt.u8): rt.u8 => { - return rt.u8Rem(b5, 3); + put(out, rt.iterMinByKey(rt.iterBox(it), (b9: rt.u8): rt.u8 => { + return rt.u8Rem(b9, 3); }, rt.lt, true)); } else { put(out, rt.iterMax(rt.iterBox(it), rt.lt, true)); @@ -890,39 +1022,53 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: } } else if (pick === 10) { if (!(rt.usizeRem(k, 2) === 0)) { - const _118: rt.Iter = it; - const _119: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.ownedLast(rt.iterSkip(rt.iterBox(_118), _119))); + const _175: rt.Iter = it; + const _176: rt.usize = rt.usizeDiv(k, 2); + put(out, rt.ownedLast(rt.iterSkip(rt.iterBox(_175), _176))); } else { - const _113: rt.Iter = it; - const _114: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterBox(_113), _114)) & 0xff); + const _170: rt.Iter = it; + const _171: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterBox(_170), _171)) & 0xff); } } else if (pick === 11) { - const _121: rt.usize = rt.usizeRem(k, 4); - if (_121 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterBox(it)), 1, (a6: rt.u8, b4: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a6, 5) ^ b4; + const _178: rt.usize = rt.usizeRem(k, 4); + if (_178 === 0) { + rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterBox(it)), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a8, 5) ^ b8; }, true)); - } else if (_121 === 1) { + } else if (_178 === 1) { put(out, rt.iterNth(rt.iterRev(rt.iterBox(it)), rt.usizeDiv(k, 4))); - } else if (_121 === 2) { + } else if (_178 === 2) { put(out, rt.ownedLast(rt.iterRev(rt.iterBox(it)))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterBox(it)), 1, (a5: rt.u8, b3: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a5, 5) ^ b3; + rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterBox(it)), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a7, 5) ^ b7; }, true)); } } else if (pick === 12) { - const _139: rt.Iter = it; - const _140: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterBox(_139), _140); + const _196: rt.Iter = it; + const _197: rt.usize = rt.usizeDiv(k, 2); + const skip: rt.Iter = rt.iterSkip(rt.iterBox(_196), _197); put(out, rt.iterToOption(skip.next())); put(out, rt.iterToOption(skip.nextBack())); } else if (pick === 13) { - const _150: rt.Iter = it; - const _151: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterBox(_150), _151), "next")); + if (!(rt.usizeRem(k, 2) === 0)) { + const _216: rt.Iter = it; + const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + s.v = s.v ^ b5; + return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + }; + const scan: rt.Iter = rt.iterScan(rt.iterBox(_216), 0, _217, true); + putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); + put(out, rt.iterToOption(scan.next())); + rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + return a6 ^ b6; + }, true)); + } else { + const _210: rt.Iter = it; + const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); + putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterBox(_210), _211), "next")); + } } else if (pick === 14) { if (!(rt.usizeRem(k, 2) === 0)) { const peek: rt.Peekable = rt.iterPeekable(rt.iterBox(it)); @@ -932,9 +1078,9 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: put(out, rt.ownedLast(rt.iterFuse(rt.iterBox(it)))); } } else { - const _175: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it))), _175), 0, (a4: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a4, 1); + const _249: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it))), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { + return rt.u8Add(a5, 1); })); put(out, rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it))))); rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); @@ -947,86 +1093,133 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: * fold panics past `k` items, with what was logged so far. */ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - let _27!: Uint8Array; - let _38!: Uint8Array; - let _53!: Uint8Array; + let _50!: Uint8Array; + let r3!: rt.Result; + let _66!: Uint8Array; + let _84!: rt.u8 | undefined; + let _99!: Uint8Array; const k8: rt.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 1, (a12: rt.u8, b13: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a12, 3) ^ b13; + rt.byteVecPush(out, rt.iterFold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a16, 3) ^ b22; })); } else if (pick === 1) { const _10: Counted.Counted = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a11: rt.u8, b12: rt.u8): rt.u8 => { + const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { if (!(k < 15)) { - if (!(b12 !== 2)) { + if (!(b21 !== 2)) { const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b12, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a11, 3) ^ b12; + return rt.u8WrappingMul(a15, 3) ^ b21; }; rt.byteVecPush(out, rt.iterRfold(rt.iterFrom(_10, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 1, _11)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 2) === 0)) { - const r: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), undefined as rt.u8 | undefined, (a10: rt.u8 | undefined, b11: rt.u8): rt.u8 | undefined | rt.None => { - const _410: rt.u8 = rt.u8Rem(b11, 3); - if (_410 === 0) { - return rt.None; - } - if (_410 === 1) { - return undefined; + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 2)) { + if (!(rt.usizeRem(k, 4) === 3)) { + const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { + const _416: rt.u8 = rt.u8Rem(b20, 3); + if (_416 === 0) { + return rt.None; + } + if (_416 === 1) { + return undefined; + } + return option_or$1loyskh(a14, b20); + }, true, undefined, rt.None); + if (r2 === rt.None) { + _50 = Uint8Array.of(1, 0); + } else { + _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + } + rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); + rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); + } else { + const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { + return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { + rt.byteVecPush(out, b19); + }); + }; + rt.byteVecPush(out, rt.iterTryForEach(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); + rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } - return option_or$1loyskh(a10, b11); - }, true, undefined, rt.None); - if (r === rt.None) { - _27 = Uint8Array.of(1, 0); } else { - _27 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r, 255)); + const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + }; + put(out, rt.iterTryFold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _29, true)); + rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } - rt.iterExtendBytes(out, rt.iterSlice(_27), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a9: rt.u8, b10: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b10 !== k8, a9 ^ b10); + const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b17 !== k8, a12 ^ b17); }; put(out, rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _19, true)); rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } } else if (pick === 3) { - const _35: (a0: rt.u8, a1: rt.u8) => rt.Result = (a8: rt.u8, b9: rt.u8): rt.Result => { - if (!(rt.u8Rem(b9, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a8 ^ b9); - } - return rt.Err(b9); - }; - const r2: rt.Result = rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _35); - if (r2.ok) { - _38 = Uint8Array.of(0, r2.value); + if (rt.usizeRem(k, 2) === 0) { + const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { + if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a11 ^ b16); + } + return rt.Err(b16); + }; + r3 = rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _60); + } else { + const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { + if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a10 ^ b15); + } + return rt.Err(b15); + }; + r3 = rt.iterTryFold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _63); + } + if (r3.ok) { + _66 = Uint8Array.of(0, r3.value); } else { - _38 = Uint8Array.of(1, r2.error); + _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_38), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); put(out, rt.iterToOption(Counted.next$iter_Iterator(it))); } else if (pick === 4) { - const r3: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 0, (a7: rt.u8, b8: rt.u8): rt.Result => { - if (!(b8 > k8)) { - return rt.Ok(a7 ^ b8); + if (!(rt.usizeRem(k, 2) === 1)) { + const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(b14 > k8)) { + return rt.Ok(a9 ^ b14); + } + return rt.Err(b14); + }); + if (r5.ok) { + _99 = Uint8Array.of(0, r5.value); + } else { + _99 = Uint8Array.of(1, r5.error); } - return rt.Err(b8); - }); - if (r3.ok) { - _53 = Uint8Array.of(0, r3.value); + rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); + rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); } else { - _53 = Uint8Array.of(1, r3.error); + const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), (b13: rt.u8): rt.Result => { + if (!(b13 > rt.u8Div(k8, 2))) { + rt.byteVecPush(out, b13); + return rt.OK; + } + return rt.Err(b13); + }); + if (r4.ok) { + _84 = undefined; + } else { + _84 = r4.error; + } + put(out, _84); + rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); } - rt.iterExtendBytes(out, rt.iterSlice(_53), undefined, true); - rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); } else if (pick === 5) { if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b7: rt.u8): rt.u8 => { - return b7 ^ 1; + rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b12: rt.u8): rt.u8 => { + return b12 ^ 1; })) & 0xff); } else { rt.byteVecPush(out, rt.iterCount(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })) & 0xff); @@ -1038,10 +1231,22 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usiz put(out, rt.iterLast(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b6: rt.u8): undefined => { - rt.byteVecPush(out, b6); - }); + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 1)) { + const _140: Counted.Counted = it; + const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { + return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + }; + const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterFrom(_140, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart()); + const a4: rt.ByteVec = _139[0]; + const b4: rt.ByteVec = _139[1]; + putVec(out, a4); + putVec(out, b4); + } else { + rt.iterForEach(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b10: rt.u8): undefined => { + rt.byteVecPush(out, b10); + }); + } } else { rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (a0: rt.u8): rt.u32 => { return a0 as rt.u32; @@ -1049,8 +1254,8 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usiz } } else if (pick === 8) { if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b5: rt.u8): rt.u8 => { - return rt.u8Rem(b5, 3); + put(out, rt.iterMinByKey(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b9: rt.u8): rt.u8 => { + return rt.u8Rem(b9, 3); }, rt.lt)); } else { put(out, rt.iterMax(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rt.lt)); @@ -1063,39 +1268,53 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usiz } } else if (pick === 10) { if (!(rt.usizeRem(k, 2) === 0)) { - const _118: Counted.Counted = it; - const _119: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.iterLast(rt.iterSkip(rt.iterFrom(_118, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _119))); + const _175: Counted.Counted = it; + const _176: rt.usize = rt.usizeDiv(k, 2); + put(out, rt.iterLast(rt.iterSkip(rt.iterFrom(_175, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _176))); } else { - const _113: Counted.Counted = it; - const _114: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterFrom(_113, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _114)) & 0xff); + const _170: Counted.Counted = it; + const _171: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterFrom(_170, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _171)) & 0xff); } } else if (pick === 11) { - const _121: rt.usize = rt.usizeRem(k, 4); - if (_121 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a6: rt.u8, b4: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a6, 5) ^ b4; + const _178: rt.usize = rt.usizeRem(k, 4); + if (_178 === 0) { + rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a8, 5) ^ b8; })); - } else if (_121 === 1) { + } else if (_178 === 1) { put(out, rt.iterNth(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), rt.usizeDiv(k, 4))); - } else if (_121 === 2) { + } else if (_178 === 2) { put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a5: rt.u8, b3: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a5, 5) ^ b3; + rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a7, 5) ^ b7; })); } } else if (pick === 12) { - const _139: Counted.Counted = it; - const _140: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_139, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _140); + const _196: Counted.Counted = it; + const _197: rt.usize = rt.usizeDiv(k, 2); + const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_196, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _197); put(out, rt.iterToOption(skip.next())); put(out, rt.iterToOption(skip.nextBack())); } else if (pick === 13) { - const _150: Counted.Counted = it; - const _151: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_150, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _151), "next")); + if (!(rt.usizeRem(k, 2) === 0)) { + const _216: Counted.Counted = it; + const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + s.v = s.v ^ b5; + return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + }; + const scan: rt.Iter = rt.iterScan(rt.iterFrom(_216, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _217, true); + putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); + put(out, rt.iterToOption(scan.next())); + rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + return a6 ^ b6; + })); + } else { + const _210: Counted.Counted = it; + const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); + putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_210, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _211), "next")); + } } else if (pick === 14) { if (!(rt.usizeRem(k, 2) === 0)) { const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })); @@ -1105,9 +1324,9 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usiz put(out, rt.iterLast(rt.iterFuse(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); } } else { - const _175: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _175), 0, (a4: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a4, 1); + const _249: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { + return rt.u8Add(a5, 1); })); put(out, rt.iterLast(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))); rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); @@ -1120,84 +1339,131 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usiz * fold panics past `k` items, with what was logged so far. */ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - let _27!: Uint8Array; - let _38!: Uint8Array; - let _53!: Uint8Array; + let _50!: Uint8Array; + let r3!: rt.Result; + let _66!: Uint8Array; + let _84!: rt.u8 | undefined; + let _99!: Uint8Array; const k8: rt.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, Overrides.fold$iter_Iterator_u8_ends_folded_closure0_ends_Overrides(it, 1, (a12: rt.u8, b13: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a12, 3) ^ b13; + rt.byteVecPush(out, Overrides.fold$iter_Iterator_u8_ends_folded_closure0_ends_Overrides(it, 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a16, 3) ^ b22; })); } else if (pick === 1) { - rt.byteVecPush(out, Overrides.rfold$iter_DoubleEndedIterator_u8_ends_folded_closure1_ends_Overrides(it, 1, (a11: rt.u8, b12: rt.u8): rt.u8 => { + rt.byteVecPush(out, Overrides.rfold$iter_DoubleEndedIterator_u8_ends_folded_closure1_ends_Overrides(it, 1, (a15: rt.u8, b21: rt.u8): rt.u8 => { if (!(k < 15)) { - if (!(b12 !== 2)) { + if (!(b21 !== 2)) { const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b12, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a11, 3) ^ b12; + return rt.u8WrappingMul(a15, 3) ^ b21; })); } else if (pick === 2) { - if (!(rt.usizeRem(k, 2) === 0)) { - const r: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), undefined as rt.u8 | undefined, (a10: rt.u8 | undefined, b11: rt.u8): rt.u8 | undefined | rt.None => { - const _410: rt.u8 = rt.u8Rem(b11, 3); - if (_410 === 0) { - return rt.None; - } - if (_410 === 1) { - return undefined; + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 2)) { + if (!(rt.usizeRem(k, 4) === 3)) { + const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { + const _416: rt.u8 = rt.u8Rem(b20, 3); + if (_416 === 0) { + return rt.None; + } + if (_416 === 1) { + return undefined; + } + return option_or$1loyskh(a14, b20); + }, true, undefined, rt.None); + if (r2 === rt.None) { + _50 = Uint8Array.of(1, 0); + } else { + _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + } + rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); + rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), "next"); + } else { + const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { + return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { + rt.byteVecPush(out, b19); + }); + }; + rt.byteVecPush(out, rt.iterTryForEach(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); + rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), "next"); } - return option_or$1loyskh(a10, b11); - }, true, undefined, rt.None); - if (r === rt.None) { - _27 = Uint8Array.of(1, 0); } else { - _27 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r, 255)); + const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + }; + put(out, rt.iterTryFold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), 0, _29, true)); + rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), "next"); } - rt.iterExtendBytes(out, rt.iterSlice(_27), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), "next"); } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a9: rt.u8, b10: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b10 !== k8, a9 ^ b10); + const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b17 !== k8, a12 ^ b17); }; put(out, rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), 0, _19, true)); rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), "next"); } } else if (pick === 3) { - const _35: (a0: rt.u8, a1: rt.u8) => rt.Result = (a8: rt.u8, b9: rt.u8): rt.Result => { - if (!(rt.u8Rem(b9, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a8 ^ b9); - } - return rt.Err(b9); - }; - const r2: rt.Result = rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), 0, _35); - if (r2.ok) { - _38 = Uint8Array.of(0, r2.value); + if (rt.usizeRem(k, 2) === 0) { + const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { + if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a11 ^ b16); + } + return rt.Err(b16); + }; + r3 = rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), 0, _60); + } else { + const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { + if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a10 ^ b15); + } + return rt.Err(b15); + }; + r3 = rt.iterTryFold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), 0, _63); + } + if (r3.ok) { + _66 = Uint8Array.of(0, r3.value); } else { - _38 = Uint8Array.of(1, r2.error); + _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_38), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); put(out, rt.iterToOption(Overrides.next$iter_Iterator(it))); } else if (pick === 4) { - const r3: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), 0, (a7: rt.u8, b8: rt.u8): rt.Result => { - if (!(b8 > k8)) { - return rt.Ok(a7 ^ b8); + if (!(rt.usizeRem(k, 2) === 1)) { + const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(b14 > k8)) { + return rt.Ok(a9 ^ b14); + } + return rt.Err(b14); + }); + if (r5.ok) { + _99 = Uint8Array.of(0, r5.value); + } else { + _99 = Uint8Array.of(1, r5.error); } - return rt.Err(b8); - }); - if (r3.ok) { - _53 = Uint8Array.of(0, r3.value); + rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); + rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }).len() & 0xff); } else { - _53 = Uint8Array.of(1, r3.error); + const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b13: rt.u8): rt.Result => { + if (!(b13 > rt.u8Div(k8, 2))) { + rt.byteVecPush(out, b13); + return rt.OK; + } + return rt.Err(b13); + }); + if (r4.ok) { + _84 = undefined; + } else { + _84 = r4.error; + } + put(out, _84); + rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }).len() & 0xff); } - rt.iterExtendBytes(out, rt.iterSlice(_53), undefined, true); - rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }).len() & 0xff); } else if (pick === 5) { if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), (b7: rt.u8): rt.u8 => { - return b7 ^ 1; + rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), (b12: rt.u8): rt.u8 => { + return b12 ^ 1; })) & 0xff); } else { rt.byteVecPush(out, Overrides.count$iter_Iterator(it) & 0xff); @@ -1209,10 +1475,22 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: r put(out, Overrides.last$iter_Iterator(it)); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), (b6: rt.u8): undefined => { - rt.byteVecPush(out, b6); - }, true); + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 1)) { + const _140: Overrides.Overrides = it; + const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { + return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + }; + const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterFrom(_140, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart(), true); + const a4: rt.ByteVec = _139[0]; + const b4: rt.ByteVec = _139[1]; + putVec(out, a4); + putVec(out, b4); + } else { + rt.iterForEach(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), (b10: rt.u8): undefined => { + rt.byteVecPush(out, b10); + }, true); + } } else { rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), (a0: rt.u8): rt.u32 => { return a0 as rt.u32; @@ -1220,8 +1498,8 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: r } } else if (pick === 8) { if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), (b5: rt.u8): rt.u8 => { - return rt.u8Rem(b5, 3); + put(out, rt.iterMinByKey(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), (b9: rt.u8): rt.u8 => { + return rt.u8Rem(b9, 3); }, rt.lt, true)); } else { put(out, rt.iterMax(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), rt.lt, true)); @@ -1234,39 +1512,53 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: r } } else if (pick === 10) { if (!(rt.usizeRem(k, 2) === 0)) { - const _118: Overrides.Overrides = it; - const _119: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.ownedLast(rt.iterSkip(rt.iterFrom(_118, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _119))); + const _175: Overrides.Overrides = it; + const _176: rt.usize = rt.usizeDiv(k, 2); + put(out, rt.ownedLast(rt.iterSkip(rt.iterFrom(_175, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _176))); } else { - const _113: Overrides.Overrides = it; - const _114: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterFrom(_113, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _114)) & 0xff); + const _170: Overrides.Overrides = it; + const _171: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterFrom(_170, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _171)) & 0xff); } } else if (pick === 11) { - const _121: rt.usize = rt.usizeRem(k, 4); - if (_121 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 1, (a6: rt.u8, b4: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a6, 5) ^ b4; + const _178: rt.usize = rt.usizeRem(k, 4); + if (_178 === 0) { + rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a8, 5) ^ b8; }, true)); - } else if (_121 === 1) { + } else if (_178 === 1) { put(out, rt.iterNth(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), rt.usizeDiv(k, 4))); - } else if (_121 === 2) { + } else if (_178 === 2) { put(out, rt.ownedLast(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 1, (a5: rt.u8, b3: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a5, 5) ^ b3; + rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a7, 5) ^ b7; }, true)); } } else if (pick === 12) { - const _139: Overrides.Overrides = it; - const _140: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_139, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _140); + const _196: Overrides.Overrides = it; + const _197: rt.usize = rt.usizeDiv(k, 2); + const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_196, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _197); put(out, rt.iterToOption(skip.next())); put(out, rt.iterToOption(skip.nextBack())); } else if (pick === 13) { - const _150: Overrides.Overrides = it; - const _151: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_150, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _151), "next")); + if (!(rt.usizeRem(k, 2) === 0)) { + const _216: Overrides.Overrides = it; + const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + s.v = s.v ^ b5; + return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + }; + const scan: rt.Iter = rt.iterScan(rt.iterFrom(_216, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), 0, _217, true); + putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); + put(out, rt.iterToOption(scan.next())); + rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + return a6 ^ b6; + }, true)); + } else { + const _210: Overrides.Overrides = it; + const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); + putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_210, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }), _211), "next")); + } } else if (pick === 14) { if (!(rt.usizeRem(k, 2) === 0)) { const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })); @@ -1276,9 +1568,9 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: r put(out, rt.ownedLast(rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 })))); } } else { - const _175: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _175), 0, (a4: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a4, 1); + const _249: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { + return rt.u8Add(a5, 1); })); put(out, rt.iterLast(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))); rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32 }).len() & 0xff); @@ -1291,86 +1583,133 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: r * fold panics past `k` items, with what was logged so far. */ export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - let _27!: Uint8Array; - let _38!: Uint8Array; - let _53!: Uint8Array; + let _50!: Uint8Array; + let r3!: rt.Result; + let _66!: Uint8Array; + let _84!: rt.u8 | undefined; + let _99!: Uint8Array; const k8: rt.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 1, (a12: rt.u8, b13: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a12, 3) ^ b13; + rt.byteVecPush(out, rt.iterFold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a16, 3) ^ b22; })); } else if (pick === 1) { const _10: Run.Run = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a11: rt.u8, b12: rt.u8): rt.u8 => { + const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { if (!(k < 15)) { - if (!(b12 !== 2)) { + if (!(b21 !== 2)) { const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b12, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a11, 3) ^ b12; + return rt.u8WrappingMul(a15, 3) ^ b21; }; rt.byteVecPush(out, rt.iterRfold(rt.iterFrom(_10, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 1, _11)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 2) === 0)) { - const r: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), undefined as rt.u8 | undefined, (a10: rt.u8 | undefined, b11: rt.u8): rt.u8 | undefined | rt.None => { - const _410: rt.u8 = rt.u8Rem(b11, 3); - if (_410 === 0) { - return rt.None; - } - if (_410 === 1) { - return undefined; + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 2)) { + if (!(rt.usizeRem(k, 4) === 3)) { + const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { + const _416: rt.u8 = rt.u8Rem(b20, 3); + if (_416 === 0) { + return rt.None; + } + if (_416 === 1) { + return undefined; + } + return option_or$1loyskh(a14, b20); + }, true, undefined, rt.None); + if (r2 === rt.None) { + _50 = Uint8Array.of(1, 0); + } else { + _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + } + rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); + rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + } else { + const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { + return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { + rt.byteVecPush(out, b19); + }); + }; + rt.byteVecPush(out, rt.iterTryForEach(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); + rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } - return option_or$1loyskh(a10, b11); - }, true, undefined, rt.None); - if (r === rt.None) { - _27 = Uint8Array.of(1, 0); } else { - _27 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r, 255)); + const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + }; + put(out, rt.iterTryFold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _29, true)); + rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } - rt.iterExtendBytes(out, rt.iterSlice(_27), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a9: rt.u8, b10: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b10 !== k8, a9 ^ b10); + const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { + return thenSome$0d5am30(b17 !== k8, a12 ^ b17); }; put(out, rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _19, true)); rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } } else if (pick === 3) { - const _35: (a0: rt.u8, a1: rt.u8) => rt.Result = (a8: rt.u8, b9: rt.u8): rt.Result => { - if (!(rt.u8Rem(b9, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a8 ^ b9); - } - return rt.Err(b9); - }; - const r2: rt.Result = rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _35); - if (r2.ok) { - _38 = Uint8Array.of(0, r2.value); + if (rt.usizeRem(k, 2) === 0) { + const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { + if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a11 ^ b16); + } + return rt.Err(b16); + }; + r3 = rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _60); + } else { + const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { + if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { + return rt.Ok(a10 ^ b15); + } + return rt.Err(b15); + }; + r3 = rt.iterTryFold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _63); + } + if (r3.ok) { + _66 = Uint8Array.of(0, r3.value); } else { - _38 = Uint8Array.of(1, r2.error); + _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_38), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); put(out, rt.iterToOption(Run.next$iter_Iterator(it))); } else if (pick === 4) { - const r3: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 0, (a7: rt.u8, b8: rt.u8): rt.Result => { - if (!(b8 > k8)) { - return rt.Ok(a7 ^ b8); + if (!(rt.usizeRem(k, 2) === 1)) { + const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(b14 > k8)) { + return rt.Ok(a9 ^ b14); + } + return rt.Err(b14); + }); + if (r5.ok) { + _99 = Uint8Array.of(0, r5.value); + } else { + _99 = Uint8Array.of(1, r5.error); } - return rt.Err(b8); - }); - if (r3.ok) { - _53 = Uint8Array.of(0, r3.value); + rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); + rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } else { - _53 = Uint8Array.of(1, r3.error); + const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b13: rt.u8): rt.Result => { + if (!(b13 > rt.u8Div(k8, 2))) { + rt.byteVecPush(out, b13); + return rt.OK; + } + return rt.Err(b13); + }); + if (r4.ok) { + _84 = undefined; + } else { + _84 = r4.error; + } + put(out, _84); + rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } - rt.iterExtendBytes(out, rt.iterSlice(_53), undefined, true); - rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } else if (pick === 5) { if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b7: rt.u8): rt.u8 => { - return b7 ^ 1; + rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b12: rt.u8): rt.u8 => { + return b12 ^ 1; })) & 0xff); } else { rt.byteVecPush(out, rt.iterCount(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })) & 0xff); @@ -1382,10 +1721,22 @@ export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.R put(out, rt.iterLast(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b6: rt.u8): undefined => { - rt.byteVecPush(out, b6); - }); + if (!(rt.usizeRem(k, 4) === 0)) { + if (!(rt.usizeRem(k, 4) === 1)) { + const _140: Run.Run = it; + const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { + return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + }; + const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterFrom(_140, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart()); + const a4: rt.ByteVec = _139[0]; + const b4: rt.ByteVec = _139[1]; + putVec(out, a4); + putVec(out, b4); + } else { + rt.iterForEach(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b10: rt.u8): undefined => { + rt.byteVecPush(out, b10); + }); + } } else { rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (a0: rt.u8): rt.u32 => { return a0 as rt.u32; @@ -1393,8 +1744,8 @@ export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.R } } else if (pick === 8) { if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b5: rt.u8): rt.u8 => { - return rt.u8Rem(b5, 3); + put(out, rt.iterMinByKey(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b9: rt.u8): rt.u8 => { + return rt.u8Rem(b9, 3); }, rt.lt)); } else { put(out, rt.iterMax(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.lt)); @@ -1407,39 +1758,53 @@ export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.R } } else if (pick === 10) { if (!(rt.usizeRem(k, 2) === 0)) { - const _118: Run.Run = it; - const _119: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.iterLast(rt.iterSkip(rt.iterFrom(_118, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _119))); + const _175: Run.Run = it; + const _176: rt.usize = rt.usizeDiv(k, 2); + put(out, rt.iterLast(rt.iterSkip(rt.iterFrom(_175, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _176))); } else { - const _113: Run.Run = it; - const _114: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterFrom(_113, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _114)) & 0xff); + const _170: Run.Run = it; + const _171: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterFrom(_170, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _171)) & 0xff); } } else if (pick === 11) { - const _121: rt.usize = rt.usizeRem(k, 4); - if (_121 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a6: rt.u8, b4: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a6, 5) ^ b4; + const _178: rt.usize = rt.usizeRem(k, 4); + if (_178 === 0) { + rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a8, 5) ^ b8; })); - } else if (_121 === 1) { + } else if (_178 === 1) { put(out, rt.iterNth(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), rt.usizeDiv(k, 4))); - } else if (_121 === 2) { + } else if (_178 === 2) { put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a5: rt.u8, b3: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a5, 5) ^ b3; + rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { + return rt.u8WrappingMul(a7, 5) ^ b7; })); } } else if (pick === 12) { - const _139: Run.Run = it; - const _140: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_139, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _140); + const _196: Run.Run = it; + const _197: rt.usize = rt.usizeDiv(k, 2); + const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_196, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _197); put(out, rt.iterToOption(skip.next())); put(out, rt.iterToOption(skip.nextBack())); } else if (pick === 13) { - const _150: Run.Run = it; - const _151: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_150, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _151), "next")); + if (!(rt.usizeRem(k, 2) === 0)) { + const _216: Run.Run = it; + const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + s.v = s.v ^ b5; + return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + }; + const scan: rt.Iter = rt.iterScan(rt.iterFrom(_216, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _217, true); + putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); + put(out, rt.iterToOption(scan.next())); + rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + return a6 ^ b6; + })); + } else { + const _210: Run.Run = it; + const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); + putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_210, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _211), "next")); + } } else if (pick === 14) { if (!(rt.usizeRem(k, 2) === 0)) { const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); @@ -1449,9 +1814,9 @@ export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.R put(out, rt.iterLast(rt.iterFuse(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); } } else { - const _175: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _175), 0, (a4: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a4, 1); + const _249: rt.usize = rt.usizeDiv(k, 2); + rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { + return rt.u8Add(a5, 1); })); put(out, rt.iterLast(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))); rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); diff --git a/ts/fixtures/lang/ends/src/ends.rs b/ts/fixtures/lang/ends/src/ends.rs index 15416ae6a..b4d7c8f97 100644 --- a/ts/fixtures/lang/ends/src/ends.rs +++ b/ts/fixtures/lang/ends/src/ends.rs @@ -345,11 +345,21 @@ fn folded + ExactSizeIterator>( assert!(k < 15 || b != 2, "rfold at {b} after {:?}", log.borrow().as_slice()); a.wrapping_mul(3) ^ b })), - // Each `try_rfold` breaks at an item, then the rest are read on by `next`. - 2 if k % 2 == 0 => { + // Each `try_rfold`, `try_fold`, or `try_for_each` breaks at an item, then the rest are + // read on by `next`. + 2 if k % 4 == 0 => { put(out, it.try_rfold(0u8, |a, b| (b != k8).then_some(a ^ b))); out.extend(it); } + 2 if k % 4 == 2 => { + put(out, it.try_fold(0u8, |a, b| (b != k8 / 4).then_some(a ^ b))); + out.extend(it); + } + 2 if k % 4 == 3 => { + let r = it.try_for_each(|b| (b != k8 / 4).then(|| out.push(b))); + out.push(r.is_some() as u8); + out.extend(it); + } // Of an `Option` accumulator, whose `Some(None)` goes on and whose `None` breaks. 2 => { let r = it.try_rfold(None, |a: Option, b| match b % 3 { @@ -364,13 +374,31 @@ fn folded + ExactSizeIterator>( out.extend(it); } 3 => { - let r: Result = it.try_rfold(0u8, |a, b| if b % 4 == k8 % 4 { Err(b) } else { Ok(a ^ b) }); + let r: Result = match k % 2 { + 0 => it.try_rfold(0u8, |a, b| if b % 4 == k8 % 4 { Err(b) } else { Ok(a ^ b) }), + _ => it.try_fold(0u8, |a, b| if b % 4 == k8 % 4 { Err(b) } else { Ok(a ^ b) }), + }; out.extend(match r { Ok(a) => [0, a], Err(b) => [1, b], }); put(out, it.next()); } + 4 if k % 2 == 1 => { + use std::ops::ControlFlow; + let r = it.by_ref().rev().try_for_each(|b| match b > k8 / 2 { + true => ControlFlow::Break(b), + false => ControlFlow::Continue(out.push(b)), + }); + put( + out, + match r { + ControlFlow::Break(b) => Some(b), + ControlFlow::Continue(()) => None, + }, + ); + out.push(it.len() as u8); + } 4 => { use std::ops::ControlFlow; let r = it.by_ref().rev().try_rfold(0u8, |a, b| match b > k8 { @@ -387,8 +415,14 @@ fn folded + ExactSizeIterator>( 5 => out.push(it.map(|b| b ^ 1).count() as u8), 6 if k % 2 == 0 => put(out, it.last()), 6 => put(out, it.rev().last()), - 7 if k % 2 == 0 => out.push(it.map(u32::from).sum::() as u8), - 7 => it.for_each(|b| out.push(b)), + 7 if k % 4 == 0 => out.push(it.map(u32::from).sum::() as u8), + 7 if k % 4 == 1 => it.for_each(|b| out.push(b)), + // `partition`, which folds it into two `Vec`s. + 7 => { + let (a, b): (Vec, Vec) = it.partition(|b| b % 3 == k8 % 3); + put_vec(out, a); + put_vec(out, b); + } 8 if k % 2 == 0 => put(out, it.max()), 8 => put(out, it.min_by_key(|b| b % 3)), 9 if k % 2 == 0 => out.push(it.chain([7, 8]).count() as u8), @@ -406,7 +440,17 @@ fn folded + ExactSizeIterator>( put(out, skip.next()); put(out, skip.next_back()); } - 13 => put_vec(out, it.step_by(k / 4 + 1).collect()), + 13 if k % 2 == 0 => put_vec(out, it.step_by(k / 4 + 1).collect()), + // `scan`, whose `None` ends the collect, and which `next` reads on past. + 13 => { + let mut scan = it.scan(0u8, |s, b| { + *s ^= b; + (*s != k8 / 2).then_some(*s) + }); + put_vec(out, scan.by_ref().collect()); + put(out, scan.next()); + out.push(scan.fold(0, |a, b| a ^ b)); + } 14 if k % 2 == 0 => put(out, it.fuse().last()), 14 => { let mut peek = it.peekable(); diff --git a/ts/fixtures/lang/iters/expected/core/bool.ts b/ts/fixtures/lang/iters/expected/core/bool.ts index f14754359..b4b3e3227 100644 --- a/ts/fixtures/lang/iters/expected/core/bool.ts +++ b/ts/fixtures/lang/iters/expected/core/bool.ts @@ -2,6 +2,13 @@ import * as rt from "../rt.ts"; +export function thenSome$185ufyt(self: boolean, t: rt.u8 | undefined): rt.u8 | undefined | rt.None { + if (!self) { + return rt.None; + } + return t; +} + export function thenSome$0b23a33(self: boolean, t: rt.u16): rt.u16 | undefined { if (!self) { return undefined; @@ -16,4 +23,11 @@ export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { return t; } +export function thenSome$1j8foe9(self: boolean, _: undefined): undefined | rt.None { + if (!self) { + return rt.None; + } + return undefined; +} + //# sourceMappingURL=bool.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index a9e2f43d6..0cc6e4d37 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -2,7 +2,7 @@ import * as rt from "./rt.ts"; import { of$u8 } from "./lib.ts"; -import { thenSome$0b23a33, thenSome$0d5am30 } from "./core/bool.ts"; +import { thenSome$185ufyt, thenSome$0b23a33, thenSome$0d5am30, thenSome$1j8foe9 } from "./core/bool.ts"; import { unwrapOr$0k15iai as option_unwrapOr$0k15iai, unwrapOr$00uis1j as option_unwrapOr$00uis1j, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$14m5xjm as option_unwrapOr$14m5xjm, unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0wx44sw as option_unwrapOrDefault$0wx44sw, map$1uo1d4o as option_map$1uo1d4o, map$1httady as option_map$1httady, map$0of9gds as option_map$0of9gds, map$1c7zybz as option_map$1c7zybz, map$0cs071d as option_map$0cs071d, map$0p22lts as option_map$0p22lts, mapOr$0lcrgk1 as option_mapOr$0lcrgk1, mapOr$1kiffmd as option_mapOr$1kiffmd, mapOr$1a3irjf as option_mapOr$1a3irjf, mapOr$0sl5app as option_mapOr$0sl5app, mapOr$0atjiti as option_mapOr$0atjiti, mapOr$0okqj9y as option_mapOr$0okqj9y, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$1lznlgz as option_mapOr$1lznlgz, mapOr$0tmtgfi as option_mapOr$0tmtgfi, mapOr$0ev76sb as option_mapOr$0ev76sb, mapOr$1surhce as option_mapOr$1surhce, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$0a96v80 as option_mapOr$0a96v80, mapOr$1vjqo89 as option_mapOr$1vjqo89, mapOr$1h04da8 as option_mapOr$1h04da8, mapOr$0f73bb7 as option_mapOr$0f73bb7, mapOr$0mmpeqx as option_mapOr$0mmpeqx, mapOr$06gg5x7 as option_mapOr$06gg5x7, mapOr$1dmz9kd as option_mapOr$1dmz9kd, mapOr$1sxa8ki as option_mapOr$1sxa8ki, mapOr$02k4ito as option_mapOr$02k4ito, asDeref$0w8at8i as option_asDeref$0w8at8i, filter$0v80fk8 } from "./core/option.ts"; import { unwrapOr$01jdcm7 as result_unwrapOr$01jdcm7 } from "./core/result.ts"; import type * as Badge from "./iters.Badge.ts"; @@ -1502,8 +1502,8 @@ export function optionItems(data: rt.ByteSlice, out: rt.ByteVec): void { if (_111 === rt.DONE) { break; } - rt.byteVecPush(out, option_mapOr$1sxa8ki(_111, 167, (a4: rt.u32): rt.u8 => { - return a4 & 0xff; + rt.byteVecPush(out, option_mapOr$1sxa8ki(_111, 167, (a5: rt.u32): rt.u8 => { + return a5 & 0xff; })); } rt.byteVecPush(out, present$unit(units)); @@ -1552,11 +1552,24 @@ export function optionItems(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } + let sum: rt.u8 = 0; + for (const _179 of rt.iterToArray(rt.iterScan(rt.iterSlice(rt.byteSliceView(data)), rt.place(() => sum, (value) => sum = value), (n: rt.Place>, _310: rt.u8): rt.u8 | undefined | rt.None => { + const b9: rt.u8 = _310; + const _55: rt.u8 = rt.u8WrappingAdd(n.v.v, b9); + n.v.v = _55; + return thenSome$185ufyt(rt.u8Rem(b9, 5) !== 4, thenSome$0d5am30(rt.u8Rem(b9, 2) === 0, n.v.v)); + }, true, undefined, rt.None), "next", 2)) { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(_179, 173)); + } + rt.byteVecPush(out, sum); + rt.byteVecPush(out, rt.iterCount(rt.iterScan(rt.iterSlice(rt.byteSliceView(data)), undefined, (_25: rt.Place, _311: rt.u8): undefined | rt.None => { + return thenSome$1j8foe9(rt.u8Rem(_311, 5) !== 4, undefined); + }, true, undefined, rt.None)) & 0xff); const weighed: Weighed.Weighed = { inner: rt.iterSlice(rt.byteSliceView(data)), weight: 0 }; while (true) { - const _174: rt.u8 | rt.Done = Weighed.next$iter_Iterator(weighed); - if (_174 !== rt.DONE) { - rt.byteVecPush(out, _174); + const _194: rt.u8 | rt.Done = Weighed.next$iter_Iterator(weighed); + if (_194 !== rt.DONE) { + rt.byteVecPush(out, _194); } else { break; } diff --git a/ts/fixtures/lang/iters/src/iters.rs b/ts/fixtures/lang/iters/src/iters.rs index bc246dbeb..e944e5302 100644 --- a/ts/fixtures/lang/iters/src/iters.rs +++ b/ts/fixtures/lang/iters/src/iters.rs @@ -827,6 +827,20 @@ pub fn option_items(data: &[u8], out: &mut Vec) { while let Some(found) = first_present(&mut it) { out.push(found); } + // `scan` of items whose `None` is `rt.None`, each ending where its closure's `None` is. + let mut sum = 0u8; + let scanned: Vec> = data + .iter() + .scan(&mut sum, |n, &b| { + **n = n.wrapping_add(b); + (b % 5 != 4).then_some((b % 2 == 0).then_some(**n)) + }) + .collect(); + for a in scanned { + out.push(a.unwrap_or(0xad)); + } + out.push(sum); + out.push(data.iter().scan((), |_, &b| (b % 5 != 4).then_some(())).count() as u8); let mut weighed = Weighed { inner: data.iter(), weight: 0, diff --git a/ts/fixtures/lang/sorts/expected/sorts.Item.ts b/ts/fixtures/lang/sorts/expected/sorts.Item.ts index e150d093e..f262b56f2 100644 --- a/ts/fixtures/lang/sorts/expected/sorts.Item.ts +++ b/ts/fixtures/lang/sorts/expected/sorts.Item.ts @@ -25,6 +25,10 @@ export function eq$cmp_PartialEq_unit(self: Item, other: Item, other: Item): rt.Ordering | undefined { + return cmp$cmp_Ord_u8(self, other); +} + export function lt$cmp_PartialOrd_Cell_u32(self: Item>, other: Item>): boolean { note(60, self.tag, other.tag); return self.key < other.key; @@ -85,6 +89,11 @@ export function cmp$cmp_Ord_sorts_Held(self: Item, other: Item, other: Item): rt.Ordering { + note(99, self.tag, other.tag); + return rt.cmp(self.key, other.key); +} + export function cmp$cmp_Ord_unit(self: Item, other: Item): rt.Ordering { note(99, self.tag, other.tag); return rt.cmp(self.key, other.key); diff --git a/ts/fixtures/lang/sorts/expected/sorts.ts b/ts/fixtures/lang/sorts/expected/sorts.ts index ce804a84c..b12bf7d97 100644 --- a/ts/fixtures/lang/sorts/expected/sorts.ts +++ b/ts/fixtures/lang/sorts/expected/sorts.ts @@ -409,6 +409,12 @@ export function sorted$Cell_u32_sorts_sorts_closure1(keys: rt.u16[], pad: () => return rt.u16Rem(x2.key, 3); }, rt.lt), 8, false, false); put$Cell_u32(v6, out); + const v7: Item.Item>[] = items(); + rt.sliceSortByCachedKey(v7, (x3: Item.Item>): Item.Item => { + note(107, x3.tag, 0); + return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); + }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + put$Cell_u32(v7, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ @@ -443,6 +449,12 @@ export function sorted$array10_u32_sorts_sorts_closure3(keys: rt.u16[], pad: () return rt.u16Rem(x2.key, 3); }, rt.lt), 44, true, true); put$array10_u32(v6, out); + const v7: Item.Item[] = items(); + rt.sliceSortByCachedKey(v7, (x3: Item.Item): Item.Item => { + note(107, x3.tag, 0); + return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); + }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + put$array10_u32(v7, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ @@ -477,6 +489,12 @@ export function sorted$array22_u32_sorts_sorts_closure4(keys: rt.u16[], pad: () return rt.u16Rem(x2.key, 3); }, rt.lt), 92, true, true); put$array22_u32(v6, out); + const v7: Item.Item[] = items(); + rt.sliceSortByCachedKey(v7, (x3: Item.Item): Item.Item => { + note(107, x3.tag, 0); + return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); + }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + put$array22_u32(v7, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ @@ -511,6 +529,12 @@ export function sorted$array30_u32_sorts_sorts_closure5(keys: rt.u16[], pad: () return rt.u16Rem(x2.key, 3); }, rt.lt), 124, true, true); put$array30_u32(v6, out); + const v7: Item.Item[] = items(); + rt.sliceSortByCachedKey(v7, (x3: Item.Item): Item.Item => { + note(107, x3.tag, 0); + return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); + }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + put$array30_u32(v7, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ @@ -545,6 +569,12 @@ export function sorted$sorts_Held_sorts_sorts_closure2(keys: rt.u16[], pad: () = return rt.u16Rem(x2.key, 3); }, rt.lt), 6, true, false); put$sorts_Held(v6, out); + const v7: Item.Item[] = items(); + rt.sliceSortByCachedKey(v7, (x3: Item.Item): Item.Item => { + note(107, x3.tag, 0); + return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); + }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + put$sorts_Held(v7, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ @@ -579,6 +609,12 @@ export function sorted$unit_sorts_sorts_closure0(keys: rt.u16[], pad: () => unde return rt.u16Rem(x2.key, 3); }, rt.lt), 4, true, true); put$unit(v6, out); + const v7: Item.Item[] = items(); + rt.sliceSortByCachedKey(v7, (x3: Item.Item): Item.Item => { + note(107, x3.tag, 0); + return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); + }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + put$unit(v7, out); } /** diff --git a/ts/fixtures/lang/sorts/src/sorts.rs b/ts/fixtures/lang/sorts/src/sorts.rs index 8977c5bc1..5d0f93098 100644 --- a/ts/fixtures/lang/sorts/src/sorts.rs +++ b/ts/fixtures/lang/sorts/src/sorts.rs @@ -1,5 +1,5 @@ //! std's slice sorts, of items that log each test they make: by `PartialOrd::lt`, `Ord::cmp`, -//! a comparator, and a key, stable and not, at lengths across each of std's thresholds, of +//! a comparator, and a key, stable and not, and cached, at lengths across each of std's thresholds, of //! element types whose size, `Freeze`, and `Copy` pick each of its small sorts and //! partitions. Then sorts by a comparator that orders nothing, which std may answer with a //! panic, and B-trees collected of the crate's own keys, which sort them. @@ -186,6 +186,17 @@ fn sorted

(keys: &[u16], pad: impl Fn() -> P, out: &mut Vec) { x.key % 3 }); put(&v, out); + // Keys that fit std's network sort alone, but not paired with their index. + let mut v = items(); + v.sort_by_cached_key(|x| { + note(b'k', x.tag, 0); + Item { + key: x.key % 5, + tag: x.tag, + pad: 0u8, + } + }); + put(&v, out); } /// One sort, stable or not, of items of the kind `kind` picks, by a comparator whose diff --git a/ts/fixtures/reject/census.txt b/ts/fixtures/reject/census.txt index aaea27525..c8b9f7795 100644 --- a/ts/fixtures/reject/census.txt +++ b/ts/fixtures/reject/census.txt @@ -46,8 +46,6 @@ fixtures/reject/src/iters.rs:impl Iterator for Probes+8:11: overriding `Iterator fixtures/reject/src/iters.rs:impl Iterator for Sizes+8:11: overriding `Iterator::fold` with a constant generic over its accumulator or closure, which is not supported yet fixtures/reject/src/iters.rs:parts_summed+1:17: unsupported call to ` as std::iter::Iterator>::sum::` fixtures/reject/src/iters.rs:parts_summed+1:38: unsupported call to ` as std::iter::Iterator>::sum::` -fixtures/reject/src/iters.rs:scanned+2:4: `Iterator::scan` of `Option>`, whose `None` is `rt.None`, which is not supported yet -fixtures/reject/src/iters.rs:scanned_unit+1:11: `Iterator::scan` of `Option<()>`, whose `None` is `rt.None`, which is not supported yet fixtures/reject/src/iters.rs:tens+1:31: `Extend` of `(std::vec::Vec, iters::Tens)` by `(u8, u8)`, whose `iters::Tens` of `u8` is not supported yet fixtures/reject/src/kept.rs:atomic_exchanged+4:30: a raw pointer to `std::cell::UnsafeCell` in `kept::ByExchanged`, which the crate may put another object in place of fixtures/reject/src/kept.rs:atomic_swapped+3:76: a raw pointer to `std::cell::UnsafeCell` in `kept::BySwapped`, which the crate may put another object in place of diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index fb494d831..18cbf1dd0 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -48,8 +48,6 @@ fixtures/reject/src/iters.rs:impl Iterator for Probes+8:11: overriding `Iterator fixtures/reject/src/iters.rs:impl Iterator for Sizes+8:11: overriding `Iterator::fold` with a constant generic over its accumulator or closure, which is not supported yet fixtures/reject/src/iters.rs:parts_summed+1:17: unsupported call to ` as std::iter::Iterator>::sum::` fixtures/reject/src/iters.rs:parts_summed+1:38: unsupported call to ` as std::iter::Iterator>::sum::` -fixtures/reject/src/iters.rs:scanned+2:4: `Iterator::scan` of `Option>`, whose `None` is `rt.None`, which is not supported yet -fixtures/reject/src/iters.rs:scanned_unit+1:11: `Iterator::scan` of `Option<()>`, whose `None` is `rt.None`, which is not supported yet fixtures/reject/src/iters.rs:tens+1:31: `Extend` of `(std::vec::Vec, iters::Tens)` by `(u8, u8)`, whose `iters::Tens` of `u8` is not supported yet fixtures/reject/src/kept.rs:atomic_exchanged+4:30: a raw pointer to `std::cell::UnsafeCell` in `kept::ByExchanged`, which the crate may put another object in place of fixtures/reject/src/kept.rs:atomic_swapped+3:76: a raw pointer to `std::cell::UnsafeCell` in `kept::BySwapped`, which the crate may put another object in place of diff --git a/ts/fixtures/reject/src/iters.rs b/ts/fixtures/reject/src/iters.rs index 6423004bd..e2eda7e8e 100644 --- a/ts/fixtures/reject/src/iters.rs +++ b/ts/fixtures/reject/src/iters.rs @@ -1,12 +1,5 @@ //! Iterators and collections of the crate's own that override what std's adaptors call. -/// `scan` of items that can be `undefined`: its closure's `None` and `Some(None)` would both be. -pub fn scanned(v: &[u8]) -> usize { - v.iter() - .scan(Vec::::new(), |_, &b| Some((b > 1).then_some(b))) - .count() -} - /// An iterator whose own `fold` holds its accumulator in an `Option`, of an `rt.None` or not. pub struct Folds; @@ -51,11 +44,6 @@ pub fn backs() -> Option { Backs.rev().find(|&b| b == 0) } -/// `scan` of `()`s: its closure's `None` and `Some(())` would both be `undefined`. -pub fn scanned_unit(v: &[u8]) -> usize { - v.iter().scan(Vec::::new(), |_, _| Some(())).count() -} - pub struct Part(pub u64); impl std::iter::Sum for std::time::Duration { diff --git a/ts/fixtures/reject/ts.toml b/ts/fixtures/reject/ts.toml index b5d87afc2..735e2cdb6 100644 --- a/ts/fixtures/reject/ts.toml +++ b/ts/fixtures/reject/ts.toml @@ -36,8 +36,6 @@ roots = [ "iters::measures", "iters::parts_summed", "iters::probes", - "iters::scanned", - "iters::scanned_unit", "iters::sizes", "iters::tens", "kept::atomic_exchanged", diff --git a/ts/fixtures/task/expected/core/bool.ts b/ts/fixtures/task/expected/core/bool.ts index 954fd4e8a..91ede7538 100644 --- a/ts/fixtures/task/expected/core/bool.ts +++ b/ts/fixtures/task/expected/core/bool.ts @@ -27,6 +27,13 @@ export function thenSome$1af3oea(self: boolean, t: rt.u32): rt.u32 | undefined { return t; } +export function thenSome$1j8foe9(self: boolean, _: undefined): undefined | rt.None { + if (!self) { + return rt.None; + } + return undefined; +} + export function then$06wuxll(self: boolean, f: () => Guard.Guard | undefined): Guard.Guard | undefined | rt.None { if (!self) { return rt.None; diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 6b3f3e189..829fe1122 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -5,6 +5,7 @@ import { drop$Option_Result_model_Guard_u8 as lib_drop$Option_Result_model_Guard import { thenSome$0zvoczk } from "./core/bool.ts"; import { isSomeAnd$17cacqw, unwrapOr$0v6ziq2 as option_unwrapOr$0v6ziq2, unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, map$0hegtde as option_map$0hegtde, map$0ccnsmq as option_map$0ccnsmq, map$0782hf5 as option_map$0782hf5, map$0lq7mno as option_map$0lq7mno, mapOr$1w10sgd as option_mapOr$1w10sgd, mapOr$0ey19f0 as option_mapOr$0ey19f0, okOr$1alhe7b as option_okOr$1alhe7b, filter$1vqc90z, orElse$02wco5t as option_orElse$02wco5t, zip$1rr0evn, clone$1sxxxkp as option_clone$1sxxxkp } from "./core/option.ts"; import { ok$0rngk0g, err$126l6wy, asRef$01pd5k9, mapOr$1hlk3iq as result_mapOr$1hlk3iq, mapOrElse$196aho3 as result_mapOrElse$196aho3, andThen$0r804hk as result_andThen$0r804hk, unwrapOr$0urixfm as result_unwrapOr$0urixfm } from "./core/result.ts"; +import { called as called_called } from "./drops/called.ts"; import { scoped, discarded, iterated } from "./drops/closures.ts"; import { flattened as flattened_flattened } from "./drops/flattened.ts"; import { folded as folds_folded, rfolded as folds_rfolded } from "./drops/folds.ts"; @@ -1274,6 +1275,14 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { folds_folded(log, id, arg); } +/** + * Run scenario `arg % 12` of std's calls of a closure that owns a guard. The last panics + * in a `try_fold`. + */ +export function called(log: Log.Log, id: rt.u32, arg: rt.u8): void { + called_called(log, id, arg); +} + /** * Run scenario `arg % 18` of what folds back to front, through what wraps a closure beside * another, and through a crate's iterator with folds of its own. The last panics in a fold. diff --git a/ts/fixtures/task/expected/drops/called.ts b/ts/fixtures/task/expected/drops/called.ts new file mode 100644 index 000000000..343bb47b5 --- /dev/null +++ b/ts/fixtures/task/expected/drops/called.ts @@ -0,0 +1,567 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "../rt.ts"; +import { copy$array_u32, drop$Result_cell_Ref_u32_cell_BorrowError as lib_drop$Result_cell_Ref_u32_cell_BorrowError, drop$Vec_model_Guard as lib_drop$Vec_model_Guard } from "../lib.ts"; +import { thenSome$1af3oea, thenSome$1j8foe9 } from "../core/bool.ts"; +import { map$1raha9y as option_map$1raha9y } from "../core/option.ts"; +import { mapErr$0nvqjog as result_mapErr$0nvqjog } from "../core/result.ts"; +import * as Key from "../drops.Key.ts"; +import * as Log from "../log.Log.ts"; +import * as Guard from "../model.Guard.ts"; + +/** Run scenario `arg % 12`. The last panics in a `try_fold`, with the log so far. */ +export function called(log: Log.Log, id: rt.u32, arg: rt.u8): void { + let broke!: rt.u32 | undefined; + let f!: Guard.Guard; + const _536: () => rt.Iter = (): rt.Iter => { + const _2: Guard.Guard[] = []; + return rt.iterSlice(_2, rt.drop); + }; + let _679: boolean = false; + let _678: boolean = false; + const guard: (a0: rt.u32) => Guard.Guard = (n3: rt.u32): Guard.Guard => { + return Guard.new(rt.u32Add(id, n3), Log.clone$Clone(log)); + }; + const guards: (a0: rt.u32, a1: rt.u32) => Guard.Guard[] = (from: rt.u32, to: rt.u32): Guard.Guard[] => { + return rt.iterToArray(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + }; + const _10: [Guard.Guard, Guard.Guard] = [guard(20), guard(21)]; + _679 = true; + const c: Guard.Guard = _10[0]; + _678 = true; + const d: Guard.Guard = _10[1]; + const _17: rt.u8 = rt.u8Rem(arg, 12); + if (_17 === 0) { + const it: rt.Iter = rt.iterSlice(guards(1, 6), rt.drop); + _679 = false; + const captured32 = c; + const captured33 = id; + const n: rt.u32 | undefined = rt.iterTryFold(it, 0, rt.closure((n17: rt.u32, g24: Guard.Guard): rt.u32 | undefined => { + const _1014: rt.u32 = Guard.id(g24); + const _1317: rt.u32 = Guard.id(captured32); + const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1014, f), (f: rt.Formatter) => rt.u32Display(_1317, f)]; + Log.note(log, rt.fmtFormat(["try ", args82[0], " ", args82[1]])); + const _039: rt.u32 | undefined = thenSome$1af3oea(Guard.id(g24) !== rt.u32Add(captured33, 3), rt.u32Sub(rt.u32Add(n17, Guard.id(g24)), captured33)); + g24[Symbol.dispose](); + return _039; + }, (): void => { + captured32[Symbol.dispose](); + }), true, true); + const _32: rt.u32 | undefined = option_map$1raha9y(rt.iterToOption(it.next()), (g25: Guard.Guard): rt.u32 => { + const _040: rt.u32 = Guard.id(g25); + g25[Symbol.dispose](); + return _040; + }); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(n, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_32, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["broke ", args2[0], " ", args2[1]])); + const m: rt.u32 | undefined = rt.iterTryFold(it, 0, (n18: rt.u32, g26: Guard.Guard): rt.u32 | undefined => { + const _041: rt.u32 | undefined = rt.u32Sub(rt.u32Add(n18, Guard.id(g26)), id); + g26[Symbol.dispose](); + return _041; + }, true); + const _51: rt.u32 = Guard.id(d); + const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(m, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_51, f)]; + Log.note(log, rt.fmtFormat(["ended ", args4[0], " ", args4[1]])); + rt.drop(it); + } else if (_17 === 1) { + const _60: rt.Iter = rt.iterChain(rt.iterSlice(guards(1, 3), rt.drop), rt.iterSlice(guards(3, 6), rt.drop)); + _679 = false; + const captured31 = c; + const it2: rt.Iter<[Guard.Guard, rt.u32]> = rt.iterMap(_60, rt.closure((g20: Guard.Guard): [Guard.Guard, rt.u32] => { + return [g20, Guard.id(captured31)] as [Guard.Guard, rt.u32]; + }, (): void => { + captured31[Symbol.dispose](); + })); + const part17 = result_mapErr$0nvqjog(rt.iterTryFold(it2, 0, (n15: rt.u32, _335: [Guard.Guard, rt.u32]): rt.Result => { + let _036!: rt.Result; + let _2112: boolean = false; + _2112 = true; + const g21: Guard.Guard = _335[0]; + if (!(Guard.id(g21) === rt.u32Add(id, 4))) { + _036 = rt.Ok(rt.u32Sub(rt.u32Add(n15, Guard.id(g21)), id)); + } else { + _2112 = false; + _036 = rt.Err(g21); + } + if (_2112) { + g21[Symbol.dispose](); + } + _2112 = false; + return _036; + }), (g22: Guard.Guard): rt.u32 => { + const _037: rt.u32 = Guard.id(g22); + g22[Symbol.dispose](); + return _037; + }); + const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part17, f, rt.u32Debug, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["err ", args6[0]])); + const r2: rt.Result = rt.iterTryFold(it2, 0, (n16: rt.u32, _336: [Guard.Guard, rt.u32]): rt.Result => { + const g23: Guard.Guard = _336[0]; + const _038: rt.Result = rt.Ok(rt.u32Sub(rt.u32Add(n16, Guard.id(g23)), id)); + g23[Symbol.dispose](); + return _038; + }); + const _94: rt.u32 = Guard.id(d); + const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(r2, f, rt.u32Debug, rt.fmtUnit), (f: rt.Formatter) => rt.u32Display(_94, f)]; + Log.note(log, rt.fmtFormat(["ok ", args8[0], " ", args8[1]])); + rt.drop(it2); + } else if (_17 === 2) { + const _103: rt.Iter = rt.iterRev(rt.iterSlice(guards(1, 6), rt.drop)); + _679 = false; + const captured29 = c; + const it3: rt.Iter = rt.iterFilter(_103, rt.closure((g17: Guard.Guard): boolean => { + return Guard.id(g17) !== rt.u32Sub(Guard.id(captured29), 18); + }, (): void => { + captured29[Symbol.dispose](); + }), rt.drop); + const r3: rt.Result = rt.iterTryFold(it3, 0, (n13: rt.u32, g18: Guard.Guard): rt.Result => { + let _033!: rt.Result; + let _2013: boolean = false; + _2013 = true; + if (!(Guard.id(g18) === rt.u32Add(id, 3))) { + _033 = rt.Ok(rt.u32Sub(rt.u32Add(n13, Guard.id(g18)), id)); + } else { + _2013 = false; + _033 = rt.Err(g18); + } + if (_2013) { + g18[Symbol.dispose](); + return _033; + } + return _033; + }); + if (r3.ok) { + broke = undefined; + } else { + const g: Guard.Guard = r3.error; + broke = Guard.id(g); + g[Symbol.dispose](); + } + const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(broke, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["break ", args10[0]])); + const _131: Guard.Guard[] = []; + const _130: rt.Iter = rt.iterSlice(_131, rt.drop); + _678 = false; + const captured30 = d; + const none: rt.u32 | undefined = rt.iterTryFold(_130, 0, rt.closure((n14: rt.u32, g19: Guard.Guard): rt.u32 | undefined => { + const _034: rt.u32 | undefined = rt.u32Add(rt.u32Add(n14, Guard.id(g19)), Guard.id(captured30)); + g19[Symbol.dispose](); + return _034; + }, (): void => { + captured30[Symbol.dispose](); + }), true, true); + rt.drop(_130); + const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(none, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["none ", args12[0]])); + rt.drop(it3); + } else if (_17 === 3) { + const it4: rt.Iter = rt.iterSlice(guards(1, 6), rt.drop); + _679 = false; + const captured26 = id; + const captured27 = c; + const part14 = rt.iterTryForEach(it4, rt.closure((g14: Guard.Guard): rt.Result => { + let _029!: rt.Result; + if (!(Guard.id(g14) === rt.u32Add(captured26, 2))) { + const part13 = Guard.id(g14); + const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part13, f)]; + Log.note(log, rt.fmtFormat(["each ", args80[0]])); + _029 = rt.OK; + } else { + _029 = rt.Err(rt.u32Sub(rt.u32Add(Guard.id(g14), Guard.id(captured27)), Guard.id(captured27))); + } + g14[Symbol.dispose](); + return _029; + }, (): void => { + captured27[Symbol.dispose](); + }), undefined, true); + const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part14, f, rt.fmtUnit, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["each ", args14[0]])); + const part15 = rt.iterTryForEach(it4, (g15: Guard.Guard): rt.Result => { + let _030!: rt.Result; + if (!(Guard.id(g15) === rt.u32Add(id, 4))) { + _030 = rt.OK; + } else { + _030 = rt.Err(Guard.id(g15)); + } + g15[Symbol.dispose](); + return _030; + }); + const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtControlFlow(part15, f, rt.fmtUnit, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["flow ", args16[0]])); + _678 = false; + const captured28 = d; + const part16 = rt.iterTryForEach(it4, rt.closure((g16: Guard.Guard): undefined | rt.None => { + const _031: undefined | rt.None = thenSome$1j8foe9(Guard.id(g16) !== Guard.id(captured28), undefined); + g16[Symbol.dispose](); + return _031; + }, (): void => { + captured28[Symbol.dispose](); + }), true, true, rt.None); + const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part16, f, rt.fmtUnit, rt.None)]; + Log.note(log, rt.fmtFormat(["some ", args18[0]])); + rt.drop(it4); + } else if (_17 === 4) { + const _190: rt.Iter = rt.iterSlice(guards(1, 7), rt.drop); + _679 = false; + const captured22 = c; + const _189: [Guard.Guard[], Guard.Guard[]] = rt.iterPartition(_190, rt.closure((g11: Guard.Guard): boolean => { + const _913: rt.u32 = Guard.id(g11); + const _1115: rt.u32 = Guard.id(captured22); + const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_913, f), (f: rt.Formatter) => rt.u32Display(_1115, f)]; + Log.note(log, rt.fmtFormat(["side ", args78[0], " ", args78[1]])); + return rt.u32Rem(Guard.id(g11), 2) === 1; + }, (): void => { + captured22[Symbol.dispose](); + }), [[] as Guard.Guard[], [] as Guard.Guard[]], rt.vecPart(8), true, true); + const odd: Guard.Guard[] = _189[0]; + const even: Guard.Guard[] = _189[1]; + const part12 = rt.iterToArray(rt.iterMap(rt.iterSlice(odd), Guard.id), undefined, 4, true); + const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part12, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["odd ", args20[0]])); + rt.dropAll(even); + const _213: [rt.u32[], rt.u32[]] = rt.iterPartition(new rt.Range(1, 4), (_220: rt.u32): boolean => { + return true; + }, [[] as rt.u32[], [] as rt.u32[]], rt.vecPart(4)); + const all: rt.u32[] = _213[0]; + const none2: rt.u32[] = _213[1]; + const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(all, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtList(none2, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["all ", args22[0], " ", args22[1]])); + const e: Guard.Guard = guard(22); + const _234: rt.Iter = rt.iterSlice(guards(1, 4), rt.drop); + const captured23 = e; + const _233: rt.Iter = rt.iterMap(_234, rt.closure((g12: Guard.Guard): Guard.Guard => { + return ([g12, Guard.id(captured23)] as [Guard.Guard, rt.u32])[0]; + }, (): void => { + captured23[Symbol.dispose](); + })); + _678 = false; + const captured24 = d; + const captured25 = id; + const _232: [Guard.Guard[], Guard.Guard[]] = rt.iterPartition(_233, rt.closure((g13: Guard.Guard): boolean => { + return rt.u32Sub(rt.u32Add(Guard.id(g13), Guard.id(captured24)), Guard.id(captured24)) < rt.u32Add(captured25, 2); + }, (): void => { + captured24[Symbol.dispose](); + }), [[] as Guard.Guard[], [] as Guard.Guard[]], rt.vecPart(8), true, true); + const low: Guard.Guard[] = _232[0]; + const high: Guard.Guard[] = _232[1]; + const _246: rt.usize = low.length; + const _249: rt.usize = high.length; + const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_246, f), (f: rt.Formatter) => rt.usizeDisplay(_249, f)]; + Log.note(log, rt.fmtFormat(["sides ", args24[0], " ", args24[1]])); + rt.dropAll(high); + rt.dropAll(low); + rt.dropAll(odd); + } else if (_17 === 5) { + _679 = false; + let captured18: rt.u32 = 0; + const captured19 = c; + const captured20 = guard; + const made: Guard.Guard[] = rt.iterToArray(rt.iterTake(rt.iterRepeatWith(rt.closure((): Guard.Guard => { + captured18 = rt.u32Add(captured18, 1); + const _912: rt.u32 = Guard.id(captured19); + const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(captured18, f), (f: rt.Formatter) => rt.u32Display(_912, f)]; + Log.note(log, rt.fmtFormat(["make ", args76[0], " ", args76[1]])); + return captured20(captured18); + }, (): void => { + captured19[Symbol.dispose](); + })), 3, rt.drop), "fold", 8, true); + const part11 = made.length; + const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part11, f)]; + Log.note(log, rt.fmtFormat(["made ", args26[0]])); + _678 = false; + const captured21 = d; + const it5: rt.Iter = rt.iterRepeatWith(rt.closure((): rt.u32 => { + return Guard.id(captured21); + }, (): void => { + captured21[Symbol.dispose](); + })); + const _280: rt.u32 | undefined = rt.iterToOption(it5.next()); + const _283: [rt.usize, rt.usize | undefined] = it5.sizeHint(); + const _286: [rt.usize, rt.usize | undefined] = rt.iterTake(rt.iterBorrow(it5), 2).sizeHint(); + const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_280, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_283[0], f), (f: rt.Formatter) => rt.fmtOption(_283[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_286[0], f), (f: rt.Formatter) => rt.fmtOption(_286[1], f, rt.usizeDebug)], f)]; + Log.note(log, rt.fmtFormat(["first ", args28[0], " ", args28[1], " ", args28[2]])); + rt.drop(it5); + Log.note(log, "dropped"); + rt.dropAll(made); + } else if (_17 === 6) { + const _303: rt.Iter = rt.iterSlice(guards(1, 7), rt.drop); + _679 = false; + const captured13 = id; + const captured14 = c; + const it6: rt.Iter = rt.iterScan(_303, 0, rt.closure((sum: rt.Place, g9: Guard.Guard): rt.u32 | undefined => { + const _433: rt.u32 = rt.u32Sub(Guard.id(g9), captured13); + sum.v = rt.u32Add(sum.v, _433); + const _169: rt.u32 = Guard.id(g9); + const _1910: rt.u32 = Guard.id(captured14); + const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_169, f), (f: rt.Formatter) => rt.u32Display(sum.v, f), (f: rt.Formatter) => rt.u32Display(_1910, f)]; + Log.note(log, rt.fmtFormat(["scan ", args72[0], " ", args72[1], " ", args72[2]])); + const _020: rt.u32 | undefined = thenSome$1af3oea(sum.v < 10, sum.v); + g9[Symbol.dispose](); + return _020; + }, (): void => { + captured14[Symbol.dispose](); + }), true); + const sums: rt.u32[] = rt.iterToArray(rt.iterBorrow(it6), "next", 4); + const _317: rt.u32 | undefined = rt.iterToOption(it6.next()); + const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(sums, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_317, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["sums ", args30[0], " ", args30[1]])); + rt.drop(it6); + const part9 = rt.iterSum(rt.iterScan(new rt.Range(1, 4), 1, (n11: rt.Place, k2: rt.u32): rt.u32 | undefined => { + n11.v = rt.u32Mul(n11.v, k2); + return n11.v; + }, true), rt.u32Add, 0); + const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part9, f)]; + Log.note(log, rt.fmtFormat(["total ", args32[0]])); + const e2: Guard.Guard = guard(22); + const v: Guard.Guard[][] = []; + const _351: Guard.Guard[] = guards(1, 3); + v.push(_351); + const _356: Guard.Guard[] = guards(3, 6); + v.push(_356); + const _345: rt.Iter = rt.iterFlatten(rt.iterSlice(v, lib_drop$Vec_model_Guard), (value: Guard.Guard[]) => rt.iterSlice(value, rt.drop), true); + const _359: Guard.Guard = guard(23); + _678 = false; + const captured15 = d; + const captured16 = id; + const captured17 = e2; + const part10 = rt.iterFold(rt.iterScan(_345, _359, rt.closure((held: Guard.Guard, g10: Guard.Guard): rt.u32 | undefined => { + const _109: rt.u32 = Guard.id(held); + const _1311: rt.u32 = Guard.id(g10); + const _1610: rt.u32 = Guard.id(captured15); + const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_109, f), (f: rt.Formatter) => rt.u32Display(_1311, f), (f: rt.Formatter) => rt.u32Display(_1610, f)]; + Log.note(log, rt.fmtFormat(["held ", args74[0], " ", args74[1], " ", args74[2]])); + const _022: rt.u32 | undefined = thenSome$1af3oea(Guard.id(g10) !== rt.u32Add(captured16, 4), rt.u32Sub(rt.u32Add(Guard.id(g10), Guard.id(captured17)), Guard.id(captured17))); + g10[Symbol.dispose](); + return _022; + }, (): void => { + captured15[Symbol.dispose](); + captured17[Symbol.dispose](); + }), undefined, rt.drop), 0, (n12: rt.u32, k3: rt.u32): rt.u32 => { + return rt.u32Sub(rt.u32Add(n12, k3), id); + }, true); + const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part10, f)]; + Log.note(log, rt.fmtFormat(["flat ", args34[0]])); + } else if (_17 === 7) { + const v2: Guard.Guard[] = rt.iterToArray(rt.iterSlice(rt.arrayMap([3, 1, 4, 5, 2], guard), rt.drop), "fold", 8, true); + const _380: Guard.Guard[] = v2; + _679 = false; + const captured12 = c; + rt.sliceSortByCachedKey(_380, rt.closure((g8: Guard.Guard): Key.Key => { + const _910: rt.u32 = Guard.id(g8); + const _1113: rt.u32 = Guard.id(captured12); + const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_910, f), (f: rt.Formatter) => rt.u32Display(_1113, f)]; + Log.note(log, rt.fmtFormat(["key ", args70[0], " ", args70[1]])); + return Key.new(rt.u32Rem(rt.u32Mul(Guard.id(g8), 7), 5), Log.clone$Clone(log)); + }, (): void => { + captured12[Symbol.dispose](); + }), rt.cmpLt(rt.cmpTuple<[Key.Key, rt.usize], rt.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rt.cmp])), 16, true, false, true, rt.drop); + const part8 = rt.iterToArray(rt.iterMap(rt.iterSlice(v2), Guard.id), undefined, 4, true); + const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part8, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["sorted ", args36[0]])); + const w: rt.u32[] = [3, 1, 2]; + rt.sliceSortByCachedKey(w, (_210: rt.u32): rt.u32 => { + return rt.u32Add(_210, Guard.id(d)); + }, rt.cmpLt(rt.cmpTuple<[rt.u32, rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmp])), 8, true, true); + const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(w, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["rev ", args38[0]])); + rt.dropAll(v2); + } else if (_17 === 8) { + _679 = false; + const captured9 = c; + const lazy: rt.LazyCell = new rt.LazyCell(rt.closure((): rt.u32 => { + const part6 = Guard.id(captured9); + const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; + Log.note(log, rt.fmtFormat(["force ", args68[0]])); + const _015: rt.u32 = rt.u32Add(Guard.id(captured9), 1); + captured9[Symbol.dispose](); + return _015; + }, (): void => { + captured9[Symbol.dispose](); + })); + Log.note(log, "made"); + const _425: rt.u32 = lazy.force(); + const _427: rt.u32 = lazy.force(); + const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_425, f), (f: rt.Formatter) => rt.u32Display(_427, f)]; + Log.note(log, rt.fmtFormat(["forced ", args40[0], " ", args40[1]])); + _678 = false; + const captured10 = d; + rt.lazyDrop(new rt.LazyCell(rt.closure((): rt.u32 => { + const _016: rt.u32 = Guard.id(captured10); + captured10[Symbol.dispose](); + return _016; + }, (): void => { + captured10[Symbol.dispose](); + })), undefined, rt.drop); + Log.note(log, "unused"); + const captured11 = guard(22); + const lazy2: rt.LazyCell = new rt.LazyCell(rt.once(rt.closure((): rt.u32 => { + return Guard.id(captured11); + }, (): void => { + captured11[Symbol.dispose](); + }))); + const part7 = lazy2.force(); + const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; + Log.note(log, rt.fmtFormat(["by Fn ", args42[0]])); + rt.lazyDrop(lazy2, undefined, rt.drop); + rt.lazyDrop(lazy, undefined, rt.drop); + } else if (_17 === 9) { + const cell: rt.Cell = new rt.Cell(1); + _679 = false; + const captured6 = c; + rt.cellUpdate(cell, rt.closure((n7: rt.u32): rt.u32 => { + const _93: rt.u32 = Guard.id(captured6); + const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n7, f), (f: rt.Formatter) => rt.u32Display(_93, f)]; + Log.note(log, rt.fmtFormat(["update ", args62[0], " ", args62[1]])); + const _010: rt.u32 = rt.u32Add(n7, 1); + captured6[Symbol.dispose](); + return _010; + }, (): void => { + captured6[Symbol.dispose](); + })); + const part = cell.v; + const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; + Log.note(log, rt.fmtFormat(["updated ", args44[0]])); + const cell2: rt.RefCell = new rt.RefCell(5); + const old: rt.u32 = rt.refCellReplaceWith(cell2, (n8: rt.Place): rt.u32 => { + const _95: rt.u32 = Guard.id(d); + const _137: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(cell2); + const _1110: boolean = !_137.ok; + const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n8.v, f), (f: rt.Formatter) => rt.u32Display(_95, f), (f: rt.Formatter) => rt.fmtBool(_1110, f)]; + const _511: string = rt.fmtFormat(["replace ", args64[0], " ", args64[1], " ", args64[2]]); + lib_drop$Result_cell_Ref_u32_cell_BorrowError(_137); + Log.note(log, _511); + n8.v = rt.u32Add(n8.v, 1); + return rt.u32Mul(n8.v, 2); + }, true); + const _484: rt.RefCell = rt.refCellBorrow(cell2); + const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(old, f), (f: rt.Formatter) => rt.u32Display(_484.value, f)]; + const _480: string = rt.fmtFormat(["replaced ", args46[0], " ", args46[1]]); + rt.refRelease(_484); + Log.note(log, _480); + const _494: [Guard.Guard, Guard.Guard] = [guard(22), guard(23)]; + const e4: Guard.Guard = _494[0]; + f = _494[1]; + const captured7 = e4; + const captured8 = f; + const add: (a0: rt.u32) => rt.u32 = rt.closure((n9: rt.u32): rt.u32 => { + return rt.u32Add(rt.u32Sub(rt.u32Add(n9, Guard.id(captured7)), Guard.id(captured7)), 1); + }, (): void => { + captured7[Symbol.dispose](); + }); + const doubled: (a0: rt.Place) => rt.u32 = rt.closure((n10: rt.Place): rt.u32 => { + return rt.u32Sub(rt.u32Add(rt.u32Mul(n10.v, 2), Guard.id(captured8)), Guard.id(captured8)); + }, (): void => { + captured8[Symbol.dispose](); + }); + rt.cellUpdate(new rt.Cell(1), rt.once(add)); + const pair: rt.Cell = new rt.Cell([1, 2]); + rt.cellUpdate(pair, (p: rt.u32[]): rt.u32[] => { + p = copy$array_u32(p); + p[0] = rt.u32Add(p[0], 10); + const _155: rt.u32[] = copy$array_u32(pair.v); + const part2 = p[0]; + const part3 = _155[0]; + const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f), (f: rt.Formatter) => rt.u32Display(part3, f)]; + Log.note(log, rt.fmtFormat(["pair ", args66[0], " ", args66[1]])); + return copy$array_u32(p); + }); + const part4 = copy$array_u32(pair.v); + const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4, f, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["paired ", args48[0]])); + const part5 = rt.refCellReplaceWith(cell2, rt.once(doubled), true); + const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; + Log.note(log, rt.fmtFormat(["by Fn ", args50[0]])); + } else if (_17 === 10) { + const _539: rt.Iter = _536(); + _679 = false; + const captured3 = c; + const r7: rt.Result = rt.iterTryFold(_539, 0, rt.closure((n5: rt.u32, g3: Guard.Guard): rt.Result => { + const _05: rt.Result = rt.Ok(rt.u32Add(rt.u32Add(n5, Guard.id(g3)), Guard.id(captured3))); + g3[Symbol.dispose](); + return _05; + }, (): void => { + captured3[Symbol.dispose](); + }), undefined, true); + rt.drop(_539); + const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(r7, f, rt.u32Debug, rt.u32Debug)]; + Log.note(log, rt.fmtFormat(["fold ", args52[0]])); + const _554: rt.Iter = _536(); + _678 = false; + const captured4 = d; + const r8: undefined | rt.None = rt.iterTryForEach(_554, rt.closure((g4: Guard.Guard): undefined | rt.None => { + const _06: undefined | rt.None = thenSome$1j8foe9(Guard.id(g4) !== Guard.id(captured4), undefined); + g4[Symbol.dispose](); + return _06; + }, (): void => { + captured4[Symbol.dispose](); + }), true, true, rt.None); + rt.drop(_554); + const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(r8, f, rt.fmtUnit, rt.None)]; + Log.note(log, rt.fmtFormat(["each ", args54[0]])); + const _569: [Guard.Guard[], Guard.Guard[]] = rt.iterPartition(_536(), (g5: Guard.Guard): boolean => { + return Guard.id(g5) > 0; + }, [[] as Guard.Guard[], [] as Guard.Guard[]], rt.vecPart(8), true); + const a: Guard.Guard[] = _569[0]; + const b: Guard.Guard[] = _569[1]; + const _578: rt.usize = a.length; + const _581: rt.usize = b.length; + const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_578, f), (f: rt.Formatter) => rt.usizeDisplay(_581, f)]; + Log.note(log, rt.fmtFormat(["sides ", args56[0], " ", args56[1]])); + const scanned: rt.u32[] = rt.iterToArray(rt.iterScan(_536(), 0, (n6: rt.Place, g6: Guard.Guard): rt.u32 | undefined => { + const _08: rt.u32 | undefined = rt.u32Add(n6.v, Guard.id(g6)); + g6[Symbol.dispose](); + return _08; + }, true), "next", 4, false, 8); + const empty: Guard.Guard[] = []; + rt.sliceSortByCachedKey(empty, Guard.id, rt.cmpLt(rt.cmpTuple<[rt.u32, rt.usize], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 8, true, true); + const one: Guard.Guard[] = guards(1, 2); + const e5: Guard.Guard = guard(22); + const _603: Guard.Guard[] = one; + const captured5 = e5; + rt.sliceSortByCachedKey(_603, rt.closure((g7: Guard.Guard): rt.u32 => { + return rt.u32Add(Guard.id(g7), Guard.id(captured5)); + }, (): void => { + captured5[Symbol.dispose](); + }), rt.cmpLt(rt.cmpTuple<[rt.u32, rt.usize], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 8, true, true, true); + const _612: rt.usize = scanned.length; + const _615: rt.usize = empty.length; + const _618: rt.usize = one.length; + const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_612, f), (f: rt.Formatter) => rt.usizeDisplay(_615, f), (f: rt.Formatter) => rt.usizeDisplay(_618, f)]; + Log.note(log, rt.fmtFormat(["scanned ", args58[0], " ", args58[1], " ", args58[2]])); + rt.dropAll(one); + rt.dropAll(empty); + rt.dropAll(b); + rt.dropAll(a); + } else { + const a2: Guard.Guard = guard(30); + const _631: rt.Iter = rt.iterSlice(guards(1, 6), rt.drop); + const captured = id; + const captured2 = a2; + rt.iterTryFold(_631, 0, rt.closure((n4: rt.u32, g2: Guard.Guard): rt.u32 | undefined => { + if (!(Guard.id(g2) !== rt.u32Add(captured, 3))) { + const _142: rt.u32 = Guard.id(g2); + const _173: rt.u32 = Guard.id(captured2); + const _205: string = rt.resultUnwrap(rt.stringFromUtf8(Log.text(log)), rt.fmtFromUtf8ErrorDebug); + const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_142, f), (f: rt.Formatter) => rt.u32Display(_173, f), (f: rt.Formatter) => rt.fmtPad(f, _205)]; + rt.panicFmt(["try_fold of g", args60[0], " with g", args60[1], " after\n", args60[2]]); + } else { + const _04: rt.u32 | undefined = rt.u32Add(n4, Guard.id(g2)); + g2[Symbol.dispose](); + return _04; + } + }, (): void => { + captured2[Symbol.dispose](); + }), true, true); + rt.drop(_631); + } + if (_678) { + d[Symbol.dispose](); + } + _678 = false; + if (_679) { + c[Symbol.dispose](); + } + _679 = false; +} + +//# sourceMappingURL=called.ts.map diff --git a/ts/fixtures/task/expected/lib.ts b/ts/fixtures/task/expected/lib.ts index 8e82e7f2d..6ad8831d5 100644 --- a/ts/fixtures/task/expected/lib.ts +++ b/ts/fixtures/task/expected/lib.ts @@ -11,6 +11,10 @@ import * as Wrap from "./drops.Wrap.ts"; import * as Guard from "./model.Guard.ts"; import type * as Tally from "./model.Tally.ts"; +export function copy$array_u32(v: rt.u32[]): rt.u32[] { + return v.slice(); +} + export function copy$model_Tally(v: Tally.Tally): Tally.Tally { return { n: v.n }; } @@ -79,6 +83,12 @@ export function drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(_1: rt.Resul } } +export function drop$Result_cell_Ref_u32_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { + if (_1.ok) { + rt.refRelease(_1.value); + } +} + export function drop$Result_model_Guard_model_Guard(_1: rt.Result): void { if (_1.ok) { _1.value[Symbol.dispose](); diff --git a/ts/fixtures/task/src/drops.rs b/ts/fixtures/task/src/drops.rs index 645ea69f3..f2954b37d 100644 --- a/ts/fixtures/task/src/drops.rs +++ b/ts/fixtures/task/src/drops.rs @@ -22,6 +22,7 @@ macro_rules! list { }}; } +mod called; mod closures; mod flattened; mod folds; @@ -725,6 +726,12 @@ pub fn folded(log: &Log, id: u32, arg: u8) { folds::folded(log, id, arg); } +/// Run scenario `arg % 12` of std's calls of a closure that owns a guard. The last panics +/// in a `try_fold`. +pub fn called(log: &Log, id: u32, arg: u8) { + called::called(log, id, arg); +} + /// Run scenario `arg % 18` of what folds back to front, through what wraps a closure beside /// another, and through a crate's iterator with folds of its own. The last panics in a fold. pub fn rfolded(log: &Log, id: u32, arg: u8) { diff --git a/ts/fixtures/task/src/drops/called.rs b/ts/fixtures/task/src/drops/called.rs new file mode 100644 index 000000000..9f2db5220 --- /dev/null +++ b/ts/fixtures/task/src/drops/called.rs @@ -0,0 +1,235 @@ +//! std's calls of a closure that owns a guard: each call logged, and the guard dropped where +//! std drops the closure. + +use std::cell::{Cell, LazyCell, RefCell}; +use std::ops::ControlFlow; + +use super::Key; +use crate::log::Log; +use crate::model::Guard; + +/// Run scenario `arg % 12`. The last panics in a `try_fold`, with the log so far. +pub(super) fn called(log: &Log, id: u32, arg: u8) { + let guard = |n: u32| Guard::new(id + n, log.clone()); + let guards = |from: u32, to: u32| (from..to).map(guard).collect::>(); + let (c, d) = (guard(20), guard(21)); + match arg % 12 { + 0 => { + // `try_fold` by `Option`, which breaks by `None` and reads on after, and drops + // each item it reads. + let mut it = guards(1, 6).into_iter(); + let n = it.try_fold(0u32, move |n, g| { + log.note(format!("try {} {}", g.id(), c.id())); + (g.id() != id + 3).then_some(n + g.id() - id) + }); + log.note(format!("broke {n:?} {:?}", it.next().map(|g| g.id()))); + let m = it.try_fold(0u32, |n, g| Some(n + g.id() - id)); + log.note(format!("ended {m:?} {}", d.id())); + } + 1 => { + // By `Result`, through `map` and `chain`, which drop each half as it ends. + let mut it = guards(1, 3).into_iter().chain(guards(3, 6)).map(move |g| (g, c.id())); + let r = it.try_fold(0u32, |n, (g, _)| match g.id() == id + 4 { + true => Err(g), + false => Ok(n + g.id() - id), + }); + log.note(format!("err {:?}", r.map_err(|g| g.id()))); + let r: Result = it.try_fold(0, |n, (g, _)| Ok(n + g.id() - id)); + log.note(format!("ok {r:?} {}", d.id())); + } + 2 => { + // By `ControlFlow`, through `rev` and `filter`, and over none. + let mut it = guards(1, 6).into_iter().rev().filter(move |g| g.id() != c.id() - 18); + let r = it.try_fold(0u32, |n, g| match g.id() == id + 3 { + true => ControlFlow::Break(g), + false => ControlFlow::Continue(n + g.id() - id), + }); + let broke = match r { + ControlFlow::Break(g) => Some(g.id()), + ControlFlow::Continue(_) => None, + }; + log.note(format!("break {broke:?}")); + let none = Vec::::new() + .into_iter() + .try_fold(0u32, move |n, g| Some(n + g.id() + d.id())); + log.note(format!("none {none:?}")); + } + 3 => { + // `try_for_each` by each type, which drops its closure as it returns. + let mut it = guards(1, 6).into_iter(); + let r = it.try_for_each(move |g| match g.id() == id + 2 { + true => Err(g.id() + c.id() - c.id()), + false => Ok(log.note(format!("each {}", g.id()))), + }); + log.note(format!("each {r:?}")); + let r = it.try_for_each(|g| match g.id() == id + 4 { + true => ControlFlow::Break(g.id()), + false => ControlFlow::Continue(()), + }); + log.note(format!("flow {r:?}")); + let r = it.try_for_each(move |g| (g.id() != d.id()).then_some(())); + log.note(format!("some {r:?}")); + } + 4 => { + // `partition`, which moves each item to a side and drops its closure as it ends. + let (odd, even): (Vec, Vec) = guards(1, 7).into_iter().partition(move |g| { + log.note(format!("side {} {}", g.id(), c.id())); + g.id() % 2 == 1 + }); + log.note(format!("odd {:?}", odd.iter().map(Guard::id).collect::>())); + drop(even); + let (all, none): (Vec, Vec) = (1..4).partition(|_| true); + log.note(format!("all {all:?} {none:?}")); + // Through `map`, whose fold drops `partition`'s closure before its own. + let e = guard(22); + let (low, high): (Vec, Vec) = guards(1, 4) + .into_iter() + .map(move |g| (g, e.id()).0) + .partition(move |g| g.id() + d.id() - d.id() < id + 2); + log.note(format!("sides {} {}", low.len(), high.len())); + } + 5 => { + // `repeat_with`, which drops its closure with the iterator, each item as it goes. + let mut k = 0; + let made: Vec = std::iter::repeat_with(move || { + k += 1; + log.note(format!("make {k} {}", c.id())); + guard(k) + }) + .take(3) + .collect(); + log.note(format!("made {}", made.len())); + let mut it = std::iter::repeat_with(move || d.id()); + log.note(format!( + "first {:?} {:?} {:?}", + it.next(), + it.size_hint(), + it.by_ref().take(2).size_hint() + )); + drop(it); + log.note("dropped".into()); + } + 6 => { + // `scan` of a state JS copies, which stops at the first `None` and drops its + // closure with the iterator. + let mut it = guards(1, 7).into_iter().scan(0u32, move |sum, g| { + *sum += g.id() - id; + log.note(format!("scan {} {sum} {}", g.id(), c.id())); + (*sum < 10).then_some(*sum) + }); + let sums: Vec = it.by_ref().collect(); + log.note(format!("sums {sums:?} {:?}", it.next())); + drop(it); + let total: u32 = (1..4) + .scan(1u32, |n, k| { + *n *= k; + Some(*n) + }) + .sum(); + log.note(format!("total {total}")); + // Of a state that drops, after the closure, and folded through `flatten`. + let e = guard(22); + let n = list![guards(1, 3), guards(3, 6)] + .into_iter() + .flatten() + .scan(guard(23), move |held, g| { + log.note(format!("held {} {} {}", held.id(), g.id(), d.id())); + (g.id() != id + 4).then_some(g.id() + e.id() - e.id()) + }) + .fold(0, |n, k| n + k - id); + log.note(format!("flat {n}")); + } + 7 => { + // `sort_by_cached_key`, whose keys drop after the sort, and whose closure drops + // as it returns. + let mut v: Vec = [3, 1, 4, 5, 2].map(guard).into_iter().collect(); + v.sort_by_cached_key(move |g| { + log.note(format!("key {} {}", g.id(), c.id())); + Key::new((g.id() * 7) % 5, log.clone()) + }); + log.note(format!("sorted {:?}", v.iter().map(Guard::id).collect::>())); + let mut w = vec![3u32, 1, 2]; + w.sort_by_cached_key(|&k| std::cmp::Reverse(k + d.id())); + log.note(format!("rev {w:?}")); + } + 8 => { + // `LazyCell::new`, which drops its closure as the first `force` calls it, and + // with the cell if none does. + let lazy = LazyCell::new(move || { + log.note(format!("force {}", c.id())); + c.id() + 1 + }); + log.note("made".into()); + log.note(format!("forced {} {}", *lazy, *lazy)); + let unused = LazyCell::new(move || d.id()); + drop(unused); + log.note("unused".into()); + // One that `Fn` calls, which drops after `force`'s call through `FnOnce`. + let e = guard(22); + let make = move || e.id(); + let lazy = LazyCell::new(make); + log.note(format!("by Fn {}", *lazy)); + } + 9 => { + // `Cell::update` and `RefCell::replace_with` of a value JS copies, each of which + // drops its closure as it returns. + let cell = Cell::new(1u32); + cell.update(move |n| { + log.note(format!("update {n} {}", c.id())); + n + 1 + }); + log.note(format!("updated {}", cell.get())); + let cell = RefCell::new(5u32); + let old = cell.replace_with(|n| { + log.note(format!("replace {n} {} {}", d.id(), cell.try_borrow().is_err())); + *n += 1; + *n * 2 + }); + log.note(format!("replaced {old} {}", cell.borrow())); + // Each of one that `Fn` calls, which drops after their call through `FnOnce`. + let (e, f) = (guard(22), guard(23)); + let add = move |n: u32| n + e.id() - e.id() + 1; + let doubled = move |n: &mut u32| *n * 2 + f.id() - f.id(); + Cell::new(1u32).update(add); + // Of what JS shares, which the function changes and the cell keeps. + let pair = Cell::new([1u32, 2]); + pair.update(|mut p| { + p[0] += 10; + log.note(format!("pair {} {}", p[0], pair.get()[0])); + p + }); + log.note(format!("paired {:?}", pair.get())); + log.note(format!("by Fn {}", cell.replace_with(doubled))); + } + 10 => { + // Each over none: the closure never runs, and drops as std's does. + let none = || Vec::::new().into_iter(); + let r: Result = none().try_fold(0, move |n, g| Ok(n + g.id() + c.id())); + log.note(format!("fold {r:?}")); + let r: Option<()> = none().try_for_each(move |g| (g.id() != d.id()).then_some(())); + log.note(format!("each {r:?}")); + let (a, b): (Vec, Vec) = none().partition(|g| g.id() > 0); + log.note(format!("sides {} {}", a.len(), b.len())); + let scanned: Vec = none().scan(0u32, |n, g| Some(*n + g.id())).collect(); + let mut empty: Vec = Vec::new(); + empty.sort_by_cached_key(Guard::id); + let mut one = guards(1, 2); + let e = guard(22); + one.sort_by_cached_key(move |g| g.id() + e.id()); + log.note(format!("scanned {} {} {}", scanned.len(), empty.len(), one.len())); + } + _ => { + let a = guard(30); + let _ = guards(1, 6).into_iter().try_fold(0, move |n, g| { + assert!( + g.id() != id + 3, + "try_fold of g{} with g{} after\n{}", + g.id(), + a.id(), + String::from_utf8(log.text()).unwrap() + ); + Some(n + g.id()) + }); + } + } +} diff --git a/ts/fixtures/task/src/harness.rs b/ts/fixtures/task/src/harness.rs index 3847273fc..10767cc6f 100644 --- a/ts/fixtures/task/src/harness.rs +++ b/ts/fixtures/task/src/harness.rs @@ -132,6 +132,9 @@ fn steps() -> Vec<(&'static str, Step)> { ("rfolded", |log, exec, _, arg| { drops::rfolded(log, 1000 * exec.len() as u32, arg) }), + ("called", |log, exec, _, arg| { + drops::called(log, 1000 * exec.len() as u32, arg) + }), ("watch", |log, exec, channels, arg| { if let Some(c) = pick(channels.len(), arg) { let guard = Guard::new(exec.len() as u32, log.clone()); diff --git a/ts/fixtures/task/ts.toml b/ts/fixtures/task/ts.toml index 562608a72..0baf8b8c9 100644 --- a/ts/fixtures/task/ts.toml +++ b/ts/fixtures/task/ts.toml @@ -17,6 +17,7 @@ roots = [ "drops::cells", "drops::folded", "drops::rfolded", + "drops::called", "drops::inside", "drops::flattened", "drops::indexed", diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index d7e85f97c..8f1c22c6d 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -28,6 +28,7 @@ import { iterChain, iterEmpty, iterFilter, + iterFold, iterMap, iterOnce, iterSlice, @@ -40,7 +41,7 @@ import { capNext, trustedUpper, } from "./iter.ts"; -import { type Arc, drop as dispose, dropAll, dropRange } from "./task.ts"; +import { type Arc, closure, drop as dispose, dropAll, dropRange } from "./task.ts"; // Ordering @@ -4033,6 +4034,20 @@ export interface Part { one(c: C, item: T): C; } +/** + * `Iterator::partition` into `sides`, the collection's two defaults: each item `f` tests + * true into the first, and the rest into the second, by `part`'s `extend_one`, through + * `fold`, which drops `f` as it ends if it `owns` it. + */ +export function iterPartition(it: Iter, f: (item: T) => boolean, sides: [C, C], part: Part, drops = false, owns = false): [C, C] { + const g = (_: undefined, item: T): undefined => { + const i = f(item) ? 0 : 1; + sides[i] = part.one(sides[i], item); + }; + iterFold(it, undefined, owns ? closure(g, () => dispose(f)) : g, drops, owns); + return sides; +} + /** * `Extend::extend` of `t`, a tuple of collections, by `items`, and `collect` into the * tuple of their defaults: each reserves the lower bound of the size hint, if any, in diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index bff8ac9d6..8a7cbdac2 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -557,6 +557,11 @@ export function iterFromFn(f: () => T | undefined | None, none?: None): Iter< return new FromNext(f, (f) => iterFromOption(f(), none), dispose); } +/** `iter::repeat_with`: `f` called for each item, endlessly, which drops with it. */ +export function iterRepeatWith(f: () => T): Iter { + return new FromNext(f, (f) => f(), dispose, { hint: () => [USIZE_MAX, undefined] }); +} + /** * `iter::successors`: `first`, then `succ` of each item, called as that item is yielded. * The item it holds next drops by `drop`, and then `succ`, as std's fields drop. @@ -817,6 +822,16 @@ export function iterMapWhile(it: Iter, f: (item: T) => U | undefined | return new MapWhileIter(it, f, none); } +/** + * `Iterator::scan`, which hands `f` its state, as its place if `copied`, where JS copies it, + * and drops it by `drop` after `f`, as std's fields drop. + */ +export function iterScan(it: Iter, state: S, f: (state: never, item: T) => U | undefined, copied?: boolean, drop?: Drop): Iter; +export function iterScan(it: Iter, state: S, f: (state: never, item: T) => U | None, copied: boolean | undefined, drop: Drop | undefined, none: None): Iter; +export function iterScan(it: Iter, state: S, f: (state: never, item: T) => U | undefined | None, copied = false, drop?: Drop, none?: None): Iter { + return new ScanIter(it, state, f, copied, drop, none); +} + /** `Iterator::step_by`, panicking on a step of 0, and dropping what it steps over by `drop`. */ export function iterStepBy(it: Iter, step: number, drop?: Drop): Iter { return new StepByIter(it, step, drop); @@ -1071,23 +1086,39 @@ export function iterRfold(it: Iter, init: A, f: (acc: A, item: T) => A, } /** - * `DoubleEndedIterator::try_rfold`, from the back as `try_rfold` steps it, until `f` - * breaks: by an `Option`'s `None`, `none` where that is `rt.None`, if `option`, and else by - * an `rt.Result`'s `Err`, as a `Result` or a `ControlFlow` breaks. It returns what broke, or - * the accumulator as the type continues with it. If it `owns` `f`, `f` drops as it returns. + * `Iterator::try_fold`, as `try_fold` steps it, until `f` breaks: by an `Option`'s `None`, + * `none` where that is `rt.None`, if `option`, and else by an `rt.Result`'s `Err`, as a + * `Result` or a `ControlFlow` breaks. It returns what broke, or the accumulator as the type + * continues with it. If it `owns` `f`, `f` drops as it returns. */ +export function iterTryFold(it: Iter, init: A, f: (acc: A, item: T) => R, option = false, owns = false, none?: None): R { + return tryFold(it, false, init, f, option, none, owns ? () => dispose(f) : undefined); +} + +/** `DoubleEndedIterator::try_rfold`, from the back, as `iterTryFold`. */ export function iterTryRfold(it: Iter, init: A, f: (acc: A, item: T) => R, option = false, owns = false, none?: None): R { + return tryFold(it, true, init, f, option, none, owns ? () => dispose(f) : undefined); +} + +/** `Iterator::try_for_each`, as `iterTryFold` of `()`. */ +export function iterTryForEach(it: Iter, f: (item: T) => R, option = false, owns = false, none?: None): R { + return tryFold(it, false, undefined, (_, item: T) => f(item), option, none, owns ? () => dispose(f) : undefined); +} + +/** `iterTryFold`, or from the back if `back`, which ends by `release`. */ +function tryFold(it: Iter, back: boolean, init: A, f: (acc: A, item: T) => R, option: boolean, none: None | undefined, release: (() => void) | undefined): R { const folded = it.folded(); + const read = back ? () => folded.nextBack() : () => folded.next(); let acc = init; - for (let item = folded.nextBack(); item !== DONE; item = folded.nextBack()) { + for (let item = read(); item !== DONE; item = read()) { const step = f(acc, item); if (option ? step === none : !(step as Result).ok) { - if (owns) dispose(f); + release?.(); return step; } acc = option ? (step as unknown as A) : (step as { value: A }).value; } - if (owns) dispose(f); + release?.(); return (option ? acc : Ok(acc)) as R; } @@ -3401,6 +3432,64 @@ class MapWhileIter extends Calling U | undefined | None } } +/** + * `Scan`, which hands `f` its state, or its place, and yields what `f` returns until it + * returns `None`: its `next` reads on after, but a fold, by `try_fold`, stops there. + */ +class ScanIter extends Calling U | undefined | None> { + private state: S; + private readonly at: S | Place; + private readonly drop: Drop | undefined; + /** The `Option`'s `None` that `f` returns. */ + private readonly none: None | undefined; + private stateDropped = false; + + constructor(inner: Iter, state: S, f: (state: never, item: T) => U | undefined | None, copied: boolean, drop?: Drop, none?: None) { + super(inner, f); + this.state = state; + this.at = copied + ? place( + () => this.state, + (v) => { + this.state = v; + }, + ) + : state; + this.drop = drop; + this.none = none; + } + + next(): U | Done { + return this.scan(this.inner.next()); + } + + /** std's folds read its iterator as its `try_fold` does. */ + override folded(): Iter { + const inner = this.inner.folded(); + if (inner === this.inner) return this; + return new Folded( + () => this.scan(inner.next()), + () => this.nextBack(), + ); + } + + /** What `f` makes of `item`, which ends it at `None`. */ + private scan(item: T | Done): U | Done { + return item === DONE ? DONE : iterFromOption(this.f(this.at as never, item), this.none); + } + + override sizeHint(): SizeHint { + return fewer(this.inner); + } + + override [Symbol.dispose](): void { + super[Symbol.dispose](); + if (this.stateDropped) return; + this.stateDropped = true; + this.drop?.(this.state); + } +} + /** `StepBy`, whose items drop by `drop` as its iterator's own `nth` and `nth_back` step over them. */ class StepByIter extends Adaptor { readonly step: number; diff --git a/ts/runtime/rt/sort.ts b/ts/runtime/rt/sort.ts index bd008efdd..57df84fd6 100644 --- a/ts/runtime/rt/sort.ts +++ b/ts/runtime/rt/sort.ts @@ -10,6 +10,7 @@ // panic aborts, never shows. import { panic } from "../rt.ts"; +import { drop as dispose } from "./task.ts"; type Slice = { [i: number]: T; length: number }; type Less = (a: T, b: T) => boolean; @@ -67,6 +68,32 @@ export function sliceSortUnstable(s: Slice, less: Less, size: number, f quicksortUnstable(c, 0, n, false, undefined, 2 * log2(n)); } +/** + * `sort_by_cached_key`: `key` of each element in order, paired with its index, and then + * `key` dropped if the sort `owns` it, the pairs, `size` bytes long on wasm32, sorted by + * `sort_unstable` by `lt`, which then permute `s`, and drop by `drop`. + */ +export function sliceSortByCachedKey(s: Slice, key: (item: T) => K, lt: Less<[K, number]>, size: number, freeze: boolean, copy: boolean, owns = false, drop?: (key: K) => void): void { + const n = s.length; + if (n < 2) { + if (owns) dispose(key); + return; + } + const indices: [K, number][] = []; + for (let i = 0; i < n; i++) indices.push([key(s[i]), i]); + if (owns) dispose(key); + sliceSortUnstable(indices, lt, size, freeze, copy); + for (let i = 0; i < n; i++) { + let index = indices[i][1]; + while (index < i) index = indices[index][1]; + indices[i][1] = index; + const t = s[i]; + s[i] = s[index]; + s[index] = t; + } + if (drop !== undefined) for (const [k] of indices) drop(k); +} + /** `sort_by_key`'s test: `lt` of the keys `key` makes of each, the first's first. */ export function keyLt(key: (item: T) => K, lt: Less): Less { return (a, b) => lt(key(a), key(b)); diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rt/task.ts index 584c58602..f8a2ec885 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rt/task.ts @@ -532,6 +532,27 @@ export function refCellReplace(cell: RefCell, value: T): T { return old; } +/** + * `RefCell::replace_with`: its value, which what `f` returns of it, or of its place if + * `copied`, where JS copies it, replaces, exclusively borrowed until then. + */ +export function refCellReplaceWith(cell: RefCell, f: (value: never) => T, copied = false): T { + refCellBorrowMut(cell); + const at = copied + ? place( + () => cell.value, + (v) => { + cell.value = v; + }, + ) + : cell.value; + const replacement = f(at as never); + const old = cell.value; + cell.value = replacement; + refMutRelease(cell); + return old; +} + /** `Debug` of a `RefCell`: its value, borrowed while it is written, or `` unpadded while borrowed exclusively. */ export function refCellDebug(cell: RefCell, f: Formatter, debug: Debug): FmtResult { const b = fmtDebugStruct(f, "RefCell"); @@ -811,6 +832,11 @@ export function cellReplace(cell: Cell, v: T): T { return old; } +/** `Cell::update`: what `f` returns of its value, in its place. */ +export function cellUpdate(cell: Cell, f: (v: T) => T): void { + cell.v = f(cell.v); +} + /** `Cell::set`: `v` in place of the value it held, which `dropOld` drops after. */ export function cellSet(cell: Cell, v: T, dropOld?: (old: T) => void): void { const old = cell.v; diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 41ae0a7b8..409bc7772 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -1980,6 +1980,29 @@ pub fn tuple_extend<'tcx>( Some(Expr::rt(f, [vec![target], rest].concat())) } +/// `Iterator::partition` of `items`, an iterator of `item`s, by `f`, into two defaults of +/// `coll`, as std's makes them, each extended as a tuple's `Extend` extends it: `flags` say +/// whether the iterator drops and whether `f` drops as its fold ends. +pub fn partition<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + coll: Ty<'tcx>, + item: Ty<'tcx>, + items: Expr, + f: Expr, + flags: Vec, + span: Span, +) -> Option { + let part = part(b, coll, item, span)?; + let left = default(b, coll, span)?; + let left = empty(b, left, coll, span); + let right = default(b, coll, span)?; + let right = empty(b, right, coll, span); + Some(Expr::rt( + "iterPartition", + super::iter::tail(vec![items, f, Expr::Array(vec![left, right]), part], flags), + )) +} + /// The `rt.Part` a tuple's `Extend` adds `item`s to a collection of type `coll` by, or to a /// tuple of them, which is one too: `None` for any other. fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: Span) -> Option { diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 912424284..44660e1f4 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -834,6 +834,7 @@ pub fn call<'tcx>( let none = b.t.none_arg(targ(0)?); return Some(Expr::rt("iterFromFn", [args, none.into_iter().collect()].concat())); } + ["iter", "sources", "repeat_with", "repeat_with"] => return Some(Expr::rt("iterRepeatWith", args)), // What drops the item it holds next. ["iter", "sources", "successors", "successors"] => { let droppers = [b.t.dropper(targ(0)?, span)].into_iter().chain(b.t.none_arg(targ(0)?)); @@ -964,16 +965,32 @@ pub fn call<'tcx>( let owns = flag(b.t.drops(targ(gargs.types().count() - 1)?)); method(&camel, tail(rest, vec![drops, owns])) } - // `try_rfold::`, which drops its closure as it returns, but not the - // iterator, which it borrows. - "try_rfold" => { - let (option, none) = try_flow(b, targ(3)?)?; - let owns = flag(b.t.drops(targ(2)?)); + // `try_fold::` and `try_for_each::`, which drop their closure as they + // return, but not the iterator, which they borrow. + "try_fold" | "try_rfold" | "try_for_each" => { + let n = gargs.types().count(); + let (option, none) = try_flow(b, targ(n - 1)?)?; + let owns = flag(b.t.drops(targ(n - 2)?)); method( &camel, tail(rest, [flag(option), owns].into_iter().chain(none).collect()), ) } + // `partition::`, into two of `B`'s defaults. + "partition" => { + let f = rest.into_iter().next()?; + let flags = vec![iter_drops(b, self_ty, span), flag(b.t.drops(targ(2)?))]; + super::collections::partition(b, targ(1)?, item, recv.clone(), f, flags, span) + } + // `scan::`, whose state is lent as its place where JS copies it, and drops + // after the closure. + "scan" => { + let state = targ(1)?; + let copied = flag(b.t.needs_place(state)); + let dropper = b.t.dropper(state, span); + let none = b.t.none_arg(targ(2)?); + method(name, tail(rest, [copied, dropper].into_iter().chain(none).collect())) + } // std's `Sum` and `Product` are of the type or a reference to it: another is the crate's. "sum" | "product" if item.peel_refs() != targ(1)? => None, // `Duration`'s carries its nanoseconds and panics as std's does, not as `+` would. @@ -1551,7 +1568,9 @@ pub(super) fn holds_closure(tcx: ty::TyCtxt<'_>, did: DefId) -> bool { _, "Map" | "Filter" | "FilterMap" | "SkipWhile" | "TakeWhile" | "MapWhile" | "Inspect" ] | ["iter", "adapters", "flatten", "FlatMap"] + | ["iter", "adapters", "scan", "Scan"] | ["iter", "sources", "from_fn", "FromFn"] + | ["iter", "sources", "repeat_with", "RepeatWith"] | ["iter", "sources", "successors", "Successors"] | ["collections", "linked_list", "ExtractIf"] | [ diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 8a0682148..75261e0e3 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -953,6 +953,7 @@ fn discards(owner: &str, name: &str) -> Option<&'static [usize]> { // `is_sorted_by::` drops its comparator before the last item, as `all` takes it. ("Iterator", "is_sorted_by") => &[1], ("LocalKey", "with" | "try_with" | "initialize_with" | "with_borrow_mut") => &[1], + ("Cell", "update") | ("RefCell", "replace_with") => &[1], _ => return None, }) } @@ -967,6 +968,9 @@ fn releases(owner: &str, name: &str) -> bool { "Iterator", "for_each" | "fold" + | "try_fold" + | "try_for_each" + | "partition" | "reduce" | "max_by" | "min_by" @@ -978,6 +982,7 @@ fn releases(owner: &str, name: &str) -> bool { | "partial_cmp_by" ) | ("DoubleEndedIterator", "rfold" | "try_rfold") | ("Entry", "or_insert_with" | "or_insert_with_key" | "and_modify") + | ("slice", "sort_by_cached_key") ) } @@ -1015,7 +1020,8 @@ fn takes_none(owner: &str, name: &str) -> bool { ) | ( "Iterator", "max_by" | "min_by" | "reduce" | "find_map" | "filter_map" | "map_while" - ) | ("Peekable", "peek" | "next_if" | "next_if_eq") + ) | ("Iterator", "try_fold" | "try_for_each" | "scan") + | ("Peekable", "peek" | "next_if" | "next_if_eq") | ( "OnceCell" | "OnceLock", "get" | "get_mut" | "set" | "get_or_init" | "get_or_try_init" | "take" | "into_inner" @@ -1181,16 +1187,22 @@ fn called_closures<'tcx>( } let mentions = |t: Ty<'tcx>| t.walk().any(|a| a.as_type() == Some(input)); if mentions(output) { - // An `rt.Iter` drops the closure it holds, and an `rt.PollFn` one it owns. + // An `rt.Iter` drops the closure it holds, an `rt.PollFn` one it owns, and an + // `rt.LazyCell` one it never calls, and one it calls through `FnOnce` as it does. let holder = match output.kind() { ty::Adt(adt, args) if args.types().any(|a| a == input) => Some(adt.did()), _ => None, }; let iter = holder.is_some_and(|did| super::iter::holds_closure(tcx, did)); + let holds = holder.and_then(|did| Std::of(tcx, did)); + let lazy = matches!(holds, Some(Std::LazyCell | Std::LazyLock)); if lent && iter && i < args.len() { let f = std::mem::replace(&mut args[i], Expr::undefined()); args[i] = Expr::rt("lent", vec![f]); - } else if !lent && !iter && holder.and_then(|did| Std::of(tcx, did)) != Some(Std::PollFn) { + } else if lazy && !lent && called != ty::ClosureKind::FnOnce && i < args.len() { + let f = std::mem::replace(&mut args[i], Expr::undefined()); + args[i] = Expr::rt("once", vec![f]); + } else if !lent && !iter && !lazy && holds != Some(Std::PollFn) { closures.leaked = closures.leaked.or(Some(ty)); } continue; @@ -2108,6 +2120,25 @@ fn mapping<'tcx>( false => Expr::rt("sliceSort", values), } } + // By `sort_unstable` of each key `f` makes paired with its index, a `usize`, as a + // `u32` is no smaller on wasm32, `f` dropped once it made them, and then the keys + // dropped. + ("slice", "sort_by_cached_key") => { + let (elem, key) = (targ(gargs, 0), targ(gargs, 1)); + let mut values = args.into_iter(); + let s = elements(values.next()?, Ty::new_slice(tcx, elem)); + let f = values.next()?; + let pair = Ty::new_tup(tcx, &[key, tcx.types.usize]); + let lt = super::collections::test_fn(b, pair, "lt", span); + let [size, freeze] = sort_of(b, pair, span); + let copy = Expr::lit(b.t.is_copy(key).to_string()); + let owns = Expr::lit(b.t.drops(targ(gargs, 2)).to_string()); + let drop = b.t.dropper(key, span); + Expr::rt( + "sliceSortByCachedKey", + super::iter::tail(vec![s, f, lt, size, freeze, copy], vec![owns, drop]), + ) + } // Whether each element and the next are in order, as `sort` would leave them: by // `PartialOrd::le` in std's chunks, or as the slice's iterator's `is_sorted_by` and // `is_sorted_by_key` test them, which std's are. diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 43d764954..a242c335b 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -395,8 +395,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { | ("Arc" | "Rc", "get_mut" | "make_mut") | ("Mutex" | "RwLock" | "RefCell" | "OnceCell" | "OnceLock", "get_mut") | ("RefMut", "leak") - | ("RefCell", "undo_leak") - | ("Iterator", "by_ref") + | ("RefCell", "undo_leak" | "replace_with") + | ("Iterator", "by_ref" | "scan") | ("empty", "empty") | ( "RefMut" | "MutexGuard" | "MappedMutexGuard" | "RwLockWriteGuard" | "MappedRwLockWriteGuard", diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index de9e1888d..9795ba86f 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -283,6 +283,14 @@ pub fn call<'tcx>( ("MutexGuard" | "MappedMutexGuard", "map" | "filter_map") => guard_map(b, call, name, "mutex", args, out), ("Ref", "clone") => Expr::rt("refClone", args), ("RefCell", "replace") => Expr::rt("refCellReplace", args), + // With the value's place where JS would copy it. + ("RefCell", "replace_with") => { + let copied = b.t.needs_place(call.args.type_at(0)); + Expr::rt( + "refCellReplaceWith", + super::iter::tail(args, vec![Expr::lit(copied.to_string())]), + ) + } ("RefCell", "take") => { let ty = call.args.type_at(0); let f = super::collections::trait_fn(tcx, "Default", "default"); @@ -324,6 +332,7 @@ pub fn call<'tcx>( } ("Atomic", _) => return atomic(b, call, name, args), ("LazyCell" | "LazyLock", "force") => first(args).member("force").call(vec![]), + ("LazyCell" | "LazyLock", "new") => Expr::New(Box::new(Expr::Rt(owner.into())), args), ("OnceCell" | "OnceLock", _) => return once(b, call, name, args), // A `OnceLock` of `true`, which nothing poisons, as a panic aborts. ("Once", "new") => once_unrun(), @@ -523,6 +532,7 @@ fn cell<'tcx>( "get" => b.t.copied(first(args).member("v"), ty, call.span), "into_inner" => first(args).member("v"), "replace" => Expr::rt("cellReplace", args), + "update" => Expr::rt("cellUpdate", args), // With what drops the value it replaces. "set" => { let Some(droppers) = b.t.droppers([ty], call.span) else { diff --git a/ts/tests/task.ts b/ts/tests/task.ts index 53b27074a..04a3b367f 100644 --- a/ts/tests/task.ts +++ b/ts/tests/task.ts @@ -57,6 +57,7 @@ export interface Fixture { cells(log: Log, id: number, arg: number): void; folded(log: Log, id: number, arg: number): void; rfolded(log: Log, id: number, arg: number): void; + called(log: Log, id: number, arg: number): void; inside(log: Log, id: number, arg: number): void; released(log: Log, id: number, arg: number): void; flattened(log: Log, id: number, arg: number): void; @@ -311,6 +312,7 @@ export const steps: [string, (r: Run, arg: number) => void][] = [ ["cells", (r, arg) => r.f.drops.cells(r.log, 1000 * r.exec.tasks.length, arg)], ["folded", (r, arg) => r.f.drops.folded(r.log, 1000 * r.exec.tasks.length, arg)], ["rfolded", (r, arg) => r.f.drops.rfolded(r.log, 1000 * r.exec.tasks.length, arg)], + ["called", (r, arg) => r.f.drops.called(r.log, 1000 * r.exec.tasks.length, arg)], [ "watch", (r, arg) => { @@ -432,6 +434,7 @@ export const cases: Uint8Array[] = [ // Each scenario of adaptors' closures that drop, folded either way. ...Array.from({ length: 42 }, (_, arg) => script(["folded", arg])), ...Array.from({ length: 18 }, (_, arg) => script(["rfolded", arg])), + ...Array.from({ length: 12 }, (_, arg) => script(["called", arg])), // Where std drops values inside its iterators and formatting. ...[...Array.from({ length: 10 }, (_, arg) => arg), 19, 29].map((arg) => script(["inside", arg])), // Where std drops a closure given to a consumer or an entry.