diff --git a/quest/m3/ts-slice-object.md b/quest/m3/ts-slice-object.md index 0209480c2..72a31a87c 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -2,20 +2,17 @@ ## Goal -[rust2-ts](/ts/README.md) translates `&[T]`, `&mut [T]`, and `Box<[T]>` of values other -than bytes as `rs.Slice`, its array, start, and length, as `rs.ByteSlice` is for bytes. -What remains: - -- A `&[T; N]` and `&mut [T; N]` of other values is an `rs.Slice` too, as `&[u8; N]` is an - `rs.ByteSlice`, so the run `first_chunk_mut`, `split_first_chunk_mut`, an array subslice - pattern, and `array::from_mut` lend is where the slice holds it, rather than the - runtime's `arrayView` `Proxy`. -- Pointers to a `[T; N]` and to elements JS copies compare where they point, as `ptr::eq` - does natively, lifting the refusal of - [moq-dev/rust2#510](https://github.com/moq-dev/rust2/pull/510) and of comparing two - `rs.Place`s of one element. +[rust2-ts](/ts/README.md) translates slices and references to arrays as `rs.Slice` and +`rs.ByteSlice`, their array, start, and length. What remains: + +- A `&mut [[T; N]]` that `as_chunks_mut` and `as_rchunks_mut` lend holds its runs where + the slice holds their elements, rather than as the runtime's `Runs` and `ByteRuns` + `Proxy` views and `arrayView`, along with the detaching copies they need before a + whole write. - `slice::from_mut` and `array::from_mut` of a `&mut u8` translate, writing the byte through the slice where the caller holds it. +- Pointers to a `[T]` of values JS copies compare where they point, as pointers to a + `[T; N]` do. Each is proven by differential tests against native Rust. @@ -25,20 +22,24 @@ Decided with the maintainer on 2026-11-03: Rust types the runtime can't hold as get a runtime wrapper, converted at API boundaries, rather than a JS native type ([#555](https://github.com/moq-dev/rust2/pull/555) made `Vec` one). -A `[T; N]` value stays a JS array. A reference to one would be an `rs.Slice` of it, as -`Pointee::Bytes` makes a reference to a `[u8; N]` an `rs.ByteSlice`, generalized to any -element. Then `as_chunks_mut`'s `Runs` and `ByteRuns` views and `arrayView` go, along with -the detaching copies they need before a whole write. - -Pointer identity then compares an `rs.AtIndex` by its array and index, and an `rs.Slice` -by its data, start, and length, as `rs.ByteSlice` already does. +A slice of arrays holds each array as a JS array of its own, so a run of a flat slice has +no array to be. One option is a slice of runs over the flat array, whose element `i` is +the `rs.Slice` of run `i`, which a `&mut [[T; N]]` would be wherever its runs alias +another slice's elements. A slice of one over a `&mut u8` was found fragile when it meant a one-byte buffer for each -local; a slice whose storage can be an `rs.Place` may avoid that. Measure what each form -costs a hot `&mut u8`, such as `read_exact(slice::from_mut(&mut byte))`. - -Public API: the translator's output and what a hand-written caller passes for a -reference to an array. +local; an `rs.ByteSlice` whose storage can be an `rs.Place` may avoid that. Measure what +each form costs a hot `&mut u8`, such as `read_exact(slice::from_mut(&mut byte))`. + +✅ Decided with the maintainer on 2026-11-04: generated code fails at run time only where +Rust panics, so a pointer comparison the translator can't answer exactly is refused at +translation with a span. Pointers to arrays compare as slices; comparing pointers to +elements and other places of values JS copies, which JS may make two `rs.Place`s for, +stays refused, as do pointers to an array of one, and their exact path is +[a quest of its own](/quest/m3/ts-runtime-throws.md). + +Public API: the translator's output and what a hand-written caller passes for a slice of +arrays. ## Related diff --git a/ts/README.md b/ts/README.md index 648549913..dfe8e1ceb 100644 --- a/ts/README.md +++ b/ts/README.md @@ -104,12 +104,12 @@ crate translation reaches is refused, and so are two versions of one crate it re | `Option` | `T \| undefined`; `T \| rs.None` where `T` can already be `undefined`, as `()` and `Option` can, so `Option<()>` and `Option>` keep `None` apart from each `Some` | | `Result` | `rs.Result`: `{ ok: true, value }` or `{ ok: false, error }`; `rs.OK` or `rs.ERR` where the payload is `undefined`, as in `Ok(())` | | `ControlFlow` | `rs.Result`, `Ok` to continue; what `?` branches on is the value it was applied to, but for a `Poll`'s `Pending` and `Ready(None)`, which continue as `Ok` of themselves | -| tuple, `[T; N]`, `&[T; N]` | an array; for bytes, `u8` or `MaybeUninit`, `Uint8Array` for `[u8; N]`, and `rs.ByteSlice` for `&[u8; N]` | +| tuple, `[T; N]`, `&[T; N]` | an array, and `rs.Slice` of all of it for `&[T; N]`; for bytes, `u8` or `MaybeUninit`, `Uint8Array` for `[u8; N]`, and `rs.ByteSlice` for `&[u8; N]` | | `&[T]`, `&mut [T]`, `Box<[T]>` | `rs.Slice`, a range of an array; `rs.ByteSlice` for bytes | | `Vec` | `rs.Vec`: its items, the array `items`, and the capacity std's holds; `rs.vecFrom(items)` makes one of an array with room for exactly them. `rs.ByteVec` of bytes | | `Cow<[T]>`, `Cow` | `rs.Cow`: the `Vec` it owns, or an `rs.Borrowed` holding the slice it borrows; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | | `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | -| `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rs.ByteSlice` of a `[u8; N]`'s bytes, which compares by the buffer and offset they are at, or an `rs.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to an array of other values than bytes, which a slice lends as a copy of its own; `rs.NULL` for null and `rs.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rs.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rs.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rs.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rs` class such as `rs.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | +| `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rs.Slice` of a `[T; N]`'s elements or an `rs.ByteSlice` of a `[u8; N]`'s bytes, which compares by the array or buffer and offset they are at, refused for an array of one, which `array::from_ref`, `from_mut` of a variable, and `Option::as_slice` make of their own, or an `rs.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to other values JS copies, each a place JS makes of its own; `rs.NULL` for null and `rs.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rs.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rs.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rs.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rs` class such as `rs.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | | `MaybeUninit` | `T`: `undefined` until written, `0` for a byte, or an object whose parts kept as objects are there, holding `undefined` | | `ManuallyDrop` | `T`, which nothing drops but its own `drop`; its `Debug`, comparisons, and constants are refused | | `union` | an object of slots named by offset, `at0` and `at8`, each holding the field part kept there; fields must overlap in the same type, or in a non-null pointer and an `Option` of it | @@ -134,7 +134,7 @@ crate translation reaches is refused, and so are two versions of one crate it re | `static` | a module's value, named for the static, that every use shares, read from the memory rustc evaluated; one that reads another static or a class is an `rs.LazyCell` of it, made on first use, since that may not be made yet when its module is. A `static mut`, and a pointer in one into memory the translation can't name, fail translation | | a type that drops | a class with `[Symbol.dispose]`: its `Drop` impl, then its fields | | 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` | `rs.Arc` for either, of what a `Box` is for a slice or `str`, with its strong and weak counts, an `Arc<[T; N]>` unsized to an `Arc<[T]>` refused, as its slice would be made inside the `rs.Arc` its other owners share, an `Arc<[u8]>` of an `Arc`'s bytes sharing its count, 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 `rs.Arc` while another `Arc` shares it, or moving it there while only `Weak`s do, which then dangle, as a copy where pointers to it compare, `as_ptr` and `into_raw` pointing where a reference to its value does, or at its place where JS copies it, as a pointer the body shows made from a reference to that value does, which `from_raw`, `increment_strong_count`, and `decrement_strong_count` take back to its `rs.Arc` and count, refused for one the body shows a borrow made, and failing at run time on another pointer no `as_ptr` or `into_raw` of that type of `Arc` gave, or one whose value dropped, and refused for one to a slice or bytes, which JS makes anew each time, and `ptr::addr_eq` comparing what `ptr::eq` compares, of one pointee type, and `into_inner` giving it only from the last strong `Arc`, after which its `Weak`s no longer upgrade; `rs.Weak`, counted in its `rs.Arc` until it drops, and of no `Arc` once made by `Weak::new`; `rs.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 `rs.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 `rs.Place` of it where JS copies it | +| `Arc`, `Rc`, `Weak`, `Mutex` | `rs.Arc` for either, of what a `Box` is for a slice or `str`, with its strong and weak counts, an `Arc<[T; N]>` unsized to an `Arc<[T]>` an `rs.ArcDyn` of the slice of its array, sharing its count, an `Arc<[u8]>` of an `Arc`'s bytes sharing its count, 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 `rs.Arc` while another `Arc` shares it, or moving it there while only `Weak`s do, which then dangle, as a copy where pointers to it compare, `as_ptr` and `into_raw` pointing where a reference to its value does, or at its place where JS copies it, as a pointer the body shows made from a reference to that value does, which `from_raw`, `increment_strong_count`, and `decrement_strong_count` take back to its `rs.Arc` and count, refused for one the body shows a borrow made, and failing at run time on another pointer no `as_ptr` or `into_raw` of that type of `Arc` gave, or one whose value dropped, and refused for one to a slice or bytes, which JS makes anew each time, and `ptr::addr_eq` comparing what `ptr::eq` compares, of one pointee type, and `into_inner` giving it only from the last strong `Arc`, after which its `Weak`s no longer upgrade; `rs.Weak`, counted in its `rs.Arc` until it drops, and of no `Arc` once made by `Weak::new`; `rs.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 `rs.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 `rs.Place` of it where JS copies it | | `PoisonError`, `TryLockError` | the `T` it holds; `rs.TryLockError`, tagged as `Bound` is | | `Cell`, `UnsafeCell`, `RefCell`, `RwLock` | `rs.Cell`, the place holding its value in `v`, for either of the first two: `UnsafeCell::get`'s and `Cell::as_ptr`'s pointer, and `get_mut`'s reference, is the cell where it is an `rs.Place`, and otherwise the object in `v`, refused where the crate may put another cell or object in its place; `rs.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 `rs.BorrowError` and `rs.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 `rs.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 `rs.LocalKey`, a module's value that each copy of the key is, 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 | @@ -167,10 +167,13 @@ its `data`, a JS array, from `start`, for `length` elements, read and written wh are, so `&mut v[a..b]`, `split_at_mut`, `chunks_mut`, and `split_mut` lend parts of the same array. A caller passes one as `rs.sliceFrom(array)` and reads one it gets as `rs.sliceItems(slice)`, the array itself where the slice is all of it. A `[T; N]` stays a -JS array, which has no views, so the `&mut [T; N]` that `first_chunk_mut` and -`array::from_mut` lend is a `Proxy` of an array whose elements are the slice's. -`as_chunks_mut` and `as_rchunks_mut` lend their runs as such a `Proxy` too, of a view of -each run, a `Uint8Array` one for bytes, and a whole write of a run copies into it. +JS array, and a `&[T; N]` or `&mut [T; N]` is an `rs.Slice` of its elements where they +are, as a `&[u8; N]` is an `rs.ByteSlice`, so `first_chunk_mut`, `split_first_chunk_mut`, +a subslice pattern, and `array::from_mut` lend part of the same array, and a whole write +through one writes each element in place. A slice of arrays has each as a JS array of its +own, so `as_chunks_mut` and `as_rchunks_mut` lend their runs as a `Proxy` of an array +whose elements are views of each run, a `Uint8Array` one for bytes, and a whole write of +a run copies into it. Before that write, a view of other values that a read took detaches to a copy of what it held. A byte run's view can't, so it is copied wherever it is read by value: the call counts as a write into the bytes, which has translated code copy each `[u8; N]` it @@ -513,16 +516,18 @@ other as std's do, by their lengths and then each pair of items in order, throug items' own `PartialEq`, and its `ne` where the crate overrides it, which a tuple's and an `Arc`'s `!=` call as well. What a composite holds compares, orders, and hashes through a reference or a `Box` as std's impls forward it, by what it points at, or by the crate's -own impl on the reference or `Box` itself. A reference std makes to a byte array it holds, as a +own impl on the reference or `Box` itself. A reference std makes to an array it holds, as a collection's `keys`, `HashSet::get`, and `retain`'s closure, `Option::iter`, -`slice::first`, and `filter`'s closure over `[u8; N]` items get one, is an `rs.ByteSlice` -of its bytes, as a `&[u8; N]` is elsewhere; a `&mut` writes where std holds them. A -`&[u8; N]` std was given and holds, as a `HashMap<&[u8; N], V>`'s keys, stays the slice it -was, and `extend` by references to arrays copies each into its own `Uint8Array`. A -`&[u8; N]` std is given as a `&T`, as `Option<&T>::copied`, `slice::contains`, and -`assert_eq!` take one, is a view of the slice's bytes, which std reads, copies, and -writes through where the reference points; `mem::swap`, `replace`, and `take` through a -`&mut [u8; N]` copy bytes in place. A `&mut` to a value a map holds that JS copies, +`slice::first`, and `filter`'s closure over `[T; N]` items get one, is an `rs.Slice` of +its elements, an `rs.ByteSlice` for bytes, as a `&[T; N]` is elsewhere; a `&mut` writes +where std holds them. A `&[u8; N]` std was given and holds, as a `HashMap<&[u8; N], V>`'s +keys, stays the slice it was, and `extend` by references to arrays copies each into its +own array. A `&[T; N]` std is given as a `&T`, as `Option<&T>::copied`, +`slice::contains`, and `assert_eq!` take one, and a key a map looks up by a `&[T; N]` of +other values than bytes, is the slice's elements, the array itself where the slice is all +of it, and else a copy, or for bytes a view of them, which std reads, copies, and writes +through where the reference points; `mem::swap`, `replace`, and `take` through a +`&mut [T; N]` write each element in place. A `&mut` to a value a map holds that JS copies, such as a number, from `get_mut` or the entry API, is an `rs.Place` whose `v` reads and writes the map's slot. A hash map iterates in an order of the runtime's, mostly insertion order, which std leaves unspecified, and hashes a key @@ -595,7 +600,8 @@ object of the type shares, whose methods call that type's impls; one from a `&mu value JS copies holds its `rs.Place`, as `ofPlace$dyns_Square`, so `&mut self` writes where the value is. An upcast, to `dyn Any` too, is the same object. Objects of two traits of one name, with a method of one name, or of one generic trait at two arguments, are -refused for one type, whose class can't hold both. A `Box` drops what it holds through its `[Symbol.dispose]`, which +refused for one type, whose class can't hold both, as are objects of an array, which a +box holds as the array and a reference as a slice of it. A `Box` drops what it holds through its `[Symbol.dispose]`, which a TS caller's object may leave out. An `Arc` unsized to an `Arc`, or to an `Arc`, is an `rs.ArcDyn`: the object a box of its value would be, and the `Arc` it was made from, whose one count both sides' clones and drops change, and the diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 4a91334df..9430b1ac3 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -512,8 +512,8 @@ export function format(data: rs.ByteSlice, out: rs.ByteVec): void { const point: Point.Point = { x: i, y: rs.i64Neg(i) }; const _26: rs.f64 = rs.i64ToF64(i) / 3.0; const _29: rs.i64 = rs.i64Neg(i); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(i, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => rs.f64Display(_26, f), (f: rs.Formatter) => rs.i64Display(_29, f)]; - s = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ precision: 2 }, args2[2]), "|", args2[3], "\n"]).s; + const args3 = [(f: rs.Formatter) => rs.i64Display(i, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => rs.f64Display(_26, f), (f: rs.Formatter) => rs.i64Display(_29, f)]; + s = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 6 }, args3[0]), "|", args3[1], "|", rs.fmtSpec({ precision: 2 }, args3[2]), "|", args3[3], "\n"]).s; } putUsize(out, rs.stringLen(s)); harness_putU64(out, rs.iterSum(rs.iterMap(rs.strBytes(s), (a0: rs.u8): rs.u64 => { diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index 4504471d9..bb6f6fb0a 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -17,8 +17,7 @@ export function fmt$fmt_Display(self: DecodeError, __formatter: rs.Formatter): r } if (self.tag === "InvalidMessage") { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(arg, f)]; - return rs.fmtWriteFmt(__formatter, ["invalid message: ", args2[0]]); + return rs.fmtWriteFmt(__formatter, ["invalid message: ", (f: rs.Formatter) => rs.u64Debug(arg, f)]); } if (self.tag === "InvalidSubscribeLocation") { return rs.fmtWriteStr(__formatter, "invalid subscribe location"); @@ -38,8 +37,8 @@ export function fmt$fmt_Display(self: DecodeError, __formatter: rs.Formatter): r if (self.tag === "MessageTooLarge") { const _26: rs.usize = asDisplay$thiserror___private21_AsDisplay_ref_usize(self.size); const _28: rs.usize = asDisplay$thiserror___private21_AsDisplay_ref_usize(self.max); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_26, f), (f: rs.Formatter) => rs.usizeDisplay(_28, f)]; - return rs.fmtWriteFmt(__formatter, ["message too large: ", args4[0], " bytes exceeds ", args4[1], " byte limit"]); + const args5 = [(f: rs.Formatter) => rs.usizeDisplay(_26, f), (f: rs.Formatter) => rs.usizeDisplay(_28, f)]; + return rs.fmtWriteFmt(__formatter, ["message too large: ", args5[0], " bytes exceeds ", args5[1], " byte limit"]); } if (self.tag === "ExpectedData") { return rs.fmtWriteStr(__formatter, "expected data"); diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 563fce646..0bc416c84 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -104,17 +104,13 @@ export function takeU64(data: rs.ByteSlice): [rs.u64, rs.ByteSlice] { /** A decode error's code, then its text. */ export function decodeFailed(out: rs.ByteVec, err: DecodeError.DecodeError): void { decodeError(out, err); - const _5: string = rs.fmtToString((f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; - putText(out, _5, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtToString((f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)), rs.fmtFormat([(f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f)])); } /** An encode error's code, then its text. */ export function encodeFailed(out: rs.ByteVec, err: EncodeError.EncodeError): void { encodeError(out, err); - const _5: string = rs.fmtToString((f: rs.Formatter) => EncodeError.fmt$fmt_Display(err, f)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => EncodeError.fmt$fmt_Debug(err, f)]; - putText(out, _5, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtToString((f: rs.Formatter) => EncodeError.fmt$fmt_Display(err, f)), rs.fmtFormat([(f: rs.Formatter) => EncodeError.fmt$fmt_Debug(err, f)])); } /** An error's thiserror `Display` and derived `Debug`, which callers see. */ @@ -591,16 +587,14 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, const arg = {}; const _26: string = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); const arg2 = {}; - const args2: rs.Fmt[] = [(f: rs.Formatter) => BoundsExceeded.fmt$fmt_Debug(arg2, f)]; - putText(out, _26, rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0])])); + const args7 = [(f: rs.Formatter) => BoundsExceeded.fmt$fmt_Debug(arg2, f)]; + putText(out, _26, rs.fmtFormat([args7[0], " ", rs.fmtSpec({ alternate: true }, args7[0])])); break b0; } err = { tag: "MalformedAuthToken" } as DecodeError.DecodeError; } - const args4: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)]; - const _38: string = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|"]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; - putText(out, _38, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args6[0])])); + const args8 = [(f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)]; + putText(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ align: ">", width: 30 }, args8[0]), "|"]), rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f))])); decodeFailed(out, err); } } diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index 9eb6b81be..a0935678a 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -8,8 +8,7 @@ export function fmt$fmt_Display(self: SessionError, __formatter: rs.Formatter): return rs.fmtWriteStr(__formatter, "protocol violation"); } const arg = asDisplay$thiserror___private21_AsDisplay_ref_u16(self._0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f)]; - return rs.fmtWriteFmt(__formatter, ["app code=", args2[0]]); + return rs.fmtWriteFmt(__formatter, ["app code=", (f: rs.Formatter) => rs.u16Display(arg, f)]); } export function fmt$fmt_Debug(self: SessionError, f: rs.Formatter): rs.Result { diff --git a/ts/fixtures/crates/bind/slots.ts b/ts/fixtures/crates/bind/slots.ts index 6fa5432b4..dad55cfd6 100644 --- a/ts/fixtures/crates/bind/slots.ts +++ b/ts/fixtures/crates/bind/slots.ts @@ -8,7 +8,7 @@ export function withBase(base: rs.i16): Slots { return { base }; } -export function fill(self: Slots, out: rs.i16[]): undefined { - out[0] = self.base; - out[1] = rs.i16Sub(self.base, 1 as rs.i16); +export function fill(self: Slots, out: rs.Slice): undefined { + out.data[out.start] = self.base; + out.data[out.start + 1] = rs.i16Sub(self.base, 1 as rs.i16); } diff --git a/ts/fixtures/crates/expected/bind/slots.ts b/ts/fixtures/crates/expected/bind/slots.ts index 7596643bb..e0a74b51b 100644 --- a/ts/fixtures/crates/expected/bind/slots.ts +++ b/ts/fixtures/crates/expected/bind/slots.ts @@ -9,7 +9,7 @@ export function withBase(base: rs.i16): Slots { return { base }; } -export function fill(self: Slots, out: rs.i16[]): undefined { - out[0] = self.base; - out[1] = rs.i16Sub(self.base, 1 as rs.i16); +export function fill(self: Slots, out: rs.Slice): undefined { + out.data[out.start] = self.base; + out.data[out.start + 1] = rs.i16Sub(self.base, 1 as rs.i16); } diff --git a/ts/fixtures/crates/expected/harness.ts b/ts/fixtures/crates/expected/harness.ts index ba2402604..41f4a5107 100644 --- a/ts/fixtures/crates/expected/harness.ts +++ b/ts/fixtures/crates/expected/harness.ts @@ -88,7 +88,7 @@ export function run(input: rs.ByteSlice): rs.ByteVec { } const kept: rs.i16[] = [(input.length << 16) >> 16, 7]; const filled: rs.i16[] = copy$array_i16(kept); - Slots.fill(Slots.withBase(kept[0]), filled); + Slots.fill(Slots.withBase(kept[0]), rs.sliceFrom(filled)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(kept[0] & 0xff, kept[1] & 0xff, filled[0] & 0xff, filled[1] & 0xff)), undefined, true); const _202: rs.u8 = first(input.data, input.start, input.length); rs.byteVecPush(out, _202); diff --git a/ts/fixtures/lang/args/expected/harness.ts b/ts/fixtures/lang/args/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/args/expected/harness.ts +++ b/ts/fixtures/lang/args/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index f7d480a40..54a89a3d9 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -23,8 +23,11 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u64Shl(op as rs.u64, rs.usizeMul(i7, 30)); }); const _23: rs.ByteSlice = rs.byteSliceFrom(bytes); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_23), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtList(seen.items, f, rs.usizeDebug)]; - s = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + [_23, rs.sliceFrom(wide), seen] as [rs.ByteSlice, rs.Slice, rs.Vec]; + const _27: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_23), f, rs.u8Debug); + const arg4 = rs.sliceFrom(wide); + const args21 = [_27, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg4), f, rs.u64Debug), (f: rs.Formatter) => rs.fmtList(seen.items, f, rs.usizeDebug)]; + s = rs.fmtFormat([args21[0], " ", args21[1], " ", args21[2]]); } else if (_10 === 1) { const counts: rs.Atomic[] = rs.arrayFromFn(8, (_2: rs.usize): rs.Atomic => { return new rs.Atomic(op as rs.u64); @@ -34,34 +37,41 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _37); } rs.atomicFetch(counts[_37], rs.u64WrappingAdd, 1, 0); + const _44: rs.Slice> = rs.sliceFrom(counts); const copy: rs.Atomic[] = rs.arrayFromFn(8, (i4: rs.usize): rs.Atomic => { if (!(i4 < 8)) { rs.panic("index out of bounds: the len is " + 8 + " but the index is " + i4); } - return new rs.Atomic(rs.atomicLoad(counts[i4], 0)); + return new rs.Atomic(rs.atomicLoad(_44.data[_44.start + i4], 0)); }); rs.atomicStore(copy[0], 0, 0); + const _52: rs.Slice> = rs.sliceFrom(counts); const loads: rs.u64[] = rs.arrayFromFn(8, (i5: rs.usize): rs.u64 => { if (!(i5 < 8)) { rs.panic("index out of bounds: the len is " + 8 + " but the index is " + i5); } - return rs.atomicLoad(counts[i5], 0); + return rs.atomicLoad(_52.data[_52.start + i5], 0); }); const _57: rs.u64 = rs.atomicLoad(copy[0], 0); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(loads, f, rs.u64Debug), (f: rs.Formatter) => rs.u64Display(_57, f)]; - s = rs.fmtFormat([args4[0], " ", args4[1]]); + [_57, rs.sliceFrom(loads)] as [rs.u64, rs.Slice]; + const arg3 = rs.sliceFrom(loads); + const args20 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.u64Debug), (f: rs.Formatter) => rs.u64Display(_57, f)]; + s = rs.fmtFormat([args20[0], " ", args20[1]]); } else if (_10 === 2) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(op, f)]; - const captured = rs.fmtFormat(["w", args6[0]]); + const captured = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u8Display(op, f)]); const words: string[] = rs.arrayFromFn(3, (i2: rs.usize): string => { - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.usizeDisplay(i2, f)]; - return rs.fmtFormat([args14[0], args14[1]]); + const args18 = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.usizeDisplay(i2, f)]; + return rs.fmtFormat([args18[0], args18[1]]); }); const _79: string[] = rs.arrayFromFn(0, (i3: rs.usize): string => { return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(i3, f)); }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(_79, f, rs.fmtStr)]; - s = rs.fmtFormat([args8[0], " ", args8[1]]); + const _83: rs.Slice = rs.sliceFrom(words); + [_83, rs.sliceFrom(_79)] as [rs.Slice, rs.Slice]; + const _86: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_83), f, rs.fmtStr); + const arg2 = rs.sliceFrom(_79); + const args19 = [_86, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, rs.fmtStr)]; + s = rs.fmtFormat([args19[0], " ", args19[1]]); } else if (_10 === 3) { const grid: Uint8Array[] = rs.arrayFromFn(3, (i: rs.usize): Uint8Array => { return rs.bytesFromFn(2, (j: rs.usize): rs.u8 => { @@ -69,13 +79,17 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { }); }); const named: rs.u16[] = rs.arrayFromFn(4, doubled); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(named, f, rs.u16Debug)]; - s = rs.fmtFormat([args10[0], " ", args10[1]]); + const _97: rs.Slice = rs.sliceFrom(grid); + [_97, rs.sliceFrom(named)] as [rs.Slice, rs.Slice]; + const _100: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_97), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const arg = rs.sliceFrom(named); + const args14 = [_100, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.u16Debug)]; + s = rs.fmtFormat([args14[0], " ", args14[1]]); } else { - const _108: rs.usize[] = counted$2(op); - const _110: rs.usize[] = counted$5(op); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(_108, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(_110, f, rs.usizeDebug)]; - s = rs.fmtFormat([args12[0], " ", args12[1]]); + const _107: rs.Slice = rs.sliceFrom(counted$2(op)); + const _109: rs.Slice = rs.sliceFrom(counted$5(op)); + const args13 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(_107), f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_109), f, rs.usizeDebug)]; + s = rs.fmtFormat([args13[0], " ", args13[1]]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); rs.byteVecPush(out, 10); @@ -127,10 +141,17 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u32WrappingMul(w4, 16777619); }); const _31: rs.ByteSlice = rs.byteSliceFrom(bytes); + const _32: rs.Slice = rs.sliceFrom(wide); const _33: rs.ByteSlice = rs.byteSliceFrom(narrow); const _34: rs.ByteSlice = rs.byteSliceFrom(same); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_31), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_33), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_34), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; - s = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]]); + [_31, _32, _33, _34, rs.sliceFrom(words), seen] as [rs.ByteSlice, rs.Slice, rs.ByteSlice, rs.ByteSlice, rs.Slice, rs.ByteVec]; + const _38: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_31), f, rs.u8Debug); + const _39: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_32), f, rs.u16Debug); + const _40: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_33), f, rs.u8Debug); + const _41: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_34), f, rs.u8Debug); + const arg6 = rs.sliceFrom(words); + const args24 = [_38, _39, _40, _41, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg6), f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; + s = rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2], " ", args24[3], " ", args24[4], " ", args24[5]]); } else if (_10 === 1) { const _46: rs.u16[] = rs.arrayMap(Uint8Array.of(), (a0: rs.u8): rs.u16 => { return a0 as rs.u16; @@ -141,23 +162,27 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const _48: string[] = rs.arrayMap([], (n: rs.u32): string => { return rs.fmtToString((f: rs.Formatter) => rs.u32Display(n, f)); }); - const _53: rs.ByteSlice = rs.byteSliceFrom(_47); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(_46, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_53), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_48, f, rs.fmtStr)]; - s = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]); + const _52: rs.Slice = rs.sliceFrom(_46); + [_52, rs.byteSliceFrom(_47), rs.sliceFrom(_48)] as [rs.Slice, rs.ByteSlice, rs.Slice]; + const _56: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_52), f, rs.u16Debug); + const arg4 = rs.byteSliceFrom(_47); + const _57: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg4), f, rs.u8Debug); + const arg5 = rs.sliceFrom(_48); + const args23 = [_56, _57, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg5), f, rs.fmtStr)]; + s = rs.fmtFormat([args23[0], " ", args23[1], " ", args23[2]]); } else if (_10 === 2) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(op, f)]; - const captured = rs.fmtFormat(["w", args6[0]]); + const captured = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u8Display(op, f)]); const words2: string[] = rs.arrayMap(Uint8Array.of(1, 2, 3), (i: rs.u8): string => { - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.u8Display(i, f)]; - return rs.fmtFormat([args16[0], args16[1]]); + const args20 = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.u8Display(i, f)]; + return rs.fmtFormat([args20[0], args20[1]]); }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words2, f, rs.fmtStr)]; - const shown: string = rs.fmtFormat([args8[0]]); + const arg3 = rs.sliceFrom(words2); + const shown: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.fmtStr)]); const _89: rs.ByteSlice = rs.byteSliceFrom(rs.bytesMap(words2, (w: string): rs.u8 => { return rs.u8Add(rs.stringLen(w) & 0xff, rs.u8Rem(op, 3)); })); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, shown), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_89), f, rs.u8Debug)]; - s = rs.fmtFormat([args10[0], " ", args10[1]]); + const args22 = [(f: rs.Formatter) => rs.fmtPad(f, shown), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_89), f, rs.u8Debug)]; + s = rs.fmtFormat([args22[0], " ", args22[1]]); } else if (_10 === 3) { const options: Array = [op, undefined, rs.u8WrappingAdd(op, 60)]; const nested: Array = rs.arrayMap(options, (o: rs.u8 | undefined): rs.u8 | undefined | rs.None => { @@ -174,8 +199,16 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const units: Array = rs.arrayMap(nested, (o3: rs.u8 | undefined | rs.None): undefined | rs.None => { return option_map$1tggsfb(o3, (_2: rs.u8 | undefined): undefined => {}); }); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(options, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(nested, f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)), (f: rs.Formatter) => rs.fmtList(flat, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(units, f, (value: undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None))]; - s = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3]]); + const _106: rs.Slice = rs.sliceFrom(options); + const _107: rs.Slice = rs.sliceFrom(nested); + const _108: rs.Slice = rs.sliceFrom(flat); + [_106, _107, _108, rs.sliceFrom(units)] as [rs.Slice, rs.Slice, rs.Slice, rs.Slice]; + const _111: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_106), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)); + const _112: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_107), f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)); + const _113: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_108), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)); + const arg2 = rs.sliceFrom(units); + const args16 = [_111, _112, _113, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, (value: undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None))]; + s = rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); } else { const grid: Uint8Array[] = [Uint8Array.of(op, 1), Uint8Array.of(2, 3), Uint8Array.of(4, op)]; const flipped: Uint8Array[] = rs.arrayMap(grid, (row: Uint8Array): Uint8Array => { @@ -195,9 +228,16 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _124); } same2[_124][0] = same2[_124][0] ^ 128; - const _134: rs.u64[] = shifted$3(op); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(flipped, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(sums, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(same2, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(_134, f, rs.u64Debug)]; - s = rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4]]); + const _133: rs.Slice = rs.sliceFrom(shifted$3(op)); + const _135: rs.Slice = rs.sliceFrom(grid); + const _136: rs.Slice = rs.sliceFrom(flipped); + const _138: rs.Slice = rs.sliceFrom(same2); + [_133, _135, _136, rs.sliceFrom(sums), _138] as [rs.Slice, rs.Slice, rs.Slice, rs.Slice, rs.Slice]; + const _140: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_135), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const _141: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_136), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const arg = rs.sliceFrom(sums); + const args15 = [_140, _141, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_138), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_133), f, rs.u64Debug)]; + s = rs.fmtFormat([args15[0], " ", args15[1], " ", args15[2], " ", args15[3], " ", args15[4]]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); rs.byteVecPush(out, 10); @@ -236,13 +276,13 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const i: rs.usize = op as rs.usize; const _21: rs.u8 = rs.u8Rem(op, 6); if (_21 === 0) { - const _23: rs.Place[] = rs.arrayPlaces(rs.byteSliceView(rs.byteSliceFrom(bytes))); + const _23: rs.Place[] = rs.slicePlaces(rs.byteSliceFrom(bytes)); const _25: rs.usize = rs.usizeRem(i, 3); if (!(_25 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _25); } _23[_25].v = _23[_25].v ^ op; - const iter2: rs.Iter> = rs.iterSlice(rs.arrayPlaces(rs.byteSliceView(rs.byteSliceFrom(bytes)))); + const iter2: rs.Iter> = rs.iterSlice(rs.slicePlaces(rs.byteSliceFrom(bytes))); while (true) { const _32: rs.Place | rs.Done = iter2.next(); if (_32 === rs.DONE) { @@ -251,13 +291,13 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { _32.v = rs.u8WrappingAdd(_32.v, 1); } } else if (_21 === 1) { - const _40: rs.Place[] = rs.arrayPlaces(wide); + const _40: rs.Place[] = rs.slicePlaces(rs.sliceFrom(wide)); _40[0].v = rs.u16WrappingAdd(_40[0].v, ((op as rs.u16) << 7) & 0xffff); const swapped = _40[0].v; _40[0].v = _40[1].v; _40[1].v = swapped; } else if (_21 === 2) { - const _49: rs.Place[] = rs.arrayPlaces(words); + const _49: rs.Place[] = rs.slicePlaces(rs.sliceFrom(words)); const _51: rs.usize = rs.usizeRem(i, 2); if (!(_51 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _51); @@ -280,16 +320,16 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _71); } rs.byteSliceView(rows[_71]).reverse(); - const _78: rs.u32[][] = rs.arrayFrom(pairs); + const _78: rs.Slice[] = rs.arrayMap(pairs, rs.sliceFrom); const _80: rs.u32 = op as rs.u32; const _83: rs.usize = rs.usizeRem(i, 2); if (!(_83 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _83); } - _78[0][_83] = (_80 << 20) >>> 0; - rs.sliceCopyFromSlice(rs.sliceFrom(_78[1]), rs.sliceFrom([_78[0][1], op as rs.u32])); + _78[0].data[_78[0].start + _83] = (_80 << 20) >>> 0; + rs.sliceCopyFromSlice(_78[1], rs.sliceFrom([_78[0].data[_78[0].start + 1], op as rs.u32])); } else if (_21 === 4) { - rs.arrayPlaces(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of()))); + rs.slicePlaces(rs.byteSliceFrom(Uint8Array.of())); const iter3: rs.Iter> = rs.iterSlice([]); while (true) { const _99: rs.Place | rs.Done = iter3.next(); @@ -304,8 +344,8 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const rows2: Uint8Array = rs.bytesMap(rs.arrayMap(grid, rs.byteSliceFrom), (row: rs.ByteSlice): rs.u8 => { return row.data[row.start] ^ row.data[row.start + 1]; }); - const sums: rs.u32[] = rs.arrayMap(rs.arrayFrom(pairs), (pair: rs.u32[]): rs.u32 => { - return rs.u32WrappingAdd(pair[0], pair[1]); + const sums: rs.u32[] = rs.arrayMap(rs.arrayMap(pairs, rs.sliceFrom), (pair: rs.Slice): rs.u32 => { + return rs.u32WrappingAdd(pair.data[pair.start], pair.data[pair.start + 1]); }); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(lens)); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rows2)); @@ -317,15 +357,27 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const read: rs.u8[] = rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(bytes))); const wides: rs.u16[] = rs.arrayFrom(wide); - const _135: rs.u8[] = rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of()))); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wides, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(_135, f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); - } - } - [rs.byteSliceFrom(bytes), wide, words, grid, pairs] as [rs.ByteSlice, rs.u16[], string[], Uint8Array[], rs.u32[][]]; - const arg = rs.byteSliceFrom(bytes); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(pairs, f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]]))); + const _134: rs.Slice = rs.sliceFrom(rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of())))); + const _137: rs.Slice = rs.sliceFrom(read); + [_134, _137, rs.sliceFrom(wides)] as [rs.Slice, rs.Slice, rs.Slice]; + const _140: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_137), f, rs.u8Debug); + const arg = rs.sliceFrom(wides); + const args5 = [_140, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_134), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2]]))); + } + } + [rs.byteSliceFrom(bytes), rs.sliceFrom(wide), rs.sliceFrom(words), rs.sliceFrom(grid), rs.sliceFrom(pairs)] as [rs.ByteSlice, rs.Slice, rs.Slice, rs.Slice, rs.Slice]; + const arg2 = rs.byteSliceFrom(bytes); + const _158: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); + const arg3 = rs.sliceFrom(wide); + const _159: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.u16Debug); + const arg4 = rs.sliceFrom(words); + const _160: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg4), f, rs.fmtStr); + const arg5 = rs.sliceFrom(grid); + const _161: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg5), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const arg6 = rs.sliceFrom(pairs); + const args6 = [_158, _159, _160, _161, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg6), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4]]))); } /** @@ -398,7 +450,7 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceFill(rs.byteSliceFrom(Uint8Array.of()), op); rs.byteVecPush(out, rs.u8Add(rs.sliceFrom([]).length & 0xff, rs.byteSliceFrom(Uint8Array.of()).length & 0xff)); } else if (_22 === 6) { - written(rs.byteSliceFrom(bytes), wide, op); + written(rs.byteSliceFrom(bytes), rs.sliceFrom(wide), op); } else { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterSlice(wide), (_2: rs.u16): rs.u32 => { return _2 as rs.u32; @@ -413,18 +465,18 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const _155: rs.Slice = rs.sliceFrom(pairs); const _158: rs.Slice = rs.sliceFrom([]); const _161: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of()); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6]]))); + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " ", args3[5], " ", args3[6]]))); } /** Arrays lent by `&mut`, written through their slices. */ -export function written(bytes: rs.ByteSlice, wide: rs.u16[], op: rs.u8): void { +export function written(bytes: rs.ByteSlice, wide: rs.Slice, op: rs.u8): void { const s: rs.ByteSlice = bytes; rs.idx(s, 0); const _5: rs.u8 = rs.u8WrappingAdd(s.data[s.start], op); rs.idx(s, 3); s.data[s.start + 3] = _5; - const w: rs.Slice = rs.sliceFrom(wide); + const w: rs.Slice = wide; const _16: rs.u16 = op as rs.u16; rs.idx(w, 0); w.data[w.start] = _16; @@ -695,20 +747,18 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { put$0(out, rs.sliceFrom([copy$array_u8(b)])); const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; - const kind: string = "=="; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; - const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const args6 = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); - rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); + rs.assertFailed("==", (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), ["after ", args6[0]]); } } } @@ -812,20 +862,18 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { put$1(out, rs.sliceFrom([copy$array_u8(b)])); const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; - const kind: string = "=="; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; - const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const args6 = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); - rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); + rs.assertFailed("==", (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), ["after ", args6[0]]); } } } @@ -929,20 +977,18 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { put$3(out, rs.sliceFrom([copy$array_u8(b)])); const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; - const kind: string = "=="; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; - const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const args6 = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); - rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); + rs.assertFailed("==", (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), ["after ", args6[0]]); } } } @@ -1046,20 +1092,18 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { put$40(out, rs.sliceFrom([copy$array_u8(b)])); const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; - const kind: string = "=="; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; - const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const args6 = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); - rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); + rs.assertFailed("==", (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), ["after ", args6[0]]); } } } @@ -1084,8 +1128,7 @@ export function fields(data: rs.ByteSlice, out: rs.ByteVec): void { held.bytes[0] = held.bytes[0] ^ 16; put$3(out, rs.sliceFrom([copy$array_u8(a), old, copy$array_u8(held.bytes)])); const part = { _0: copy$array_u8(held.bytes) }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]; - const shown: string = rs.fmtFormat([args2[0]]); + const shown: string = rs.fmtFormat([(f: rs.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]); const _41: rs.ByteSlice = rs.byteSliceFrom(held.bytes); const taken2 = rs.byteSliceToArray(_41); _41.data.set(rs.bytes(3), _41.start); @@ -1097,12 +1140,10 @@ export function fields(data: rs.ByteSlice, out: rs.ByteVec): void { [rs.byteSliceFrom(old), rs.byteSliceFrom(a)] as [rs.ByteSlice, rs.ByteSlice]; if (rs.eqBytes(rs.byteSliceFrom(old), rs.byteSliceFrom(a))) { const arg = data.length; - const kind: string = "!="; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; - const _60: rs.Arguments | undefined = ["fields of ", args4[0]]; + const args6 = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; const arg2 = rs.byteSliceView(rs.byteSliceFrom(old)); const arg3 = rs.byteSliceView(rs.byteSliceFrom(a)); - rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _60); + rs.assertFailed("!=", (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), ["fields of ", args6[0]]); } } } @@ -1190,9 +1231,8 @@ export function flattened(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else { flattenedN$5(data, out); } - const part = [{ _0: bytesAt$3(data, 1) }, { _0: undefined }]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: Listed.Listed, f: rs.Formatter) => Listed.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + const part = rs.sliceFrom([{ _0: bytesAt$3(data, 1) }, { _0: undefined }]); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: Listed.Listed, f: rs.Formatter) => Listed.fmt$fmt_Debug(value, f))]))); } /** [`flattened`] of `N` bytes. */ @@ -1381,9 +1421,9 @@ export function flattenedN$0(data: rs.ByteSlice, out: rs.ByteVec): void { putOptions$0(out, rs.sliceFrom(options.items)); putSome$0(out, other); const copied: rs.Vec = rs.iterToVec(rs.iterCopied(rs.vecIntoIter(rs.iterToVec(rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 0)]), rs.byteSliceFrom), undefined, 4, true)), rs.byteSliceToArray), undefined, 0, true); - rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 0, true); + rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), (held) => rs.byteSliceToArray(held)), undefined, 0, true); const _289: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); - rs.iterExtend(copied, rs.iterMap(_289, rs.byteSliceToArray), "next", 0); + rs.iterExtend(copied, rs.iterMap(_289, (held2) => rs.byteSliceToArray(held2)), "next", 0); put$0(out, rs.sliceFrom(copied.items)); const nested: rs.Vec = rs.vecFrom(copy$array_Option_Option_array0_u8([undefined, rs.None, copy$Option_array0_u8(options.items[rs.idx(options.items, 0)]), bytesAt$0(data, 3), undefined]).map(copy$Option_Option_array0_u8)); const iter17: rs.Iter = rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); @@ -1425,9 +1465,9 @@ export function flattenedN$0(data: rs.ByteSlice, out: rs.ByteVec): void { const _373: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_374); }); - const iter21: rs.Iter = rs.iterFlatten(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array0_u8(_373); - })), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true, 2); + })), rs.sliceFrom), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true, 2); while (true) { const _381: rs.ByteSlice | rs.Done = iter21.next(); if (_381 === rs.DONE) { @@ -1630,9 +1670,9 @@ export function flattenedN$1(data: rs.ByteSlice, out: rs.ByteVec): void { putOptions$1(out, rs.sliceFrom(options.items)); putSome$1(out, other); const copied: rs.Vec = rs.iterToVec(rs.iterCopied(rs.vecIntoIter(rs.iterToVec(rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 0)]), rs.byteSliceFrom), undefined, 4, true)), rs.byteSliceToArray), undefined, 1, true); - rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 1, true); + rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), (held) => rs.byteSliceToArray(held)), undefined, 1, true); const _289: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); - rs.iterExtend(copied, rs.iterMap(_289, rs.byteSliceToArray), "next", 1); + rs.iterExtend(copied, rs.iterMap(_289, (held2) => rs.byteSliceToArray(held2)), "next", 1); put$1(out, rs.sliceFrom(copied.items)); const nested: rs.Vec = rs.vecFrom(copy$array_Option_Option_array1_u8([undefined, rs.None, copy$Option_array1_u8(options.items[rs.idx(options.items, 0)]), bytesAt$1(data, 3), undefined]).map(copy$Option_Option_array1_u8)); const iter17: rs.Iter = rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); @@ -1674,9 +1714,9 @@ export function flattenedN$1(data: rs.ByteSlice, out: rs.ByteVec): void { const _373: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_374); }); - const iter21: rs.Iter = rs.iterFlatten(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array1_u8(_373); - })), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true, 2); + })), rs.sliceFrom), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true, 2); while (true) { const _381: rs.ByteSlice | rs.Done = iter21.next(); if (_381 === rs.DONE) { @@ -1879,9 +1919,9 @@ export function flattenedN$5(data: rs.ByteSlice, out: rs.ByteVec): void { putOptions$5(out, rs.sliceFrom(options.items)); putSome$5(out, other); const copied: rs.Vec = rs.iterToVec(rs.iterCopied(rs.vecIntoIter(rs.iterToVec(rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 0)]), rs.byteSliceFrom), undefined, 4, true)), rs.byteSliceToArray), undefined, 5, true); - rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 5, true); + rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), (held) => rs.byteSliceToArray(held)), undefined, 5, true); const _289: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); - rs.iterExtend(copied, rs.iterMap(_289, rs.byteSliceToArray), "next", 5); + rs.iterExtend(copied, rs.iterMap(_289, (held2) => rs.byteSliceToArray(held2)), "next", 5); put$5(out, rs.sliceFrom(copied.items)); const nested: rs.Vec = rs.vecFrom(copy$array_Option_Option_array5_u8([undefined, rs.None, copy$Option_array5_u8(options.items[rs.idx(options.items, 0)]), bytesAt$5(data, 3), undefined]).map(copy$Option_Option_array5_u8)); const iter17: rs.Iter = rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); @@ -1923,9 +1963,9 @@ export function flattenedN$5(data: rs.ByteSlice, out: rs.ByteVec): void { const _373: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_374); }); - const iter21: rs.Iter = rs.iterFlatten(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array5_u8(_373); - })), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true, 2); + })), rs.sliceFrom), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true, 2); while (true) { const _381: rs.ByteSlice | rs.Done = iter21.next(); if (_381 === rs.DONE) { diff --git a/ts/fixtures/lang/arrays/expected/harness.ts b/ts/fixtures/lang/arrays/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/arrays/expected/harness.ts +++ b/ts/fixtures/lang/arrays/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/ascii/expected/ascii.ts b/ts/fixtures/lang/ascii/expected/ascii.ts index ef57202d7..7f8db8d59 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.ts @@ -58,8 +58,8 @@ export function steps$ascii_EscapeDefault(e: rs.Iter, data: rs.ByteSlice, if (next !== undefined) { rs.byteVecPush(out, next); let shown: string = ""; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f)]; - const written = rs.fmtWriteString(shown, [args2[0]]); + const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f)]; + const written = rs.fmtWriteString(shown, [args3[0]]); shown = written.s; rs.resultUnwrap(written.result, rs.fmtErrorDebug); put(out, shown); @@ -142,8 +142,8 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let shown: string = ""; const _113: rs.Iter = rs.escapeAscii(b3); const _115: rs.usize = rs.iterCount(e.clone()); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.fmtEscapeAscii(_113, f), (f: rs.Formatter) => rs.usizeDisplay(_115, f)]; - const written = rs.fmtWriteString(shown, [args2[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", args2[2]]); + const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.fmtEscapeAscii(_113, f), (f: rs.Formatter) => rs.usizeDisplay(_115, f)]; + const written = rs.fmtWriteString(shown, [args3[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args3[1]), "|", args3[2]]); shown = written.s; rs.resultUnwrap(written.result, rs.fmtErrorDebug); put(out, shown); @@ -292,8 +292,8 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const e: rs.Iter = rs.byteSliceEscapeAscii(data); put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f))); const _221: rs.usize = rs.iterCount(e.clone()); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.usizeDisplay(_221, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1]])); + const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.usizeDisplay(_221, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 40 }, args3[0]), "|", args3[1]])); rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(e.clone()), 255)); } else { diff --git a/ts/fixtures/lang/ascii/expected/harness.ts b/ts/fixtures/lang/ascii/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/ascii/expected/harness.ts +++ b/ts/fixtures/lang/ascii/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/atomics/expected/harness.ts b/ts/fixtures/lang/atomics/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/atomics/expected/harness.ts +++ b/ts/fixtures/lang/atomics/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/borrows/expected/borrows.Probe.ts b/ts/fixtures/lang/borrows/expected/borrows.Probe.ts index b9c8a1be8..87fc18830 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Probe.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Probe.ts @@ -28,8 +28,8 @@ export function fmt$fmt_Debug(self: Probe, f: rs.Formatter): rs.Result rs.fmtBool(shared, f), (f: rs.Formatter) => rs.fmtBool(exclusive, f), (f: rs.Formatter) => rs.fmtBool(_19, f)]; - const _0: rs.Result = rs.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2]]); + const args3 = [(f: rs.Formatter) => rs.fmtBool(shared, f), (f: rs.Formatter) => rs.fmtBool(exclusive, f), (f: rs.Formatter) => rs.fmtBool(_19, f)]; + const _0: rs.Result = rs.fmtWriteFmt(f, [args3[0], " ", args3[1], " ", args3[2]]); cell[Symbol.dispose](); return _0; } diff --git a/ts/fixtures/lang/borrows/expected/borrows.ts b/ts/fixtures/lang/borrows/expected/borrows.ts index b8b370277..4f3760045 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.ts @@ -177,8 +177,8 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, 254); } else { const part3 = new rs.BorrowMutError(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.borrowMutErrorDisplay(part3, f), (f: rs.Formatter) => rs.borrowMutErrorDebug(part3, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args5 = [(f: rs.Formatter) => rs.borrowMutErrorDisplay(part3, f), (f: rs.Formatter) => rs.borrowMutErrorDebug(part3, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); } if (_116.ok) { drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_116); @@ -191,8 +191,8 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, 254); } else { const part4 = new rs.BorrowError(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.borrowErrorDisplay(part4, f), (f: rs.Formatter) => rs.borrowErrorDebug(part4, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args6 = [(f: rs.Formatter) => rs.borrowErrorDisplay(part4, f), (f: rs.Formatter) => rs.borrowErrorDebug(part4, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1]]))); } if (_141.ok) { drop$Result_cell_Ref_Vec_u8_cell_BorrowError(_141); @@ -552,8 +552,8 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { })(rs.valuePlace(_376))); const _387: string = text3.value; const _390: rs.u32 = rs.u32Add(n4.value, 1); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _387), (f: rs.Formatter) => rs.u32Display(_390, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, _387), (f: rs.Formatter) => rs.u32Display(_390, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1]]))); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(borrowed$borrows_Parts(parts), borrowed$u32(number)))); drop$tuple2_cell_Ref_str_cell_RefMut_u32([text3, n4] as [rs.RefCell, rs.RefCell]); const _411: rs.RefCell = rs.refCellBorrowMut(parts); @@ -740,35 +740,33 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.byteSliceFrom(p4.quad); })(_186.value))); const n2: rs.RefCell = rs.refCellBorrow(number); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text.value), (f: rs.Formatter) => rs.fmtStr(text.value, f), (f: rs.Formatter) => rs.fmtList(quad.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(n2.value, f), (f: rs.Formatter) => rs.u32Display(n2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " [", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "] ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", args2[3], " ", rs.fmtSpec({ align: ">", width: 5 }, args2[4])]))); + const args13 = [(f: rs.Formatter) => rs.fmtPad(f, text.value), (f: rs.Formatter) => rs.fmtStr(text.value, f), (f: rs.Formatter) => rs.fmtList(quad.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(n2.value, f), (f: rs.Formatter) => rs.u32Display(n2.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args13[0], " ", args13[1], " [", rs.fmtSpec({ align: ">", width: 4 }, args13[0]), "] ", args13[2], " ", rs.fmtSpec({ alternate: true }, args13[3]), " ", args13[3], " ", rs.fmtSpec({ align: ">", width: 5 }, args13[4])]))); drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32([text, quad, n2] as [rs.RefCell, rs.RefCell, rs.RefCell]); const _211: rs.RefCell = rs.refCellBorrowMut(parts); const maybe: rs.RefCell = rs.refMutMap(_211, ((p5: Parts.Parts): rs.Place => { return rs.place(() => p5.maybe, (value2) => p5.maybe = value2); })(_211.value)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(maybe.value, f, rs.u16Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0])]))); + const args14 = [(f: rs.Formatter) => rs.fmtOption(maybe.value, f, rs.u16Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0])]))); rs.refMutRelease(maybe); const _227: rs.RefCell = rs.refCellBorrowMut(parts); const bytes2: rs.RefCell = rs.refMutMap(_227, rs.partPlace(((p6: Parts.Parts): rs.ByteVec => { return p6.bytes; })(_227.value))); const _237: rs.RefCell = rs.refCellBorrowMut(number); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(_237.value, f)]; - const _233: string = rs.fmtFormat([args6[0], " ", args6[1]]); + const args15 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(_237.value, f)]; + const _233: string = rs.fmtFormat([args15[0], " ", args15[1]]); rs.refMutRelease(_237); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_233)); rs.refMutRelease(bytes2); const pair: rs.RefCell<[rs.u8, string]> = new rs.RefCell([op, "pair"] as [rs.u8, string]); const _256: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_256.value[0], f), (f: rs.Formatter) => rs.fmtStr(_256.value[1], f)], f)]; - const _252: string = rs.fmtFormat([args8[0], " "]); + const _252: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_256.value[0], f), (f: rs.Formatter) => rs.fmtStr(_256.value[1], f)], f), " "]); rs.refRelease(_256); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_252)); const _270: rs.RefCell<[rs.u8, string]> = rs.refCellBorrowMut(pair); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_270.value[0], f), (f: rs.Formatter) => rs.fmtStr(_270.value[1], f)], f)]; - const _266: string = rs.fmtFormat([rs.fmtSpec({ alternate: true }, args10[0])]); + const _266: string = rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_270.value[0], f), (f: rs.Formatter) => rs.fmtStr(_270.value[1], f)], f))]); rs.refMutRelease(_270); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_266)); const _277: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); @@ -778,8 +776,7 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { } return rs.Ok(p7[1]); })(_277.value)); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried4, f, (value: rs.RefCell, f: rs.Formatter) => rs.fmtStr(value.value, f), (value: [rs.RefCell<[rs.u8, string]>, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0].value[0], f), (f: rs.Formatter) => rs.fmtStr(value[0].value[1], f)], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried4, f, (value: rs.RefCell, f: rs.Formatter) => rs.fmtStr(value.value, f), (value: [rs.RefCell<[rs.u8, string]>, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0].value[0], f), (f: rs.Formatter) => rs.fmtStr(value[0].value[1], f)], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]))); drop$Result_cell_Ref_ref_str_tuple2_cell_Ref_tuple2_u8_ref_str_u8(tried4); } else { const _291: rs.u8 = op >> 4; @@ -1091,48 +1088,47 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { const _30: rs.RefCell = rs.refCellBorrowMut(number); _30.value = rs.u32Add(_30.value, _27); rs.refMutRelease(_30); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; - const free: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); + const args40 = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; + const free: string = rs.fmtFormat([args40[0], " ", rs.fmtSpec({ alternate: true }, args40[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args40[0])]); const shared: rs.RefCell = rs.refCellBorrow(number); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; - const read: string = rs.fmtFormat([args4[0]]); + const read: string = rs.fmtFormat([(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]); rs.refRelease(shared); const _held: rs.RefCell = rs.refCellBorrowMut(number); const dynamic: rs.Fmt = (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, read), (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug), (f: rs.Formatter) => dynamic(f)]; - text = rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", rs.fmtSpec({ alternate: true }, args6[2]), " ", rs.fmtSpec({ align: ">", width: 16 }, args6[2]), " ", args6[3]]); + const args42 = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, read), (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug), (f: rs.Formatter) => dynamic(f)]; + text = rs.fmtFormat([args42[0], " ", args42[1], " ", args42[2], " ", rs.fmtSpec({ alternate: true }, args42[2]), " ", rs.fmtSpec({ align: ">", width: 16 }, args42[2]), " ", args42[3]]); rs.refMutRelease(_held); } else if (_25 === 1) { const _75: rs.RefCell>> = rs.refCellBorrowMut(nested); const _77: rs.RefCell = new rs.RefCell(thenSome$0quywni(rs.u8Rem(v, 3) !== 0, v)); _75.value.items.push(_77); rs.refMutRelease(_75); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; - const free2: string = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0])]); + const args38 = [(f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; + const free2: string = rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0])]); const cells: rs.RefCell>> = rs.refCellBorrow(nested); const _95: rs.Vec> = cells.value; const _inner: rs.RefCell = rs.refCellBorrowMut(_95.items[rs.idx(_95.items, rs.usizeSub(cells.value.items.length, 1))]); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; - text = rs.fmtFormat([args10[0], " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1])]); + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; + text = rs.fmtFormat([args39[0], " ", args39[1], " ", rs.fmtSpec({ alternate: true }, args39[1])]); rs.refMutRelease(_inner); rs.refRelease(cells); } else if (_25 === 2) { const outer: rs.RefCell> = new rs.RefCell(new rs.RefCell(v)); const shared2: rs.RefCell> = rs.refCellBorrow(outer); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(shared2.value, f, rs.u8Debug)]; - const free3: string = rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]); + const args35 = [(f: rs.Formatter) => rs.refCellDebug(shared2.value, f, rs.u8Debug)]; + const free3: string = rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0])]); rs.refRelease(shared2); const exclusive: rs.RefCell> = rs.refCellBorrowMut(outer); const inner: rs.RefCell = rs.refCellBorrowMut(exclusive.value); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(outer, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.u8Debug(inner.value, f)]; - const held: string = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", args14[1], " ", args14[2]]); + const args36 = [(f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(outer, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.u8Debug(inner.value, f)]; + const held: string = rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0]), " ", args36[1], " ", args36[2]]); rs.refMutRelease(inner); const _146: rs.RefCell>> = rs.refCellBorrow(nested); const last: rs.RefCell> = rs.refMap(_146, ((n: rs.Vec>): rs.RefCell => { return n.items[rs.idx(n.items, 0)]; })(_146.value)); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free3), (f: rs.Formatter) => rs.fmtPad(f, held), (f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(last.value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - text = rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); + const args37 = [(f: rs.Formatter) => rs.fmtPad(f, free3), (f: rs.Formatter) => rs.fmtPad(f, held), (f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(last.value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + text = rs.fmtFormat([args37[0], " ", args37[1], " ", args37[2], " ", args37[3]]); rs.refRelease(last); rs.refMutRelease(exclusive); } else if (_25 === 3) { @@ -1141,36 +1137,36 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.Cell = new rs.Cell(rs.u64Shl(v as rs.u64, 56)); const maybe: rs.Cell = new rs.Cell(thenSome$0quywni(rs.u8Rem(v, 2) === 0, v)); const _184: rs.Cell = new rs.Cell(undefined); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.cellDebug(() => pair.v, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f)), (f: rs.Formatter) => rs.cellDebug(() => wide.v, f, rs.u64Debug), (f: rs.Formatter) => rs.cellDebug(() => maybe.v, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.cellDebug(() => _184.v, f, rs.fmtUnit)]; - text = rs.fmtFormat([args18[0], " ", rs.fmtSpec({ alternate: true }, args18[0]), " ", args18[1], " ", args18[2], " ", rs.fmtSpec({ alternate: true }, args18[2]), " ", args18[3], " ", rs.fmtSpec({ align: ">", width: 3 }, args18[0])]); + const args34 = [(f: rs.Formatter) => rs.cellDebug(() => pair.v, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f)), (f: rs.Formatter) => rs.cellDebug(() => wide.v, f, rs.u64Debug), (f: rs.Formatter) => rs.cellDebug(() => maybe.v, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.cellDebug(() => _184.v, f, rs.fmtUnit)]; + text = rs.fmtFormat([args34[0], " ", rs.fmtSpec({ alternate: true }, args34[0]), " ", args34[1], " ", args34[2], " ", rs.fmtSpec({ alternate: true }, args34[2]), " ", args34[3], " ", rs.fmtSpec({ align: ">", width: 3 }, args34[0])]); } else if (_25 === 4) { rs.cellSet(shown.cell, v); const _204: rs.RefCell = rs.refCellBorrowMut(shown.refcell); rs.byteVecPush(_204.value, v); rs.refMutRelease(_204); - const args20: rs.Fmt[] = [(f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; - const free4: string = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])]); + const args32 = [(f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; + const free4: string = rs.fmtFormat([args32[0], " ", rs.fmtSpec({ alternate: true }, args32[0])]); const _held2: rs.RefCell = rs.refCellBorrowMut(shown.refcell); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free4), (f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; - text = rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ alternate: true }, args22[1])]); + const args33 = [(f: rs.Formatter) => rs.fmtPad(f, free4), (f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; + text = rs.fmtFormat([args33[0], " ", args33[1], " ", rs.fmtSpec({ alternate: true }, args33[1])]); rs.refMutRelease(_held2); } else if (_25 === 5) { new rs.Cell(v); const inRefcell: rs.RefCell> = new rs.RefCell(new rs.Cell(v)); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "UnsafeCell")), (f: rs.Formatter) => rs.refCellDebug(inRefcell, f, (value: rs.Cell, f: rs.Formatter) => rs.cellDebug(() => value.v, f, rs.u8Debug))]; - text = rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[0]), " ", args24[1], " ", rs.fmtSpec({ alternate: true }, args24[1])]); + const args31 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "UnsafeCell")), (f: rs.Formatter) => rs.refCellDebug(inRefcell, f, (value: rs.Cell, f: rs.Formatter) => rs.cellDebug(() => value.v, f, rs.u8Debug))]; + text = rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", args31[1], " ", rs.fmtSpec({ alternate: true }, args31[1])]); } else if (_25 === 6) { const probe: rs.Arc> = rs.arcNewCyclic((me: rs.Weak>): rs.RefCell => { return new rs.RefCell(new Probe.Probe(rs.weakClone(me))); }); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(probe.value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f))]; - text = rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0])]); + const args30 = [(f: rs.Formatter) => rs.refCellDebug(probe.value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f))]; + text = rs.fmtFormat([args30[0], " ", rs.fmtSpec({ alternate: true }, args30[0])]); probe[Symbol.dispose](); } else { const _253: rs.RefCell = new rs.RefCell("s"); const _256: rs.RefCell = new rs.RefCell(rs.bytes(2).fill(v)); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(_253, f, rs.fmtStr), (f: rs.Formatter) => rs.refCellDebug(_256, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - text = rs.fmtFormat([args28[0], " ", args28[1]]); + const args29 = [(f: rs.Formatter) => rs.refCellDebug(_253, f, rs.fmtStr), (f: rs.Formatter) => rs.refCellDebug(_256, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + text = rs.fmtFormat([args29[0], " ", args29[1]]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } diff --git a/ts/fixtures/lang/borrows/expected/harness.ts b/ts/fixtures/lang/borrows/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/borrows/expected/harness.ts +++ b/ts/fixtures/lang/borrows/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/bounds/expected/harness.ts b/ts/fixtures/lang/bounds/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/bounds/expected/harness.ts +++ b/ts/fixtures/lang/bounds/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index 4e658fad8..67f0459c4 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -220,8 +220,8 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.byteSliceView(a).includes(0) ? 1 : 0); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceFirst(a), 170)); const _261: rs.ByteSlice = rs.byteSliceFrom(new Uint8Array(0)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_261), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + const args9 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_261), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args9[0], "|", args9[1], "|", args9[2]])); } else if (_15 === 2) { const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_24: rs.u8): rs.u16 => { return rs.u16Mul(_24 as rs.u16, 257); @@ -261,8 +261,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.eqSlice(rs.same)(collected2, cloned2) ? 1 : 0); rs.byteVecPush(out, rs.cmpSlice(rs.cmp)(collected2, cloned2) & 0xff); rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_slice_u16(collected2), hash$slice_u16(collected2)) ? 1 : 0); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected2), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected2), f, rs.u16Debug)])); const v3: rs.Vec = rs.vecFrom(rs.sliceItems(fromVec2)); v3.items.push(5); wides(rs.sliceFrom(v3.items), out); @@ -424,8 +423,8 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, fromRef4 === into2 ? 1 : 0); rs.byteVecPush(out, rs.cmpStr(collected4, fromRef4) & 0xff); rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_str(fromRef4), hash$str(s)) ? 1 : 0); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, fromRef4), (f: rs.Formatter) => rs.fmtStr(collected4, f)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1]])); + const args7 = [(f: rs.Formatter) => rs.fmtPad(f, fromRef4), (f: rs.Formatter) => rs.fmtStr(collected4, f)]; + put(out, rs.fmtFormat([args7[0], "|", args7[1]])); let back2: string = into2; back2 = back2 + "!"; put(out, back2); diff --git a/ts/fixtures/lang/boxes/expected/harness.ts b/ts/fixtures/lang/boxes/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/boxes/expected/harness.ts +++ b/ts/fixtures/lang/boxes/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 20d5badc3..d9a28c9d8 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -141,9 +141,11 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d rs.vecTruncate(v, 0); } else if (_39 === 14) { const keep: () => boolean = alternate(); - rs.vecRetain(v, (_28: rs.u64[]): boolean => { + const _101: rs.Vec = v; + const _102: (a0: rs.Slice) => boolean = (_28: rs.Slice): boolean => { return keep(); - }); + }; + rs.vecRetain(_101, (held4) => _102(rs.sliceFrom(held4))); } else if (_39 === 15) { rs.drop(rs.vecDrain(v, { end: rs.min(v.items.length, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 16) { @@ -152,9 +154,9 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d v = rs.vecFrom(v.items); } else if (_39 === 18) { const keep2: () => boolean = alternate(); - v = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_27: rs.u64[]): boolean => { + v = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), rs.lending((_27: rs.Slice): boolean => { return keep2(); - }), "next", 1280, false, 1280); + }, (f2) => (held3) => f2(rs.sliceFrom(held3)))), "next", 1280, false, 1280); } else if (_39 === 19) { const it: rs.Iter = rs.vecIntoIter(v); const _129: rs.u8 = rs.u8Rem(arg, 8); @@ -198,9 +200,11 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else if (_39 === 24) { v = rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$array_u64); } else if (_39 === 25) { - rs.vecPopIf(v, (_26: rs.u64[]): boolean => { + const _205: rs.Vec = v; + const _206: (a0: rs.Slice) => boolean = (_26: rs.Slice): boolean => { return rs.u8Rem(arg, 2) === 1; - }); + }; + rs.vecPopIf(_205, (held2) => _206(rs.sliceFrom(held2))); } else if (_39 === 26) { v = rs.slicesJoin(rs.sliceFrom([rs.vecFrom(v.items.map(copy$array_u64)), v]), 1280, undefined, rs.vecSlice, copy$array_u64); } else if (_39 === 27) { @@ -282,9 +286,9 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } } else if (_39 === 36) { const keep3: () => boolean = alternate(); - rs.ownedCount(rs.iterTake(rs.vecExtractIf(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), (_23: rs.u64[]): boolean => { + rs.ownedCount(rs.iterTake(rs.vecExtractIf(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), rs.lending((_23: rs.Slice): boolean => { return keep3(); - }), rs.u8Rem(arg, 5) as rs.usize)); + }, (f) => (held) => f(rs.sliceFrom(held)))), rs.u8Rem(arg, 5) as rs.usize)); } else if (_39 === 37) { const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 2560); const iter4: rs.Iter> = rs.sliceChunksExact(rs.sliceFrom(v.items), 2); @@ -294,9 +298,9 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d break; } rs.idx(_392, 0); - const _399: rs.u64[] = copy$array_u64(copy$array_u64(_392.data[_392.start])); + const _399: rs.u64[] = copy$array_u64(_392.data[_392.start].slice()); rs.idx(_392, 1); - const _398: rs.u64[][] = [_399, copy$array_u64(copy$array_u64(_392.data[_392.start + 1]))]; + const _398: rs.u64[][] = [_399, copy$array_u64(_392.data[_392.start + 1].slice())]; pairs.items.push(_398); } const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 1280); @@ -310,8 +314,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else { tried = rs.vecTryReserveExact(v, additional2, 1280); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 1280)); } @@ -552,8 +555,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } else { tried = rs.vecTryReserveExact(v, additional2, 16); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 16)); } @@ -794,8 +796,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n } else { tried = rs.vecTryReserveExact(v, additional2, 2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 2)); } @@ -1034,8 +1035,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu } else { tried = rs.byteVecTryReserveExact(v, additional2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, v.length, v.data.length); } @@ -1285,8 +1285,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.vecTryReserveExact(v, additional2, 0); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 0)); } @@ -1354,9 +1353,9 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 return v; } const j: rs.u8 = _192; - const _243: rs.Vec = v; + const _247: rs.Vec = v; const _25: rs.u64[] = copy$array_u64(make(j)); - _243.items.push(_25); + _247.items.push(_25); } }; const source: (a0: rs.usize) => rs.Vec = (i3: rs.usize): rs.Vec => { @@ -1376,8 +1375,7 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 }), undefined, 12, true); }; const array: rs.Vec[] = [held(0), held(1)]; - const _28: rs.Vec[] = [source(2), source(3)]; - rs.arrayCloneFrom(array, _28, (a0: rs.Vec): rs.Vec => { + rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.map(copy$array_u64)); }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); const part3 = rs.sliceFrom(array); @@ -1465,19 +1463,17 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 _17(part18, out); let deep: rs.Vec[] | undefined = [held(52)]; const _256: rs.Vec[] | undefined = [source(53)]; - deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec[]): rs.Vec[] => { - return a011.map((a012: rs.Vec): rs.Vec => { - return ((a013: rs.Vec): rs.Vec => { - return rs.vecFrom(a013.items.map(copy$array_u64)); - })(a012); - }); - }, undefined, rs.arrayCloneFromFn((a014: rs.Vec): rs.Vec => { - return ((a015: rs.Vec): rs.Vec => { - return rs.vecFrom(a015.items.map(copy$array_u64)); - })(a014); + deep = rs.optionCloneFrom(deep, _256, (a: rs.Vec[]) => a.map((a011: rs.Vec): rs.Vec => { + return ((a012: rs.Vec): rs.Vec => { + return rs.vecFrom(a012.items.map(copy$array_u64)); + })(a011); + }), undefined, rs.arrayCloneFromFn((a013: rs.Vec): rs.Vec => { + return ((a014: rs.Vec): rs.Vec => { + return rs.vecFrom(a014.items.map(copy$array_u64)); + })(a013); }, undefined, rs.vecCloneFromFn(1280, copy$array_u64))); - const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$1n6i7tn(deep, (_27: rs.Vec[]): rs.Vec => { - return _27[0]; + const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$1n6i7tn(deep, (_211: rs.Vec[]): rs.Vec => { + return _211[0]; })), undefined, 12, true).items); _17(part19, out); const part20 = len(54); @@ -1486,8 +1482,8 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 const part21 = len(58); const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); - rs.listCloneFrom(list, _282, (a016: rs.Vec): rs.Vec => { - return rs.vecFrom(a016.items.map(copy$array_u64)); + rs.listCloneFrom(list, _282, (a015: rs.Vec): rs.Vec => { + return rs.vecFrom(a015.items.map(copy$array_u64)); }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); const part22 = rs.sliceFrom(rs.iterToVec(rs.listIter(list), undefined, 12, true).items); _17(part22, out); @@ -1495,8 +1491,8 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; - rs.dequeCloneFrom(deque, _308, (a017: rs.Vec): rs.Vec => { - return rs.vecFrom(a017.items.map(copy$array_u64)); + rs.dequeCloneFrom(deque, _308, (a016: rs.Vec): rs.Vec => { + return rs.vecFrom(a016.items.map(copy$array_u64)); }); const part25 = rs.sliceFrom(rs.dequeToVec(deque).items); _17(part25, out); @@ -1506,20 +1502,18 @@ export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8 const part26 = rs.sliceFrom([heap]); _17(part26, out); const heaps: rs.BinaryHeap[] = [rs.heapFrom(held(72), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)))]; - const _349: rs.BinaryHeap[] = [rs.heapFrom(source(73), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)))]; - rs.arrayCloneFrom(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { - return rs.heapClone(a018, copy$array_u64); + rs.sliceCloneFromSlice(rs.sliceFrom(heaps), rs.sliceFrom([rs.heapFrom(source(73), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)))]), (a017: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a017, copy$array_u64); }, undefined, rs.heapCloneFromFn(1280, copy$array_u64)); put(out, rs.vecCapacity(heaps[0], 1280)); const deques: rs.VecDeque[] = [rs.dequeFromVec(held(74), 1280) as rs.VecDeque]; - const _367: rs.VecDeque[] = [rs.dequeFromVec(source(75), 1280) as rs.VecDeque]; - rs.arrayCloneFrom(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { - return rs.dequeClone(a019, copy$array_u64); + rs.sliceCloneFromSlice(rs.sliceFrom(deques), rs.sliceFrom([rs.dequeFromVec(source(75), 1280) as rs.VecDeque]), (a018: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a018, copy$array_u64); }, undefined, rs.dequeCloneFromFn(copy$array_u64)); put(out, rs.dequeCapacity(deques[0])); let pair: [rs.Vec, rs.u8] = [held(76), 0]; - pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a020: rs.Vec): rs.Vec => { - return rs.vecFrom(a020.items.map(copy$array_u64)); + pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a019: rs.Vec): rs.Vec => { + return rs.vecFrom(a019.items.map(copy$array_u64)); }, undefined]); let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_array160_u64(new Holds.Holds(source(79))); @@ -1557,9 +1551,9 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u return v; } const j: rs.u8 = _192; - const _243: rs.Vec<[rs.u64, rs.u8]> = v; + const _247: rs.Vec<[rs.u64, rs.u8]> = v; const _25: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(j)); - _243.items.push(_25); + _247.items.push(_25); } }; const source: (a0: rs.usize) => rs.Vec<[rs.u64, rs.u8]> = (i3: rs.usize): rs.Vec<[rs.u64, rs.u8]> => { @@ -1579,8 +1573,7 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u }), undefined, 12, true); }; const array: rs.Vec<[rs.u64, rs.u8]>[] = [held(0), held(1)]; - const _28: rs.Vec<[rs.u64, rs.u8]>[] = [source(2), source(3)]; - rs.arrayCloneFrom(array, _28, (a0: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { return rs.vecFrom(a0.items.map(copy$tuple2_u64_u8)); }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); const part3 = rs.sliceFrom(array); @@ -1668,19 +1661,17 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u _17(part18, out); let deep: rs.Vec<[rs.u64, rs.u8]>[] | undefined = [held(52)]; const _256: rs.Vec<[rs.u64, rs.u8]>[] | undefined = [source(53)]; - deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec<[rs.u64, rs.u8]>[]): rs.Vec<[rs.u64, rs.u8]>[] => { - return a011.map((a012: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { - return ((a013: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { - return rs.vecFrom(a013.items.map(copy$tuple2_u64_u8)); - })(a012); - }); - }, undefined, rs.arrayCloneFromFn((a014: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { - return ((a015: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { - return rs.vecFrom(a015.items.map(copy$tuple2_u64_u8)); - })(a014); + deep = rs.optionCloneFrom(deep, _256, (a: rs.Vec<[rs.u64, rs.u8]>[]) => a.map((a011: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return ((a012: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a012.items.map(copy$tuple2_u64_u8)); + })(a011); + }), undefined, rs.arrayCloneFromFn((a013: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return ((a014: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a014.items.map(copy$tuple2_u64_u8)); + })(a013); }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8))); - const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$12r4ivp(deep, (_27: rs.Vec<[rs.u64, rs.u8]>[]): rs.Vec<[rs.u64, rs.u8]> => { - return _27[0]; + const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$12r4ivp(deep, (_211: rs.Vec<[rs.u64, rs.u8]>[]): rs.Vec<[rs.u64, rs.u8]> => { + return _211[0]; })), undefined, 12, true).items); _17(part19, out); const part20 = len(54); @@ -1689,8 +1680,8 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u const part21 = len(58); const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); - rs.listCloneFrom(list, _282, (a016: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { - return rs.vecFrom(a016.items.map(copy$tuple2_u64_u8)); + rs.listCloneFrom(list, _282, (a015: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a015.items.map(copy$tuple2_u64_u8)); }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); const part22 = rs.sliceFrom(rs.iterToVec(rs.listIter(list), undefined, 12, true).items); _17(part22, out); @@ -1698,8 +1689,8 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; - rs.dequeCloneFrom(deque, _308, (a017: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { - return rs.vecFrom(a017.items.map(copy$tuple2_u64_u8)); + rs.dequeCloneFrom(deque, _308, (a016: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a016.items.map(copy$tuple2_u64_u8)); }); const part25 = rs.sliceFrom(rs.dequeToVec(deque).items); _17(part25, out); @@ -1709,20 +1700,18 @@ export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u const part26 = rs.sliceFrom([heap]); _17(part26, out); const heaps: rs.BinaryHeap<[rs.u64, rs.u8]>[] = [rs.heapFrom(held(72), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])))]; - const _349: rs.BinaryHeap<[rs.u64, rs.u8]>[] = [rs.heapFrom(source(73), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])))]; - rs.arrayCloneFrom(heaps, _349, (a018: rs.BinaryHeap<[rs.u64, rs.u8]>): rs.BinaryHeap<[rs.u64, rs.u8]> => { - return rs.heapClone(a018, copy$tuple2_u64_u8); + rs.sliceCloneFromSlice(rs.sliceFrom(heaps), rs.sliceFrom([rs.heapFrom(source(73), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])))]), (a017: rs.BinaryHeap<[rs.u64, rs.u8]>): rs.BinaryHeap<[rs.u64, rs.u8]> => { + return rs.heapClone(a017, copy$tuple2_u64_u8); }, undefined, rs.heapCloneFromFn(16, copy$tuple2_u64_u8)); put(out, rs.vecCapacity(heaps[0], 16)); const deques: rs.VecDeque<[rs.u64, rs.u8]>[] = [rs.dequeFromVec(held(74), 16) as rs.VecDeque<[rs.u64, rs.u8]>]; - const _367: rs.VecDeque<[rs.u64, rs.u8]>[] = [rs.dequeFromVec(source(75), 16) as rs.VecDeque<[rs.u64, rs.u8]>]; - rs.arrayCloneFrom(deques, _367, (a019: rs.VecDeque<[rs.u64, rs.u8]>): rs.VecDeque<[rs.u64, rs.u8]> => { - return rs.dequeClone(a019, copy$tuple2_u64_u8); + rs.sliceCloneFromSlice(rs.sliceFrom(deques), rs.sliceFrom([rs.dequeFromVec(source(75), 16) as rs.VecDeque<[rs.u64, rs.u8]>]), (a018: rs.VecDeque<[rs.u64, rs.u8]>): rs.VecDeque<[rs.u64, rs.u8]> => { + return rs.dequeClone(a018, copy$tuple2_u64_u8); }, undefined, rs.dequeCloneFromFn(copy$tuple2_u64_u8)); put(out, rs.dequeCapacity(deques[0])); let pair: [rs.Vec<[rs.u64, rs.u8]>, rs.u8] = [held(76), 0]; - pair = rs.tupleClone([source(77), 1] as [rs.Vec<[rs.u64, rs.u8]>, rs.u8], [(a020: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { - return rs.vecFrom(a020.items.map(copy$tuple2_u64_u8)); + pair = rs.tupleClone([source(77), 1] as [rs.Vec<[rs.u64, rs.u8]>, rs.u8], [(a019: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a019.items.map(copy$tuple2_u64_u8)); }, undefined]); let holder: Holds.Holds<[rs.u64, rs.u8]> = new Holds.Holds(held(78)); holder = Holds.clone$Clone_tuple2_u64_u8(new Holds.Holds(source(79))); @@ -1760,9 +1749,9 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u return v; } const j: rs.u8 = _192; - const _243: rs.Vec = v; + const _247: rs.Vec = v; const _25: rs.u16 = make(j); - _243.items.push(_25); + _247.items.push(_25); } }; const source: (a0: rs.usize) => rs.Vec = (i3: rs.usize): rs.Vec => { @@ -1782,8 +1771,7 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u }), undefined, 12, true); }; const array: rs.Vec[] = [held(0), held(1)]; - const _28: rs.Vec[] = [source(2), source(3)]; - rs.arrayCloneFrom(array, _28, (a0: rs.Vec): rs.Vec => { + rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.slice()); }, undefined, rs.vecCloneFromFn(2)); const part3 = rs.sliceFrom(array); @@ -1871,19 +1859,17 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u _17(part18, out); let deep: rs.Vec[] | undefined = [held(52)]; const _256: rs.Vec[] | undefined = [source(53)]; - deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec[]): rs.Vec[] => { - return a011.map((a012: rs.Vec): rs.Vec => { - return ((a013: rs.Vec): rs.Vec => { - return rs.vecFrom(a013.items.slice()); - })(a012); - }); - }, undefined, rs.arrayCloneFromFn((a014: rs.Vec): rs.Vec => { - return ((a015: rs.Vec): rs.Vec => { - return rs.vecFrom(a015.items.slice()); - })(a014); + deep = rs.optionCloneFrom(deep, _256, (a: rs.Vec[]) => a.map((a011: rs.Vec): rs.Vec => { + return ((a012: rs.Vec): rs.Vec => { + return rs.vecFrom(a012.items.slice()); + })(a011); + }), undefined, rs.arrayCloneFromFn((a013: rs.Vec): rs.Vec => { + return ((a014: rs.Vec): rs.Vec => { + return rs.vecFrom(a014.items.slice()); + })(a013); }, undefined, rs.vecCloneFromFn(2))); - const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$03x2fqt(deep, (_27: rs.Vec[]): rs.Vec => { - return _27[0]; + const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$03x2fqt(deep, (_211: rs.Vec[]): rs.Vec => { + return _211[0]; })), undefined, 12, true).items); _17(part19, out); const part20 = len(54); @@ -1892,8 +1878,8 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u const part21 = len(58); const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); - rs.listCloneFrom(list, _282, (a016: rs.Vec): rs.Vec => { - return rs.vecFrom(a016.items.slice()); + rs.listCloneFrom(list, _282, (a015: rs.Vec): rs.Vec => { + return rs.vecFrom(a015.items.slice()); }, undefined, rs.vecCloneFromFn(2)); const part22 = rs.sliceFrom(rs.iterToVec(rs.listIter(list), undefined, 12, true).items); _17(part22, out); @@ -1901,8 +1887,8 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; - rs.dequeCloneFrom(deque, _308, (a017: rs.Vec): rs.Vec => { - return rs.vecFrom(a017.items.slice()); + rs.dequeCloneFrom(deque, _308, (a016: rs.Vec): rs.Vec => { + return rs.vecFrom(a016.items.slice()); }); const part25 = rs.sliceFrom(rs.dequeToVec(deque).items); _17(part25, out); @@ -1912,20 +1898,18 @@ export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u const part26 = rs.sliceFrom([heap]); _17(part26, out); const heaps: rs.BinaryHeap[] = [rs.heapFrom(held(72), rs.le, rs.ge, rs.lt)]; - const _349: rs.BinaryHeap[] = [rs.heapFrom(source(73), rs.le, rs.ge, rs.lt)]; - rs.arrayCloneFrom(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { - return rs.heapClone(a018, undefined); + rs.sliceCloneFromSlice(rs.sliceFrom(heaps), rs.sliceFrom([rs.heapFrom(source(73), rs.le, rs.ge, rs.lt)]), (a017: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a017, undefined); }, undefined, rs.heapCloneFromFn(2)); put(out, rs.vecCapacity(heaps[0], 2)); const deques: rs.VecDeque[] = [rs.dequeFromVec(held(74), 2) as rs.VecDeque]; - const _367: rs.VecDeque[] = [rs.dequeFromVec(source(75), 2) as rs.VecDeque]; - rs.arrayCloneFrom(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { - return rs.dequeClone(a019); + rs.sliceCloneFromSlice(rs.sliceFrom(deques), rs.sliceFrom([rs.dequeFromVec(source(75), 2) as rs.VecDeque]), (a018: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a018); }, undefined, rs.dequeCloneFromFn()); put(out, rs.dequeCapacity(deques[0])); let pair: [rs.Vec, rs.u8] = [held(76), 0]; - pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a020: rs.Vec): rs.Vec => { - return rs.vecFrom(a020.items.slice()); + pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a019: rs.Vec): rs.Vec => { + return rs.vecFrom(a019.items.slice()); }, undefined]); let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_u16(new Holds.Holds(source(79))); @@ -1982,8 +1966,7 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 }), undefined, 12, true); }; const array: rs.ByteVec[] = [held(0), held(1)]; - const _28: rs.ByteVec[] = [source(2), source(3)]; - rs.arrayCloneFrom(array, _28, (a0: rs.ByteVec): rs.ByteVec => { + rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.ByteVec): rs.ByteVec => { return rs.byteVecFrom(rs.byteVecView(a0)); }, undefined, rs.byteVecCloneFromFn()); const part3 = rs.sliceFrom(array); @@ -2071,19 +2054,17 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 _17(part18, out); let deep: rs.ByteVec[] | undefined = [held(52)]; const _256: rs.ByteVec[] | undefined = [source(53)]; - deep = rs.optionCloneFrom(deep, _256, (a011: rs.ByteVec[]): rs.ByteVec[] => { - return a011.map((a012: rs.ByteVec): rs.ByteVec => { - return ((a013: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a013)); - })(a012); - }); - }, undefined, rs.arrayCloneFromFn((a014: rs.ByteVec): rs.ByteVec => { - return ((a015: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a015)); - })(a014); + deep = rs.optionCloneFrom(deep, _256, (a: rs.ByteVec[]) => a.map((a011: rs.ByteVec): rs.ByteVec => { + return ((a012: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a012)); + })(a011); + }), undefined, rs.arrayCloneFromFn((a013: rs.ByteVec): rs.ByteVec => { + return ((a014: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a014)); + })(a013); }, undefined, rs.byteVecCloneFromFn())); - const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$1o9z3sm(deep, (_27: rs.ByteVec[]): rs.ByteVec => { - return _27[0]; + const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$1o9z3sm(deep, (_211: rs.ByteVec[]): rs.ByteVec => { + return _211[0]; })), undefined, 12, true).items); _17(part19, out); const part20 = len(54); @@ -2092,8 +2073,8 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 const part21 = len(58); const _283: rs.Iter = rs.vecIntoIter(sources(59, part21)); const _282: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _283); - rs.listCloneFrom(list, _282, (a016: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a016)); + rs.listCloneFrom(list, _282, (a015: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a015)); }, undefined, rs.byteVecCloneFromFn()); const part22 = rs.sliceFrom(rs.iterToVec(rs.listIter(list), undefined, 12, true).items); _17(part22, out); @@ -2101,8 +2082,8 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 const deque: rs.VecDeque = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque; const part24 = len(66); const _308: rs.VecDeque = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque; - rs.dequeCloneFrom(deque, _308, (a017: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a017)); + rs.dequeCloneFrom(deque, _308, (a016: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a016)); }); const part25 = rs.sliceFrom(rs.dequeToVec(deque).items); _17(part25, out); @@ -2112,20 +2093,18 @@ export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 const part26 = rs.sliceFrom([rs.byteVecFromVec(heap)]); _17(part26, out); const heaps: rs.BinaryHeap[] = [rs.heapFrom(rs.byteVecToVec(held(72)), rs.le, rs.ge, rs.lt)]; - const _349: rs.BinaryHeap[] = [rs.heapFrom(rs.byteVecToVec(source(73)), rs.le, rs.ge, rs.lt)]; - rs.arrayCloneFrom(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { - return rs.heapClone(a018, undefined); + rs.sliceCloneFromSlice(rs.sliceFrom(heaps), rs.sliceFrom([rs.heapFrom(rs.byteVecToVec(source(73)), rs.le, rs.ge, rs.lt)]), (a017: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a017, undefined); }, undefined, rs.heapCloneFromFn(1)); put(out, rs.vecCapacity(heaps[0], 1)); const deques: rs.VecDeque[] = [rs.dequeFromVec(rs.byteVecToVec(held(74)), 1, true) as rs.VecDeque]; - const _367: rs.VecDeque[] = [rs.dequeFromVec(rs.byteVecToVec(source(75)), 1, true) as rs.VecDeque]; - rs.arrayCloneFrom(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { - return rs.dequeClone(a019); + rs.sliceCloneFromSlice(rs.sliceFrom(deques), rs.sliceFrom([rs.dequeFromVec(rs.byteVecToVec(source(75)), 1, true) as rs.VecDeque]), (a018: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a018); }, undefined, rs.dequeCloneFromFn()); put(out, rs.dequeCapacity(deques[0])); let pair: [rs.ByteVec, rs.u8] = [held(76), 0]; - pair = rs.tupleClone([source(77), 1] as [rs.ByteVec, rs.u8], [(a020: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a020)); + pair = rs.tupleClone([source(77), 1] as [rs.ByteVec, rs.u8], [(a019: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a019)); }, undefined]); let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_u8(new Holds.Holds(source(79))); @@ -2163,9 +2142,9 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und return v; } const j: rs.u8 = _192; - const _243: rs.Vec = v; + const _247: rs.Vec = v; make(j); - _243.items.push(undefined); + _247.items.push(undefined); } }; const source: (a0: rs.usize) => rs.Vec = (i3: rs.usize): rs.Vec => { @@ -2185,8 +2164,7 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und }), undefined, 12, true); }; const array: rs.Vec[] = [held(0), held(1)]; - const _28: rs.Vec[] = [source(2), source(3)]; - rs.arrayCloneFrom(array, _28, (a0: rs.Vec): rs.Vec => { + rs.sliceCloneFromSlice(rs.sliceFrom(array), rs.sliceFrom([source(2), source(3)]), (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.slice()); }, undefined, rs.vecCloneFromFn(0)); const part3 = rs.sliceFrom(array); @@ -2274,16 +2252,14 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und _17(part18, out); let deep: rs.Vec[] | undefined = [held(52)]; const _256: rs.Vec[] | undefined = [source(53)]; - deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec[]): rs.Vec[] => { - return a011.map((a012: rs.Vec): rs.Vec => { - return ((a013: rs.Vec): rs.Vec => { - return rs.vecFrom(a013.items.slice()); - })(a012); - }); - }, undefined, rs.arrayCloneFromFn((a014: rs.Vec): rs.Vec => { - return ((a015: rs.Vec): rs.Vec => { - return rs.vecFrom(a015.items.slice()); - })(a014); + deep = rs.optionCloneFrom(deep, _256, (a: rs.Vec[]) => a.map((a011: rs.Vec): rs.Vec => { + return ((a012: rs.Vec): rs.Vec => { + return rs.vecFrom(a012.items.slice()); + })(a011); + }), undefined, rs.arrayCloneFromFn((a013: rs.Vec): rs.Vec => { + return ((a014: rs.Vec): rs.Vec => { + return rs.vecFrom(a014.items.slice()); + })(a013); }, undefined, rs.vecCloneFromFn(0))); const part19 = rs.sliceFrom(rs.iterToVec(rs.iterOption(option_map$1d4d0v7(deep, (_25: rs.Vec[]): rs.Vec => { return _25[0]; @@ -2295,8 +2271,8 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und const part21 = len(58); const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); - rs.listCloneFrom(list, _282, (a016: rs.Vec): rs.Vec => { - return rs.vecFrom(a016.items.slice()); + rs.listCloneFrom(list, _282, (a015: rs.Vec): rs.Vec => { + return rs.vecFrom(a015.items.slice()); }, undefined, rs.vecCloneFromFn(0)); const part22 = rs.sliceFrom(rs.iterToVec(rs.listIter(list), undefined, 12, true).items); _17(part22, out); @@ -2304,8 +2280,8 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; - rs.dequeCloneFrom(deque, _308, (a017: rs.Vec): rs.Vec => { - return rs.vecFrom(a017.items.slice()); + rs.dequeCloneFrom(deque, _308, (a016: rs.Vec): rs.Vec => { + return rs.vecFrom(a016.items.slice()); }); const part25 = rs.sliceFrom(rs.dequeToVec(deque).items); _17(part25, out); @@ -2315,20 +2291,18 @@ export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => und const part26 = rs.sliceFrom([heap]); _17(part26, out); const heaps: rs.BinaryHeap[] = [rs.heapFrom(held(72), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing))]; - const _349: rs.BinaryHeap[] = [rs.heapFrom(source(73), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing))]; - rs.arrayCloneFrom(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { - return rs.heapClone(a018, undefined); + rs.sliceCloneFromSlice(rs.sliceFrom(heaps), rs.sliceFrom([rs.heapFrom(source(73), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing))]), (a017: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a017, undefined); }, undefined, rs.heapCloneFromFn(0)); put(out, rs.vecCapacity(heaps[0], 0)); const deques: rs.VecDeque[] = [rs.dequeFromVec(held(74), 0) as rs.VecDeque]; - const _367: rs.VecDeque[] = [rs.dequeFromVec(source(75), 0) as rs.VecDeque]; - rs.arrayCloneFrom(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { - return rs.dequeClone(a019); + rs.sliceCloneFromSlice(rs.sliceFrom(deques), rs.sliceFrom([rs.dequeFromVec(source(75), 0) as rs.VecDeque]), (a018: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a018); }, undefined, rs.dequeCloneFromFn()); put(out, rs.dequeCapacity(deques[0])); let pair: [rs.Vec, rs.u8] = [held(76), 0]; - pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a020: rs.Vec): rs.Vec => { - return rs.vecFrom(a020.items.slice()); + pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a019: rs.Vec): rs.Vec => { + return rs.vecFrom(a019.items.slice()); }, undefined]); let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_unit(new Holds.Holds(source(79))); @@ -2423,9 +2397,11 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, rs.dequeClear(q); } else if (_39 === 13) { const keep: () => boolean = alternate(); - rs.dequeRetain(q, (_26: rs.u64[]): boolean => { + const _95: rs.VecDeque = q; + const _96: (a0: rs.Slice) => boolean = (_26: rs.Slice): boolean => { return keep(); - }); + }; + rs.dequeRetain(_95, (held2) => _96(rs.sliceFrom(held2))); } else if (_39 === 14) { rs.drop(rs.dequeDrain(q, { end: rs.min(q.n, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 15) { @@ -2436,9 +2412,9 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, q = rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 1280, true), 1280) as rs.VecDeque; } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.dequeIntoIter(q), (_25: rs.u64[]): boolean => { + q = rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.dequeIntoIter(q), rs.lending((_25: rs.Slice): boolean => { return keep2(); - }), "next", 1280), 1280) as rs.VecDeque; + }, (f) => (held) => f(rs.sliceFrom(held)))), "next", 1280), 1280) as rs.VecDeque; } else if (_39 === 19) { const it: rs.Iter = rs.dequeIntoIter(q); const _127: rs.u8 = rs.u8Rem(arg, 4); @@ -2490,8 +2466,7 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, } else { tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2625,8 +2600,7 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number } else { tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2760,8 +2734,7 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2895,8 +2868,7 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -3042,8 +3014,7 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen } else { tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -3138,7 +3109,7 @@ export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, const top: rs.PeekMut = _78; const _82: rs.u64[] = copy$array_u64(make(arg)); rs.peekMutDerefMut(top); - Object.assign(top.v, _82); + rs.sliceSet(rs.sliceFrom(top.v), _82); } } else if (_40 === 12) { h = rs.heapFrom(h, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); @@ -3149,8 +3120,7 @@ export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, } else { tried = rs.vecTryReserveExact(h, additional2, 1280); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 1280)); } @@ -3232,8 +3202,7 @@ export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } else { tried = rs.vecTryReserveExact(h, additional2, 16); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 16)); } @@ -3315,8 +3284,7 @@ export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.vecTryReserveExact(h, additional2, 2); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 2)); } @@ -3398,8 +3366,7 @@ export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: n } else { tried = rs.vecTryReserveExact(h, additional2, 1); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 1)); } @@ -3483,8 +3450,7 @@ export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.vecTryReserveExact(h, additional2, 0); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 0)); } @@ -3700,8 +3666,7 @@ export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const i: rs.usize = _180[0]; const tried: rs.Result = _180[1][0]; const n: rs.usize = _180[1][1]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); if (!tried.ok) { if (!(i < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i); diff --git a/ts/fixtures/lang/capacity/expected/harness.ts b/ts/fixtures/lang/capacity/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/capacity/expected/harness.ts +++ b/ts/fixtures/lang/capacity/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/captures/expected/harness.ts b/ts/fixtures/lang/captures/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/captures/expected/harness.ts +++ b/ts/fixtures/lang/captures/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/cells/expected/cells.ts b/ts/fixtures/lang/cells/expected/cells.ts index f192a9337..c995eff90 100644 --- a/ts/fixtures/lang/cells/expected/cells.ts +++ b/ts/fixtures/lang/cells/expected/cells.ts @@ -88,8 +88,7 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { @@ -126,17 +125,16 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num let inner3: string = ""; const _125: rs.OnceCell = cell; const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]); return make(v2); }, undefined, rs.None); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -276,8 +274,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: string = rs.onceGetOrInit(cell, (): string => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -314,17 +311,16 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num let inner3: string = ""; const _125: rs.OnceCell = cell; const t7: string = rs.onceGetOrInit(cell, (): string => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtStr)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtStr)]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -458,8 +454,7 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -496,17 +491,16 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number let inner3: string = ""; const _125: rs.OnceCell = cell; const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u64Debug)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u64Debug)]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -646,8 +640,7 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -684,17 +677,16 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, let inner3: string = ""; const _125: rs.OnceCell = cell; const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u8Debug)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u8Debug)]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -831,8 +823,7 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: undefined = rs.onceGetOrInit(cell, (): undefined => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { @@ -869,17 +860,16 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe let inner3: string = ""; const _125: rs.OnceCell = cell; const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtUnit, rs.None)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtUnit, rs.None)]); make(v2); }, undefined, rs.None); put(out, t4); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -1014,8 +1004,7 @@ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -1056,17 +1045,16 @@ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number let inner3: string = ""; const _125: rs.OnceCell = cell; const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -1228,8 +1216,7 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { @@ -1266,17 +1253,16 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num let inner3: string = ""; const _125: rs.OnceLock = cell; const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]); return make(v2); }, undefined, rs.None); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -1416,8 +1402,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: string = rs.onceGetOrInit(cell, (): string => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -1454,17 +1439,16 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num let inner3: string = ""; const _125: rs.OnceLock = cell; const t7: string = rs.onceGetOrInit(cell, (): string => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtStr)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtStr)]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -1598,8 +1582,7 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -1636,17 +1619,16 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number let inner3: string = ""; const _125: rs.OnceLock = cell; const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u64Debug)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u64Debug)]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -1786,8 +1768,7 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -1824,17 +1805,16 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, let inner3: string = ""; const _125: rs.OnceLock = cell; const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u8Debug)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u8Debug)]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -1971,8 +1951,7 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: undefined = rs.onceGetOrInit(cell, (): undefined => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { @@ -2009,17 +1988,16 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe let inner3: string = ""; const _125: rs.OnceLock = cell; const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtUnit, rs.None)]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtUnit, rs.None)]); make(v2); }, undefined, rs.None); put(out, t4); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { @@ -2154,8 +2132,7 @@ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { const _76: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; - rs.panicFmt(["init ", args8[0]]); + rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); } else if (_18 === 8) { @@ -2196,17 +2173,16 @@ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number let inner3: string = ""; const _125: rs.OnceLock = cell; const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; - inner3 = rs.fmtFormat([args6[0]]); + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; - text = rs.fmtFormat([args2[0], " ", args2[1]]); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; - text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { diff --git a/ts/fixtures/lang/cells/expected/harness.ts b/ts/fixtures/lang/cells/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/cells/expected/harness.ts +++ b/ts/fixtures/lang/cells/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/chars/expected/chars.ts b/ts/fixtures/lang/chars/expected/chars.ts index a6990c3a5..a31f6de8a 100644 --- a/ts/fixtures/lang/chars/expected/chars.ts +++ b/ts/fixtures/lang/chars/expected/chars.ts @@ -127,8 +127,8 @@ export function chars(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _140 of scalars(data).items) { const _144: rs.char | undefined = rs.charFromU32(_140); if (_144 !== undefined) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(_144, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 2 }, args2[0])])); + const args5 = [(f: rs.Formatter) => rs.fmtCharDisplay(_144, f)]; + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 3 }, args5[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 4 }, args5[0]), "|", rs.fmtSpec({ align: "<", width: 2 }, args5[0])])); } } const iter6: rs.Iter = rs.iterSlice([97, 39, 34, 92, 10, 0, 127, 233, 769, 173, 57344, 128512, 65438, 65439, 4447, 4448, 12644, 65440]); @@ -137,8 +137,8 @@ export function chars(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_161 === rs.DONE) { break; } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(_161, f), (f: rs.Formatter) => rs.fmtCharDisplay(_161, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args4[0]), "|", args4[1]])); + const args6 = [(f: rs.Formatter) => rs.fmtCharDebug(_161, f), (f: rs.Formatter) => rs.fmtCharDisplay(_161, f)]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", args6[1]])); } } } @@ -195,8 +195,8 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug")]; + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -206,22 +206,22 @@ export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): vo const copy: rs.Iter = it.clone(); const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault")]; + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -231,22 +231,22 @@ export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): const copy: rs.Iter = it.clone(); const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode")]; + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -256,22 +256,22 @@ export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): const copy: rs.Iter = it.clone(); const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase")]; + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -281,22 +281,22 @@ export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): vo const copy: rs.Iter = it.clone(); const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase")]; + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -306,16 +306,16 @@ export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): vo const copy: rs.Iter = it.clone(); const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); const rest: string = rs.stringExtendChars("", it); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]])); } /** @@ -342,8 +342,8 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _36: rs.char | undefined = rs.iterToOption(up.nextBack()); const _39: rs.char | undefined = rs.iterToOption(up.next()); const _42: rs.usize = up.len(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_36, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtOption(_39, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(up, f), (f: rs.Formatter) => rs.fmtCharsDebug(up, f, "ToUppercase"), (f: rs.Formatter) => rs.usizeDisplay(_42, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(_36, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtOption(_39, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(up, f), (f: rs.Formatter) => rs.fmtCharsDebug(up, f, "ToUppercase"), (f: rs.Formatter) => rs.usizeDisplay(_42, f)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3], "|", args3[4]])); } else if (_15 === 2) { walk$char_EscapeUnicode(out, rs.charEscapeUnicode(c)); } else if (_15 === 3) { @@ -374,8 +374,8 @@ export function encodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const bytes: Uint8Array = rs.bytes(4).fill(170); const s: rs.Place = rs.charEncodeUtf8(c, rs.byteSliceFrom(bytes)); const _34: rs.usize = rs.stringLen(s.v); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.usizeDisplay(_34, f), (f: rs.Formatter) => rs.fmtStr(s.v, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.usizeDisplay(_34, f), (f: rs.Formatter) => rs.fmtStr(s.v, f)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2]])); s.v = rs.strToAsciiUppercase(s.v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); const units: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { @@ -445,8 +445,8 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(r.value as rs.u32))); } else { const e: rs.DecodeUtf16Error = r.error; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtDecodeUtf16ErrorDebug)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2]])); + const args5 = [(f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtDecodeUtf16ErrorDebug)]; + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", args5[2]])); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(e.code))); const _79: rs.DecodeUtf16Error | undefined = last; const _82: rs.DecodeUtf16Error | undefined = e; @@ -463,8 +463,8 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const lossy: string = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { return result_unwrapOr$1yj84xe(r3, 63); })); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, lossy)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1]])); + const args6 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, lossy)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1]])); } /** @@ -484,8 +484,7 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void break; } const part3 = rs.charFromDigit(_11, radix); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtCharDebug)])); } } else if (_6 === 1) { const iter2: rs.Iter = rs.iterSlice([48, 57, 97, 122, 65, 90, 47, 58, 64, 91, 96, 123, 1635, 65345]); @@ -499,12 +498,11 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else { for (const n2 of scalars(data).items) { const r: rs.Result = rs.charTryFrom(n2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtCharTryFromErrorDebug)]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtCharTryFromErrorDebug)])); if (!r.ok) { const part = new rs.CharTryFromError(); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharTryFromErrorDisplay(part, f), (f: rs.Formatter) => rs.fmtCharTryFromErrorDebug(part, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args6[0]), "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1])])); + const args12 = [(f: rs.Formatter) => rs.fmtCharTryFromErrorDisplay(part, f), (f: rs.Formatter) => rs.fmtCharTryFromErrorDebug(part, f)]; + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args12[0]), "|", args12[1], "|", rs.fmtSpec({ alternate: true }, args12[1])])); const _78: rs.CharTryFromError = new rs.CharTryFromError(); rs.byteVecPush(out, convert_eq$1efmo6b(new rs.CharTryFromError(), _78) ? 1 : 0); } @@ -516,15 +514,15 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const w: rs.Result = _85[1]; const _96: rs.u64 = c2 as rs.u64; const _98: rs.u128 = c2 as rs.u128; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(b, f, rs.u8Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.fmtResult(w, f, rs.u16Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.u64Display(_96, f), (f: rs.Formatter) => rs.u128Display(_98, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); + const args13 = [(f: rs.Formatter) => rs.fmtResult(b, f, rs.u8Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.fmtResult(w, f, rs.u16Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.u64Display(_96, f), (f: rs.Formatter) => rs.u128Display(_98, f)]; + put(out, rs.fmtFormat([args13[0], "|", args13[1], "|", args13[2], "|", args13[3]])); const _109: rs.Result = result_map$1q32zo4(b, (a0: rs.u8): rs.u16 => { return a0 as rs.u16; }); if (!result_and$02o4suw(w, _109).ok) { const part2 = new rs.TryFromCharError(); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromCharErrorDisplay(part2, f), (f: rs.Formatter) => rs.fmtTryFromCharErrorDebug(part2, f)]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args10[0]), "|", args10[1], "|", rs.fmtSpec({ alternate: true }, args10[1])])); + const args14 = [(f: rs.Formatter) => rs.fmtTryFromCharErrorDisplay(part2, f), (f: rs.Formatter) => rs.fmtTryFromCharErrorDebug(part2, f)]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[1])])); const _130: rs.TryFromCharError = new rs.TryFromCharError(); rs.byteVecPush(out, char_eq$1g188ap(new rs.TryFromCharError(), _130) ? 1 : 0); } @@ -549,18 +547,16 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _21: string = rs.strTrimMatches(s2, (a012: rs.char): boolean => { return rs.charIsNumeric(a012); }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(parts.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(_21, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + const args13 = [(f: rs.Formatter) => rs.fmtList(parts.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(_21, f)]; + put(out, rs.fmtFormat([args13[0], "|", args13[1]])); const part = rs.strFind(s2, (a013: rs.char): boolean => { return rs.charIsUppercase(a013); }); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.usizeDebug)])); const part2 = rs.strRfind(s2, (a014: rs.char): boolean => { return rs.charIsControl(a014); }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, rs.usizeDebug)])); } else if (_9 === 1) { const lens: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a07: rs.char): rs.usize => { return rs.charLenUtf8(a07); @@ -574,8 +570,8 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const lower: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { return rs.charToLowercase(a010); }, undefined, true)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper), (f: rs.Formatter) => rs.fmtPad(f, lower)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); + const args12 = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper), (f: rs.Formatter) => rs.fmtPad(f, lower)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", args12[3]])); } else { const escaped: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { return rs.charEscapeDefault(a0); @@ -590,8 +586,8 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), (e2: rs.Iter): rs.usize => { return e2.len(); }), "next", 4); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, escaped), (f: rs.Formatter) => rs.fmtPad(f, debug), (f: rs.Formatter) => rs.fmtList(unicode.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtPad(f, escaped), (f: rs.Formatter) => rs.fmtPad(f, debug), (f: rs.Formatter) => rs.fmtList(unicode.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterAll(rs.strChars(s2), (a04: rs.char): boolean => { return rs.charIsAlphanumeric(a04); }), rs.iterAny(rs.strChars(s2), (a05: rs.char): boolean => { diff --git a/ts/fixtures/lang/chars/expected/harness.ts b/ts/fixtures/lang/chars/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/chars/expected/harness.ts +++ b/ts/fixtures/lang/chars/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/chunks/expected/chunks.ts b/ts/fixtures/lang/chunks/expected/chunks.ts index 2f05fbe8e..33392c25d 100644 --- a/ts/fixtures/lang/chunks/expected/chunks.ts +++ b/ts/fixtures/lang/chunks/expected/chunks.ts @@ -148,12 +148,12 @@ export function chunks(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecExtendFromSlice(out, chosen2); rs.byteVecPush(out, chosen2.data[chosen2.start + 1]); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chosen2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(lit), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chosen2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(lit), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (data.length >= 3) { const chunk2: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, 3); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args6 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1]]))); } } else if (_4 === 4) { const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Uint8Array => { diff --git a/ts/fixtures/lang/chunks/expected/harness.ts b/ts/fixtures/lang/chunks/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/chunks/expected/harness.ts +++ b/ts/fixtures/lang/chunks/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/clones/expected/clones.Fussy.ts b/ts/fixtures/lang/clones/expected/clones.Fussy.ts index 58beb24cf..4bebbfbae 100644 --- a/ts/fixtures/lang/clones/expected/clones.Fussy.ts +++ b/ts/fixtures/lang/clones/expected/clones.Fussy.ts @@ -12,8 +12,7 @@ export function clone$Clone(self: Fussy): Fussy { return { _0: self._0 }; } const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - rs.panicFmt(["cloning ", args2[0]]); + rs.panicFmt(["cloning ", (f: rs.Formatter) => rs.u8Display(arg, f)]); } //# sourceMappingURL=clones.Fussy.ts.map diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index 68e4a7db6..bddd7d194 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -7622,8 +7622,8 @@ export function closures(data: rs.ByteSlice, plan: Plan.Plan, out: rs.ByteVec): } /** `x` cloned where only its bound says it clones. */ -export function cloned$array2_clones_Logged(x: Logged.Logged[]): Logged.Logged[] { - return x.map(Logged.clone$Clone); +export function cloned$array2_clones_Logged(x: rs.Slice): Logged.Logged[] { + return rs.sliceItems(x).map(Logged.clone$Clone); } /** @@ -7633,6 +7633,7 @@ export function cloned$array2_clones_Logged(x: Logged.Logged[]): Logged.Logged[] * a derived `Clone`, a `Vec`, and a generic function clone theirs. */ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let a!: Logged.Logged[]; const _13: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a3: rs.Slice, out2: rs.ByteVec): undefined => { rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a3)), Logged.id), undefined, true); }; @@ -7648,7 +7649,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; const _14: rs.u8 = rs.u8Rem(kind, 8); if (_14 === 0) { - const a: Logged.Logged[] = three(); + a = three(); const b: Logged.Logged[] = a.map(Logged.clone$Clone); flush(log.value, out); const part32 = rs.sliceFrom(b); @@ -7671,7 +7672,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _60: Logged.Logged = logged(part25); const part26 = at(5); const b2: Logged.Logged[] = [_54, _60, logged(part26)]; - rs.arrayCloneFrom(a2, b2, Logged.clone$Clone, rs.drop); + rs.sliceCloneFromSlice(rs.sliceFrom(a2), rs.sliceFrom(b2), Logged.clone$Clone, rs.drop); flush(log.value, out); const part27 = rs.sliceFrom(a2); _13(part27, out); @@ -7681,7 +7682,8 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _90: Logged.Logged = logged(part29); const part30 = at(8); const c2: Logged.Logged[] = [_84, _90, logged(part30)]; - rs.arrayCloneFrom(c2, b2, Logged.clone$Clone, rs.drop); + const _103: rs.Slice = rs.sliceFrom(b2); + rs.sliceCloneFromSlice(rs.sliceFrom(c2), _103, Logged.clone$Clone, rs.drop); flush(log.value, out); const part31 = rs.sliceFrom(c2); _13(part31, out); @@ -7698,7 +7700,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Logged.Logged[] | undefined = _137[1]; flush(log.value, out); rs.byteVecPush(out, y === undefined ? 1 : 0); - const part23 = rs.sliceFrom(rs.optionUnwrap(x)); + const part23 = rs.optionUnwrap(rs.optionMap(x, rs.sliceFrom)); _13(part23, out); rs.dropAll(some); flush(log.value, out); @@ -7714,9 +7716,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _178: string = "t"; const part15 = at(2); const tuple: [Logged.Logged[], string, Logged.Logged] = [_165, _178, logged(part15)]; - const copy: [Logged.Logged[], string, Logged.Logged] = rs.tupleClone(tuple, [(a05: Logged.Logged[]): Logged.Logged[] => { - return a05.map(Logged.clone$Clone); - }, undefined, Logged.clone$Clone]); + const copy: [Logged.Logged[], string, Logged.Logged] = rs.tupleClone(tuple, [(a: Logged.Logged[]) => a.map(Logged.clone$Clone), undefined, Logged.clone$Clone]); flush(log.value, out); const part16 = rs.sliceFrom(copy[0]); _13(part16, out); @@ -7727,8 +7727,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const part18 = at(4); const _200: Logged.Logged[] = [_201, logged(part18)]; const part19 = at(5); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part19, f)]; - const pair: Pair.Pair = new Pair.Pair(_200, rs.fmtFormat([args2[0]])); + const pair: Pair.Pair = new Pair.Pair(_200, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(part19, f)])); const other: Pair.Pair = Pair.clone$Clone(pair); flush(log.value, out); const part20 = rs.sliceFrom(other.left); @@ -7747,9 +7746,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _263: Logged.Logged = logged(part10); const part11 = at(3); const grid: Logged.Logged[][] = [_249, [_263, logged(part11)]]; - const copy2: Logged.Logged[][] = grid.map((a03: Logged.Logged[]): Logged.Logged[] => { - return a03.map(Logged.clone$Clone); - }); + const copy2: Logged.Logged[][] = grid.map((a: Logged.Logged[]) => a.map(Logged.clone$Clone)); flush(log.value, out); rs.dropAll(grid, drop$array2_clones_Logged); flush(log.value, out); @@ -7758,8 +7755,8 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _295: rs.u8 = at(4); const words: string[] = ["a", rs.fmtToString((f: rs.Formatter) => rs.u8Display(_295, f)), ""]; const vecs: rs.ByteVec[] = [rs.byteSliceToByteVec(data), rs.byteVecFrom(Uint8Array.of(at(5)))]; - const _308: [string[], rs.ByteVec[]] = [words.slice(), vecs.map((a04: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a04)); + const _308: [string[], rs.ByteVec[]] = [words.slice(), vecs.map((a02: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a02)); })]; const words2: string[] = _308[0]; const vecs2: rs.ByteVec[] = _308[1]; @@ -7777,15 +7774,13 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _351: Logged.Logged = logged(part6); const part7 = at(3); const rows: rs.Vec = rs.vecFrom([_337, [_351, logged(part7)]]); - const copy3: rs.Vec = rs.vecFrom(rows.items.map((a0: Logged.Logged[]): Logged.Logged[] => { - return a0.map(Logged.clone$Clone); - })); + const copy3: rs.Vec = rs.vecFrom(rows.items.map((a: Logged.Logged[]) => a.map(Logged.clone$Clone))); flush(log.value, out); - const generic: Logged.Logged[] = cloned$array2_clones_Logged(copy3.items[rs.idx(copy3.items, 0)]); + const generic: Logged.Logged[] = cloned$array2_clones_Logged(rs.sliceFrom(copy3.items[rs.idx(copy3.items, 0)])); flush(log.value, out); let sum: rs.u8 = 0; - const iter: rs.Iter = rs.iterMap(rs.iterSlice(rows.items), (a02: Logged.Logged[]): Logged.Logged[] => { - return a02.map(Logged.clone$Clone); + const iter: rs.Iter = rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.sliceFrom), (a0: rs.Slice): Logged.Logged[] => { + return rs.sliceItems(a0).map(Logged.clone$Clone); }); while (true) { const _381: Logged.Logged[] | rs.Done = iter.next(); @@ -7814,9 +7809,10 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * elements it keeps, and extends, and a slice's of arrays clones each over its own. */ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let a!: Logged.Logged[] | undefined; let _156!: rs.usize; - const _14: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a6: rs.Slice, out2: rs.ByteVec): undefined => { - rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a6)), Logged.id), undefined, true); + const _14: (a0: rs.Slice, a1: rs.ByteVec) => undefined = (a7: rs.Slice, out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(rs.sliceItems(a7)), Logged.id), undefined, true); }; const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { @@ -7840,12 +7836,10 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo return [logged(at(i13)), logged(at(rs.usizeAdd(i13, 1)))]; }); }; - let a: Logged.Logged[] | undefined = pick(0); + a = pick(0); const b: Logged.Logged[] | undefined = pick(2); flush(log.value, out); - a = rs.optionCloneFrom(a, b, (a013: Logged.Logged[]): Logged.Logged[] => { - return a013.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + a = rs.optionCloneFrom(a, b, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); rs.byteVecPush(out, a !== undefined ? 1 : 0); if (a !== undefined) { @@ -7853,9 +7847,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo _14(part57, out); } let c: Logged.Logged[] | undefined = pick(4); - c = rs.optionCloneFrom(c, a, (a014: Logged.Logged[]): Logged.Logged[] => { - return a014.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + c = rs.optionCloneFrom(c, a, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged([a, b, c] as [Logged.Logged[] | undefined, Logged.Logged[] | undefined, Logged.Logged[] | undefined]); flush(log.value, out); @@ -7865,32 +7857,32 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo return row(i12, len(i12)); }); }; - let a2: rs.Vec | undefined = pick2(0); + let a3: rs.Vec | undefined = pick2(0); const b2: rs.Vec | undefined = pick2(4); flush(log.value, out); - a2 = rs.optionCloneFrom(a2, b2, (a012: rs.Vec): rs.Vec => { - return rs.vecFrom(a012.items.map(Logged.clone$Clone)); + a3 = rs.optionCloneFrom(a3, b2, (a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); - if (a2 !== undefined) { - const part53 = rs.sliceFrom(a2.items); + if (a3 !== undefined) { + const part53 = rs.sliceFrom(a3.items); _14(part53, out); } - drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged([a2, b2] as [rs.Vec | undefined, rs.Vec | undefined]); + drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged([a3, b2] as [rs.Vec | undefined, rs.Vec | undefined]); flush(log.value, out); } else if (_15 === 2) { const part45 = len(0); - const a3: rs.Vec = row(0, part45); + const a4: rs.Vec = row(0, part45); const _101: rs.usize = len(1); - rs.vecReserve(a3, _101, 8); + rs.vecReserve(a4, _101, 8); const part46 = len(4); const b3: rs.Vec = row(4, part46); flush(log.value, out); - rs.vecCloneFrom(a3, b3, 8, Logged.clone$Clone, rs.drop); + rs.vecCloneFrom(a4, b3, 8, Logged.clone$Clone, rs.drop); flush(log.value, out); - const part47 = rs.sliceFrom(a3.items); + const part47 = rs.sliceFrom(a4.items); _14(part47, out); - rs.byteVecPush(out, rs.vecCapacity(a3, 8) & 0xff); + rs.byteVecPush(out, rs.vecCapacity(a4, 8) & 0xff); const part48 = len(8); const c2: rs.Vec = row(8, part48); rs.vecCloneFrom(c2, b3, 8, Logged.clone$Clone, rs.drop); @@ -7898,7 +7890,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const part49 = rs.sliceFrom(c2.items); _14(part49, out); const _146: rs.Slice = rs.sliceFrom(b3.items); - rs.vecCloneFrom(a3, _146, 8, Logged.clone$Clone, rs.drop); + rs.vecCloneFrom(a4, _146, 8, Logged.clone$Clone, rs.drop); flush(log.value, out); const d: rs.Vec = new rs.Vec(); let iterStart: rs.usize = 0; @@ -7912,7 +7904,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo flush(log.value, out); rs.byteVecPush(out, rs.vecCapacity(d, 8) & 0xff); rs.dropVec(d); - drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged([a3, b3, c2] as [rs.Vec, rs.Vec, rs.Vec]); + drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged([a4, b3, c2] as [rs.Vec, rs.Vec, rs.Vec]); flush(log.value, out); } else if (_15 === 3) { const part36 = at(0); @@ -7932,15 +7924,12 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const part43 = at(7); const other: Logged.Logged[][] = [_217, [_231, logged(part43)]]; flush(log.value, out); - rs.arrayCloneFrom(grid, other, (a010: Logged.Logged[]): Logged.Logged[] => { - return a010.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + rs.sliceCloneFromSlice(rs.sliceFrom(grid), rs.sliceFrom(other), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); const part44 = rs.sliceFrom(grid[1]); _14(part44, out); - rs.arrayCloneFrom(grid, other, (a011: Logged.Logged[]): Logged.Logged[] => { - return a011.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + const _260: rs.Slice = rs.sliceFrom(other); + rs.sliceCloneFromSlice(rs.sliceFrom(grid), _260, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged([grid, other] as [Logged.Logged[][], Logged.Logged[][]]); flush(log.value, out); @@ -7962,21 +7951,15 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const part30 = at(7); const other2: Logged.Logged[][] = [_300, [_314, logged(part30)]]; flush(log.value, out); - rs.sliceCloneFromSlice(rs.sliceFrom(rows.items), rs.sliceFrom(other2), (a06: Logged.Logged[]): Logged.Logged[] => { - return a06.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + rs.sliceCloneFromSlice(rs.sliceFrom(rows.items), rs.sliceFrom(other2), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); - rs.sliceFill(rs.sliceRange(rs.sliceFrom(rows.items), 0, 1), other2[1].map(Logged.clone$Clone), (a07: Logged.Logged[]): Logged.Logged[] => { - return a07.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + rs.sliceFill(rs.sliceRange(rs.sliceFrom(rows.items), 0, 1), other2[1].map(Logged.clone$Clone), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); const _349: rs.Slice = rs.sliceFrom(rows.items); const part31 = at(8); const _352: Logged.Logged = logged(part31); const part32 = at(9); - rs.sliceFill(_349, [_352, logged(part32)], (a08: Logged.Logged[]): Logged.Logged[] => { - return a08.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + rs.sliceFill(_349, [_352, logged(part32)], (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); const part33 = rs.sliceFrom(rows.items[rs.idx(rows.items, 0)]); _14(part33, out); @@ -7984,9 +7967,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const part34 = at(10); const _378: Logged.Logged = logged(part34); const part35 = at(11); - rs.sliceFill(_375, [_378, logged(part35)], (a09: Logged.Logged[]): Logged.Logged[] => { - return a09.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + rs.sliceFill(_375, [_378, logged(part35)], (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged([rows, other2] as [rs.Vec, Logged.Logged[][]]); flush(log.value, out); @@ -8005,12 +7986,12 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo return row(rs.usizeAdd(20, i11), len(rs.usizeAdd(20, i11))); }), undefined, 12, true); flush(log.value, out); - rs.vecCloneFrom(rows2, other3, 12, (a03: rs.Vec): rs.Vec => { - return rs.vecFrom(a03.items.map(Logged.clone$Clone)); + rs.vecCloneFrom(rows2, other3, 12, (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); - rs.vecCloneFrom(cut, other3, 12, (a04: rs.Vec): rs.Vec => { - return rs.vecFrom(a04.items.map(Logged.clone$Clone)); + rs.vecCloneFrom(cut, other3, 12, (a02: rs.Vec): rs.Vec => { + return rs.vecFrom(a02.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); const part22 = rs.sliceFrom(cut.items[rs.idx(cut.items, 0)].items); @@ -8018,21 +7999,21 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _462: rs.usize = len(1); rs.vecTruncate(rows2, _462, drop$Vec_clones_Logged); const n: rs.usize = rows2.items.length; - rs.sliceCloneFromSlice(rs.sliceFrom(rows2.items), rs.sliceRange(rs.sliceFrom(other3.items), 0, n), (a05: rs.Vec): rs.Vec => { - return rs.vecFrom(a05.items.map(Logged.clone$Clone)); + rs.sliceCloneFromSlice(rs.sliceFrom(rows2.items), rs.sliceRange(rs.sliceFrom(other3.items), 0, n), (a03: rs.Vec): rs.Vec => { + return rs.vecFrom(a03.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged([rows2, other3, cut] as [rs.Vec>, rs.Vec>, rs.Vec>]); flush(log.value, out); } else if (_15 === 6) { const part7 = len(0); - let a4: rs.Slice = rs.sliceFrom(row(0, part7).items); + let a5: rs.Slice = rs.sliceFrom(row(0, part7).items); const part8 = len(4); const b4: rs.Slice = rs.sliceFrom(row(4, part8).items); flush(log.value, out); - a4 = rs.boxSliceCloneFrom(a4, b4, Logged.clone$Clone, rs.drop); + a5 = rs.boxSliceCloneFrom(a5, b4, Logged.clone$Clone, rs.drop); flush(log.value, out); - _14(a4, out); + _14(a5, out); const ones: (a0: rs.usize, a1: rs.usize) => rs.Slice = (from2: rs.usize, n3: rs.usize): rs.Slice => { return rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n3), (i10: rs.usize): Logged.Logged[] => { return [logged(at(rs.usizeAdd(from2, i10)))]; @@ -8043,30 +8024,27 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const part13 = len(12); const d2: rs.Slice = ones(12, part13); flush(log.value, out); - c3 = rs.boxSliceCloneFrom(c3, d2, (a02: Logged.Logged[]): Logged.Logged[] => { - return a02.map(Logged.clone$Clone); - }, drop$array1_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + c3 = rs.boxSliceCloneFrom(c3, d2, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array1_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); - drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged([a4, b4, c3, d2] as [rs.Slice, rs.Slice, rs.Slice, rs.Slice]); + drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged([a5, b4, c3, d2] as [rs.Slice, rs.Slice, rs.Slice, rs.Slice]); flush(log.value, out); } else { const kept: (a0: rs.usize) => Kept.Kept = (i5: rs.usize): Kept.Kept => { return new Kept.Kept(logged(at(i5))); }; - const a5: rs.Vec = rs.vecFrom([kept(0), kept(1)]); + const a6: rs.Vec = rs.vecFrom([kept(0), kept(1)]); const _555: rs.usize = len(0); - rs.vecTruncate(a5, _555, rs.drop); + rs.vecTruncate(a6, _555, rs.drop); const b5: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, len(1)), (i6: rs.usize): Kept.Kept => { return kept(rs.usizeAdd(2, i6)); }), undefined, 8, true); flush(log.value, out); - rs.vecCloneFrom(a5, b5, 8, Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); + rs.vecCloneFrom(a6, b5, 8, Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); flush(log.value, out); const grid2: Kept.Kept[][] = [[kept(5), kept(6)]]; + const _584: rs.Slice = rs.sliceFrom(grid2); const _586: Kept.Kept[][] = [[kept(7), kept(8)]]; - rs.arrayCloneFrom(grid2, _586, (a0: Kept.Kept[]): Kept.Kept[] => { - return a0.map(Kept.clone$Clone); - }, drop$array2_clones_Kept, rs.arrayCloneFromFn(Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined))); + rs.sliceCloneFromSlice(_584, rs.sliceFrom(_586), (a: Kept.Kept[]) => a.map(Kept.clone$Clone), drop$array2_clones_Kept, rs.arrayCloneFromFn(Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined))); rs.dropAll(_586, drop$array2_clones_Kept); flush(log.value, out); let some: Kept.Kept | undefined = kept(9); @@ -8081,8 +8059,9 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo return { tag: "Held", _0: kept(i7) } as Slot.Slot; }; const slots: Slot.Slot[] = [slot(11), slot(12)]; + const _621: rs.Slice = rs.sliceFrom(slots); const _623: Slot.Slot[] = [slot(13), slot(14)]; - rs.arrayCloneFrom(slots, _623, Slot.clone$Clone, drop$clones_Slot, rs.cloneFromPlaceFn(Slot.cloneFrom$Clone as (a0: rs.Place, a1: Slot.Slot) => undefined)); + rs.sliceCloneFromSlice(_621, rs.sliceFrom(_623), Slot.clone$Clone, drop$clones_Slot, rs.cloneFromPlaceFn(Slot.cloneFrom$Clone as (a0: rs.Place, a1: Slot.Slot) => undefined)); rs.dropAll(_623, drop$clones_Slot); flush(log.value, out); const _634: rs.Iter = rs.iterMap(new rs.Range(0, len(15)), (i8: rs.usize): Kept.Kept => { @@ -8096,7 +8075,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo flush(log.value, out); rs.listCloneFrom(list, other4, Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); flush(log.value, out); - drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept([a5, b5, grid2, some, slots, list, other4] as [rs.Vec, rs.Vec, Kept.Kept[][], Kept.Kept | undefined, Slot.Slot[], rs.LinkedList, rs.LinkedList]); + drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept([a6, b5, grid2, some, slots, list, other4] as [rs.Vec, rs.Vec, Kept.Kept[][], Kept.Kept | undefined, Slot.Slot[], rs.LinkedList, rs.LinkedList]); flush(log.value, out); } log[Symbol.dispose](); @@ -8125,11 +8104,11 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }; const _12: rs.u8 = rs.u8Rem(kind, 8); if (_12 === 0) { - const part20 = at(0); - const v: rs.Vec = rs.vecFromElem(logged(part20), n(1), Logged.clone$Clone, rs.drop); + const part19 = at(0); + const v: rs.Vec = rs.vecFromElem(logged(part19), n(1), Logged.clone$Clone, rs.drop); flush(log.value, out); - const part21 = rs.sliceFrom(v.items); - _11(part21, out); + const part20 = rs.sliceFrom(v.items); + _11(part20, out); rs.byteVecPush(out, rs.vecCapacity(v, 8) & 0xff); rs.dropVec(v); flush(log.value, out); @@ -8139,13 +8118,13 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return logged(at(rs.usizeAdd(2, i3))); }); rs.iterExtend(row, _43, undefined, 8, true); - const v2: rs.Vec> = rs.vecFromElem(row, n(0), (a04: rs.Vec): rs.Vec => { - return rs.vecFrom(a04.items.map(Logged.clone$Clone)); + const v2: rs.Vec> = rs.vecFromElem(row, n(0), (a03: rs.Vec): rs.Vec => { + return rs.vecFrom(a03.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged); flush(log.value, out); for (const _62 of v2.items) { - const part19 = rs.sliceFrom(_62.items); - _11(part19, out); + const part18 = rs.sliceFrom(_62.items); + _11(part18, out); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(254, rs.vecCapacity(_62, 8) & 0xff)), undefined, true); } rs.dropVec(v2, drop$Vec_clones_Logged); @@ -8154,12 +8133,10 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part14 = at(0); const _80: Logged.Logged = logged(part14); const part15 = at(1); - const v3: rs.Vec = rs.vecFromElem([_80, logged(part15)], n(2), (a03: Logged.Logged[]): Logged.Logged[] => { - return a03.map(Logged.clone$Clone); - }, drop$array2_clones_Logged); + const v3: rs.Vec = rs.vecFromElem([_80, logged(part15)], n(2), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged); flush(log.value, out); - rs.iterForEach(rs.iterSlice(v3.items), (row3: Logged.Logged[]): undefined => { - _11(rs.sliceFrom(row3), out); + rs.iterForEach(rs.iterLend(rs.iterSlice(v3.items), rs.sliceFrom), (row3: rs.Slice): undefined => { + _11(row3, out); }); rs.dropVec(v3, drop$array2_clones_Logged); flush(log.value, out); diff --git a/ts/fixtures/lang/clones/expected/harness.ts b/ts/fixtures/lang/clones/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/clones/expected/harness.ts +++ b/ts/fixtures/lang/clones/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/collections/expected/collections.Fussy.ts b/ts/fixtures/lang/collections/expected/collections.Fussy.ts index 6fd9f881b..58ace5554 100644 --- a/ts/fixtures/lang/collections/expected/collections.Fussy.ts +++ b/ts/fixtures/lang/collections/expected/collections.Fussy.ts @@ -16,8 +16,7 @@ export function clone$Clone(self: Fussy): Fussy { return { _0: self._0 }; } const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - rs.panicFmt(["cloning ", args2[0]]); + rs.panicFmt(["cloning ", (f: rs.Formatter) => rs.u8Display(arg, f)]); } //# sourceMappingURL=collections.Fussy.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index b85b4194e..a7e9efab2 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -1106,8 +1106,7 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v it = rs.dequeRange(q, new rs.Range(a, a)); } rs.byteVecPush(out, it.len() & 0xff); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]))); let i2: rs.i32 = 0; while (true) { if ((rs.u8Shr(kind, rs.i32Add(5, rs.i32Rem(i2, 3))) & 1) === 1) { @@ -1117,8 +1116,7 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v } if (item !== undefined) { rs.byteVecPush(out, item); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]))); if (i2 === 1) { rs.iterExtendBytes(out, rs.iterRev(it.clone()), undefined, true); } @@ -1486,16 +1484,13 @@ export function optional$Option_String_collections_HashMap_u8_Option_String(map: if (_14 === 0) { const _24: string | undefined = value(b); const part3 = insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k, _24); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; - read = rs.fmtFormat([args2[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None), " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; - read = rs.fmtFormat([args4[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None), " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; - read = rs.fmtFormat([args6[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None), " "]); } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); if (_49 === undefined) { @@ -1504,15 +1499,13 @@ export function optional$Option_String_collections_HashMap_u8_Option_String(map: const v: rs.Place = _49; const _53: string | undefined = value(rs.u8Div(b, 2)); v.v = _53; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, rs.fmtStr)]; - read = rs.fmtFormat(["=", args8[0], " "]); + read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtOption(v.v, f, rs.fmtStr), " "]); } } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, string | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.fmtStr)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, string | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.fmtStr)], f))]))); } /** @@ -1527,16 +1520,13 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr if (_14 === 0) { const _24: rs.u8 | undefined = value(b); const part3 = insert$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k, _24); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - read = rs.fmtFormat([args2[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - read = rs.fmtFormat([args4[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - read = rs.fmtFormat([args6[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), " "]); } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); if (_49 === undefined) { @@ -1545,15 +1535,13 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr const v: rs.Place = _49; const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); v.v = _53; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug)]; - read = rs.fmtFormat(["=", args8[0], " "]); + read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug), " "]); } } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]))); } /** @@ -1568,16 +1556,13 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash if (_14 === 0) { const _24: rs.u8 | undefined = value(b); const part3 = insert$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k, _24); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - read = rs.fmtFormat([args2[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - read = rs.fmtFormat([args4[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - read = rs.fmtFormat([args6[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), " "]); } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); if (_49 === undefined) { @@ -1586,15 +1571,13 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash const v: rs.Place = _49; const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); v.v = _53; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug)]; - read = rs.fmtFormat(["=", args8[0], " "]); + read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug), " "]); } } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]))); } /** @@ -1609,16 +1592,13 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap rs.fmtOption(part3, f, rs.fmtUnit, rs.None)]; - read = rs.fmtFormat([args2[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtUnit, rs.None), " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.fmtUnit, rs.None)]; - read = rs.fmtFormat([args4[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, rs.fmtUnit, rs.None), " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtUnit, rs.None)]; - read = rs.fmtFormat([args6[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtUnit, rs.None), " "]); } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); if (_49 === undefined) { @@ -1627,15 +1607,13 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap = _49; value(rs.u8Div(b, 2)); v.v = undefined; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(v.v, f)]; - read = rs.fmtFormat(["=", args8[0], " "]); + read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtUnit(v.v, f), " "]); } } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]))); } /** @@ -1650,16 +1628,13 @@ export function optional$unit_collections_HashMap_u8_unit(map: rs.HashMap rs.fmtOption(part3, f, rs.fmtUnit, rs.None)]; - read = rs.fmtFormat([args2[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtUnit, rs.None), " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.fmtUnit, rs.None)]; - read = rs.fmtFormat([args4[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, rs.fmtUnit, rs.None), " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtUnit, rs.None)]; - read = rs.fmtFormat([args6[0], " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtUnit, rs.None), " "]); } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); if (_49 === undefined) { @@ -1668,15 +1643,13 @@ export function optional$unit_collections_HashMap_u8_unit(map: rs.HashMap = _49; value(rs.u8Div(b, 2)); v.v = undefined; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(v.v, f)]; - read = rs.fmtFormat(["=", args8[0], " "]); + read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtUnit(v.v, f), " "]); } } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_unit_collections_HashMap_u8_unit(map); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]))); } /** `b`, unless a multiple of 3. */ @@ -1733,13 +1706,12 @@ export function optionals(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _50: rs.u8 | undefined = option_flatten$0ux6gqw(read); const _53: boolean = rs.hashContains(map, k); const _56: rs.u8 | undefined | rs.None = read; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_56, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_53, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]))); + const args5 = [(f: rs.Formatter) => rs.fmtOption(_56, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_53, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " "]))); } const all: rs.Vec<[[rs.u8, boolean], rs.u8 | undefined]> = rs.iterToVec(rs.hashIter(map), "next", 4); rs.sliceSort(rs.sliceFrom(all.items), rs.cmpLt(rs.cmpTuple<[[rs.u8, boolean], rs.u8 | undefined], rs.Ordering | undefined>([rs.cmpTuple<[rs.u8, boolean], rs.Ordering | undefined>([rs.cmp, rs.cmp]), rs.cmpOption(rs.cmp)])), 4, true); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [[rs.u8, boolean], rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0][0], f), (f: rs.Formatter) => rs.fmtBool(value[0][1], f)], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [[rs.u8, boolean], rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0][0], f), (f: rs.Formatter) => rs.fmtBool(value[0][1], f)], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]))); } } @@ -3705,36 +3677,40 @@ export function unlikeEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi putEq(rs.eqSeq((a4: Left.Left, b9: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a4, b9); })(_46, rights_), log, out); - const _54: Right.Right[] = pair(); + const _53: rs.Slice = rs.sliceFrom(pair()); putEq(rs.eqSeq((a5: Left.Left, b10: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a5, b10); - })(mine, _54), log, out); - const _62: Right.Right[] = pair(); + })(mine, _53), log, out); + const _61: rs.Slice = rs.sliceFrom(pair()); putEq(rs.eqSeq((a6: Left.Left, b11: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a6, b11); - })(mine, _62), log, out); + })(mine, _61), log, out); const _68: rs.Slice = rs.sliceFrom(mine.items); - const _71: Right.Right[] = pair(); + const _70: rs.Slice = rs.sliceFrom(pair()); putEq(rs.eqSeq((a7: Left.Left, b12: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a7, b12); - })(_68, _71), log, out); + })(_68, _70), log, out); const two: Left.Left[] = [{ _0: at(0), _1: log }, { _0: at(1), _1: log }]; - const _89: Right.Right[] = pair(); + const _87: rs.Slice = rs.sliceFrom(two); + const _88: rs.Slice = rs.sliceFrom(pair()); putEq(rs.eqSeq((a8: Left.Left, b13: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a8, b13); - })(two, _89), log, out); - const _96: Right.Right[] = pair(); + })(_87, _88), log, out); + const _94: rs.Slice = rs.sliceFrom(two); + const _95: rs.Slice = rs.sliceFrom(pair()); putEq(!rs.eqSeq((a9: Left.Left, b14: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a9, b14); - })(two, _96), log, out); + })(_94, _95), log, out); + const _101: rs.Slice = rs.sliceFrom(two); const _102: rs.Slice = rs.sliceFrom(rights_.items); putEq(rs.eqSeq((a10: Left.Left, b15: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a10, b15); - })(two, _102), log, out); + })(_101, _102), log, out); + const _107: rs.Slice = rs.sliceFrom(two); const _109: rs.Slice = rs.sliceFrom(rights_.items); putEq(rs.eqSeq((a11: Left.Left, b16: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a11, b16); - })(two, _109), log, out); + })(_107, _109), log, out); const _115: rs.Vec = new rs.Vec(); const _117: rs.Vec = new rs.Vec(); putEq(rs.eqSeq((a12: Left.Left, b17: Right.Right): boolean => { @@ -3744,10 +3720,9 @@ export function unlikeEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi putEq(rs.eqSeq((a13: Left.Left, b18: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a13, b18); })(_122, rights_), log, out); - const _128: Right.Right[] = []; putEq(rs.eqSeq((a14: Left.Left, b19: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a14, b19); - })(mine, _128), log, out); + })(mine, rs.sliceFrom([])), log, out); const _133: rs.ByteVec = rs.byteSliceToByteVec(data); putEq(rs.eqSeq(eq$cmp_PartialEq_collections_Right_u8)(_133, rights_), log, out); const _140: rs.Slice = rs.sliceFrom(rights_.items); @@ -3767,10 +3742,10 @@ export function unlikeEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi })(rs.byteSliceFrom(a15), b20); })(_148, _150), log, out); const _162: rs.Vec> = rs.vecFrom([lefts(), lefts()]); - const _169: rs.Slice[] = [rs.sliceFrom(rights_.items), rs.sliceFrom(rights_.items)]; + const _168: rs.Slice> = rs.sliceFrom([rs.sliceFrom(rights_.items), rs.sliceFrom(rights_.items)]); putEq(rs.eqSeq(rs.eqSeq((a16: Left.Left, b21: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a16, b21); - }))(_162, _169), log, out); + }))(_162, _168), log, out); const refs: rs.Vec = rs.iterToVec(rs.iterSlice(rights_.items), undefined, 4, true); putEq(rs.eqSeq(Left.eq$cmp_PartialEq_ref_collections_Right)(mine, refs), log, out); const _187: rs.Vec = rs.iterToVec(rs.iterSlice(mine.items), undefined, 4, true); @@ -3813,18 +3788,18 @@ export function unlikeEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi putEq(rs.eqSeq((a21: Left.Left, b27: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a21, b27); })(q, _272), log, out); - const _279: Right.Right[] = pair(); + const _278: rs.Slice = rs.sliceFrom(pair()); putEq(rs.eqSeq((a22: Left.Left, b28: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a22, b28); - })(q, _279), log, out); - const _287: Right.Right[] = pair(); + })(q, rs.sliceItems(_278)), log, out); + const _286: rs.Slice = rs.sliceFrom(pair()); putEq(rs.eqSeq((a23: Left.Left, b29: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a23, b29); - })(q, _287), log, out); - const _295: Right.Right[] = pair(); + })(q, _286), log, out); + const _294: rs.Slice = rs.sliceFrom(pair()); putEq(rs.eqSeq((a24: Left.Left, b30: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a24, b30); - })(q, _295), log, out); + })(q, _294), log, out); const bytes: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; const iter3: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, half)))); while (true) { @@ -3857,8 +3832,8 @@ export function unlikeEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } putEq(rs.eqSeq(rs.same)(wide, wrapped), log, out); const _366: rs.Vec> = rs.vecFrom([rs.dequeClone(wide)]); - const _371: rs.VecDeque[] = [wrapped]; - putEq(rs.eqSlice(rs.eqSeq(rs.same))(_366, _371), log, out); + const _370: rs.Slice> = rs.sliceFrom([wrapped]); + putEq(rs.eqSlice(rs.eqSeq(rs.same))(_366, _370), log, out); const it: rs.Peekable> = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom([lefts(), lefts(), lefts()]))); const exact: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): Right.Right => { return { _0: _29 as rs.u16 }; @@ -4072,26 +4047,31 @@ export function ownNes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _81: [Picky.Picky[], Picky.Picky[]] = [_82, [_94, one(part4, 1)]]; const pa: Picky.Picky[] = _82; const pb: Picky.Picky[] = _81[1]; + const _106: rs.Slice = rs.sliceFrom(pa); + const _107: rs.Slice = rs.sliceFrom(pb); putEq(rs.eqSlice((a8: Picky.Picky, b8: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a8, b8); - })(pa, pb), log, out); + })(_106, _107), log, out); + const _111: rs.Slice = rs.sliceFrom(pa); + const _112: rs.Slice = rs.sliceFrom(pb); putEq(!rs.eqSlice((a9: Picky.Picky, b9: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a9, b9); - })(pa, pb), log, out); + })(_111, _112), log, out); + const _116: rs.Slice = rs.sliceFrom(pa); const _117: rs.Slice = rs.sliceFrom(b.items); putEq(rs.eqSlice((a10: Picky.Picky, b10: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a10, b10); - })(pa, _117), log, out); + })(_116, _117), log, out); const _123: rs.Vec> = rs.vecFrom([rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(a.items.map(Picky.clone$Clone))]); - const _130: rs.Vec[] = [rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(b.items.map(Picky.clone$Clone))]; + const _129: rs.Slice> = rs.sliceFrom([rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(b.items.map(Picky.clone$Clone))]); putEq(rs.eqSlice(rs.eqSlice((a11: Picky.Picky, b11: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a11, b11); - }))(_123, _130), log, out); + }))(_123, _129), log, out); const _139: rs.Vec> = rs.vecFrom([rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(b.items.map(Picky.clone$Clone))]); - const _146: rs.Vec[] = [rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(a.items.map(Picky.clone$Clone))]; + const _145: rs.Slice> = rs.sliceFrom([rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(a.items.map(Picky.clone$Clone))]); putEq(!rs.eqSlice(rs.eqSlice((a12: Picky.Picky, b12: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a12, b12); - }))(_139, _146), log, out); + }))(_139, _145), log, out); const tuple: (a0: rs.Slice) => [Picky.Picky, rs.u8, Picky.Picky] = (v3: rs.Slice): [Picky.Picky, rs.u8, Picky.Picky] => { return [one(v3, 0), _34(v3, 2) & 0xff, one(v3, 1)] as [Picky.Picky, rs.u8, Picky.Picky]; }; @@ -4301,9 +4281,10 @@ export function ownNes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return !Picky.ne$cmp_PartialEq(a39, b39); })(_570, rs.cowSlice(cb)), log, out); const _576: rs.Slice = rs.cowSlice(cb); + const _578: rs.Slice = rs.sliceFrom(pa); putEq(rs.eqSlice((a40: Picky.Picky, b40: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a40, b40); - })(_576, pa), log, out); + })(_576, _578), log, out); const owned: rs.Vec> = each$collections_Picky_borrow_Cow_slice_collections_Picky_collections_own_nes_closure18(rs.sliceFrom(a.items), (p14: Picky.Picky): rs.Cow => { return rs.vecFrom([Picky.clone$Clone(p14)]); }); @@ -4841,15 +4822,15 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _123: rs.Slice = rs.sliceFrom([a, b]); const _126: rs.Slice = rs.sliceFrom([b, a]); rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_123, _126))); - const _134: ByRef.ByRef[] = [a, b]; - const _136: ByRef.ByRef[] = [b, a]; - const _132: rs.Ordering = rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_134, _136); + const _133: rs.Slice = rs.sliceFrom([a, b]); + const _135: rs.Slice = rs.sliceFrom([b, a]); + const _132: rs.Ordering = rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_133, _135); const _139: rs.Vec = rs.vecFrom([a]); const _142: rs.Vec = rs.vecFrom([b]); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_132, rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_139, _142)], cmpByte$ref_orders)), undefined, true); - const _149: ByRef.ByRef[] = [a, b]; - const _151: ByRef.ByRef[] = [b, a]; - const _147: boolean = rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_149, _151); + const _148: rs.Slice = rs.sliceFrom([a, b]); + const _150: rs.Slice = rs.sliceFrom([b, a]); + const _147: boolean = rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_148, _150); const _153: rs.Slice = rs.sliceFrom([a]); const _156: rs.Slice = rs.sliceFrom([b]); const _152: boolean = rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_153, _156) === -1; @@ -4958,15 +4939,15 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _434: rs.Slice = rs.sliceFrom([a2, b2]); const _437: rs.Slice = rs.sliceFrom([b2, a2]); rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_434, _437))); - const _445: ByRef.ByRef[] = [a2, b2]; - const _447: ByRef.ByRef[] = [b2, a2]; - const _443: rs.Ordering = rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_445, _447); + const _444: rs.Slice = rs.sliceFrom([a2, b2]); + const _446: rs.Slice = rs.sliceFrom([b2, a2]); + const _443: rs.Ordering = rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_444, _446); const _450: rs.Vec = rs.vecFrom([a2]); const _453: rs.Vec = rs.vecFrom([b2]); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_443, rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_450, _453)], cmpByte$ref_orders)), undefined, true); - const _460: ByRef.ByRef[] = [a2, b2]; - const _462: ByRef.ByRef[] = [b2, a2]; - const _458: boolean = rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_460, _462); + const _459: rs.Slice = rs.sliceFrom([a2, b2]); + const _461: rs.Slice = rs.sliceFrom([b2, a2]); + const _458: boolean = rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_459, _461); const _464: rs.Slice = rs.sliceFrom([a2]); const _467: rs.Slice = rs.sliceFrom([b2]); const _463: boolean = rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_464, _467) === -1; @@ -5075,15 +5056,15 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _737: rs.Slice = rs.sliceFrom([a3, b3]); const _740: rs.Slice = rs.sliceFrom([b3, a3]); rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_737, _740))); - const _748: ByVal.ByVal[] = [a3, b3]; - const _750: ByVal.ByVal[] = [b3, a3]; - const _746: rs.Ordering = rs.cmpSlice(ByVal.cmp$cmp_Ord)(_748, _750); + const _747: rs.Slice = rs.sliceFrom([a3, b3]); + const _749: rs.Slice = rs.sliceFrom([b3, a3]); + const _746: rs.Ordering = rs.cmpSlice(ByVal.cmp$cmp_Ord)(_747, _749); const _753: rs.Vec = rs.vecFrom([a3]); const _756: rs.Vec = rs.vecFrom([b3]); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_746, rs.cmpSlice(ByVal.cmp$cmp_Ord)(_753, _756)], cmpByte$ref_orders)), undefined, true); - const _763: ByVal.ByVal[] = [a3, b3]; - const _765: ByVal.ByVal[] = [b3, a3]; - const _761: boolean = rs.eqSlice(ByVal.eq$cmp_PartialEq)(_763, _765); + const _762: rs.Slice = rs.sliceFrom([a3, b3]); + const _764: rs.Slice = rs.sliceFrom([b3, a3]); + const _761: boolean = rs.eqSlice(ByVal.eq$cmp_PartialEq)(_762, _764); const _767: rs.Slice = rs.sliceFrom([a3]); const _770: rs.Slice = rs.sliceFrom([b3]); const _766: boolean = rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_767, _770) === -1; @@ -5192,15 +5173,15 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _1044: rs.Slice = rs.sliceFrom([a4, b4]); const _1047: rs.Slice = rs.sliceFrom([b4, a4]); rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_1044, _1047))); - const _1055: ByVal.ByVal[] = [a4, b4]; - const _1057: ByVal.ByVal[] = [b4, a4]; - const _1053: rs.Ordering = rs.cmpSlice(ByVal.cmp$cmp_Ord)(_1055, _1057); + const _1054: rs.Slice = rs.sliceFrom([a4, b4]); + const _1056: rs.Slice = rs.sliceFrom([b4, a4]); + const _1053: rs.Ordering = rs.cmpSlice(ByVal.cmp$cmp_Ord)(_1054, _1056); const _1060: rs.Vec = rs.vecFrom([a4]); const _1063: rs.Vec = rs.vecFrom([b4]); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1053, rs.cmpSlice(ByVal.cmp$cmp_Ord)(_1060, _1063)], cmpByte$ref_orders)), undefined, true); - const _1070: ByVal.ByVal[] = [a4, b4]; - const _1072: ByVal.ByVal[] = [b4, a4]; - const _1068: boolean = rs.eqSlice(ByVal.eq$cmp_PartialEq)(_1070, _1072); + const _1069: rs.Slice = rs.sliceFrom([a4, b4]); + const _1071: rs.Slice = rs.sliceFrom([b4, a4]); + const _1068: boolean = rs.eqSlice(ByVal.eq$cmp_PartialEq)(_1069, _1071); const _1074: rs.Slice = rs.sliceFrom([a4]); const _1077: rs.Slice = rs.sliceFrom([b4]); const _1073: boolean = rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_1074, _1077) === -1; @@ -5274,9 +5255,9 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _1278: Mixed.Mixed | undefined = b5; const order13 = rs.cmpOption(Mixed.partialCmp$cmp_PartialOrd)(_1276, _1278); const _1274: boolean = order13 !== undefined && order13 <= 0; - const _1281: Mixed.Mixed[] = [a5]; - const _1283: Mixed.Mixed[] = [b5]; - const _1279: boolean = rs.eqSlice(Mixed.eq$cmp_PartialEq)(_1281, _1283); + const _1280: rs.Slice = rs.sliceFrom([a5]); + const _1282: rs.Slice = rs.sliceFrom([b5]); + const _1279: boolean = rs.eqSlice(Mixed.eq$cmp_PartialEq)(_1280, _1282); const _1286: rs.Vec = rs.vecFrom([a5]); const _1289: rs.Vec = rs.vecFrom([b5]); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1269, _1274, _1279, rs.cmpSlice(Mixed.partialCmp$cmp_PartialOrd)(_1286, _1289) === -1], (a025: boolean): rs.u8 => { @@ -5288,9 +5269,9 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _1299: Mixed.Mixed | undefined = a5; const _1301: Mixed.Mixed | undefined = b5; const _1297: rs.Ordering = rs.cmpOption(Mixed.cmp$cmp_Ord_ref)(_1299, _1301); - const _1304: Mixed.Mixed[] = [a5]; - const _1306: Mixed.Mixed[] = [b5]; - const _1302: rs.Ordering = rs.cmpSlice(Mixed.cmp$cmp_Ord_ref)(_1304, _1306); + const _1303: rs.Slice = rs.sliceFrom([a5]); + const _1305: rs.Slice = rs.sliceFrom([b5]); + const _1302: rs.Ordering = rs.cmpSlice(Mixed.cmp$cmp_Ord_ref)(_1303, _1305); const _1309: Mixed.Mixed = a5; const _1311: Mixed.Mixed = b5; rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1292, _1297, _1302, rs.cmpReverse(Mixed.cmp$cmp_Ord_ref)(_1309, _1311)], cmpByte$ref_orders)), undefined, true); @@ -5321,9 +5302,9 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _1381: Boxed.Boxed | undefined = b6; const order14 = rs.cmpOption(partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed)(_1378, _1381); const _1376: boolean = order14 !== undefined && order14 >= 0; - const _1385: Boxed.Boxed[] = [a6]; - const _1388: Boxed.Boxed[] = [b6]; - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1362, _1369, _1376, !rs.eqSlice(eq$cmp_PartialEq_boxed_Box_collections_Boxed)(_1385, _1388)], (a026: boolean): rs.u8 => { + const _1384: rs.Slice = rs.sliceFrom([a6]); + const _1387: rs.Slice = rs.sliceFrom([b6]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1362, _1369, _1376, !rs.eqSlice(eq$cmp_PartialEq_boxed_Box_collections_Boxed)(_1384, _1387)], (a026: boolean): rs.u8 => { return a026 ? 1 : 0; })), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterEq(rs.iterSlice([a6]), rs.iterSlice([b6]), eq$cmp_PartialEq_boxed_Box_collections_Boxed, true), !rs.iterEq(rs.iterSlice([a6]), rs.iterSlice([b6]), eq$cmp_PartialEq_boxed_Box_collections_Boxed, true), rs.iterCmp(rs.iterSlice([a6]), rs.iterSlice([b6]), partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed) === -1], (a027: boolean): rs.u8 => { @@ -5405,16 +5386,16 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set2), (x11: ByVal.ByVal): rs.u8 => { return x11._0 & 0xff; }), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(rs.btreeIter(map2), (_222: [[ByVal.ByVal], rs.usize]): Uint8Array => { - return Uint8Array.of(_222[0][0]._0 & 0xff, _222[1] & 0xff); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(rs.btreeIter(map2), (_233: [[ByVal.ByVal], rs.usize]): Uint8Array => { + return Uint8Array.of(_233[0][0]._0 & 0xff, _233[1] & 0xff); }), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); rs.iterExtendBytes(out, rs.iterOption(option_map$093awy8(rs.btreeKey(set2, xs2.items[rs.idx(xs2.items, 0)]), (x12: ByVal.ByVal): rs.u8 => { return x12._0 & 0xff; })), undefined, true); const _1594: rs.Iter = rs.iterSlice(xs2.items); rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined, ByVal.eq$cmp_PartialEq)) as rs.HashSet, _1594, undefined, undefined, 234881024)) & 0xff); - const _1603: rs.Iter<[ByVal.ByVal, ByVal.ByVal | undefined]> = rs.iterMap(rs.iterSlice(xs2.items), (_226: ByVal.ByVal): [ByVal.ByVal, ByVal.ByVal | undefined] => { - const x13: ByVal.ByVal = _226; + const _1603: rs.Iter<[ByVal.ByVal, ByVal.ByVal | undefined]> = rs.iterMap(rs.iterSlice(xs2.items), (_253: ByVal.ByVal): [ByVal.ByVal, ByVal.ByVal | undefined] => { + const x13: ByVal.ByVal = _253; return [x13, x13] as [ByVal.ByVal, ByVal.ByVal | undefined]; }); rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined, rs.hashOption(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)]), rs.eqTuple([ByVal.eq$cmp_PartialEq, rs.eqOption(ByVal.eq$cmp_PartialEq)]))) as rs.HashSet<[ByVal.ByVal, ByVal.ByVal | undefined]>, _1603, undefined, undefined, 117440512)) & 0xff); @@ -5454,16 +5435,16 @@ export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set3), (x17: Mixed.Mixed): rs.u8 => { return x17._0 & 0xff; }), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(rs.btreeIter(map3), (_233: [[Mixed.Mixed], rs.usize]): Uint8Array => { - return Uint8Array.of(_233[0][0]._0 & 0xff, _233[1] & 0xff); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(rs.btreeIter(map3), (_257: [[Mixed.Mixed], rs.usize]): Uint8Array => { + return Uint8Array.of(_257[0][0]._0 & 0xff, _257[1] & 0xff); }), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); rs.iterExtendBytes(out, rs.iterOption(option_map$0aug5m6(rs.btreeKey(set3, xs3.items[rs.idx(xs3.items, 0)]), (x18: Mixed.Mixed): rs.u8 => { return x18._0 & 0xff; })), undefined, true); const _1704: rs.Iter = rs.iterSlice(xs3.items); rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined, Mixed.eq$cmp_PartialEq)) as rs.HashSet, _1704, undefined, undefined, 234881024)) & 0xff); - const _1713: rs.Iter<[Mixed.Mixed, Mixed.Mixed | undefined]> = rs.iterMap(rs.iterSlice(xs3.items), (_247: Mixed.Mixed): [Mixed.Mixed, Mixed.Mixed | undefined] => { - const x19: Mixed.Mixed = _247; + const _1713: rs.Iter<[Mixed.Mixed, Mixed.Mixed | undefined]> = rs.iterMap(rs.iterSlice(xs3.items), (_258: Mixed.Mixed): [Mixed.Mixed, Mixed.Mixed | undefined] => { + const x19: Mixed.Mixed = _258; return [x19, x19] as [Mixed.Mixed, Mixed.Mixed | undefined]; }); rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined, rs.hashOption(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined)]), rs.eqTuple([Mixed.eq$cmp_PartialEq, rs.eqOption(Mixed.eq$cmp_PartialEq)]))) as rs.HashSet<[Mixed.Mixed, Mixed.Mixed | undefined]>, _1713, undefined, undefined, 117440512)) & 0xff); @@ -5530,31 +5511,31 @@ export function hashed$ref_orders_Vec_ref_ref_collections_ByVal(value: rs.Vec undefined)(value, h); + rs.hashSlice(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined)(rs.sliceFrom(value), h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_collections_ByRef(value: ByRef.ByRef[]): Uint8Array { const h: rs.Hasher = rs.hasher(); - rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(rs.sliceFrom(value), h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_collections_ByVal(value: ByVal.ByVal[]): Uint8Array { const h: rs.Hasher = rs.hasher(); - rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(rs.sliceFrom(value), h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_ref_collections_ByRef(value: ByRef.ByRef[]): Uint8Array { const h: rs.Hasher = rs.hasher(); - rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(rs.sliceFrom(value), h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_ref_collections_ByVal(value: ByVal.ByVal[]): Uint8Array { const h: rs.Hasher = rs.hasher(); - rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(rs.sliceFrom(value), h); return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } @@ -5863,28 +5844,28 @@ export function btreeExtracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): return rs.u16Rem(k8 ^ limit as rs.u16, every) === 0; }); const _62: [rs.usize, rs.usize | undefined] = it.sizeHint(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_62[0], f), (f: rs.Formatter) => rs.fmtOption(_62[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + const args26 = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_62[0], f), (f: rs.Formatter) => rs.fmtOption(_62[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args26[0], " ", args26[1]])); const _72: rs.Iter<[rs.u16, rs.u16]> = it; const _74: rs.usize = limit as rs.usize; const taken: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterTake(rs.iterBorrow(_72), _74), "next", 4); const _83: [rs.usize, rs.usize | undefined] = it.sizeHint(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_83[0], f), (f: rs.Formatter) => rs.fmtOption(_83[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]])); + const args27 = [(f: rs.Formatter) => rs.fmtList(taken.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_83[0], f), (f: rs.Formatter) => rs.fmtOption(_83[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2]])); if (rs.u8Rem(limit, 2) === 0) { const _104: [rs.u16, rs.u16] | undefined = rs.iterToOption(it.next()); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_104, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug)]; - put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1])])); + const args28 = [(f: rs.Formatter) => rs.fmtOption(_104, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug)]; + put(out, rs.fmtFormat([args28[0], " ", rs.fmtSpec({ alternate: true }, args28[1])])); } const _122: rs.usize = rs.btreeLen(map); const _125: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterStepBy(rs.btreeIter(map), 7), "next", 8); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_122, f), (f: rs.Formatter) => rs.fmtList(_125.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args8[0], " ", args8[1]])); + const args29 = [(f: rs.Formatter) => rs.usizeDisplay(_122, f), (f: rs.Formatter) => rs.fmtList(_125.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args29[0], " ", args29[1]])); const taken2: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.btreeExtractIfMut(map, undefined, (_217: rs.u16, v3: rs.Place): boolean => { return rs.u16Rem(v3.v, 3) === 0; }), "next", 4); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken2.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u16Debug, rs.u16Debug)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1]])); + const args30 = [(f: rs.Formatter) => rs.fmtList(taken2.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u16Debug, rs.u16Debug)]; + put(out, rs.fmtFormat([args30[0], " ", args30[1]])); } else if (_44 === 1) { const _152: rs.Iter = rs.iterMap(new rs.Range(0, n), (k5: rs.u16): rs.u16 => { return rs.u16Rem(rs.u16Mul(k5, 3), rs.u16Add(n, 1)); @@ -5893,27 +5874,23 @@ export function btreeExtracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): const it2: rs.Iter = rs.btreeExtractKeysIf(set, range, (k6: rs.u16): boolean => { return rs.u16Rem(k6, every) !== 0; }); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug)])); const _174: rs.Iter = it2; const _176: rs.usize = limit as rs.usize; const taken3: rs.Vec = rs.iterToVec(rs.iterTake(rs.iterBorrow(_174), _176), "next", 2); const _185: [rs.usize, rs.usize | undefined] = it2.sizeHint(); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken3.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_185[0], f), (f: rs.Formatter) => rs.fmtOption(_185[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2]])); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args16[0]])); + const args22 = [(f: rs.Formatter) => rs.fmtList(taken3.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_185[0], f), (f: rs.Formatter) => rs.fmtOption(_185[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u16Debug)])); const part3 = rs.btreeExtractKeysIf(rs.btreeNew(rs.cmp) as rs.BTreeSet, range, (_212: rs.u16): boolean => { return true; }); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(part3, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(part3, f, rs.u16Debug)])); rs.btreeClear(set); const part4 = rs.btreeExtractKeysIf(set, undefined, (_216: rs.u16): boolean => { return true; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(part4, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(part4, f, rs.u16Debug)])); } else { const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); const _243: rs.Iter<[Logged.Logged, Logged.Logged]> = rs.iterMap(new rs.Range(0, rs.u16Div(n, 2)), (k: rs.u16): [Logged.Logged, Logged.Logged] => { diff --git a/ts/fixtures/lang/collections/expected/harness.ts b/ts/fixtures/lang/collections/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/collections/expected/harness.ts +++ b/ts/fixtures/lang/collections/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/combinators/expected/combinators.ts b/ts/fixtures/lang/combinators/expected/combinators.ts index c2a3567f0..bd9b0a83c 100644 --- a/ts/fixtures/lang/combinators/expected/combinators.ts +++ b/ts/fixtures/lang/combinators/expected/combinators.ts @@ -189,7 +189,8 @@ export function owned(a: rs.u8 | undefined, b: rs.u8 | undefined, out: rs.ByteVe return a0 as rs.u16; })); if (wide.ok) { - wide.value[0] = 9; + const p: rs.Slice = rs.sliceFrom(wide.value); + p.data[p.start] = 9; } if (pair.ok) { matched = rs.Ok(copy$array_u32(pair.value)); @@ -197,7 +198,8 @@ export function owned(a: rs.u8 | undefined, b: rs.u8 | undefined, out: rs.ByteVe matched = rs.Err(pair.error as rs.u16); } if (matched.ok) { - matched.value[1] = 8; + const p3: rs.Slice = rs.sliceFrom(matched.value); + p3.data[p3.start + 1] = 8; } const iter2: rs.Iter> = rs.iterSlice([copy$Result_array2_u32_u16(result_mapErr$12sqndm(pair, (a02: rs.u8): rs.u16 => { return a02 as rs.u16; @@ -222,13 +224,11 @@ export function panics(a: rs.u8 | undefined, b: rs.u8 | undefined, limit: rs.u8, if (!(x === limit)) { return b; } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(x, f)]; - rs.panicFmt(["closure saw ", args2[0]]); + rs.panicFmt(["closure saw ", (f: rs.Formatter) => rs.u8Display(x, f)]); }), 1)); rs.byteVecPush(out, result_unwrapOrElse$1iet7cd(option_okOr$1j8owgb(b, limit), (e: rs.u8): rs.u8 => { if (rs.u8Rem(e, 4) === 0) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(e, f)]; - rs.panicFmt(["error ", args4[0]]); + rs.panicFmt(["error ", (f: rs.Formatter) => rs.u8Display(e, f)]); } else { return e; } diff --git a/ts/fixtures/lang/combinators/expected/harness.ts b/ts/fixtures/lang/combinators/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/combinators/expected/harness.ts +++ b/ts/fixtures/lang/combinators/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/constants/expected/harness.ts b/ts/fixtures/lang/constants/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/constants/expected/harness.ts +++ b/ts/fixtures/lang/constants/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index 0968c3af2..6059901f0 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -47,8 +47,7 @@ export function put$conversions_Value_u64(self: rs.u64, out: rs.ByteVec): void { /** The value `data` makes from `at`. */ export function make$conversions_Value_String(data: rs.ByteSlice, at: rs.usize): string { const part = rs.u8Rem(byte(data, at), 16); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; - return rs.fmtFormat(["s", args2[0]]); + return rs.fmtFormat(["s", (f: rs.Formatter) => rs.u8Display(part, f)]); } /** Its bytes. */ @@ -133,8 +132,8 @@ export function make$conversions_Value_array2_u32(data: rs.ByteSlice, at: rs.usi } /** Its bytes. */ -export function put$conversions_Value_array2_u32(self: rs.u32[], out: rs.ByteVec): void { - for (const _5 of self) { +export function put$conversions_Value_array2_u32(self: rs.Slice, out: rs.ByteVec): void { + for (const _5 of rs.sliceItems(self)) { rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(_5)), undefined, true); } } @@ -362,8 +361,8 @@ export function cloneFromParam$array1_u8(to: rs.ByteSlice, from: rs.ByteSlice): } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$array2_u32(to: rs.u32[], from: rs.u32[]): void { - rs.replaceIn(to, copy$array_u32(from)); +export function cloneFromParam$array2_u32(to: rs.Slice, from: rs.Slice): void { + rs.replaceIn(rs.sliceView(to), rs.sliceToArray(from)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ @@ -432,8 +431,8 @@ export function cloneIntoParam$array1_u8(from: rs.ByteSlice, to: rs.ByteSlice): } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$array2_u32(from: rs.u32[], to: rs.u32[]): void { - rs.replaceIn(to, copy$array_u32(from)); +export function cloneIntoParam$array2_u32(from: rs.Slice, to: rs.Slice): void { + rs.replaceIn(rs.sliceView(to), rs.sliceToArray(from)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ @@ -550,8 +549,9 @@ export function writeFirst$array1_u8(s: rs.Slice, value: Uint8Array) export function writeFirst$array2_u32(s: rs.Slice, value: rs.u32[]): rs.u32[] { value = copy$array_u32(value); rs.idx(s, 0); - const _8: rs.u32[] = copy$array_u32(copy$array_u32(value)); - const old: rs.u32[] = rs.sliceReplace(s.data, s.start, _8); + const _3: rs.Slice = rs.sliceFrom(s.data[s.start]); + const _8: rs.u32[] = copy$array_u32(value.slice()); + const old: rs.u32[] = rs.replaceIn(rs.sliceView(_3), _8); const _10: rs.u32[] = value; rs.idx(s, 0); s.data[s.start] = _10; @@ -640,79 +640,80 @@ export function writeFirst$u64(s: rs.Slice, value: rs.u64): rs.u64 { /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$Option_u16(s: rs.Slice>, value: Array): Array { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, copy$array_Option_u16(value)); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_Option_u16(value)); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$String(s: rs.Slice, value: string[]): string[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, value); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$Vec_u32(s: rs.Slice[]>, value: rs.Vec[]): rs.Vec[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, value, 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$Vec_u8(s: rs.Slice, value: rs.ByteVec[]): rs.ByteVec[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, value, 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array0_u8(s: rs.Slice, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); + rs.sliceFrom(s.data[s.start]); return copy$array_array0_u8(value); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array1_u8(s: rs.Slice, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, copy$array_array1_u8(value), 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array1_u8(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array2_u32(s: rs.Slice, value: rs.u32[][]): rs.u32[][] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, copy$array_array2_u32(value), 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array2_u32(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array3_u8(s: rs.Slice, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, copy$array_array3_u8(value), 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array3_u8(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array40_u8(s: rs.Slice, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, copy$array_array40_u8(value), 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array40_u8(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$conversions_Logged(s: rs.Slice, value: Logged.Logged[]): Logged.Logged[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, value, 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$conversions_Named(s: rs.Slice, value: Named.Named[]): Named.Named[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, value, 1); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$u32(s: rs.Slice, value: rs.u32[]): rs.u32[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, copy$array_u32(value)); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_u32(value)); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$u64(s: rs.Slice, value: rs.u64[]): rs.u64[] { rs.idx(s, 0); - return rs.sliceReplace(s.data, s.start, copy$array_u64(value)); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_u64(value)); } /** @@ -753,16 +754,16 @@ export function lentParam$Option_u16(to: rs.Place, data: rs. rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: Array = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: Array = [make$conversions_Value_Option_u16(data, 22)]; - put$conversions_Value_Option_u16(rs.replaceIn(a, _77)[0], out); + put$conversions_Value_Option_u16(rs.replaceIn(rs.sliceView(a), _77)[0], out); let by: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 23); rs.idx(s, 0); const borrowed3 = s.start; let r: rs.Place = rs.place(() => s.data[borrowed3], (value2) => s.data[borrowed3] = value2); - const _89: rs.Place[] = rs.arrayOfPlace(rs.place(() => r, (value3) => r = value3)); + const _89: rs.Slice> = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; - rs.replaceIn(_89, _91)[0].v = make$conversions_Value_Option_u16(data, 24); + rs.replaceIn(rs.sliceView(_89), _91)[0].v = make$conversions_Value_Option_u16(data, 24); put$conversions_Value_Option_u16(r.v, out); rs.idx(s, 0); put$conversions_Value_Option_u16(s.data[s.start], out); @@ -773,15 +774,15 @@ export function lentParam$Option_u16(to: rs.Place, data: rs. rs.idx(s, 0); const borrowed6 = s.data; const borrowed7 = s.start; - put$conversions_Value_Option_u16(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6))), [make$conversions_Value_Option_u16(data, 26)])[0], out); + put$conversions_Value_Option_u16(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6)))), [make$conversions_Value_Option_u16(data, 26)])[0], out); rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - put$conversions_Value_Option_u16(replaceFirst$Option_u16(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7))), [make$conversions_Value_Option_u16(data, 27)])[0], out); + put$conversions_Value_Option_u16(replaceFirst$Option_u16(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)))), [make$conversions_Value_Option_u16(data, 27)])[0], out); rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_Option_u16(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))), 1), [[make$conversions_Value_Option_u16(data, 28)]])[0][0], out); + put$conversions_Value_Option_u16(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))))), 1), [[make$conversions_Value_Option_u16(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -826,16 +827,16 @@ export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: string[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: string[] = [make$conversions_Value_String(data, 22)]; - put$conversions_Value_String(rs.replaceIn(a, _77)[0], out); + put$conversions_Value_String(rs.replaceIn(rs.sliceView(a), _77)[0], out); let by: string = make$conversions_Value_String(data, 23); rs.idx(s, 0); const borrowed3 = s.start; let r: rs.Place = rs.place(() => s.data[borrowed3], (value2) => s.data[borrowed3] = value2); - const _89: rs.Place[] = rs.arrayOfPlace(rs.place(() => r, (value3) => r = value3)); + const _89: rs.Slice> = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; - rs.replaceIn(_89, _91)[0].v = make$conversions_Value_String(data, 24); + rs.replaceIn(rs.sliceView(_89), _91)[0].v = make$conversions_Value_String(data, 24); put$conversions_Value_String(r.v, out); rs.idx(s, 0); put$conversions_Value_String(s.data[s.start], out); @@ -846,15 +847,15 @@ export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.idx(s, 0); const borrowed6 = s.data; const borrowed7 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6))), [make$conversions_Value_String(data, 26)])[0], out); + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6)))), [make$conversions_Value_String(data, 26)])[0], out); rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7))), [make$conversions_Value_String(data, 27)])[0], out); + put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)))), [make$conversions_Value_String(data, 27)])[0], out); rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))), 1), [[make$conversions_Value_String(data, 28)]])[0][0], out); + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))))), 1), [[make$conversions_Value_String(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -891,15 +892,15 @@ export function lentParam$Vec_u32(to: rs.Vec, data: rs.ByteSlice, out: r rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: rs.Vec[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice> = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: rs.Vec[] = [make$conversions_Value_Vec_u32(data, 22)]; - put$conversions_Value_Vec_u32(rs.replaceIn(a, _77, 1)[0], out); + put$conversions_Value_Vec_u32(rs.replaceIn(rs.sliceView(a), _77, 1)[0], out); const by: rs.Vec = make$conversions_Value_Vec_u32(data, 23); rs.idx(s, 0); let r: rs.Vec = s.data[s.start]; - const _89: rs.Vec[] = rs.arrayOfPlace(rs.place(() => r, (value2) => r = value2)); + const _89: rs.Slice> = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); const _91: rs.Vec[] = [by]; - Object.assign(rs.replaceIn(_89, _91)[0], make$conversions_Value_Vec_u32(data, 24)); + Object.assign(rs.replaceIn(rs.sliceView(_89), _91)[0], make$conversions_Value_Vec_u32(data, 24)); put$conversions_Value_Vec_u32(r, out); rs.idx(s, 0); put$conversions_Value_Vec_u32(s.data[s.start], out); @@ -908,15 +909,15 @@ export function lentParam$Vec_u32(to: rs.Vec, data: rs.ByteSlice, out: r rs.idx(s, 0); const borrowed3 = s.data; const borrowed4 = s.start; - put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3)), 1), [make$conversions_Value_Vec_u32(data, 26)])[0], out); + put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3))), 1), [make$conversions_Value_Vec_u32(data, 26)])[0], out); rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - put$conversions_Value_Vec_u32(replaceFirst$Vec_u32(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4))), [make$conversions_Value_Vec_u32(data, 27)])[0], out); + put$conversions_Value_Vec_u32(replaceFirst$Vec_u32(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)))), [make$conversions_Value_Vec_u32(data, 27)])[0], out); rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))), 2), [[make$conversions_Value_Vec_u32(data, 28)]])[0][0], out); + put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))))), 2), [[make$conversions_Value_Vec_u32(data, 28)]])[0][0], out); rs.idx(s, 0); rs.vecCloneFrom(s.data[s.start], other, 4); rs.idx(s, 0); @@ -953,15 +954,15 @@ export function lentParam$Vec_u8(to: rs.ByteVec, data: rs.ByteSlice, out: rs.Byt rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: rs.ByteVec[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: rs.ByteVec[] = [make$conversions_Value_Vec_u8(data, 22)]; - put$conversions_Value_Vec_u8(rs.replaceIn(a, _77, 1)[0], out); + put$conversions_Value_Vec_u8(rs.replaceIn(rs.sliceView(a), _77, 1)[0], out); const by: rs.ByteVec = make$conversions_Value_Vec_u8(data, 23); rs.idx(s, 0); let r: rs.ByteVec = s.data[s.start]; - const _89: rs.ByteVec[] = rs.arrayOfPlace(rs.place(() => r, (value2) => r = value2)); + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); const _91: rs.ByteVec[] = [by]; - Object.assign(rs.replaceIn(_89, _91)[0], make$conversions_Value_Vec_u8(data, 24)); + Object.assign(rs.replaceIn(rs.sliceView(_89), _91)[0], make$conversions_Value_Vec_u8(data, 24)); put$conversions_Value_Vec_u8(r, out); rs.idx(s, 0); put$conversions_Value_Vec_u8(s.data[s.start], out); @@ -970,15 +971,15 @@ export function lentParam$Vec_u8(to: rs.ByteVec, data: rs.ByteSlice, out: rs.Byt rs.idx(s, 0); const borrowed3 = s.data; const borrowed4 = s.start; - put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3)), 1), [make$conversions_Value_Vec_u8(data, 26)])[0], out); + put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3))), 1), [make$conversions_Value_Vec_u8(data, 26)])[0], out); rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - put$conversions_Value_Vec_u8(replaceFirst$Vec_u8(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4))), [make$conversions_Value_Vec_u8(data, 27)])[0], out); + put$conversions_Value_Vec_u8(replaceFirst$Vec_u8(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)))), [make$conversions_Value_Vec_u8(data, 27)])[0], out); rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))), 2), [[make$conversions_Value_Vec_u8(data, 28)]])[0][0], out); + put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))))), 2), [[make$conversions_Value_Vec_u8(data, 28)]])[0][0], out); rs.idx(s, 0); rs.byteVecCloneFrom(s.data[s.start], other); rs.idx(s, 0); @@ -1017,15 +1018,15 @@ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(t, 1); put$conversions_Value_array0_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); rs.idx(s, 0); - rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); const _76: Uint8Array[] = [copy$array_u8(make$conversions_Value_array0_u8(data, 22))]; put$conversions_Value_array0_u8(rs.byteSliceFrom(_76[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 23)); rs.idx(s, 0); let r: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); - const _89: rs.ByteSlice[] = rs.arrayOfPlace(rs.place(() => r, (value) => r = value)); + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; - const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); + const _88: rs.ByteSlice[] = rs.replaceIn(rs.sliceView(_89), _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array0_u8(r, out); @@ -1034,11 +1035,11 @@ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(s, 0); put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), copy$array_u8(make$conversions_Value_array0_u8(data, 25)))), out); rs.idx(s, 0); - put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), 1), [copy$array_u8(make$conversions_Value_array0_u8(data, 26))])[0]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 1), [copy$array_u8(make$conversions_Value_array0_u8(data, 26))])[0]), out); rs.idx(s, 0); - put$conversions_Value_array0_u8(rs.byteSliceFrom(replaceFirst$array0_u8(rs.sliceIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), [make$conversions_Value_array0_u8(data, 27)])[0]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(replaceFirst$array0_u8(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))))), [make$conversions_Value_array0_u8(data, 27)])[0]), out); rs.idx(s, 0); - put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 2), [[copy$array_u8(make$conversions_Value_array0_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))))), 2), [[copy$array_u8(make$conversions_Value_array0_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _154: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _159: rs.ByteSlice = rs.byteSliceFrom(other); @@ -1091,15 +1092,15 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(t, 1); put$conversions_Value_array1_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); rs.idx(s, 0); - const a: Uint8Array[] = rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array1_u8(data, 22))]; - put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.replaceIn(a, _77, 1)[0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 23)); rs.idx(s, 0); let r: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); - const _89: rs.ByteSlice[] = rs.arrayOfPlace(rs.place(() => r, (value) => r = value)); + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; - const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); + const _88: rs.ByteSlice[] = rs.replaceIn(rs.sliceView(_89), _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array1_u8(r, out); @@ -1108,11 +1109,11 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(s, 0); put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), copy$array_u8(make$conversions_Value_array1_u8(data, 25)))), out); rs.idx(s, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), 1), [copy$array_u8(make$conversions_Value_array1_u8(data, 26))])[0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 1), [copy$array_u8(make$conversions_Value_array1_u8(data, 26))])[0]), out); rs.idx(s, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(replaceFirst$array1_u8(rs.sliceIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), [make$conversions_Value_array1_u8(data, 27)])[0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(replaceFirst$array1_u8(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))))), [make$conversions_Value_array1_u8(data, 27)])[0]), out); rs.idx(s, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 2), [[copy$array_u8(make$conversions_Value_array1_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))))), 2), [[copy$array_u8(make$conversions_Value_array1_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _154: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _159: rs.ByteSlice = rs.byteSliceFrom(other); @@ -1127,60 +1128,64 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$array2_u32(to: rs.u32[], data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceIn(to); - put$conversions_Value_array2_u32(writeFirst$array2_u32(s, make$conversions_Value_array2_u32(data, 18)), out); - let other: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 19)); - rs.idx(s, 0); - other = rs.sliceReplace(s.data, s.start, other); - put$conversions_Value_array2_u32(other, out); - rs.idx(s, 0); - other = rs.sliceReplace(s.data, s.start, other); - put$conversions_Value_array2_u32(other, out); +export function lentParam$array2_u32(to: rs.Slice, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.Slice = rs.sliceIn(rs.sliceView(to)); + put$conversions_Value_array2_u32(rs.sliceFrom(writeFirst$array2_u32(s, make$conversions_Value_array2_u32(data, 18))), out); + const other: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 19)); + rs.idx(s, 0); + const _11: rs.Slice = rs.sliceFrom(s.data[s.start]); + const _16: rs.Slice = rs.sliceFrom(other); + rs.sliceSet(_16, rs.replaceIn(rs.sliceView(_11), rs.sliceToArray(_16))); + put$conversions_Value_array2_u32(rs.sliceFrom(other), out); + const _20: rs.Slice = rs.sliceFrom(other); + rs.idx(s, 0); + const _21: rs.Slice = rs.sliceFrom(s.data[s.start]); + rs.sliceSet(_21, rs.replaceIn(rs.sliceView(_20), rs.sliceToArray(_21))); + put$conversions_Value_array2_u32(rs.sliceFrom(other), out); const t: rs.Slice = rs.sliceFrom(rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 20), make$conversions_Value_array2_u32(data, 21)]).map(copy$array_u32)).items); rs.idx(s, 0); + const _35: rs.Slice = rs.sliceFrom(s.data[s.start]); rs.idx(t, 1); - rs.sliceSwapAcross(s.data, s.start, t.data, t.start + 1); + const _40: rs.Slice = rs.sliceFrom(t.data[t.start + 1]); + rs.sliceSet(_40, rs.replaceIn(rs.sliceView(_35), rs.sliceToArray(_40))); rs.idx(t, 0); + const _46: rs.Slice = rs.sliceFrom(t.data[t.start]); rs.idx(s, 0); - rs.sliceSwapAcross(t.data, t.start, s.data, s.start); + const _51: rs.Slice = rs.sliceFrom(s.data[s.start]); + rs.sliceSet(_51, rs.replaceIn(rs.sliceView(_46), rs.sliceToArray(_51))); rs.idx(t, 0); - put$conversions_Value_array2_u32(t.data[t.start], out); + put$conversions_Value_array2_u32(rs.sliceFrom(t.data[t.start]), out); rs.idx(t, 1); - put$conversions_Value_array2_u32(t.data[t.start + 1], out); + put$conversions_Value_array2_u32(rs.sliceFrom(t.data[t.start + 1]), out); rs.idx(s, 0); - const borrowed = s.data; - const borrowed2 = s.start; - const a: rs.u32[][] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceIn(rs.sliceView(rs.sliceFrom(s.data[s.start]))); const _77: rs.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 22))]; - put$conversions_Value_array2_u32(rs.replaceIn(a, _77, 1)[0], out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); const by: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 23)); rs.idx(s, 0); - let r: rs.u32[] = s.data[s.start]; - const _89: rs.u32[][] = rs.arrayOfPlace(rs.place(() => r, (value2) => r = value2)); - const _91: rs.u32[][] = [by]; - Object.assign(rs.replaceIn(_89, _91)[0], copy$array_u32(make$conversions_Value_array2_u32(data, 24))); + let r: rs.Slice = rs.sliceFrom(s.data[s.start]); + const _89: rs.Slice> = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); + const _91: rs.Slice[] = [rs.sliceFrom(by)]; + const _88: rs.Slice[] = rs.replaceIn(rs.sliceView(_89), _91); + const _93: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 24)); + rs.sliceSet(_88[0], _93); put$conversions_Value_array2_u32(r, out); rs.idx(s, 0); - put$conversions_Value_array2_u32(s.data[s.start], out); + put$conversions_Value_array2_u32(rs.sliceFrom(s.data[s.start]), out); rs.idx(s, 0); - put$conversions_Value_array2_u32(rs.cellReplace(rs.cellIn(s.data[s.start]), copy$array_u32(make$conversions_Value_array2_u32(data, 25))), out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceFrom(s.data[s.start]))), copy$array_u32(make$conversions_Value_array2_u32(data, 25)))), out); rs.idx(s, 0); - const borrowed3 = s.data; - const borrowed4 = s.start; - put$conversions_Value_array2_u32(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3)), 1), [copy$array_u32(make$conversions_Value_array2_u32(data, 26))])[0], out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])))), 1), [copy$array_u32(make$conversions_Value_array2_u32(data, 26))])[0]), out); rs.idx(s, 0); - const borrowed5 = s.data; - const borrowed6 = s.start; - put$conversions_Value_array2_u32(replaceFirst$array2_u32(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4))), [make$conversions_Value_array2_u32(data, 27)])[0], out); + put$conversions_Value_array2_u32(rs.sliceFrom(replaceFirst$array2_u32(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceFrom(s.data[s.start]))))), [make$conversions_Value_array2_u32(data, 27)])[0]), out); rs.idx(s, 0); - const borrowed7 = s.data; - const borrowed8 = s.start; - put$conversions_Value_array2_u32(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))), 2), [[copy$array_u32(make$conversions_Value_array2_u32(data, 28))]])[0][0], out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])))))), 2), [[copy$array_u32(make$conversions_Value_array2_u32(data, 28))]])[0][0]), out); rs.idx(s, 0); - s.data[s.start] = copy$array_u32(other); + const _154: rs.Slice = rs.sliceFrom(s.data[s.start]); + const _159: rs.Slice = rs.sliceFrom(other); + rs.replaceIn(rs.sliceView(_154), rs.sliceToArray(_159)); rs.idx(s, 0); - put$conversions_Value_array2_u32(s.data[s.start], out); + put$conversions_Value_array2_u32(rs.sliceFrom(s.data[s.start]), out); } /** @@ -1227,15 +1232,15 @@ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(t, 1); put$conversions_Value_array3_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); rs.idx(s, 0); - const a: Uint8Array[] = rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array3_u8(data, 22))]; - put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.replaceIn(a, _77, 1)[0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 23)); rs.idx(s, 0); let r: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); - const _89: rs.ByteSlice[] = rs.arrayOfPlace(rs.place(() => r, (value) => r = value)); + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; - const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); + const _88: rs.ByteSlice[] = rs.replaceIn(rs.sliceView(_89), _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array3_u8(r, out); @@ -1244,11 +1249,11 @@ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(s, 0); put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), copy$array_u8(make$conversions_Value_array3_u8(data, 25)))), out); rs.idx(s, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), 1), [copy$array_u8(make$conversions_Value_array3_u8(data, 26))])[0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 1), [copy$array_u8(make$conversions_Value_array3_u8(data, 26))])[0]), out); rs.idx(s, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(replaceFirst$array3_u8(rs.sliceIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), [make$conversions_Value_array3_u8(data, 27)])[0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(replaceFirst$array3_u8(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))))), [make$conversions_Value_array3_u8(data, 27)])[0]), out); rs.idx(s, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 2), [[copy$array_u8(make$conversions_Value_array3_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))))), 2), [[copy$array_u8(make$conversions_Value_array3_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _154: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _159: rs.ByteSlice = rs.byteSliceFrom(other); @@ -1301,15 +1306,15 @@ export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.idx(t, 1); put$conversions_Value_array40_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); rs.idx(s, 0); - const a: Uint8Array[] = rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array40_u8(data, 22))]; - put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.replaceIn(a, _77, 1)[0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 23)); rs.idx(s, 0); let r: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); - const _89: rs.ByteSlice[] = rs.arrayOfPlace(rs.place(() => r, (value) => r = value)); + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; - const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); + const _88: rs.ByteSlice[] = rs.replaceIn(rs.sliceView(_89), _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array40_u8(r, out); @@ -1318,11 +1323,11 @@ export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.idx(s, 0); put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), copy$array_u8(make$conversions_Value_array40_u8(data, 25)))), out); rs.idx(s, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))), 1), [copy$array_u8(make$conversions_Value_array40_u8(data, 26))])[0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 1), [copy$array_u8(make$conversions_Value_array40_u8(data, 26))])[0]), out); rs.idx(s, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(replaceFirst$array40_u8(rs.sliceIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), [make$conversions_Value_array40_u8(data, 27)])[0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(replaceFirst$array40_u8(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))))), [make$conversions_Value_array40_u8(data, 27)])[0]), out); rs.idx(s, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))), 2), [[copy$array_u8(make$conversions_Value_array40_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start])))))), 2), [[copy$array_u8(make$conversions_Value_array40_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _154: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _159: rs.ByteSlice = rs.byteSliceFrom(other); @@ -1364,17 +1369,17 @@ export function lentParam$conversions_Logged(to: Logged.Logged, data: rs.ByteSli rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: Logged.Logged[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: Logged.Logged[] = [Logged.make$conversions_Value(data, 22)]; - const _76: Logged.Logged[] = rs.replaceIn(a, _77, 1); + const _76: Logged.Logged[] = rs.replaceIn(rs.sliceView(a), _77, 1); Logged.put$conversions_Value(_76[0], out); rs.dropAll(_76); const by: Logged.Logged = Logged.make$conversions_Value(data, 23); rs.idx(s, 0); let r: Logged.Logged = s.data[s.start]; - const _89: Logged.Logged[] = rs.arrayOfPlace(rs.place(() => r, (value2) => r = value2)); + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); const _91: Logged.Logged[] = [by]; - const _88: Logged.Logged[] = rs.replaceIn(_89, _91); + const _88: Logged.Logged[] = rs.replaceIn(rs.sliceView(_89), _91); const _93: Logged.Logged = Logged.make$conversions_Value(data, 24); _88[0][Symbol.dispose](); Object.assign(_88[0], _93); @@ -1388,17 +1393,17 @@ export function lentParam$conversions_Logged(to: Logged.Logged, data: rs.ByteSli rs.idx(s, 0); const borrowed3 = s.data; const borrowed4 = s.start; - const old: Logged.Logged = rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3)), 1), [Logged.make$conversions_Value(data, 26)])[0]; + const old: Logged.Logged = rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3))), 1), [Logged.make$conversions_Value(data, 26)])[0]; Logged.put$conversions_Value(old, out); rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - const old2: Logged.Logged = replaceFirst$conversions_Logged(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4))), [Logged.make$conversions_Value(data, 27)])[0]; + const old2: Logged.Logged = replaceFirst$conversions_Logged(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)))), [Logged.make$conversions_Value(data, 27)])[0]; Logged.put$conversions_Value(old2, out); rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - const old3: Logged.Logged = rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))), 2), [[Logged.make$conversions_Value(data, 28)]])[0][0]; + const old3: Logged.Logged = rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))))), 2), [[Logged.make$conversions_Value(data, 28)]])[0][0]; Logged.put$conversions_Value(old3, out); rs.idx(s, 0); rs.sliceReplace(s.data, s.start, Logged.clone$Clone(other))[Symbol.dispose](); @@ -1442,15 +1447,15 @@ export function lentParam$conversions_Named(to: Named.Named, data: rs.ByteSlice, rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: Named.Named[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: Named.Named[] = [Named.make$conversions_Value(data, 22)]; - Named.put$conversions_Value(rs.replaceIn(a, _77, 1)[0], out); + Named.put$conversions_Value(rs.replaceIn(rs.sliceView(a), _77, 1)[0], out); const by: Named.Named = Named.make$conversions_Value(data, 23); rs.idx(s, 0); let r: Named.Named = s.data[s.start]; - const _89: Named.Named[] = rs.arrayOfPlace(rs.place(() => r, (value2) => r = value2)); + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); const _91: Named.Named[] = [by]; - Object.assign(rs.replaceIn(_89, _91)[0], Named.make$conversions_Value(data, 24)); + Object.assign(rs.replaceIn(rs.sliceView(_89), _91)[0], Named.make$conversions_Value(data, 24)); Named.put$conversions_Value(r, out); rs.idx(s, 0); Named.put$conversions_Value(s.data[s.start], out); @@ -1459,15 +1464,15 @@ export function lentParam$conversions_Named(to: Named.Named, data: rs.ByteSlice, rs.idx(s, 0); const borrowed3 = s.data; const borrowed4 = s.start; - Named.put$conversions_Value(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3)), 1), [Named.make$conversions_Value(data, 26)])[0], out); + Named.put$conversions_Value(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3))), 1), [Named.make$conversions_Value(data, 26)])[0], out); rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - Named.put$conversions_Value(replaceFirst$conversions_Named(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4))), [Named.make$conversions_Value(data, 27)])[0], out); + Named.put$conversions_Value(replaceFirst$conversions_Named(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)))), [Named.make$conversions_Value(data, 27)])[0], out); rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - Named.put$conversions_Value(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))), 2), [[Named.make$conversions_Value(data, 28)]])[0][0], out); + Named.put$conversions_Value(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))))), 2), [[Named.make$conversions_Value(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = Named.clone$Clone(other); rs.idx(s, 0); @@ -1512,16 +1517,16 @@ export function lentParam$u32(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: rs.u32[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: rs.u32[] = [make$conversions_Value_u32(data, 22)]; - put$conversions_Value_u32(rs.replaceIn(a, _77)[0], out); + put$conversions_Value_u32(rs.replaceIn(rs.sliceView(a), _77)[0], out); let by: rs.u32 = make$conversions_Value_u32(data, 23); rs.idx(s, 0); const borrowed3 = s.start; let r: rs.Place = rs.place(() => s.data[borrowed3], (value2) => s.data[borrowed3] = value2); - const _89: rs.Place[] = rs.arrayOfPlace(rs.place(() => r, (value3) => r = value3)); + const _89: rs.Slice> = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; - rs.replaceIn(_89, _91)[0].v = make$conversions_Value_u32(data, 24); + rs.replaceIn(rs.sliceView(_89), _91)[0].v = make$conversions_Value_u32(data, 24); put$conversions_Value_u32(r.v, out); rs.idx(s, 0); put$conversions_Value_u32(s.data[s.start], out); @@ -1532,15 +1537,15 @@ export function lentParam$u32(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed6 = s.data; const borrowed7 = s.start; - put$conversions_Value_u32(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6))), [make$conversions_Value_u32(data, 26)])[0], out); + put$conversions_Value_u32(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6)))), [make$conversions_Value_u32(data, 26)])[0], out); rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - put$conversions_Value_u32(replaceFirst$u32(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7))), [make$conversions_Value_u32(data, 27)])[0], out); + put$conversions_Value_u32(replaceFirst$u32(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)))), [make$conversions_Value_u32(data, 27)])[0], out); rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_u32(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))), 1), [[make$conversions_Value_u32(data, 28)]])[0][0], out); + put$conversions_Value_u32(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))))), 1), [[make$conversions_Value_u32(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -1585,16 +1590,16 @@ export function lentParam$u64(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: rs.u64[] = rs.arrayOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); const _77: rs.u64[] = [make$conversions_Value_u64(data, 22)]; - put$conversions_Value_u64(rs.replaceIn(a, _77)[0], out); + put$conversions_Value_u64(rs.replaceIn(rs.sliceView(a), _77)[0], out); let by: rs.u64 = make$conversions_Value_u64(data, 23); rs.idx(s, 0); const borrowed3 = s.start; let r: rs.Place = rs.place(() => s.data[borrowed3], (value2) => s.data[borrowed3] = value2); - const _89: rs.Place[] = rs.arrayOfPlace(rs.place(() => r, (value3) => r = value3)); + const _89: rs.Slice> = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; - rs.replaceIn(_89, _91)[0].v = make$conversions_Value_u64(data, 24); + rs.replaceIn(rs.sliceView(_89), _91)[0].v = make$conversions_Value_u64(data, 24); put$conversions_Value_u64(r.v, out); rs.idx(s, 0); put$conversions_Value_u64(s.data[s.start], out); @@ -1605,15 +1610,15 @@ export function lentParam$u64(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed6 = s.data; const borrowed7 = s.start; - put$conversions_Value_u64(rs.cellReplace(rs.cellIn(rs.arrayOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6))), [make$conversions_Value_u64(data, 26)])[0], out); + put$conversions_Value_u64(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6)))), [make$conversions_Value_u64(data, 26)])[0], out); rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - put$conversions_Value_u64(replaceFirst$u64(rs.sliceIn(rs.arrayOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7))), [make$conversions_Value_u64(data, 27)])[0], out); + put$conversions_Value_u64(replaceFirst$u64(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)))), [make$conversions_Value_u64(data, 27)])[0], out); rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_u64(rs.cellReplace(rs.cellIn(rs.arrayIn(rs.arrayOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))), 1), [[make$conversions_Value_u64(data, 28)]])[0][0], out); + put$conversions_Value_u64(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))))), 1), [[make$conversions_Value_u64(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -1746,15 +1751,15 @@ export function lentThrough$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): voi const a: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 0)); const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); const v: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); - lentParam$array2_u32(a, data, out); - lentParam$array2_u32(held.value, data, out); - lentParam$array2_u32(v.items[rs.idx(v.items, 1)], data, out); - let _19: rs.u32[] = v.items[rs.idx(v.items, 0)]; + lentParam$array2_u32(rs.sliceFrom(a), data, out); + lentParam$array2_u32(rs.sliceFrom(held.value), data, out); + lentParam$array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 1)]), data, out); + let _19: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 0)]); lentNested$array2_u32(rs.place(() => _19, (value) => _19 = value), data, out); - put$conversions_Value_array2_u32(a, out); - put$conversions_Value_array2_u32(held.value, out); - put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 0)], out); - put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 1)], out); + put$conversions_Value_array2_u32(rs.sliceFrom(a), out); + put$conversions_Value_array2_u32(rs.sliceFrom(held.value), out); + put$conversions_Value_array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 1)]), out); } /** @@ -1909,7 +1914,7 @@ export function lentNested$array1_u8(to: rs.Place, data: rs.ByteSl } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$array2_u32(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { +export function lentNested$array2_u32(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$array2_u32(to.v, data, out); } @@ -1974,8 +1979,8 @@ export function setThrough$array1_u8(to: rs.ByteSlice, value: Uint8Array): Uint8 } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$array2_u32(to: rs.u32[], value: rs.u32[]): rs.u32[] { - return rs.cellReplace(rs.cellIn(to), copy$array_u32(value)); +export function setThrough$array2_u32(to: rs.Slice, value: rs.u32[]): rs.u32[] { + return rs.cellReplace(rs.cellIn(rs.sliceView(to)), copy$array_u32(value)); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ @@ -2036,10 +2041,10 @@ export function converted$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void put$conversions_Value_Option_u16(held.value, out); put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 1)], out); - const one: Array = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: rs.u16 | undefined = one[0]; - put$conversions_Value_Option_u16(one[0], out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u16 | undefined = one.data[one.start]; + put$conversions_Value_Option_u16(one.data[one.start], out); a = copied; put$conversions_Value_Option_u16(copied, out); put$conversions_Value_Option_u16(a, out); @@ -2123,10 +2128,10 @@ export function converted$String(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_String(held.value, out); put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); - const one: string[] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: string = one[0]; - put$conversions_Value_String(one[0], out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: string = one.data[one.start]; + put$conversions_Value_String(one.data[one.start], out); a = copied; put$conversions_Value_String(copied, out); put$conversions_Value_String(a, out); @@ -2210,10 +2215,10 @@ export function converted$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_Vec_u32(held.value, out); put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 1)], out); - const one: rs.Vec[] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: rs.Vec = rs.vecFrom(one[0].items.slice()); - put$conversions_Value_Vec_u32(one[0], out); + const one: rs.Slice> = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.Vec = rs.vecFrom(one.data[one.start].items.slice()); + put$conversions_Value_Vec_u32(one.data[one.start], out); rs.vecCloneFrom(a, copied, 4); put$conversions_Value_Vec_u32(copied, out); put$conversions_Value_Vec_u32(a, out); @@ -2298,10 +2303,10 @@ export function converted$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_Vec_u8(held.value, out); put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 1)], out); - const one: rs.ByteVec[] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(one[0])); - put$conversions_Value_Vec_u8(one[0], out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(one.data[one.start])); + put$conversions_Value_Vec_u8(one.data[one.start], out); rs.byteVecCloneFrom(a, copied); put$conversions_Value_Vec_u8(copied, out); put$conversions_Value_Vec_u8(a, out); @@ -2396,10 +2401,10 @@ export function converted$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array0_u8(rs.byteSliceFrom(held.value), out); put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); - put$conversions_Value_array0_u8(rs.byteSliceFrom(one[0]), out); + const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one.data[one.start])); + put$conversions_Value_array0_u8(rs.byteSliceFrom(one.data[one.start]), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2504,10 +2509,10 @@ export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array1_u8(rs.byteSliceFrom(held.value), out); put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); - put$conversions_Value_array1_u8(rs.byteSliceFrom(one[0]), out); + const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one.data[one.start])); + put$conversions_Value_array1_u8(rs.byteSliceFrom(one.data[one.start]), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2582,57 +2587,72 @@ export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { /** Each conversion of a `T`, its copies put after a write to what they copied. */ export function converted$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { - let a: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 0)); + const a: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 0)); const b: rs.u32[] = make$conversions_Value_array2_u32(data, 3); - const owned: rs.u32[] = copy$array_u32(a); - a = copy$array_u32(b); - put$conversions_Value_array2_u32(owned, out); - put$conversions_Value_array2_u32(a, out); - let c: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 6)); - c = copy$array_u32(owned); - put$conversions_Value_array2_u32(c, out); - cloneFromParam$array2_u32(c, b); - cloneIntoParam$array2_u32(owned, a); - put$conversions_Value_array2_u32(c, out); - put$conversions_Value_array2_u32(a, out); + const owned: rs.u32[] = a.slice(); + const _8: rs.Slice = rs.sliceFrom(a); + const _9: rs.Slice = rs.sliceFrom(b); + rs.replaceIn(rs.sliceView(_8), rs.sliceToArray(_9)); + put$conversions_Value_array2_u32(rs.sliceFrom(owned), out); + put$conversions_Value_array2_u32(rs.sliceFrom(a), out); + const c: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 6)); + const _16: rs.Slice = rs.sliceFrom(owned); + rs.replaceIn(rs.sliceView(rs.sliceFrom(c)), rs.sliceToArray(_16)); + put$conversions_Value_array2_u32(rs.sliceFrom(c), out); + cloneFromParam$array2_u32(rs.sliceFrom(c), rs.sliceFrom(b)); + cloneIntoParam$array2_u32(rs.sliceFrom(owned), rs.sliceFrom(a)); + put$conversions_Value_array2_u32(rs.sliceFrom(c), out); + put$conversions_Value_array2_u32(rs.sliceFrom(a), out); const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); - held.value = copy$array_u32(c); + const _33: rs.Slice = rs.sliceFrom(held.value); + const _34: rs.Slice = rs.sliceFrom(c); + rs.replaceIn(rs.sliceView(_33), rs.sliceToArray(_34)); const v: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); - v.items[rs.idx(v.items, 1)] = copy$array_u32(held.value); - v.items[rs.idx(v.items, 0)] = copy$array_u32(b); - put$conversions_Value_array2_u32(held.value, out); - put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 0)], out); - put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 1)], out); - const one: rs.u32[][] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: rs.u32[] = copy$array_u32(one[0]); - put$conversions_Value_array2_u32(one[0], out); - a = copy$array_u32(copied); - put$conversions_Value_array2_u32(copied, out); - put$conversions_Value_array2_u32(a, out); - const cell: rs.Cell = rs.cellIn(c); + const _40: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); + const _42: rs.Slice = rs.sliceFrom(held.value); + rs.replaceIn(rs.sliceView(_40), rs.sliceToArray(_42)); + const _44: rs.Slice = rs.sliceFrom(b); + rs.replaceIn(rs.sliceView(rs.sliceFrom(v.items[rs.idx(v.items, 0)])), rs.sliceToArray(_44)); + put$conversions_Value_array2_u32(rs.sliceFrom(held.value), out); + put$conversions_Value_array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 1)]), out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u32[] = one.data[one.start].slice(); + put$conversions_Value_array2_u32(rs.sliceFrom(one.data[one.start]), out); + const _70: rs.Slice = rs.sliceFrom(a); + const _71: rs.Slice = rs.sliceFrom(copied); + rs.replaceIn(rs.sliceView(_70), rs.sliceToArray(_71)); + put$conversions_Value_array2_u32(rs.sliceFrom(copied), out); + put$conversions_Value_array2_u32(rs.sliceFrom(a), out); + const cell: rs.Cell = rs.cellIn(rs.sliceView(rs.sliceFrom(c))); const old: rs.u32[] = rs.cellReplace(cell, copy$array_u32(make$conversions_Value_array2_u32(data, 10))); rs.cellSet(cell, copy$array_u32(make$conversions_Value_array2_u32(data, 11))); - put$conversions_Value_array2_u32(old, out); - put$conversions_Value_array2_u32(c, out); - const at5 = rs.idx(v.items, 0); - const _91: rs.u32[] = make$conversions_Value_array2_u32(data, 12); - put$conversions_Value_array2_u32(setThrough$array2_u32(v.items[at5], _91), out); - put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 0)], out); - rs.cellSet(rs.cellIn(held.value), copy$array_u32(make$conversions_Value_array2_u32(data, 17))); - put$conversions_Value_array2_u32(held.value, out); + put$conversions_Value_array2_u32(rs.sliceFrom(old), out); + put$conversions_Value_array2_u32(rs.sliceFrom(c), out); + put$conversions_Value_array2_u32(rs.sliceFrom(setThrough$array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 0)]), make$conversions_Value_array2_u32(data, 12))), out); + put$conversions_Value_array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 0)]), out); + rs.cellSet(rs.cellIn(rs.sliceView(rs.sliceFrom(held.value))), copy$array_u32(make$conversions_Value_array2_u32(data, 17))); + put$conversions_Value_array2_u32(rs.sliceFrom(held.value), out); const array: rs.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 13)), copy$array_u32(make$conversions_Value_array2_u32(data, 14)), copy$array_u32(make$conversions_Value_array2_u32(data, 15))]; rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(array).length, rs.sliceFrom(array).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rs.u32[] = copy$array_u32(copy$array_u32(b)); + const _114: rs.u32[] = copy$array_u32(b.slice()); const _116: rs.Slice = rs.sliceFrom(array); rs.idx(_116, 0); _116.data[_116.start] = _114; const _124: rs.Slice = rs.sliceFrom(array); rs.idx(_124, 2); - _124.data[_124.start + 2] = copy$array_u32(c); - for (const _134 of array) { + const _123: rs.Slice = rs.sliceFrom(_124.data[_124.start + 2]); + const _130: rs.Slice = rs.sliceFrom(c); + rs.replaceIn(rs.sliceView(_123), rs.sliceToArray(_130)); + const iter: rs.Iter> = rs.iterLend(rs.iterSlice(array), rs.sliceFrom); + while (true) { + const _134: rs.Slice | rs.Done = iter.next(); + if (_134 === rs.DONE) { + break; + } put$conversions_Value_array2_u32(_134, out); } const list: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 13), make$conversions_Value_array2_u32(data, 14)]).map(copy$array_u32)); @@ -2640,32 +2660,34 @@ export function converted$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(list.items).length, list.items.length, rs.sliceFrom(none.items).length, rs.sliceFrom(none.items).length, rs.sliceFrom(list.items).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rs.u32[] = copy$array_u32(copy$array_u32(b)); + const _163: rs.u32[] = copy$array_u32(b.slice()); const _165: rs.Slice = rs.sliceFrom(list.items); rs.idx(_165, 0); _165.data[_165.start] = _163; const _173: rs.Slice = rs.sliceFrom(list.items); rs.idx(_173, 1); - _173.data[_173.start + 1] = copy$array_u32(c); + const _172: rs.Slice = rs.sliceFrom(_173.data[_173.start + 1]); + const _179: rs.Slice = rs.sliceFrom(c); + rs.replaceIn(rs.sliceView(_172), rs.sliceToArray(_179)); rs.sliceSwap(rs.sliceFrom(list.items), 0, 1); const _184: rs.Vec = list; const _186: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 15)); _184.items.push(_186); const _188: rs.Vec = none; - const _190: rs.u32[] = copy$array_u32(copy$array_u32(a)); + const _190: rs.u32[] = copy$array_u32(a.slice()); _188.items.push(_190); - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); + const iter2: rs.Iter> = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.sliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.sliceFrom)); while (true) { - const _199: rs.u32[] | rs.Done = iter2.next(); + const _199: rs.Slice | rs.Done = iter2.next(); if (_199 === rs.DONE) { break; } put$conversions_Value_array2_u32(_199, out); } boxed$array2_u32(data, out); - put$conversions_Value_array2_u32(b, out); - rs.ptrWrite(c, copy$array_u32(make$conversions_Value_array2_u32(data, 16))); - put$conversions_Value_array2_u32(c, out); + put$conversions_Value_array2_u32(rs.sliceFrom(b), out); + rs.sliceSet(rs.sliceFrom(c), copy$array_u32(make$conversions_Value_array2_u32(data, 16))); + put$conversions_Value_array2_u32(rs.sliceFrom(c), out); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ @@ -2701,10 +2723,10 @@ export function converted$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array3_u8(rs.byteSliceFrom(held.value), out); put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); - put$conversions_Value_array3_u8(rs.byteSliceFrom(one[0]), out); + const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one.data[one.start])); + put$conversions_Value_array3_u8(rs.byteSliceFrom(one.data[one.start]), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2810,10 +2832,10 @@ export function converted$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void put$conversions_Value_array40_u8(rs.byteSliceFrom(held.value), out); put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); - put$conversions_Value_array40_u8(rs.byteSliceFrom(one[0]), out); + const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one.data[one.start])); + put$conversions_Value_array40_u8(rs.byteSliceFrom(one.data[one.start]), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2921,10 +2943,10 @@ export function converted$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVec Logged.put$conversions_Value(held.value, out); Logged.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); Logged.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); - const one: Logged.Logged[] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: Logged.Logged = Logged.clone$Clone(one[0]); - Logged.put$conversions_Value(one[0], out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: Logged.Logged = Logged.clone$Clone(one.data[one.start]); + Logged.put$conversions_Value(one.data[one.start], out); const old7 = a; a = Logged.clone$Clone(copied); old7[Symbol.dispose](); @@ -3029,10 +3051,10 @@ export function converted$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec) Named.put$conversions_Value(held.value, out); Named.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); Named.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); - const one: Named.Named[] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: Named.Named = Named.clone$Clone(one[0]); - Named.put$conversions_Value(one[0], out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: Named.Named = Named.clone$Clone(one.data[one.start]); + Named.put$conversions_Value(one.data[one.start], out); a = Named.clone$Clone(copied); Named.put$conversions_Value(copied, out); Named.put$conversions_Value(a, out); @@ -3117,10 +3139,10 @@ export function converted$u32(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_u32(held.value, out); put$conversions_Value_u32(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_u32(v.items[rs.idx(v.items, 1)], out); - const one: rs.u32[] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: rs.u32 = one[0]; - put$conversions_Value_u32(one[0], out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u32 = one.data[one.start]; + put$conversions_Value_u32(one.data[one.start], out); a = copied; put$conversions_Value_u32(copied, out); put$conversions_Value_u32(a, out); @@ -3204,10 +3226,10 @@ export function converted$u64(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_u64(held.value, out); put$conversions_Value_u64(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_u64(v.items[rs.idx(v.items, 1)], out); - const one: rs.u64[] = [b]; - rs.byteVecPush(out, rs.sliceFrom(one).length & 0xff); - const copied: rs.u64 = one[0]; - put$conversions_Value_u64(one[0], out); + const one: rs.Slice = rs.sliceFrom([b]); + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u64 = one.data[one.start]; + put$conversions_Value_u64(one.data[one.start], out); a = copied; put$conversions_Value_u64(copied, out); put$conversions_Value_u64(a, out); @@ -3716,31 +3738,31 @@ export function boxed$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { export function boxed$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 19)); boxed = copy$array_u32(copy$array_u32(make$conversions_Value_array2_u32(data, 3))); - put$conversions_Value_array2_u32(boxed, out); + put$conversions_Value_array2_u32(rs.sliceFrom(boxed), out); const source: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 20)); boxed = copy$array_u32(source); - put$conversions_Value_array2_u32(boxed, out); - put$conversions_Value_array2_u32(source, out); + put$conversions_Value_array2_u32(rs.sliceFrom(boxed), out); + put$conversions_Value_array2_u32(rs.sliceFrom(source), out); let nested: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 21)); const _27: rs.u32[] = copy$array_u32(source); nested = ((a0: rs.u32[]): rs.u32[] => { return copy$array_u32(a0); })(_27); - put$conversions_Value_array2_u32(nested, out); + put$conversions_Value_array2_u32(rs.sliceFrom(nested), out); let maybe: rs.u32[] | undefined = copy$array_u32(make$conversions_Value_array2_u32(data, 22)); maybe = option_clone$0xr8mw0(copy$array_u32(boxed)); maybe = option_clone$0xr8mw0(undefined); rs.byteVecPush(out, maybe === undefined ? 1 : 0); maybe = option_clone$0xr8mw0(copy$array_u32(source)); rs.iterForEach(rs.iterOption(maybe), (x: rs.u32[]): undefined => { - put$conversions_Value_array2_u32(x, out); + put$conversions_Value_array2_u32(rs.sliceFrom(x), out); }); const slots: rs.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 23)), copy$array_u32(make$conversions_Value_array2_u32(data, 24))]; rs.sliceCloneFromSlice(rs.sliceFrom(slots), rs.sliceFrom([source, boxed]), (a02: rs.u32[]): rs.u32[] => { return copy$array_u32(a02); }); for (const _73 of slots) { - put$conversions_Value_array2_u32(_73, out); + put$conversions_Value_array2_u32(rs.sliceFrom(_73), out); } const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; const whole: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u32[] => { @@ -3751,9 +3773,9 @@ export function boxed$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 8, true).items); into = rs.boxSliceCloneFrom(into, whole, copy$array_u32); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(into)), rs.iterSlice(rs.sliceItems(whole))); + const iter2: rs.Iter> = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(into)), rs.sliceFrom), rs.iterLend(rs.iterSlice(rs.sliceItems(whole)), rs.sliceFrom)); while (true) { - const _108: rs.u32[] | rs.Done = iter2.next(); + const _108: rs.Slice | rs.Done = iter2.next(); if (_108 === rs.DONE) { break; } @@ -4194,10 +4216,10 @@ export function lentOne$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_Option_u16(writeFirst$Option_u16(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_Option_u16(data, 8)), out); + put$conversions_Value_Option_u16(writeFirst$Option_u16(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Option_u16(data, 8)), out); put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), b, undefined); - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5)))); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { const _61: rs.Place | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4234,10 +4256,10 @@ export function lentOne$String(data: rs.ByteSlice, out: rs.ByteVec): void { const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_String(writeFirst$String(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_String(data, 8)), out); + put$conversions_Value_String(writeFirst$String(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_String(data, 8)), out); put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), b, undefined); - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5)))); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { const _61: rs.Place | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4272,12 +4294,12 @@ export function lentOne$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_Vec_u32(writeFirst$Vec_u32(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_Vec_u32(data, 8)), out); + put$conversions_Value_Vec_u32(writeFirst$Vec_u32(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Vec_u32(data, 8)), out); put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), rs.vecFrom(b.items.slice()), (a0: rs.Vec): rs.Vec => { return rs.vecFrom(a0.items.slice()); }, undefined, rs.vecCloneFromFn(4)); - for (const _61 of rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5))) { + for (const _61 of rs.sliceItems(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5)))) { Object.assign(_61, make$conversions_Value_Vec_u32(data, 9)); } put$conversions_Value_Vec_u32(c, out); @@ -4307,12 +4329,12 @@ export function lentOne$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_Vec_u8(writeFirst$Vec_u8(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_Vec_u8(data, 8)), out); + put$conversions_Value_Vec_u8(writeFirst$Vec_u8(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Vec_u8(data, 8)), out); put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), rs.byteVecFrom(rs.byteVecView(b)), (a0: rs.ByteVec): rs.ByteVec => { return rs.byteVecFrom(rs.byteVecView(a0)); }, undefined, rs.byteVecCloneFromFn()); - for (const _61 of rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5))) { + for (const _61 of rs.sliceItems(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5)))) { Object.assign(_61, make$conversions_Value_Vec_u8(data, 9)); } put$conversions_Value_Vec_u8(c, out); @@ -4338,10 +4360,10 @@ export function lentOne$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array0_u8(rs.byteSliceFrom(a), out); put$conversions_Value_array0_u8(rs.byteSliceFrom(writeFirst$array0_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array0_u8(data, 7))), out); put$conversions_Value_array0_u8(rs.byteSliceFrom(held.value), out); - put$conversions_Value_array0_u8(rs.byteSliceFrom(writeFirst$array0_u8(rs.sliceFrom(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)])))), make$conversions_Value_array0_u8(data, 8))), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(writeFirst$array0_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array0_u8(data, 8))), out); put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4375,10 +4397,10 @@ export function lentOne$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array1_u8(rs.byteSliceFrom(a), out); put$conversions_Value_array1_u8(rs.byteSliceFrom(writeFirst$array1_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array1_u8(data, 7))), out); put$conversions_Value_array1_u8(rs.byteSliceFrom(held.value), out); - put$conversions_Value_array1_u8(rs.byteSliceFrom(writeFirst$array1_u8(rs.sliceFrom(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)])))), make$conversions_Value_array1_u8(data, 8))), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(writeFirst$array1_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array1_u8(data, 8))), out); put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4396,31 +4418,33 @@ export function lentOne$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { */ export function lentOne$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [rs.u32[], rs.u32[], rs.u32[]] = [copy$array_u32(make$conversions_Value_array2_u32(data, 0)), copy$array_u32(make$conversions_Value_array2_u32(data, 3)), copy$array_u32(make$conversions_Value_array2_u32(data, 6))]; - let a: rs.u32[] = _6[0]; + const a: rs.u32[] = _6[0]; const b: rs.u32[] = _6[1]; - let c: rs.u32[] = _6[2]; + const c: rs.u32[] = _6[2]; const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); const v: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); - const s: rs.Slice = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + const s: rs.Slice = rs.sliceIn(rs.sliceView(rs.sliceFrom(a))); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); + const _23: rs.Slice = rs.sliceFrom(s.data[s.start]); const _28: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 5)); - put$conversions_Value_array2_u32(rs.sliceReplace(s.data, s.start, _28), out); - put$conversions_Value_array2_u32(a, out); - const borrowed = held; - put$conversions_Value_array2_u32(writeFirst$array2_u32(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_array2_u32(data, 7)), out); - put$conversions_Value_array2_u32(held.value, out); - const at = rs.idx(v.items, 1); - const borrowed2 = v.items; - const borrowed3 = at; - put$conversions_Value_array2_u32(writeFirst$array2_u32(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_array2_u32(data, 8)), out); - put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 1)], out); - rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), copy$array_u32(copy$array_u32(b)), copy$array_u32); - for (const _61 of rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5))) { - Object.assign(_61, copy$array_u32(make$conversions_Value_array2_u32(data, 9))); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.replaceIn(rs.sliceView(_23), _28)), out); + put$conversions_Value_array2_u32(rs.sliceFrom(a), out); + put$conversions_Value_array2_u32(rs.sliceFrom(writeFirst$array2_u32(rs.sliceIn(rs.sliceView(rs.sliceFrom(held.value))), make$conversions_Value_array2_u32(data, 7))), out); + put$conversions_Value_array2_u32(rs.sliceFrom(held.value), out); + put$conversions_Value_array2_u32(rs.sliceFrom(writeFirst$array2_u32(rs.sliceIn(rs.sliceView(rs.sliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array2_u32(data, 8))), out); + put$conversions_Value_array2_u32(rs.sliceFrom(v.items[rs.idx(v.items, 1)]), out); + rs.sliceFill(rs.sliceIn(rs.sliceView(rs.sliceFrom(c))), copy$array_u32(b.slice()), copy$array_u32); + const iter: rs.Iter> = rs.iterLend(rs.iterSlice(rs.sliceItems(rs.sliceIn(rs.sliceView(rs.sliceFrom(a))))), rs.sliceFrom); + while (true) { + const _61: rs.Slice | rs.Done = iter.next(); + if (_61 === rs.DONE) { + break; + } + rs.sliceSet(_61, copy$array_u32(make$conversions_Value_array2_u32(data, 9))); } - put$conversions_Value_array2_u32(c, out); - put$conversions_Value_array2_u32(a, out); + put$conversions_Value_array2_u32(rs.sliceFrom(c), out); + put$conversions_Value_array2_u32(rs.sliceFrom(a), out); } /** @@ -4445,10 +4469,10 @@ export function lentOne$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array3_u8(rs.byteSliceFrom(a), out); put$conversions_Value_array3_u8(rs.byteSliceFrom(writeFirst$array3_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array3_u8(data, 7))), out); put$conversions_Value_array3_u8(rs.byteSliceFrom(held.value), out); - put$conversions_Value_array3_u8(rs.byteSliceFrom(writeFirst$array3_u8(rs.sliceFrom(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)])))), make$conversions_Value_array3_u8(data, 8))), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(writeFirst$array3_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array3_u8(data, 8))), out); put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4482,10 +4506,10 @@ export function lentOne$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array40_u8(rs.byteSliceFrom(a), out); put$conversions_Value_array40_u8(rs.byteSliceFrom(writeFirst$array40_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array40_u8(data, 7))), out); put$conversions_Value_array40_u8(rs.byteSliceFrom(held.value), out); - put$conversions_Value_array40_u8(rs.byteSliceFrom(writeFirst$array40_u8(rs.sliceFrom(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)])))), make$conversions_Value_array40_u8(data, 8))), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(writeFirst$array40_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array40_u8(data, 8))), out); put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.arrayIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4522,11 +4546,11 @@ export function lentOne$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVec): const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - const old3: Logged.Logged = writeFirst$conversions_Logged(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), Logged.make$conversions_Value(data, 8)); + const old3: Logged.Logged = writeFirst$conversions_Logged(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), Logged.make$conversions_Value(data, 8)); Logged.put$conversions_Value(old3, out); Logged.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), Logged.clone$Clone(b), Logged.clone$Clone, rs.drop); - for (const _61 of rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5))) { + for (const _61 of rs.sliceItems(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5)))) { const _65: Logged.Logged = Logged.make$conversions_Value(data, 9); _61[Symbol.dispose](); Object.assign(_61, _65); @@ -4566,10 +4590,10 @@ export function lentOne$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec): const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - Named.put$conversions_Value(writeFirst$conversions_Named(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), Named.make$conversions_Value(data, 8)), out); + Named.put$conversions_Value(writeFirst$conversions_Named(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), Named.make$conversions_Value(data, 8)), out); Named.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), Named.clone$Clone(b), Named.clone$Clone); - for (const _61 of rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5))) { + for (const _61 of rs.sliceItems(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5)))) { Object.assign(_61, Named.make$conversions_Value(data, 9)); } Named.put$conversions_Value(c, out); @@ -4601,10 +4625,10 @@ export function lentOne$u32(data: rs.ByteSlice, out: rs.ByteVec): void { const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_u32(writeFirst$u32(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_u32(data, 8)), out); + put$conversions_Value_u32(writeFirst$u32(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_u32(data, 8)), out); put$conversions_Value_u32(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), b, undefined); - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5)))); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { const _61: rs.Place | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4641,10 +4665,10 @@ export function lentOne$u64(data: rs.ByteSlice, out: rs.ByteVec): void { const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_u64(writeFirst$u64(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3))), make$conversions_Value_u64(data, 8)), out); + put$conversions_Value_u64(writeFirst$u64(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_u64(data, 8)), out); put$conversions_Value_u64(v.items[rs.idx(v.items, 1)], out); rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), b, undefined); - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(rs.arrayOfPlace(rs.place(() => a, (value5) => a = value5)))); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { const _61: rs.Place | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -5024,7 +5048,7 @@ export function searched$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { return make$conversions_Value_array2_u32(data, i2); }), undefined, 8, true); rs.sliceSort(rs.sliceFrom(v.items), rs.cmpLt(rs.cmpSlice(rs.cmp)), 8, true); - const tagged: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), copy$array_u32), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 12, true); + const tagged: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.sliceFrom), rs.sliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 12, true); const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { const _24: rs.usize | rs.Done = iter.next(); @@ -5042,16 +5066,21 @@ export function searched$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { continue l1; } const x: rs.u32[] = make$conversions_Value_array2_u32(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); - const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpSlice(rs.cmp)), rs.sliceBinarySearchBy(s, (e: rs.u32[]): rs.Ordering => { + const _59: rs.Slice = rs.sliceFrom(x); + const _58: (a0: rs.Slice) => rs.Ordering = (e: rs.Slice): rs.Ordering => { put$conversions_Value_array2_u32(e, out); - return rs.cmpSlice(rs.cmp)(e, x); - }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.u32[], rs.u8]): rs.u32[] => { + return rs.cmpSlice(rs.cmp)(e, _59); + }; + const _66: rs.Slice = rs.sliceFrom(x); + const _65: (a0: rs.Slice) => boolean = (e3: rs.Slice): boolean => { + put$conversions_Value_array2_u32(e3, out); + return rs.cmpSlice(rs.cmp)(e3, _66) === -1; + }; + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpSlice(rs.cmp)), rs.sliceBinarySearchBy(s, (held) => _58(rs.sliceFrom(held))), rs.sliceBinarySearchByKey(t, x, (_2: [rs.u32[], rs.u8]): rs.u32[] => { + const e2: rs.Slice = rs.sliceFrom(_2[0]); rs.byteVecPush(out, _2[1]); - return copy$array_u32(_2[0]); - }, rs.cmpSlice(rs.cmp)), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.u32[]): boolean => { - put$conversions_Value_array2_u32(e2, out); - return rs.cmpSlice(rs.cmp)(e2, x) === -1; - }))]); + return rs.sliceToArray(e2); + }, rs.cmpSlice(rs.cmp)), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.sliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5507,17 +5536,17 @@ export function measured(data: rs.ByteSlice, out: rs.ByteVec): void { const _48: [rs.usize, rs.usize] = [_49, 2]; const _59: [rs.usize, rs.usize] = [8, 4]; const _72: rs.u16 = n & 0xffff; - Array.from({ length: 3 }, (): rs.u16 => { + rs.sliceFrom(Array.from({ length: 3 }, (): rs.u16 => { return _72; - }); + })); const _69: rs.usize = 6; const _76: rs.u16 = n & 0xffff; const iter: rs.Iter<[rs.usize, rs.usize]> = rs.iterSlice([_12, _19, _22, _29, _36, _41, _48, _59, [_69, 2] as [rs.usize, rs.usize], [16, 4] as [rs.usize, rs.usize], [12, 4] as [rs.usize, rs.usize], [0, 1] as [rs.usize, rs.usize]]); while (true) { const _94: [rs.usize, rs.usize] | rs.Done = iter.next(); - Array.from({ length: 3 }, (): rs.u16 => { + rs.sliceFrom(Array.from({ length: 3 }, (): rs.u16 => { return _76; - }); + })); if (_94 === rs.DONE) { break; } @@ -5556,13 +5585,12 @@ export function referenced$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void const list: rs.Vec = rs.vecFrom([make$conversions_Value_Option_u16(data, 16), make$conversions_Value_Option_u16(data, 17)]); readAs$Option_u16_ref_slice_Option_u16(rs.sliceFrom(array), out); readAs$Option_u16_ref_ref_slice_Option_u16(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$Option_u16_ref_array3_Option_u16(array, out); + readAs$Option_u16_ref_array3_Option_u16(rs.sliceFrom(array), out); readAs$Option_u16_ref_Vec_Option_u16(list, out); readAs$Option_u16_mut_Vec_Option_u16(list, out); readAs$Option_u16_ref_mut_Vec_Option_u16(list, out); writeAs$Option_u16_mut_slice_Option_u16(rs.sliceFrom(array), make$conversions_Value_Option_u16(data, 18)); - const _35: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 19); - writeAs$Option_u16_mut_array3_Option_u16(array, _35); + writeAs$Option_u16_mut_array3_Option_u16(rs.sliceFrom(array), make$conversions_Value_Option_u16(data, 19)); const _38: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 20); writeAs$Option_u16_mut_Vec_Option_u16(list, _38); let _41: rs.Vec = list; @@ -5616,13 +5644,12 @@ export function referenced$String(data: rs.ByteSlice, out: rs.ByteVec): void { const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 16), make$conversions_Value_String(data, 17)]); readAs$String_ref_slice_String(rs.sliceFrom(array), out); readAs$String_ref_ref_slice_String(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$String_ref_array3_String(array, out); + readAs$String_ref_array3_String(rs.sliceFrom(array), out); readAs$String_ref_Vec_String(list, out); readAs$String_mut_Vec_String(list, out); readAs$String_ref_mut_Vec_String(list, out); writeAs$String_mut_slice_String(rs.sliceFrom(array), make$conversions_Value_String(data, 18)); - const _35: string = make$conversions_Value_String(data, 19); - writeAs$String_mut_array3_String(array, _35); + writeAs$String_mut_array3_String(rs.sliceFrom(array), make$conversions_Value_String(data, 19)); const _38: string = make$conversions_Value_String(data, 20); writeAs$String_mut_Vec_String(list, _38); let _41: rs.Vec = list; @@ -5676,13 +5703,12 @@ export function referenced$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const list: rs.Vec = rs.vecFrom([make$conversions_Value_Vec_u8(data, 16), make$conversions_Value_Vec_u8(data, 17)]); readAs$Vec_u8_ref_slice_Vec_u8(rs.sliceFrom(array), out); readAs$Vec_u8_ref_ref_slice_Vec_u8(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$Vec_u8_ref_array3_Vec_u8(array, out); + readAs$Vec_u8_ref_array3_Vec_u8(rs.sliceFrom(array), out); readAs$Vec_u8_ref_Vec_Vec_u8(list, out); readAs$Vec_u8_mut_Vec_Vec_u8(list, out); readAs$Vec_u8_ref_mut_Vec_Vec_u8(list, out); writeAs$Vec_u8_mut_slice_Vec_u8(rs.sliceFrom(array), make$conversions_Value_Vec_u8(data, 18)); - const _35: rs.ByteVec = make$conversions_Value_Vec_u8(data, 19); - writeAs$Vec_u8_mut_array3_Vec_u8(array, _35); + writeAs$Vec_u8_mut_array3_Vec_u8(rs.sliceFrom(array), make$conversions_Value_Vec_u8(data, 19)); const _38: rs.ByteVec = make$conversions_Value_Vec_u8(data, 20); writeAs$Vec_u8_mut_Vec_Vec_u8(list, _38); let _41: rs.Vec = list; @@ -5735,13 +5761,12 @@ export function referenced$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void const list: rs.Vec = rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 16), make$conversions_Value_array3_u8(data, 17)]).map(copy$array_u8)); readAs$array3_u8_ref_slice_array3_u8(rs.sliceFrom(array), out); readAs$array3_u8_ref_ref_slice_array3_u8(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$array3_u8_ref_array3_array3_u8(array, out); + readAs$array3_u8_ref_array3_array3_u8(rs.sliceFrom(array), out); readAs$array3_u8_ref_Vec_array3_u8(list, out); readAs$array3_u8_mut_Vec_array3_u8(list, out); readAs$array3_u8_ref_mut_Vec_array3_u8(list, out); writeAs$array3_u8_mut_slice_array3_u8(rs.sliceFrom(array), make$conversions_Value_array3_u8(data, 18)); - const _35: Uint8Array = make$conversions_Value_array3_u8(data, 19); - writeAs$array3_u8_mut_array3_array3_u8(array, _35); + writeAs$array3_u8_mut_array3_array3_u8(rs.sliceFrom(array), make$conversions_Value_array3_u8(data, 19)); const _38: Uint8Array = make$conversions_Value_array3_u8(data, 20); writeAs$array3_u8_mut_Vec_array3_u8(list, _38); let _41: rs.Vec = list; @@ -5790,13 +5815,12 @@ export function referenced$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVe const list: rs.Vec = rs.vecFrom([Logged.make$conversions_Value(data, 16), Logged.make$conversions_Value(data, 17)]); readAs$conversions_Logged_ref_slice_conversions_Logged(rs.sliceFrom(array), out); readAs$conversions_Logged_ref_ref_slice_conversions_Logged(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$conversions_Logged_ref_array3_conversions_Logged(array, out); + readAs$conversions_Logged_ref_array3_conversions_Logged(rs.sliceFrom(array), out); readAs$conversions_Logged_ref_Vec_conversions_Logged(list, out); readAs$conversions_Logged_mut_Vec_conversions_Logged(list, out); readAs$conversions_Logged_ref_mut_Vec_conversions_Logged(list, out); writeAs$conversions_Logged_mut_slice_conversions_Logged(rs.sliceFrom(array), Logged.make$conversions_Value(data, 18)); - const _35: Logged.Logged = Logged.make$conversions_Value(data, 19); - writeAs$conversions_Logged_mut_array3_conversions_Logged(array, _35); + writeAs$conversions_Logged_mut_array3_conversions_Logged(rs.sliceFrom(array), Logged.make$conversions_Value(data, 19)); const _38: Logged.Logged = Logged.make$conversions_Value(data, 20); writeAs$conversions_Logged_mut_Vec_conversions_Logged(list, _38); let _41: rs.Vec = list; @@ -5857,13 +5881,12 @@ export function referenced$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec const list: rs.Vec = rs.vecFrom([Named.make$conversions_Value(data, 16), Named.make$conversions_Value(data, 17)]); readAs$conversions_Named_ref_slice_conversions_Named(rs.sliceFrom(array), out); readAs$conversions_Named_ref_ref_slice_conversions_Named(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$conversions_Named_ref_array3_conversions_Named(array, out); + readAs$conversions_Named_ref_array3_conversions_Named(rs.sliceFrom(array), out); readAs$conversions_Named_ref_Vec_conversions_Named(list, out); readAs$conversions_Named_mut_Vec_conversions_Named(list, out); readAs$conversions_Named_ref_mut_Vec_conversions_Named(list, out); writeAs$conversions_Named_mut_slice_conversions_Named(rs.sliceFrom(array), Named.make$conversions_Value(data, 18)); - const _35: Named.Named = Named.make$conversions_Value(data, 19); - writeAs$conversions_Named_mut_array3_conversions_Named(array, _35); + writeAs$conversions_Named_mut_array3_conversions_Named(rs.sliceFrom(array), Named.make$conversions_Value(data, 19)); const _38: Named.Named = Named.make$conversions_Value(data, 20); writeAs$conversions_Named_mut_Vec_conversions_Named(list, _38); let _41: rs.Vec = list; @@ -5916,13 +5939,12 @@ export function referenced$u32(data: rs.ByteSlice, out: rs.ByteVec): void { const list: rs.Vec = rs.vecFrom([make$conversions_Value_u32(data, 16), make$conversions_Value_u32(data, 17)]); readAs$u32_ref_slice_u32(rs.sliceFrom(array), out); readAs$u32_ref_ref_slice_u32(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$u32_ref_array3_u32(array, out); + readAs$u32_ref_array3_u32(rs.sliceFrom(array), out); readAs$u32_ref_Vec_u32(list, out); readAs$u32_mut_Vec_u32(list, out); readAs$u32_ref_mut_Vec_u32(list, out); writeAs$u32_mut_slice_u32(rs.sliceFrom(array), make$conversions_Value_u32(data, 18)); - const _35: rs.u32 = make$conversions_Value_u32(data, 19); - writeAs$u32_mut_array3_u32(array, _35); + writeAs$u32_mut_array3_u32(rs.sliceFrom(array), make$conversions_Value_u32(data, 19)); const _38: rs.u32 = make$conversions_Value_u32(data, 20); writeAs$u32_mut_Vec_u32(list, _38); let _41: rs.Vec = list; @@ -5976,13 +5998,12 @@ export function referenced$u64(data: rs.ByteSlice, out: rs.ByteVec): void { const list: rs.Vec = rs.vecFrom([make$conversions_Value_u64(data, 16), make$conversions_Value_u64(data, 17)]); readAs$u64_ref_slice_u64(rs.sliceFrom(array), out); readAs$u64_ref_ref_slice_u64(rs.sliceRange(rs.sliceFrom(array), 1), out); - readAs$u64_ref_array3_u64(array, out); + readAs$u64_ref_array3_u64(rs.sliceFrom(array), out); readAs$u64_ref_Vec_u64(list, out); readAs$u64_mut_Vec_u64(list, out); readAs$u64_ref_mut_Vec_u64(list, out); writeAs$u64_mut_slice_u64(rs.sliceFrom(array), make$conversions_Value_u64(data, 18)); - const _35: rs.u64 = make$conversions_Value_u64(data, 19); - writeAs$u64_mut_array3_u64(array, _35); + writeAs$u64_mut_array3_u64(rs.sliceFrom(array), make$conversions_Value_u64(data, 19)); const _38: rs.u64 = make$conversions_Value_u64(data, 20); writeAs$u64_mut_Vec_u64(list, _38); let _41: rs.Vec = list; @@ -6123,8 +6144,8 @@ export function readAs$Option_u16_ref_Vec_Option_u16(b: rs.Vec, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b); +export function readAs$Option_u16_ref_array3_Option_u16(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_Option_u16(_10, out); @@ -6177,8 +6198,8 @@ export function readAs$String_ref_Vec_String(b: rs.Vec, out: rs.ByteVec) } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$String_ref_array3_String(b: string[], out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b); +export function readAs$String_ref_array3_String(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_String(_10, out); @@ -6231,8 +6252,8 @@ export function readAs$Vec_u8_ref_Vec_Vec_u8(b: rs.Vec, out: rs.Byte } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$Vec_u8_ref_array3_Vec_u8(b: rs.ByteVec[], out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b); +export function readAs$Vec_u8_ref_array3_Vec_u8(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_Vec_u8(_10, out); @@ -6295,8 +6316,8 @@ export function readAs$array3_u8_ref_Vec_array3_u8(b: rs.Vec, out: r } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$array3_u8_ref_array3_array3_u8(b: Uint8Array[], out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b); +export function readAs$array3_u8_ref_array3_array3_u8(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(s)), rs.byteSliceFrom); while (true) { @@ -6369,8 +6390,8 @@ export function readAs$conversions_Logged_ref_Vec_conversions_Logged(b: rs.Vec = rs.sliceFrom(b); +export function readAs$conversions_Logged_ref_array3_conversions_Logged(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { Logged.put$conversions_Value(_10, out); @@ -6423,8 +6444,8 @@ export function readAs$conversions_Named_ref_Vec_conversions_Named(b: rs.Vec = rs.sliceFrom(b); +export function readAs$conversions_Named_ref_array3_conversions_Named(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { Named.put$conversions_Value(_10, out); @@ -6477,8 +6498,8 @@ export function readAs$u32_ref_Vec_u32(b: rs.Vec, out: rs.ByteVec): void } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$u32_ref_array3_u32(b: rs.u32[], out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b); +export function readAs$u32_ref_array3_u32(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_u32(_10, out); @@ -6531,8 +6552,8 @@ export function readAs$u64_ref_Vec_u64(b: rs.Vec, out: rs.ByteVec): void } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$u64_ref_array3_u64(b: rs.u64[], out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b); +export function readAs$u64_ref_array3_u64(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_u64(_10, out); @@ -6629,8 +6650,8 @@ export function writeAs$Option_u16_mut_Vec_Option_u16(b: rs.Vec, value: rs.u16 | undefined): void { - const _3: rs.Place | undefined = rs.sliceLastMut(rs.sliceFrom(b)); +export function writeAs$Option_u16_mut_array3_Option_u16(b: rs.Slice, value: rs.u16 | undefined): void { + const _3: rs.Place | undefined = rs.sliceLastMut(b); if (_3 !== undefined) { _3.v = value; } @@ -6661,8 +6682,8 @@ export function writeAs$String_mut_Vec_String(b: rs.Vec, value: string): } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$String_mut_array3_String(b: string[], value: string): void { - const _3: rs.Place | undefined = rs.sliceLastMut(rs.sliceFrom(b)); +export function writeAs$String_mut_array3_String(b: rs.Slice, value: string): void { + const _3: rs.Place | undefined = rs.sliceLastMut(b); if (_3 !== undefined) { _3.v = value; } @@ -6693,8 +6714,8 @@ export function writeAs$Vec_u8_mut_Vec_Vec_u8(b: rs.Vec, value: rs.B } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$Vec_u8_mut_array3_Vec_u8(b: rs.ByteVec[], value: rs.ByteVec): void { - const _3: rs.ByteVec | undefined = rs.sliceLast(rs.sliceFrom(b)); +export function writeAs$Vec_u8_mut_array3_Vec_u8(b: rs.Slice, value: rs.ByteVec): void { + const _3: rs.ByteVec | undefined = rs.sliceLast(b); if (_3 !== undefined) { Object.assign(_3, value); } @@ -6726,9 +6747,9 @@ export function writeAs$array3_u8_mut_Vec_array3_u8(b: rs.Vec, value } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$array3_u8_mut_array3_array3_u8(b: Uint8Array[], value: Uint8Array): void { +export function writeAs$array3_u8_mut_array3_array3_u8(b: rs.Slice, value: Uint8Array): void { value = copy$array_u8(value); - const _3: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(rs.sliceFrom(b)), rs.byteSliceFrom); + const _3: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(b), rs.byteSliceFrom); if (_3 !== undefined) { _3.data.set(value, _3.start); } @@ -6768,10 +6789,10 @@ export function writeAs$conversions_Logged_mut_Vec_conversions_Logged(b: rs.Vec< } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$conversions_Logged_mut_array3_conversions_Logged(b: Logged.Logged[], value: Logged.Logged): void { +export function writeAs$conversions_Logged_mut_array3_conversions_Logged(b: rs.Slice, value: Logged.Logged): void { let _9: boolean = false; _9 = true; - const _3: Logged.Logged | undefined = rs.sliceLast(rs.sliceFrom(b)); + const _3: Logged.Logged | undefined = rs.sliceLast(b); if (_3 !== undefined) { _9 = false; _3[Symbol.dispose](); @@ -6821,8 +6842,8 @@ export function writeAs$conversions_Named_mut_Vec_conversions_Named(b: rs.Vec, value: Named.Named): void { + const _3: Named.Named | undefined = rs.sliceLast(b); if (_3 !== undefined) { Object.assign(_3, value); } @@ -6853,8 +6874,8 @@ export function writeAs$u32_mut_Vec_u32(b: rs.Vec, value: rs.u32): void } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$u32_mut_array3_u32(b: rs.u32[], value: rs.u32): void { - const _3: rs.Place | undefined = rs.sliceLastMut(rs.sliceFrom(b)); +export function writeAs$u32_mut_array3_u32(b: rs.Slice, value: rs.u32): void { + const _3: rs.Place | undefined = rs.sliceLastMut(b); if (_3 !== undefined) { _3.v = value; } @@ -6885,8 +6906,8 @@ export function writeAs$u64_mut_Vec_u64(b: rs.Vec, value: rs.u64): void } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$u64_mut_array3_u64(b: rs.u64[], value: rs.u64): void { - const _3: rs.Place | undefined = rs.sliceLastMut(rs.sliceFrom(b)); +export function writeAs$u64_mut_array3_u64(b: rs.Slice, value: rs.u64): void { + const _3: rs.Place | undefined = rs.sliceLastMut(b); if (_3 !== undefined) { _3.v = value; } diff --git a/ts/fixtures/lang/conversions/expected/harness.ts b/ts/fixtures/lang/conversions/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/conversions/expected/harness.ts +++ b/ts/fixtures/lang/conversions/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/conversions/expected/lib.ts b/ts/fixtures/lang/conversions/expected/lib.ts index b3658134d..0a7051530 100644 --- a/ts/fixtures/lang/conversions/expected/lib.ts +++ b/ts/fixtures/lang/conversions/expected/lib.ts @@ -2,7 +2,8 @@ import * as rs from "./rs.ts"; import { conversions } from "./conversions.ts"; -import type * as Logged from "./conversions.Logged.ts"; +import * as Logged from "./conversions.Logged.ts"; +import type * as Named from "./conversions.Named.ts"; export function copy$array_Option_u16(v: Array): Array { return v.slice(); @@ -40,6 +41,14 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } +export function copy$conversions_Logged(v: Logged.Logged): Logged.Logged { + return new Logged.Logged(v.id, v.log); +} + +export function copy$conversions_Named(v: Named.Named): Named.Named { + return { id: v.id, name: v.name }; +} + export function drop$tuple2_conversions_Logged_u8(_1: [Logged.Logged, rs.u8]): void { _1[0][Symbol.dispose](); } diff --git a/ts/fixtures/lang/counts/expected/harness.ts b/ts/fixtures/lang/counts/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/counts/expected/harness.ts +++ b/ts/fixtures/lang/counts/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/cows/expected/cows.Named.ts b/ts/fixtures/lang/cows/expected/cows.Named.ts index 666855c14..4b3e279d3 100644 --- a/ts/fixtures/lang/cows/expected/cows.Named.ts +++ b/ts/fixtures/lang/cows/expected/cows.Named.ts @@ -56,8 +56,7 @@ function new_(s: string, id: rs.u8): Named { if (!(trimmed.length === 0)) { name = new rs.Borrowed(trimmed); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(id, f)]; - name = rs.fmtFormat(["#", args2[0]]); + name = rs.fmtFormat(["#", (f: rs.Formatter) => rs.u8Display(id, f)]); } return { name, id }; } diff --git a/ts/fixtures/lang/cows/expected/cows.ts b/ts/fixtures/lang/cows/expected/cows.ts index 27ece197b..be2f65cbd 100644 --- a/ts/fixtures/lang/cows/expected/cows.ts +++ b/ts/fixtures/lang/cows/expected/cows.ts @@ -100,16 +100,16 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: Named.Named = Named.new(first, kind); const m2: Named.Named = Named.clone$Clone(n); Named.tag(n, 120); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Named.fmt$fmt_Debug(n, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(m2, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + const args11 = [(f: rs.Formatter) => Named.fmt$fmt_Debug(n, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(m2, f)]; + put(out, rs.fmtFormat([args11[0], " ", args11[1]])); rs.byteVecPush(out, Named.eq$cmp_PartialEq(n, m2) ? 1 : 0); rs.byteVecPush(out, Named.cmp$cmp_Ord(n, m2) > 0 ? 1 : 0); rs.byteVecPush(out, Named.partialCmp$cmp_PartialOrd(n, m2) === -1 ? 1 : 0); put(out, rs.strCowStr(Named.intoOwned(n).name)); const _270: Named.Named = Named.default$Default(); const _272: Named.Named = Named.new("", kind); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Named.fmt$fmt_Debug(_270, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(_272, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1]])); + const args12 = [(f: rs.Formatter) => Named.fmt$fmt_Debug(_270, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(_272, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1]])); } else if (_14 === 4) { const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; const iter3: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.strSplit(s, "/")); @@ -147,11 +147,10 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(names, _339) ? 1 : 0); } else { const c4: rs.StrCow = cow(s, owned); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(c4)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(c4), f)]; - put(out, rs.fmtFormat(["[", args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 3 }, args6[0]), "|", args6[1], "]"])); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(c4)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(c4), f)]; + put(out, rs.fmtFormat(["[", args9[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args9[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args9[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args9[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 3 }, args9[0]), "|", args9[1], "]"])); const part2 = cow(first, owned); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.StrCow, f: rs.Formatter) => rs.fmtStr(rs.strCowStr(value), f))]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.StrCow, f: rs.Formatter) => rs.fmtStr(rs.strCowStr(value), f))])); } } @@ -315,8 +314,8 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _250: [string, rs.Vec] = rs.tupleExtend(["", new rs.Vec()] as [string, rs.Vec], _251, [rs.STRING_COW_PART, rs.vecPart(4)]); const texts: string = _250[0]; const lens: rs.Vec = _250[1]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, collected), (f: rs.Formatter) => rs.fmtPad(f, extended), (f: rs.Formatter) => rs.fmtPad(f, texts), (f: rs.Formatter) => rs.fmtList(lens.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]])); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, collected), (f: rs.Formatter) => rs.fmtPad(f, extended), (f: rs.Formatter) => rs.fmtPad(f, texts), (f: rs.Formatter) => rs.fmtList(lens.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3]])); const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; const iter5: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); while (true) { @@ -462,8 +461,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putWords(out, rs.cowSlice(c)); putWords(out, rs.cowSlice(c)); putWords(out, rs.cowSlice(rs.cowClone(c))); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(c)), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(c)), f, rs.u16Debug)])); putWords(out, rs.sliceFrom(rs.cowIntoOwned(c).items)); putWords(out, rs.cowSlice(new rs.Vec())); const iter: rs.Iter> = rs.iterSlice([new rs.Borrowed(half), rs.vecFrom(v.items.slice()), new rs.Borrowed(rs.sliceFrom(v.items)), new rs.Borrowed(rs.sliceFrom([3, 1, 4])), rs.iterToVec(rs.iterRev(rs.iterSlice(v.items)), undefined, 2, true)]); @@ -501,8 +499,8 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const run: Run.Run = { words: cowOf(half, owned) }; const before: Run.Run = Run.clone$Clone(run); Run.bump(run); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Run.fmt$fmt_Debug(run, f), (f: rs.Formatter) => Run.fmt$fmt_Debug(before, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1]])); + const args8 = [(f: rs.Formatter) => Run.fmt$fmt_Debug(run, f), (f: rs.Formatter) => Run.fmt$fmt_Debug(before, f)]; + put(out, rs.fmtFormat([args8[0], " ", args8[1]])); putWords(out, half); putWords(out, rs.sliceFrom(rs.cowIntoOwned(c2).items)); } else if (_15 === 2) { @@ -525,10 +523,10 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _219: rs.Slice = rs.sliceFrom(v.items); const _216: boolean = !rs.eqSlice(rs.same)(_219, rs.cowSlice(a)); const _223: rs.Slice = rs.cowSlice(a); - const _222: boolean = rs.eqSlice(rs.same)(_223, array); + const _225: rs.Slice = rs.sliceFrom(array); + const _222: boolean = rs.eqSlice(rs.same)(_223, _225); const _227: rs.Slice = rs.cowSlice(b); - const part6 = rs.min(half.length, 2); - const _229: rs.Slice = rs.sliceRange(rs.sliceFrom(array), 0, part6); + const _229: rs.Slice = rs.sliceRange(rs.sliceFrom(array), 0, rs.min(half.length, 2)); const _226: boolean = rs.eqSlice(rs.same)(_227, _229); const _234: boolean = rs.cowBy(rs.cmpSlice(rs.cmp))(a, b) < 0; const _238: boolean = rs.cowBy(rs.cmpSlice(rs.cmp))(a, b) === 1; @@ -641,8 +639,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _435: Run.Run = { words: cowOf(rs.sliceRange(rs.sliceFrom(v.items), 0, part3), !owned) }; rs.byteVecPush(out, rs.hashContains(runs, _435) ? 1 : 0); const part4 = Run.default$Default(); - const args6: rs.Fmt[] = [(f: rs.Formatter) => Run.fmt$fmt_Debug(part4, f)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => Run.fmt$fmt_Debug(part4, f)])); } else { const log: rs.Cell = new rs.Cell(0); const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Tally.Tally => { @@ -727,8 +724,8 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.byteCowSlice(c).length & 0xff); rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteCowSlice(c), 0, rs.min(rs.byteCowSlice(c).length, 3))); const _35: rs.ByteCow = made(half, !owned); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(c)), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(_35)), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(c)), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(_35)), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1]])); const _47: rs.ByteCow = made(half, !owned); const _44: boolean = rs.eqBytes(c, _47); const _49: boolean = rs.eqBytes(c, data); @@ -918,8 +915,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo return rs.byteVecOf(b2, rs.u8Rem(b2, 3) as rs.usize); }), undefined, 12, true); if (!intoOwned) { - const _153: rs.ByteVec[] = []; - c4 = new rs.Borrowed(rs.sliceFrom(_153)); + c4 = new rs.Borrowed(rs.sliceFrom([])); } else { c4 = nested; } diff --git a/ts/fixtures/lang/cows/expected/harness.ts b/ts/fixtures/lang/cows/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/cows/expected/harness.ts +++ b/ts/fixtures/lang/cows/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/cycles/expected/harness.ts b/ts/fixtures/lang/cycles/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/cycles/expected/harness.ts +++ b/ts/fixtures/lang/cycles/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/defaults/expected/defaults.ts b/ts/fixtures/lang/defaults/expected/defaults.ts index e84e8f09b..4d6dae998 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.ts @@ -49,8 +49,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { made$unit(); const pair: [rs.u64 | undefined, Made.Made] = [undefined, Made.default$Default()]; const nested: [undefined, [rs.u8, boolean], Made.Made[], Bare.Bare[]] = made$tuple4_unit_tuple2_u8_bool_array0_defaults_Made_array0_defaults_Bare(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(pair[0], f, rs.u64Debug), (f: rs.Formatter) => Made.fmt$fmt_Debug(pair[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(nested[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(nested[1][0], f), (f: rs.Formatter) => rs.fmtBool(nested[1][1], f)], f), (f: rs.Formatter) => rs.fmtList(nested[2], f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(nested[3], f, (value: Bare.Bare, f: rs.Formatter) => Bare.fmt$fmt_Debug(value, f))], f)]; - s = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + const args27 = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(pair[0], f, rs.u64Debug), (f: rs.Formatter) => Made.fmt$fmt_Debug(pair[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(nested[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(nested[1][0], f), (f: rs.Formatter) => rs.fmtBool(nested[1][1], f)], f), (f: rs.Formatter) => rs.fmtList(nested[2], f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(nested[3], f, (value: Bare.Bare, f: rs.Formatter) => Bare.fmt$fmt_Debug(value, f))], f)]; + s = rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2]]); } else if (_10 === 1) { const made: Made.Made[] = made$array2_defaults_Made(); const grid: rs.u64[][] = Array.from({ length: 3 }, (): rs.u64[] => { @@ -58,9 +58,15 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { return 0; }); }); - const _35: rs.ByteSlice = rs.byteSliceFrom(madeBytes(op)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(made, f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(grid, f, (value: rs.u64[], f: rs.Formatter) => rs.fmtList(value, f, rs.u64Debug)), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_35), f, rs.u8Debug)]; - s = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]); + const bytes: Uint8Array = madeBytes(op); + const _33: rs.Slice = rs.sliceFrom(made); + [_33, rs.sliceFrom(grid), rs.byteSliceFrom(bytes)] as [rs.Slice, rs.Slice, rs.ByteSlice]; + const _37: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_33), f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)); + const arg3 = rs.sliceFrom(grid); + const _38: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, (value: rs.u64[], f: rs.Formatter) => rs.fmtList(value, f, rs.u64Debug)); + const arg4 = rs.byteSliceFrom(bytes); + const args26 = [_37, _38, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg4), f, rs.u8Debug)]; + s = rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2]]); } else if (_10 === 2) { const counts: rs.Atomic[] = Array.from({ length: 4 }, (): rs.Atomic => { return new rs.Atomic(0); @@ -74,24 +80,22 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const part2 = rs.iterToVec(rs.iterMap(rs.iterSlice(counts), (c: rs.Atomic): rs.u64 => { return rs.atomicLoad(c, 0); }), undefined, 8, true); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u64Debug)]; - s = rs.fmtFormat([args6[0]]); + s = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u64Debug)]); } else if (_10 === 3) { const boxed: Made.Made = Made.default$Default(); const shared: rs.Arc = made$sync_Arc_defaults_Made(); const again: rs.Arc = rs.arcClone(shared); const _76: Made.Made = shared.value; const _79: rs.usize = again.strong; - const args8: rs.Fmt[] = [(f: rs.Formatter) => Made.fmt$fmt_Debug(boxed, f), (f: rs.Formatter) => Made.fmt$fmt_Debug(_76, f), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; - s = rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2]]); + const args24 = [(f: rs.Formatter) => Made.fmt$fmt_Debug(boxed, f), (f: rs.Formatter) => Made.fmt$fmt_Debug(_76, f), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; + s = rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2]]); again[Symbol.dispose](); shared[Symbol.dispose](); } else if (_10 === 4) { const part = option_unwrapOrDefault$0ddgm4x(then$0t24p36(rs.u8Rem(op, 3) === 0, (): [rs.u64 | undefined, Made.Made] => { return [op as rs.u64, Made.default$Default()] as [rs.u64 | undefined, Made.Made]; })); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part[0], f, rs.u64Debug), (f: rs.Formatter) => Made.fmt$fmt_Debug(part[1], f)], f)]; - s = rs.fmtFormat([args10[0]]); + s = rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part[0], f, rs.u64Debug), (f: rs.Formatter) => Made.fmt$fmt_Debug(part[1], f)], f)]); } else if (_10 === 5) { const empty: rs.Weak = new rs.Weak(); const default_: rs.Weak = made$sync_Weak_defaults_Made(); @@ -108,8 +112,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _135: boolean = _137 === undefined; const _142: rs.Arc | undefined = rs.weakUpgrade(live); const _140: boolean = _142 !== undefined; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_115, f), (f: rs.Formatter) => rs.usizeDisplay(_120, f), (f: rs.Formatter) => rs.fmtBool(_123, f), (f: rs.Formatter) => rs.fmtBool(_127, f), (f: rs.Formatter) => rs.fmtBool(_131, f), (f: rs.Formatter) => rs.fmtBool(_135, f), (f: rs.Formatter) => rs.fmtBool(_140, f)]; - const _111: string = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4], " ", args12[5], " ", args12[6]]); + const args22 = [(f: rs.Formatter) => rs.fmtBool(_115, f), (f: rs.Formatter) => rs.usizeDisplay(_120, f), (f: rs.Formatter) => rs.fmtBool(_123, f), (f: rs.Formatter) => rs.fmtBool(_127, f), (f: rs.Formatter) => rs.fmtBool(_131, f), (f: rs.Formatter) => rs.fmtBool(_135, f), (f: rs.Formatter) => rs.fmtBool(_140, f)]; + const _111: string = rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3], " ", args22[4], " ", args22[5], " ", args22[6]]); rs.drop(_142); rs.drop(_137); rs.drop(_117); @@ -127,8 +131,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { slot.weak[Symbol.dispose](); slot.weak = _161; const _167: rs.u64 | undefined = Slot.get(slot); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(before, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtOption(_167, f, rs.u64Debug)]; - s = rs.fmtFormat([args14[0], " ", args14[1]]); + const args21 = [(f: rs.Formatter) => rs.fmtOption(before, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtOption(_167, f, rs.u64Debug)]; + s = rs.fmtFormat([args21[0], " ", args21[1]]); arc2[Symbol.dispose](); slot[Symbol.dispose](); } else if (_10 === 7) { @@ -147,11 +151,12 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { return undefined; }); } + const _185: rs.Slice = rs.sliceFrom(slots as Array); const _187: rs.usize = rs.u8Rem(op, 3) as rs.usize; if (!(_187 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _187); } - (slots as Array)[_187] = _184; + _185.data[_185.start + _187] = _184; const cell: rs.OnceCell> = new rs.OnceCell(undefined); const shared2: rs.Arc = rs.arcClone(rs.onceGetOrInit(cell, (): rs.Arc => { return new rs.Arc(Made.default$Default()); @@ -161,8 +166,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _207: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(boxed2, f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)); const _208: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(slots, f, (value: Array, f: rs.Formatter) => rs.fmtList(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))); const arg2 = _199.n; - const args16: rs.Fmt[] = [_207, _208, (f: rs.Formatter) => rs.u64Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; - s = rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); + const args20 = [_207, _208, (f: rs.Formatter) => rs.u64Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; + s = rs.fmtFormat([args20[0], " ", args20[1], " ", args20[2], " ", args20[3]]); shared2[Symbol.dispose](); cell[Symbol.dispose](); } else { @@ -170,8 +175,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _218: rs.u64 = rs.u64Add(made2.n, op as rs.u64); const _224: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_218, f); const arg = made2.tag; - const args18: rs.Fmt[] = [_224, (f: rs.Formatter) => rs.fmtPad(f, arg)]; - s = rs.fmtFormat([args18[0], " ", args18[1]]); + const args19 = [_224, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + s = rs.fmtFormat([args19[0], " ", args19[1]]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); rs.byteVecPush(out, 10); diff --git a/ts/fixtures/lang/defaults/expected/harness.ts b/ts/fixtures/lang/defaults/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/defaults/expected/harness.ts +++ b/ts/fixtures/lang/defaults/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/drops/expected/harness.ts b/ts/fixtures/lang/drops/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/drops/expected/harness.ts +++ b/ts/fixtures/lang/drops/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/durations/expected/durations.ts b/ts/fixtures/lang/durations/expected/durations.ts index edc5ffa87..f49047250 100644 --- a/ts/fixtures/lang/durations/expected/durations.ts +++ b/ts/fixtures/lang/durations/expected/durations.ts @@ -153,12 +153,12 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else if (_24 === 8) { const c: rs.Duration = rs.durationNew(0, rs.durationSubsecNanos(b)); const d2: rs.Duration = rs.durationFromNanos(rs.u32Rem(n, 1000000) as rs.u64); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), (f: rs.Formatter) => rs.fmtOption(b, f, rs.durationDebug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", rs.fmtSpec({ align: ">", width: 16 }, args2[1]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 14 }, args2[2]), "|", rs.fmtSpec({ align: "<", width: 12 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", args2[3]])); + const args10 = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), (f: rs.Formatter) => rs.fmtOption(b, f, rs.durationDebug)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", rs.fmtSpec({ align: ">", width: 16 }, args10[1]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 14 }, args10[2]), "|", rs.fmtSpec({ align: "<", width: 12 }, args10[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args10[0]), "|", args10[3]])); const p: rs.usize = rs.u32Rem(n, 13) as rs.usize; const _234: rs.Duration | undefined = b; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtOption(_234, f, rs.durationDebug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 3 }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[1]), "|", rs.fmtSpec({ precision: 12 }, args4[2]), "|", rs.fmtSpec({ plus: true }, args4[0]), "|", rs.fmtSpec({ plus: true, width: 12, precision: 2 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 10, precision: 1 }, args4[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[3]) }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[4])])); + const args11 = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtOption(_234, f, rs.durationDebug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args11[0]), "|", rs.fmtSpec({ precision: 3 }, args11[0]), "|", rs.fmtSpec({ precision: 1 }, args11[1]), "|", rs.fmtSpec({ precision: 12 }, args11[2]), "|", rs.fmtSpec({ plus: true }, args11[0]), "|", rs.fmtSpec({ plus: true, width: 12, precision: 2 }, args11[1]), "|", rs.fmtSpec({ align: "<", width: 10, precision: 1 }, args11[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args11[3]) }, args11[0]), "|", rs.fmtSpec({ precision: 1 }, args11[4])])); const iter4: rs.Iter = rs.iterSlice([1500000000, 2500000000, 1250000, 1350000, 999500, 1999999999]); while (true) { const _250: rs.u64 | rs.Done = iter4.next(); @@ -166,8 +166,8 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const part = rs.durationFromNanos(_250); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(part, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 2 }, args6[0])])); + const args12 = [(f: rs.Formatter) => rs.durationDebug(part, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args12[0]), " ", rs.fmtSpec({ precision: 1 }, args12[0]), " ", rs.fmtSpec({ precision: 2 }, args12[0])])); } } else if (_24 === 10) { let c2: rs.Duration = a; @@ -235,8 +235,8 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _398: rs.Iter = rs.iterSlice([copy$durations_Window(w2), copy$durations_Window(w2), _400]); rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Window.hash$Hash_hash_DefaultHasher as (a0: Window.Window, a1: rs.Hasher) => undefined, Window.eq$cmp_PartialEq)) as rs.HashSet, _398, undefined, undefined, 29360128)) & 0xff); const _413: Window.Window = Window.default$Default(); - const args8: rs.Fmt[] = [(f: rs.Formatter) => Window.fmt$fmt_Debug(w2, f), (f: rs.Formatter) => Window.fmt$fmt_Debug(_413, f)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[1])])); + const args9 = [(f: rs.Formatter) => Window.fmt$fmt_Debug(w2, f), (f: rs.Formatter) => Window.fmt$fmt_Debug(_413, f)]; + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ alternate: true }, args9[1])])); } } diff --git a/ts/fixtures/lang/durations/expected/harness.ts b/ts/fixtures/lang/durations/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/durations/expected/harness.ts +++ b/ts/fixtures/lang/durations/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts b/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts index f963f83a3..61e45cb22 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts @@ -55,8 +55,7 @@ export function drop$ops_Drop(self: Noisy): void { export function fmt$fmt_Debug(self: Noisy, f: rs.Formatter): rs.Result { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - return rs.fmtWriteFmt(f, ["N", args2[0]]); + return rs.fmtWriteFmt(f, ["N", (f: rs.Formatter) => rs.u8Display(arg, f)]); } //# sourceMappingURL=dyns.Noisy.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Square.ts b/ts/fixtures/lang/dyns/expected/dyns.Square.ts index 1b3ba7e19..33e6e1c70 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Square.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Square.ts @@ -44,8 +44,7 @@ export function grow$dyns_Shape(self: Square, by: rs.u8): void { export function label$dyns_Named(self: Square): string { const arg = self.side; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f)]; - return rs.fmtFormat(["square ", args2[0]]); + return rs.fmtFormat(["square ", (f: rs.Formatter) => rs.u16Display(arg, f)]); } export function asAny$dyns_Erased(self: Square): Any.Any { diff --git a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts index 8c2104051..5ac62fbb3 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts @@ -57,8 +57,7 @@ export function intoArea$dyns_Shape(self: Tri): rs.u32 { } export function label$dyns_Named(self: Tri): string { - const args2: rs.Fmt[] = [(f: rs.Formatter) => fmt$fmt_Debug(self, f)]; - return rs.fmtFormat(["tri ", args2[0]]); + return rs.fmtFormat(["tri ", (f: rs.Formatter) => fmt$fmt_Debug(self, f)]); } export function asAny$dyns_Erased(self: Tri): Any.Any { @@ -78,8 +77,8 @@ export function apply$dyns_Scaled_String(self: Tri, f: (a0: string) => string, x } export function scale$dyns_Scaled_String(self: Tri, by: string): string { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, by), (f: rs.Formatter) => fmt$fmt_Debug(self, f)]; - return rs.fmtFormat([args2[0], args2[1]]); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, by), (f: rs.Formatter) => fmt$fmt_Debug(self, f)]; + return rs.fmtFormat([args3[0], args3[1]]); } /** Writes through a `&mut` to the argument, an `rs.Place` for a number. */ diff --git a/ts/fixtures/lang/dyns/expected/dyns.ts b/ts/fixtures/lang/dyns/expected/dyns.ts index 191d003b3..114003c7e 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.ts @@ -119,18 +119,17 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o } let n: rs.u32 = c as rs.u32; const part = total(rs.sliceFrom([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)])); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - put(out, rs.fmtFormat([args2[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part, f), " "])); growTwice(new of$dyns_Square(sq), b); growTwice(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), c); growTwice(new ofPlace$u32(rs.place(() => n, (value2) => n = value2)), a); const arg = sq.side; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(tri, f), (f: rs.Formatter) => rs.u32Display(n, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "])); + const args14 = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(tri, f), (f: rs.Formatter) => rs.u32Display(n, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); const _78: rs.u8 = sidesOf$dyn_dyns_Shape(new of$dyns_Tri(tri)); const _82: rs.u8 = sidesOf$dyns_Square(sq); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_78, f), (f: rs.Formatter) => rs.u8Display(_82, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + const args15 = [(f: rs.Formatter) => rs.u8Display(_78, f), (f: rs.Formatter) => rs.u8Display(_82, f)]; + put(out, rs.fmtFormat([args15[0], " ", args15[1], " "])); const shapes: rs.Vec = new rs.Vec(); const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 3, dataLen - 3)))); while (true) { @@ -156,8 +155,8 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o const _129: string = s.v.label$Named(); const _132: rs.u32 = s.v.area$Shape(); const _135: rs.u8 = sidesOf$dyn_dyns_Shape(upcast(s.v)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => rs.u32Display(_132, f), (f: rs.Formatter) => rs.u8Display(_135, f), (f: rs.Formatter) => s.v.fmt$Debug(f)]; - put(out, rs.fmtFormat([args8[0], ":", args8[1], ":", args8[2], ":", args8[3], " "])); + const args16 = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => rs.u32Display(_132, f), (f: rs.Formatter) => rs.u8Display(_135, f), (f: rs.Formatter) => s.v.fmt$Debug(f)]; + put(out, rs.fmtFormat([args16[0], ":", args16[1], ":", args16[2], ":", args16[3], " "])); } let sum: rs.u32 = 0; for (const _150 of shapes.items) { @@ -168,15 +167,15 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o const _165: Shown.Shown = { _0: (f: rs.Formatter) => Tri.fmt$fmt_Debug(_167, f) }; const _169: rs.u32 = shapes.items[at2].larger$Shape(b as rs.u32); const _175: rs.u32 = sum; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_175, f), (f: rs.Formatter) => Shown.fmt$fmt_Debug(_165, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "])); + const args17 = [(f: rs.Formatter) => rs.u32Display(_175, f), (f: rs.Formatter) => Shown.fmt$fmt_Debug(_165, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " "])); for (const s2 of shapes.items) { sum = rs.u32WrappingAdd(sum, s2.intoArea$Shape()); } const _203: rs.u32 = new of$u32(n).intoArea$Shape(); const _204: rs.u32 = sum; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_204, f), (f: rs.Formatter) => rs.u32Display(_203, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + const args18 = [(f: rs.Formatter) => rs.u32Display(_204, f), (f: rs.Formatter) => rs.u32Display(_203, f)]; + put(out, rs.fmtFormat([args18[0], " ", args18[1]])); } } @@ -218,28 +217,27 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const shape: rs.Arc = rs.arcClone(named); const up: rs.Arc = rs.arcClone(again); const part = counts$dyns_Square(rs.sliceFrom([sq])); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args2[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " "])); const _49: string = named.value.label$Named(); const _53: rs.u32 = shape.value.area$Shape(); const _57: rs.u8 = sidesOf$dyn_dyns_Shape(up.value); const _62: Named.Named = named.value; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _49), (f: rs.Formatter) => rs.u32Display(_53, f), (f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => _62.fmt$Debug(f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); + const args26 = [(f: rs.Formatter) => rs.fmtPad(f, _49), (f: rs.Formatter) => rs.u32Display(_53, f), (f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => _62.fmt$Debug(f)]; + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " ", args26[3], " "])); const _73: [rs.Weak, rs.Weak] = [new rs.Weak(shape), new rs.Weak(up)]; const weak: rs.Weak = _73[0]; const other: rs.Weak = _73[1]; const _86: boolean = rs.arcPtrEq(named, again); const _90: boolean = rs.arcPtrEq(shape, up); const _94: boolean = rs.arcPtrEq(weak.arc, other.arc); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_86, f), (f: rs.Formatter) => rs.fmtBool(_90, f), (f: rs.Formatter) => rs.fmtBool(_94, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "])); + const args27 = [(f: rs.Formatter) => rs.fmtBool(_86, f), (f: rs.Formatter) => rs.fmtBool(_90, f), (f: rs.Formatter) => rs.fmtBool(_94, f)]; + put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2], " "])); sq[Symbol.dispose](); named[Symbol.dispose](); const _113: string = counts$dyn_dyns_Named(rs.sliceFrom([again])); const _119: rs.usize = weak.arc.strong; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _113), (f: rs.Formatter) => rs.usizeDisplay(_119, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " "])); + const args28 = [(f: rs.Formatter) => rs.fmtPad(f, _113), (f: rs.Formatter) => rs.usizeDisplay(_119, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); const upgraded: rs.u32 | undefined = option_map$1mach0o(rs.weakUpgrade(weak), (s: rs.Arc): rs.u32 => { const _0: rs.u32 = s.value.area$Shape(); s[Symbol.dispose](); @@ -247,48 +245,46 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, }); again[Symbol.dispose](); const part2 = counts$dyn_dyns_Shape(rs.sliceFrom([up])); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part2), " "])); up[Symbol.dispose](); const _156: string = counts$dyn_dyns_Shape(rs.sliceFrom([shape])); const _164: rs.Arc | undefined = rs.weakUpgrade(weak); const _162: boolean = _164 !== undefined; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _156), (f: rs.Formatter) => rs.fmtBool(_162, f), (f: rs.Formatter) => rs.fmtOption(upgraded, f, rs.u32Debug)]; - const _152: string = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "]); + const args30 = [(f: rs.Formatter) => rs.fmtPad(f, _156), (f: rs.Formatter) => rs.fmtBool(_162, f), (f: rs.Formatter) => rs.fmtOption(upgraded, f, rs.u32Debug)]; + const _152: string = rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); rs.drop(_164); put(out, _152); shape[Symbol.dispose](); const _184: rs.Arc | undefined = rs.weakUpgrade(weak); const _182: boolean = _184 === undefined; const _187: rs.usize = other.arc.strong; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_182, f), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; - const _178: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const args31 = [(f: rs.Formatter) => rs.fmtBool(_182, f), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; + const _178: string = rs.fmtFormat([args31[0], " ", args31[1], " "]); rs.drop(_184); put(out, _178); const hits: rs.Arc = new rs.Arc({ _0: new rs.Atomic(dataData[dataStart + 1] as rs.u32) }); const objects: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (_2: rs.i32): rs.Arc => { - const _34: rs.Arc = rs.arcClone(hits); - return new rs.ArcDyn(_34, new of$dyns_Hits(_34.value)); + const _36: rs.Arc = rs.arcClone(hits); + return new rs.ArcDyn(_36, new of$dyns_Hits(_36.value)); }), undefined, 8, true); const sum: rs.u32 = rs.iterFold(rs.iterSlice(objects.items), 0, (sum2: rs.u32, s2: rs.Arc): rs.u32 => { return rs.u32WrappingAdd(sum2, s2.value.area$Shape()); }); const _216: rs.u32 = rs.atomicLoad(hits.value._0, 0); const _222: string = counts$dyns_Hits(rs.sliceFrom([hits])); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.u32Display(_216, f), (f: rs.Formatter) => rs.fmtPad(f, _222)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "])); + const args32 = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.u32Display(_216, f), (f: rs.Formatter) => rs.fmtPad(f, _222)]; + put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "])); rs.dropVec(objects); const part3 = counts$dyns_Hits(rs.sliceFrom([hits])); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3)]; - put(out, rs.fmtFormat([args18[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part3), " "])); const _253: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); const n: rs.Arc = new rs.ArcDyn(_253, new of$u32(_253.value)); const _257: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); const m: rs.Arc = new rs.ArcDyn(_257, new of$u32(_257.value)); const _268: rs.u32 = n.value.area$Shape(); const _272: boolean = rs.arcPtrEq(n, m); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_268, f), (f: rs.Formatter) => rs.fmtBool(_272, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + const args34 = [(f: rs.Formatter) => rs.u32Display(_268, f), (f: rs.Formatter) => rs.fmtBool(_272, f)]; + put(out, rs.fmtFormat([args34[0], " ", args34[1], " "])); const tris: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_23: rs.u8): rs.Arc => { const x: rs.u8 = _23; const _43: rs.u8 = rs.u8Rem(x, 3); @@ -310,8 +306,8 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const _304: string = _292.value.label$Named(); const _307: rs.u32 = _292.value.area$Shape(); const _310: rs.usize = _292.strong; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _304), (f: rs.Formatter) => rs.u32Display(_307, f), (f: rs.Formatter) => rs.usizeDisplay(_310, f)]; - put(out, rs.fmtFormat([args22[0], ":", args22[1], ":", args22[2], " "])); + const args35 = [(f: rs.Formatter) => rs.fmtPad(f, _304), (f: rs.Formatter) => rs.u32Display(_307, f), (f: rs.Formatter) => rs.usizeDisplay(_310, f)]; + put(out, rs.fmtFormat([args35[0], ":", args35[1], ":", args35[2], " "])); } rs.dropVec(tris); let total: rs.u32 = 0; @@ -319,8 +315,8 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, _322.value.tally$Shape(rs.place(() => total, (value) => total = value)); } const _337: string = counts$dyn_dyns_Named(rs.sliceFrom(rs.iterToVec(rs.iterSlice(kept.items), undefined, 4, true).items)); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(total, f), (f: rs.Formatter) => rs.fmtPad(f, _337)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1]])); + const args36 = [(f: rs.Formatter) => rs.u32Display(total, f), (f: rs.Formatter) => rs.fmtPad(f, _337)]; + put(out, rs.fmtFormat([args36[0], " ", args36[1]])); rs.dropVec(kept); m[Symbol.dispose](); n[Symbol.dispose](); @@ -347,18 +343,15 @@ export function kind(a: Any.Any): string { const _2: Square.Square | undefined = a instanceof of$dyns_Square ? a.v : undefined; if (_2 !== undefined) { const arg = _2.side; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f)]; - return rs.fmtFormat(["square ", args2[0]]); + return rs.fmtFormat(["square ", (f: rs.Formatter) => rs.u16Display(arg, f)]); } const _13: rs.u32 | undefined = a instanceof of$u32 ? a.v : a instanceof ofPlace$u32 ? a.v.v : undefined; if (_13 !== undefined) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_13, f)]; - return rs.fmtFormat(["u32 ", args4[0]]); + return rs.fmtFormat(["u32 ", (f: rs.Formatter) => rs.u32Display(_13, f)]); } const _24: Tri.Tri | undefined = a instanceof of$dyns_Tri ? a.v : a instanceof ofPlace$dyns_Tri ? a.v.v : undefined; if (_24 !== undefined) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => Tri.fmt$fmt_Debug(_24, f)]; - return rs.fmtFormat(["tri ", args6[0]]); + return rs.fmtFormat(["tri ", (f: rs.Formatter) => Tri.fmt$fmt_Debug(_24, f)]); } if (!(a instanceof of$u8 || a instanceof ofPlace$u8)) { return "other"; @@ -419,8 +412,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o break; } const part = kind(_33); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args2[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " "])); } const _51: boolean = bump(new of$dyns_Square(sq), a); const _54: boolean = bump(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), b); @@ -429,8 +421,8 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const hit: [boolean, boolean, boolean, boolean] = [_51, _54, _57, bump(new ofPlace$u8(rs.place(() => _63, (value3) => _63 = value3)), a)]; const _72: Tri.Tri = tri; const arg = sq.side; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_72, f), (f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(hit[0], f), (f: rs.Formatter) => rs.fmtBool(hit[1], f), (f: rs.Formatter) => rs.fmtBool(hit[2], f), (f: rs.Formatter) => rs.fmtBool(hit[3], f)], f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); + const args44 = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_72, f), (f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(hit[0], f), (f: rs.Formatter) => rs.fmtBool(hit[1], f), (f: rs.Formatter) => rs.fmtBool(hit[2], f), (f: rs.Formatter) => rs.fmtBool(hit[3], f)], f)]; + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " ", args44[3], " "])); const iter2: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)]); while (true) { const _91: dyns_Erased.Erased | rs.Done = iter2.next(); @@ -440,8 +432,8 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _103: boolean = isA$dyns_Square(_91); const _105: boolean = isA$u32(_91); const _107: string = kind(_91.asAny$Erased()); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_103, f), (f: rs.Formatter) => rs.fmtBool(_105, f), (f: rs.Formatter) => rs.fmtPad(f, _107)]; - put(out, rs.fmtFormat([args6[0], args6[1], args6[2], " "])); + const args45 = [(f: rs.Formatter) => rs.fmtBool(_103, f), (f: rs.Formatter) => rs.fmtBool(_105, f), (f: rs.Formatter) => rs.fmtPad(f, _107)]; + put(out, rs.fmtFormat([args45[0], args45[1], args45[2], " "])); } let m: rs.u32 = a as rs.u32; const _119: Any.Any = new ofPlace$u32(rs.place(() => m, (value4) => m = value4)).asAnyMut$Erased(); @@ -449,12 +441,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o if (_118 !== undefined) { _118.v = rs.u32WrappingMul(_118.v, 3); } - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(m, f)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(m, f), " "])); const unit: Any.Any = new of$unit(undefined); const part2 = [unit instanceof of$unit ? unit.v : unit instanceof ofPlace$unit ? unit.v.v : rs.None, unit instanceof of$Option_u8 || unit instanceof ofPlace$Option_u8] as [undefined | rs.None, boolean]; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part2[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtBool(part2[1], f)], f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part2[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtBool(part2[1], f)], f), " "])); let some: rs.u8 | undefined = a; let none: rs.u8 | undefined = undefined; const iter3: rs.Iter = rs.iterSlice([new ofPlace$Option_u8(rs.place(() => some, (value5) => some = value5)), new ofPlace$Option_u8(rs.place(() => none, (value6) => none = value6)), new ofPlace$u32(rs.place(() => n, (value7) => n = value7))]); @@ -464,8 +454,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o break; } const part3 = [_167 instanceof of$unit ? _167.v : _167 instanceof ofPlace$unit ? _167.v.v : rs.None, _167 instanceof of$Option_u8 ? _167.v : _167 instanceof ofPlace$Option_u8 ? _167.v.v : rs.None] as [undefined | rs.None, rs.u8 | undefined | rs.None]; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part3[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(part3[1], f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)], f)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part3[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(part3[1], f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)], f)])); const _189: rs.Place | undefined = _167 instanceof of$Option_u8 ? _167 : _167 instanceof ofPlace$Option_u8 ? _167.v : undefined; if (_189 !== undefined) { _189.v = option_mapOr$19a4gco(_189.v, b, (_2: rs.u8): rs.u8 | undefined => { @@ -473,11 +462,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o }); } const arg2 = (_167 instanceof of$unit ? _167 : _167 instanceof ofPlace$unit ? _167.v : undefined) !== undefined; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg2, f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(arg2, f), " "])); } - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(some, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " "])); + const args50 = [(f: rs.Formatter) => rs.fmtOption(some, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args50[0], " ", args50[1], " "])); const boxes: rs.Vec = new rs.Vec(); const iter4: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2)))); while (true) { @@ -511,20 +499,17 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _261: rs.Result = boxed instanceof of$u32 ? rs.Ok(boxed.v) : rs.Err(boxed); if (_261.ok) { const part5 = _261.value; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - put(out, rs.fmtFormat(["n", args18[0], " "])); + put(out, rs.fmtFormat(["n", (f: rs.Formatter) => rs.u32Display(part5, f), " "])); } else if (!(rs.usizeRem(i2, 2) === 0)) { const other2: Any.Any = _261.error; const _282: rs.Result = other2 instanceof of$u8 ? rs.Ok(other2.v) : rs.Err(other2); if (_282.ok) { const arg3 = _282.value; - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg3, f)]; - put(out, rs.fmtFormat(["u8 ", args20[0], " "])); + put(out, rs.fmtFormat(["u8 ", (f: rs.Formatter) => rs.u8Display(arg3, f), " "])); } else { const other3: Any.Any = _282.error; const part4 = kind(other3); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; - put(out, rs.fmtFormat([args22[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part4), " "])); rs.drop(other3); } } else { @@ -540,8 +525,8 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } const _328: string = kind(_316.v); const _331: boolean = bump(_316.v, a); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _328), (f: rs.Formatter) => rs.fmtBool(_331, f)]; - put(out, rs.fmtFormat([args24[0], ":", args24[1], " "])); + const args54 = [(f: rs.Formatter) => rs.fmtPad(f, _328), (f: rs.Formatter) => rs.fmtBool(_331, f)]; + put(out, rs.fmtFormat([args54[0], ":", args54[1], " "])); } const _339: rs.Arc<[rs.u8, rs.u8]> = new rs.Arc([a, b] as [rs.u8, rs.u8]); const hold: rs.Arc = new rs.ArcDyn(_339, new of$tuple2_u8_u8(_339.value)); @@ -549,12 +534,11 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const held: rs.Arc[] = [rs.arcClone(hold), rs.arcClone(hold)]; const _354: rs.usize = hold.strong; const _357: [rs.u8, rs.u8] | undefined = _358 instanceof of$tuple2_u8_u8 ? _358.v : undefined; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_354, f), (f: rs.Formatter) => rs.fmtOption(_357, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " "])); + const args55 = [(f: rs.Formatter) => rs.usizeDisplay(_354, f), (f: rs.Formatter) => rs.fmtOption(_357, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args55[0], " ", args55[1], " "])); rs.dropAll(held); const part6 = hold.strong; - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part6, f)]; - put(out, rs.fmtFormat([args28[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part6, f), " "])); const _381: rs.Result, rs.Arc> = rs.arcDowncast(hold, of$u8, (object) => object.v); if (_381.ok) { rs.panic("internal error: entered unreachable code"); @@ -564,8 +548,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o t[Symbol.dispose](); return _02; })); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); let n3: rs.u32 = a as rs.u32; const iter7: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$u32(n3)]); while (true) { @@ -576,20 +559,17 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const any: Any.Any = _407; const _420: rs.u32 = _407.key$Keyed(); const _422: string = kind(any); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_420, f), (f: rs.Formatter) => rs.fmtPad(f, _422)]; - put(out, rs.fmtFormat([args32[0], args32[1], " "])); + const args58 = [(f: rs.Formatter) => rs.u32Display(_420, f), (f: rs.Formatter) => rs.fmtPad(f, _422)]; + put(out, rs.fmtFormat([args58[0], args58[1], " "])); } const part8 = bump(new ofPlace$u32(rs.place(() => n3, (value8) => n3 = value8)), b); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; - put(out, rs.fmtFormat([args34[0], " "])); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n3, f)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part8, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(n3, f), " "])); const any3: Any.Any = new of$dyns_Square({ side: b as rs.u16 }); const part9 = ok$1wwd922(result_map$0tx2z7o(any3 instanceof of$dyns_Square ? rs.Ok(any3.v) : rs.Err(any3), (sq2: Square.Square): rs.u16 => { return sq2.side; })); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args38[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u16Debug), " "])); const _477: rs.Arc = new rs.Arc(n3); const shared: rs.Arc = new rs.ArcDyn(_477, new of$u32(_477.value)); const weak2: rs.Weak = new rs.Weak(shared); @@ -602,8 +582,8 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o return _04; }); const _495: rs.u32 | undefined = _496 instanceof of$u32 ? _496.v : _496 instanceof ofPlace$u32 ? _496.v.v : undefined; - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_491, f), (f: rs.Formatter) => rs.fmtOption(_495, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); + const args62 = [(f: rs.Formatter) => rs.fmtBool(_491, f), (f: rs.Formatter) => rs.fmtOption(_495, f, rs.u32Debug)]; + put(out, rs.fmtFormat([args62[0], " ", args62[1], " "])); const typed2: [rs.usize, rs.u32] | undefined = ok$0y6a1w6(result_map$0njbm3o(rs.arcDowncast(any4, of$u32, (object) => object.v), (n4: rs.Arc): [rs.usize, rs.u32] => { const _05: [rs.usize, rs.u32] = [n4.strong, n4.value]; n4[Symbol.dispose](); @@ -611,8 +591,8 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o })); const _516: rs.Arc | undefined = rs.weakUpgrade(weak2); const _514: boolean = _516 !== undefined; - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(typed2, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_514, f)]; - const _510: string = rs.fmtFormat([args42[0], " ", args42[1]]); + const args63 = [(f: rs.Formatter) => rs.fmtOption(typed2, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_514, f)]; + const _510: string = rs.fmtFormat([args63[0], " ", args63[1]]); rs.drop(_516); put(out, _510); weak2[Symbol.dispose](); @@ -668,21 +648,20 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const _27: rs.u8 = twice(mul, a); const _31: rs.u8 = twice(halve, a); const _35: rs.u8 = twice(ptr, a); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_27, f), (f: rs.Formatter) => rs.u8Display(_31, f), (f: rs.Formatter) => rs.u8Display(_35, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); + const args17 = [(f: rs.Formatter) => rs.u8Display(_27, f), (f: rs.Formatter) => rs.u8Display(_31, f), (f: rs.Formatter) => rs.u8Display(_35, f)]; + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " "])); const part = firstWord((s: string): string => { return option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, " ").next()), ""); }, "ab cd"); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; - put(out, rs.fmtFormat([args4[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part, f), " "])); let sum: rs.u32 = 0; const seen: rs.ByteVec = new rs.ByteVec(); bumpAll((x2: rs.u8): undefined => { sum = rs.u32WrappingAdd(sum, x2 as rs.u32); rs.byteVecPush(seen, x2); }, rs.byteSliceRange(data, 2)); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + const args19 = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args19[0], " ", args19[1], " "])); const fs: rs.Vec<(a0: rs.u8) => rs.u8> = rs.vecFrom([adder(a), halve, mul, ptr]); const captured = a; const _94: (a0: rs.u8) => rs.u8 = (x3: rs.u8): rs.u8 => { @@ -705,8 +684,8 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const i: rs.usize = _115[0]; const y: rs.u8 = _115[1](option_unwrapOr$1fr498u(rs.byteSliceGet(rs.byteSliceRange(data, 2), i), b)); const _133: rs.u32 = hook.f(y); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(y, f), (f: rs.Formatter) => rs.u32Display(_133, f)]; - put(out, rs.fmtFormat([args8[0], ":", args8[1], " "])); + const args20 = [(f: rs.Formatter) => rs.u8Display(y, f), (f: rs.Formatter) => rs.u32Display(_133, f)]; + put(out, rs.fmtFormat([args20[0], ":", args20[1], " "])); } const _142: (a0: rs.u8) => rs.u32 = (x5: rs.u8): rs.u32 => { return x5 as rs.u32; @@ -714,19 +693,16 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { rs.drop(hook.f); hook.f = _142; const part4 = hook.f(a); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part4, f), " "])); const captured3 = rs.byteVecFrom(Uint8Array.of(a)); const part6 = ((x6: rs.u8): rs.ByteVec => { const list2: rs.ByteVec = captured3; rs.byteVecPush(list2, x6); return list2; })(b); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part6), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part6), f, rs.u8Debug), " "])); const part7 = rs.once(rs.optionUnwrap(rs.vecPop(fs)))(a); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part7, f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(part7, f), " "])); const captured4 = b; const _196: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x7: rs.u8): rs.u8 => { return x7 ^ captured4; @@ -736,8 +712,8 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const _208: rs.u8 = shared.value(a); const _213: rs.u8 = other.value(b); const _218: rs.usize = other.strong; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_208, f), (f: rs.Formatter) => rs.u8Display(_213, f), (f: rs.Formatter) => rs.usizeDisplay(_218, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2]])); + const args24 = [(f: rs.Formatter) => rs.u8Display(_208, f), (f: rs.Formatter) => rs.u8Display(_213, f), (f: rs.Formatter) => rs.usizeDisplay(_218, f)]; + put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2]])); other[Symbol.dispose](); shared[Symbol.dispose](); hook[Symbol.dispose](); @@ -756,8 +732,7 @@ export function dropped(out: rs.ByteVec): void { const part = rs.localKeyWithBorrowMut(DROPS, (d: rs.ByteVec): rs.ByteVec => { return rs.replaceIn(d, new rs.ByteVec()); }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug), " "])); } /** Each of the vtable's methods, then std's adaptors over the borrow, then by value. */ @@ -769,8 +744,8 @@ export function read(it: rs.Iter, out: rs.ByteVec): void { const rest: rs.u32 = rs.iterSum(rs.iterMap(rs.iterBorrow(it), (a0: rs.u8): rs.u32 => { return a0 as rs.u32; }), rs.u32Add, 0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0], f), (f: rs.Formatter) => rs.fmtOption(hint[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Display(rest, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "])); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0], f), (f: rs.Formatter) => rs.fmtOption(hint[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Display(rest, f)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " "])); } /** @@ -798,8 +773,8 @@ export function lens(it: rs.Iter): string { const first: rs.u8 | undefined = rs.iterToOption(it.next()); const after: rs.usize = rs.iterBorrow(it).len(); const back: rs.u8 | undefined = rs.iterLast(rs.iterBorrow(it)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(before, f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(after, f), (f: rs.Formatter) => rs.fmtOption(back, f, rs.u8Debug)]; - return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); + const args3 = [(f: rs.Formatter) => rs.usizeDisplay(before, f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(after, f), (f: rs.Formatter) => rs.fmtOption(back, f, rs.u8Debug)]; + return rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3]]); } export function tagged(tags: rs.ByteSlice): rs.Vec { @@ -830,11 +805,10 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _50: rs.u8 | undefined = scan$dyns_iters_closure1(map, rs.u8Rem(b, 8) as rs.u64, true, (v2: rs.u8): rs.u8 | undefined => { return thenSome$0quywni(rs.u8Rem(v2, 2) === 1, v2); }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_44, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " "])); + const args43 = [(f: rs.Formatter) => rs.fmtOption(_44, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args43[0], " ", args43[1], " "])); const part = lens(rs.iterDyn(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2)))))); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args4[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " "])); const _79: rs.usize = rs.usizeRem(a as rs.usize, rs.usizeAdd(rs.byteSliceRange(data, 2).length, 1)); const slice: rs.ByteSlice = rs.byteSliceRange(data, 2); if (_79 > slice.length) { @@ -858,8 +832,8 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return _06; }); dropped(out); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(ends[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtOption(nth, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + const args45 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(ends[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtOption(nth, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args45[0], " ", args45[1], " "])); rs.drop(boxed); dropped(out); const last: rs.u8 | undefined = option_map$11l9b8r(rs.ownedLast(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(front), rs.drop), rs.vecIntoIter(tagged(back), rs.drop)))), rs.drop), (t4: Tagged.Tagged): rs.u8 => { @@ -868,11 +842,9 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return _07; }); dropped(out); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug), " "])); const part2 = rs.ownedCount(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(back), rs.drop), rs.vecIntoIter(tagged(front), rs.drop)))), rs.drop); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part2, f), " "])); dropped(out); const own: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 16)), Countdown.next$iter_Iterator, rs.drop)); let sum: rs.u32 = 0; @@ -885,8 +857,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { sum = rs.u32WrappingAdd(sum, _166 as rs.u32); } rs.drop(iter); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(sum, f), " "])); dropped(out); const nested: rs.Iter = rs.iterDyn(rs.iterBox(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop))); const inner: Countdown.Countdown = new Countdown.Countdown(rs.u8Rem(b, 8)); @@ -902,8 +873,8 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _233: rs.ByteVec = rs.iterToByteVec(rs.iterBox(nested), "next"); const _235: rs.usize = rs.ownedCount(rs.iterBox(erased)); const _238: rs.usize = rs.ownedCount(rs.iterBox(rs.iterFrom(doubled, Countdown.next$iter_Iterator, rs.drop))); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_233), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(fourth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(mapped), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_235, f), (f: rs.Formatter) => rs.usizeDisplay(_238, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4], " ", args14[5], " ", args14[6], " ", args14[7], " "])); + const args49 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_233), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(fourth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(mapped), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_235, f), (f: rs.Formatter) => rs.usizeDisplay(_238, f)]; + put(out, rs.fmtFormat([args49[0], " ", args49[1], " ", args49[2], " ", args49[3], " ", args49[4], " ", args49[5], " ", args49[6], " ", args49[7], " "])); dropped(out); inner[Symbol.dispose](); dropped(out); @@ -919,8 +890,10 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const fifth: rs.u8 | undefined = rs.iterToOption(rs.iterDyn(rs.iterBorrow(rs.iterBox(rs.iterFrom(layered.v.v, Countdown.next$iter_Iterator)))).next()); const sixth: rs.u8 | undefined = rs.iterToOption(Countdown.next$iter_Iterator(layered.v.v)); const _301: rs.usize = rs.ownedCount(rs.iterBox(rs.iterFrom(held, Countdown.next$iter_Iterator, rs.drop))); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(hints, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), (f: rs.Formatter) => rs.fmtOption(fifth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(sixth, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_301, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3], " "])); + [_301, rs.sliceFrom(hints), fifth, sixth] as [rs.usize, rs.Slice<[rs.usize, rs.usize | undefined]>, rs.u8 | undefined, rs.u8 | undefined]; + const arg = rs.sliceFrom(hints); + const args50 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), (f: rs.Formatter) => rs.fmtOption(fifth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(sixth, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_301, f)]; + put(out, rs.fmtFormat([args50[0], " ", args50[1], " ", args50[2], " ", args50[3], " "])); dropped(out); own2[Symbol.dispose](); dropped(out); @@ -936,8 +909,8 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const owned: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterBox(zipped()), "next", 2); const lent3: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterBorrow(rs.iterBox(rs.iterBorrow(zipped()))), "next", 2); const _339: rs.RefCell = rs.refCellBorrow(seen2); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(owned.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(lent3.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_339.value), f, rs.u8Debug)]; - const _335: string = rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); + const args51 = [(f: rs.Formatter) => rs.fmtList(owned.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(lent3.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_339.value), f, rs.u8Debug)]; + const _335: string = rs.fmtFormat([args51[0], " ", args51[1], " ", args51[2], " "]); rs.refRelease(_339); put(out, _335); const split: Chunks.Chunks = new of$dyns_Lease({ _0: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)), _1: rs.usizeAdd(rs.u8Rem(b, 4) as rs.usize, 1) }); @@ -945,20 +918,17 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return a0.length; }), "next", 4); const _369: rs.usize = rs.ownedCount(rs.iterBox(split.chunks$Chunks())); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(lens_.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_369, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + const args52 = [(f: rs.Formatter) => rs.fmtList(lens_.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_369, f)]; + put(out, rs.fmtFormat([args52[0], " ", args52[1], " "])); const part3 = drain(rs.iterDyn(rs.iterBorrow(rs.iterFuse(rs.iterFrom({ _0: rs.u8Rem(a, 4) }, Resuming.next$iter_Iterator))))); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3)]; - put(out, rs.fmtFormat([args22[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part3), " "])); const resuming: Resuming.Resuming = { _0: rs.u8Rem(b, 4) }; const up: rs.Iter = rs.iterDyn(rs.iterFrom(resuming, Resuming.next$iter_Iterator)); const part4 = [rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next())] as [rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined]; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[2], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[3], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[4], f, rs.u8Debug)], f)]; - put(out, rs.fmtFormat([args24[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[2], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[3], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[4], f, rs.u8Debug)], f), " "])); const boxed3: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop)); const part5 = drain(boxed3); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5)]; - put(out, rs.fmtFormat([args26[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part5), " "])); rs.drop(boxed3); dropped(out); const concrete: rs.Arc> = new rs.Arc(rs.vecIntoIter(tagged(front), rs.drop)); @@ -967,8 +937,8 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const weak: rs.Weak> = new rs.Weak(other); const _456: [rs.usize, rs.usize | undefined] = other.value.sizeHint(); const _460: boolean = rs.arcGetMut(shared) === undefined; - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_456[0], f), (f: rs.Formatter) => rs.fmtOption(_456[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_460, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + const args56 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_456[0], f), (f: rs.Formatter) => rs.fmtOption(_456[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_460, f)]; + put(out, rs.fmtFormat([args56[0], " ", args56[1], " "])); other[Symbol.dispose](); weak[Symbol.dispose](); const taken: rs.u8 | undefined = option_map$11l9b8r(option_andThen$1xlvufy(rs.arcGetMut(shared), (it2: rs.Iter): Tagged.Tagged | undefined => { @@ -979,8 +949,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return _014; }); dropped(out); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(taken, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(taken, f, rs.u8Debug), " "])); shared[Symbol.dispose](); dropped(out); const _492: rs.Arc> = new rs.Arc(rs.byteVecIntoIter(rs.byteSliceToByteVec(back))); @@ -990,21 +959,20 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _510: rs.u8 | undefined | rs.None = option_map$0vt270f(rs.arcGetMut(up2), (it3: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it3.next()); }); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_506, f), (f: rs.Formatter) => rs.fmtOption(_510, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1], " "])); + const args58 = [(f: rs.Formatter) => rs.usizeDisplay(_506, f), (f: rs.Formatter) => rs.fmtOption(_510, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + put(out, rs.fmtFormat([args58[0], " ", args58[1], " "])); exact[Symbol.dispose](); const next: rs.u8 | undefined = option_andThen$0imujmv(rs.arcGetMut(up2), (it4: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it4.next()); }); const _530: [rs.usize, rs.usize | undefined] = up2.value.sizeHint(); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_530[0], f), (f: rs.Formatter) => rs.fmtOption(_530[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args34[0], " ", args34[1], " "])); + const args59 = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_530[0], f), (f: rs.Formatter) => rs.fmtOption(_530[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args59[0], " ", args59[1], " "])); const fromBox: rs.Arc> = new rs.Arc(rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop))); const part6 = option_andThen$0imujmv(rs.arcGetMut(fromBox), (it5: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it5.next()); }); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u8Debug), " "])); fromBox[Symbol.dispose](); dropped(out); const counted2: rs.Arc = new rs.Arc(new Countdown.Countdown(rs.u8Rem(a, 8))); @@ -1016,20 +984,17 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { it6[Symbol.dispose](); return _018; }); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f))]; - put(out, rs.fmtFormat([args38[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), " "])); counted2[Symbol.dispose](); const _596: rs.Arc> | undefined = rs.weakUpgrade(weak3); const part8 = _596 === undefined; - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; - const _590: string = rs.fmtFormat([args40[0], " "]); + const _590: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part8, f), " "]); rs.drop(_596); put(out, _590); dropped(out); const pinned: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop)); const part9 = rs.iterToOption(pinned.next()); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u8Debug)])); rs.drop(pinned); dropped(out); weak3[Symbol.dispose](); @@ -1042,8 +1007,8 @@ export function drain(it: rs.Iter): string { const items: rs.ByteVec = rs.iterToByteVec(rs.iterBorrow(it), "next"); const _7: rs.u8 | undefined = rs.iterToOption(it.next()); const _9: rs.u8 | undefined = rs.iterToOption(it.next()); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(items), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_7, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_9, f, rs.u8Debug)]; - return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(items), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_7, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_9, f, rs.u8Debug)]; + return rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2]]); } /** @@ -1070,8 +1035,8 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _45: rs.usize = weak2.arc.strong; const _48: rs.usize = rs.weakWeakCount(weak2); const _51: boolean = rs.arcPtrEq(weak2.arc, other.arc); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _34), (f: rs.Formatter) => rs.u32Display(_38, f), (f: rs.Formatter) => rs.usizeDisplay(_42, f), (f: rs.Formatter) => rs.usizeDisplay(_45, f), (f: rs.Formatter) => rs.usizeDisplay(_48, f), (f: rs.Formatter) => rs.fmtBool(_51, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " "])); + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, _34), (f: rs.Formatter) => rs.u32Display(_38, f), (f: rs.Formatter) => rs.usizeDisplay(_42, f), (f: rs.Formatter) => rs.usizeDisplay(_45, f), (f: rs.Formatter) => rs.usizeDisplay(_48, f), (f: rs.Formatter) => rs.fmtBool(_51, f)]; + put(out, rs.fmtFormat([args39[0], " ", args39[1], " ", args39[2], " ", args39[3], " ", args39[4], " ", args39[5], " "])); const again: rs.Weak = rs.weakClone(weak2); sq[Symbol.dispose](); named[Symbol.dispose](); @@ -1081,16 +1046,16 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe return _0; }); const _79: rs.usize = shape.strong; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_75, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " "])); + const args40 = [(f: rs.Formatter) => rs.fmtOption(_75, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; + put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); shape[Symbol.dispose](); const _97: rs.Arc | undefined = rs.weakUpgrade(weak2); const _95: boolean = _97 === undefined; const _102: rs.Arc | undefined = rs.weakUpgrade(again); const _100: boolean = _102 === undefined; const _105: rs.usize = weak2.arc.strong; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtBool(_100, f), (f: rs.Formatter) => rs.usizeDisplay(_105, f)]; - const _91: string = rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "]); + const args41 = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtBool(_100, f), (f: rs.Formatter) => rs.usizeDisplay(_105, f)]; + const _91: string = rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " "]); rs.drop(_102); rs.drop(_97); put(out, _91); @@ -1103,14 +1068,13 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe s2[Symbol.dispose](); return _02; }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug), " "])); noisy[Symbol.dispose](); const _147: rs.Arc | undefined = rs.weakUpgrade(weak4); const _145: boolean = _147 === undefined; const _150: rs.RefCell = rs.refCellBorrow(log.value); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_145, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_150.value), f, rs.u8Debug)]; - const _141: string = rs.fmtFormat([args10[0], " ", args10[1], " "]); + const args43 = [(f: rs.Formatter) => rs.fmtBool(_145, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_150.value), f, rs.u8Debug)]; + const _141: string = rs.fmtFormat([args43[0], " ", args43[1], " "]); rs.refRelease(_150); rs.drop(_147); put(out, _141); @@ -1126,20 +1090,19 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe }); const _174: rs.usize = looped.strong; const _177: rs.usize = looped.weak; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_168, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_174, f), (f: rs.Formatter) => rs.usizeDisplay(_177, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "])); + const args44 = [(f: rs.Formatter) => rs.fmtOption(_168, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_174, f), (f: rs.Formatter) => rs.usizeDisplay(_177, f)]; + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "])); const pinned: Shape.Shape = new of$dyns_Noisy(new Noisy.Noisy(rs.u8WrappingAdd(dataData[dataStart], 1), rs.arcClone(log))); let n: rs.u32 = dataData[dataStart + 1] as rs.u32; const borrowed2: Shape.Shape = new ofPlace$u32(rs.place(() => n, (value) => n = value)); const _205: rs.u32 = pinned.area$Shape(); const _209: rs.u8 = pinned.sides$Shape(); const _213: rs.u32 = borrowed2.area$Shape(); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_205, f), (f: rs.Formatter) => rs.u8Display(_209, f), (f: rs.Formatter) => rs.u32Display(_213, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); + const args45 = [(f: rs.Formatter) => rs.u32Display(_205, f), (f: rs.Formatter) => rs.u8Display(_209, f), (f: rs.Formatter) => rs.u32Display(_213, f)]; + put(out, rs.fmtFormat([args45[0], " ", args45[1], " ", args45[2], " "])); rs.drop(pinned); const _230: rs.RefCell = rs.refCellBorrow(log.value); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_230.value), f, rs.u8Debug)]; - const _226: string = rs.fmtFormat([args16[0], " "]); + const _226: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_230.value), f, rs.u8Debug), " "]); rs.refRelease(_230); put(out, _226); const boxes: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): Shape.Shape => { @@ -1180,27 +1143,23 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe }), rs.iterMap(rs.iterSlice(arcs.items), (s5: rs.Arc): rs.u32 => { return s5.value.area$Shape(); })), undefined, 4, true); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args18[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug), " "])); const _291: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_291.value); rs.refMutRelease(_291); rs.dropVec(arcs); const _304: rs.RefCell = rs.refCellBorrow(log.value); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_304.value), f, rs.u8Debug)]; - const _300: string = rs.fmtFormat([args20[0], " "]); + const _300: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_304.value), f, rs.u8Debug), " "]); rs.refRelease(_304); put(out, _300); rs.dropVec(rcs); const _321: rs.RefCell = rs.refCellBorrow(log.value); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_321.value), f, rs.u8Debug)]; - const _317: string = rs.fmtFormat([args22[0], " "]); + const _317: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_321.value), f, rs.u8Debug), " "]); rs.refRelease(_321); put(out, _317); rs.dropVec(kept); const _337: rs.RefCell = rs.refCellBorrow(log.value); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_337.value), f, rs.u8Debug)]; - const _333: string = rs.fmtFormat([args24[0], " "]); + const _333: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_337.value), f, rs.u8Debug), " "]); rs.refRelease(_337); put(out, _333); const _345: rs.Arc = new rs.Arc({ side: dataData[dataStart + 1] as rs.u16 }); @@ -1215,8 +1174,8 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _368: rs.usize = sq2.strong; const _372: rs.Fmt = (f: rs.Formatter) => rs.fmtBool(wrong, f); const arg = _365.side; - const args26: rs.Fmt[] = [_372, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " "])); + const args51 = [_372, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; + put(out, rs.fmtFormat([args51[0], " ", args51[1], " ", args51[2], " "])); sq2[Symbol.dispose](); } else { put(out, "none "); @@ -1243,8 +1202,8 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _420: boolean = rs.arcPtrEq(ex, ey); const _424: boolean = rs.arcPtrEq(ex, held); const _428: rs.usize = x.strong; - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_416, f), (f: rs.Formatter) => rs.fmtBool(_420, f), (f: rs.Formatter) => rs.fmtBool(_424, f), (f: rs.Formatter) => rs.usizeDisplay(_428, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " "])); + const args52 = [(f: rs.Formatter) => rs.fmtBool(_416, f), (f: rs.Formatter) => rs.fmtBool(_420, f), (f: rs.Formatter) => rs.fmtBool(_424, f), (f: rs.Formatter) => rs.usizeDisplay(_428, f)]; + put(out, rs.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " "])); ey[Symbol.dispose](); ex[Symbol.dispose](); y[Symbol.dispose](); @@ -1272,14 +1231,14 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _455: Noisy.Noisy = n2.value; const _458: rs.usize = n2.strong; const arg2 = _455._0; - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_458, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); + const args53 = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_458, f)]; + put(out, rs.fmtFormat([args53[0], " ", args53[1], " "])); _595 = false; held[Symbol.dispose](); const _475: rs.usize = n2.strong; const _478: rs.RefCell = rs.refCellBorrow(log.value); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_475, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_478.value), f, rs.u8Debug)]; - const _471: string = rs.fmtFormat([args32[0], " ", args32[1], " "]); + const args54 = [(f: rs.Formatter) => rs.usizeDisplay(_475, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_478.value), f, rs.u8Debug)]; + const _471: string = rs.fmtFormat([args54[0], " ", args54[1], " "]); rs.refRelease(_478); put(out, _471); n2[Symbol.dispose](); @@ -1290,8 +1249,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_444); } const _495: rs.RefCell = rs.refCellBorrow(log.value); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_495.value), f, rs.u8Debug)]; - const _491: string = rs.fmtFormat([args34[0], " "]); + const _491: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_495.value), f, rs.u8Debug), " "]); rs.refRelease(_495); put(out, _491); const part3 = option_map$1bn5ufk(ok$1oks8md(rs.arcDowncast(new rs.Arc(new of$u32(dataData[dataStart] as rs.u32)), of$u32, (object) => object.v)), (n3: rs.Arc): rs.u32 => { @@ -1299,8 +1257,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe n3[Symbol.dispose](); return _09; }); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug), " "])); const _523: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x3: rs.u8): rs.u8 => { return rs.u8WrappingAdd(x3, dataData[dataStart]); }); @@ -1310,8 +1267,8 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe }); const _537: rs.u8 = f.value(dataData[dataStart + 1]); const _543: rs.u8 = g.value(dataData[dataStart]); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_537, f), (f: rs.Formatter) => rs.u8Display(_543, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1]])); + const args57 = [(f: rs.Formatter) => rs.u8Display(_537, f), (f: rs.Formatter) => rs.u8Display(_543, f)]; + put(out, rs.fmtFormat([args57[0], " ", args57[1]])); g[Symbol.dispose](); f[Symbol.dispose](); if (_595) { @@ -1381,20 +1338,17 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const ends: [[rs.u8, rs.u8] | undefined, [rs.u8, rs.u8] | undefined] = [tags(rs.iterToOption(boxed.next())), tags(rs.iterToOption(boxed.nextBack()))]; const nths: [[rs.u8, rs.u8] | undefined, [rs.u8, rs.u8] | undefined] = [tags(rs.iterNth(rs.iterBox(boxed), 1, drop$tuple2_dyns_Tagged_dyns_Tagged)), tags(rs.iterNthBack(rs.iterBox(boxed), 0, drop$tuple2_dyns_Tagged_dyns_Tagged))]; dropped(out); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0][0], f), (f: rs.Formatter) => rs.fmtOption(hint[0][1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.usizeDebug(hint[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(ends[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(nths[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(nths[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); + const args43 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0][0], f), (f: rs.Formatter) => rs.fmtOption(hint[0][1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.usizeDebug(hint[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(ends[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(nths[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(nths[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f)]; + put(out, rs.fmtFormat([args43[0], " ", args43[1], " ", args43[2], " "])); dropped(out); const part = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args4[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); dropped(out); const part2 = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args6[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); dropped(out); const part3 = rs.ownedCount(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part3, f), " "])); dropped(out); const sum: rs.u32 = rs.iterFold(rs.iterBox(it()), 0, (n3: rs.u32, _3: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x: Tagged.Tagged = _3[0]; @@ -1405,16 +1359,15 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _02; }); dropped(out); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; - put(out, rs.fmtFormat([args10[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(sum, f), " "])); rs.iterForEach(rs.iterBox(it()), (_24: [Tagged.Tagged, Tagged.Tagged]): undefined => { const x2: Tagged.Tagged = _24[0]; const y2: Tagged.Tagged = _24[1]; const arg = x2._0; const _142: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg, f); const arg2 = y2._0; - const args44: rs.Fmt[] = [_142, (f: rs.Formatter) => rs.u8Display(arg2, f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " "])); + const args50 = [_142, (f: rs.Formatter) => rs.u8Display(arg2, f)]; + put(out, rs.fmtFormat([args50[0], " ", args50[1], " "])); y2[Symbol.dispose](); x2[Symbol.dispose](); }); @@ -1427,8 +1380,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _03; }); dropped(out); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(found, f, rs.usizeDebug), " "])); const found2: [rs.u8, rs.u8] | undefined = tags(rs.iterFind(rs.iterBox(it()), (_26: [Tagged.Tagged, Tagged.Tagged]): boolean => { return rs.u8Rem(_26[1]._0, 3) === 0; }, drop$tuple2_dyns_Tagged_dyns_Tagged)); @@ -1440,14 +1392,13 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { _28[1][Symbol.dispose](); return _05; }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_148, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " "])); + const args52 = [(f: rs.Formatter) => rs.fmtOption(found2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_148, f)]; + put(out, rs.fmtFormat([args52[0], " ", args52[1], " "])); dropped(out); const part4 = tags(rs.iterMaxByKey(rs.iterBox(it()), (p: [Tagged.Tagged, Tagged.Tagged]): rs.u8 => { return p[1]._0; }, rs.lt, undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args16[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); dropped(out); const all: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterMap(rs.vecIntoIter(rs.iterToVec(rs.iterBox(it()), "next", 2), drop$tuple2_dyns_Tagged_dyns_Tagged), (p2: [Tagged.Tagged, Tagged.Tagged]): [rs.u8, rs.u8] => { const _07: [rs.u8, rs.u8] = [p2[0]._0, p2[1]._0]; @@ -1455,8 +1406,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _07; }), "next", 2, true, 2); dropped(out); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args18[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); const back: rs.u32 = rs.iterFold(rs.iterRev(rs.iterBox(it())), 0, (n4: rs.u32, _33: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x5: Tagged.Tagged = _33[0]; const y3: Tagged.Tagged = _33[1]; @@ -1474,25 +1424,23 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { x6[Symbol.dispose](); return _09; }), rs.u32Add, 0); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(back, f), (f: rs.Formatter) => rs.u32Display(_208, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + const args55 = [(f: rs.Formatter) => rs.u32Display(back, f), (f: rs.Formatter) => rs.u32Display(_208, f)]; + put(out, rs.fmtFormat([args55[0], " ", args55[1], " "])); dropped(out); const _227: rs.usize = rs.ownedCount(rs.iterSkip(rs.iterBox(it()), 1, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); const _232: rs.usize = rs.ownedCount(rs.iterStepBy(rs.iterBox(it()), 2, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_227, f), (f: rs.Formatter) => rs.usizeDisplay(_232, f)]; - put(out, rs.fmtFormat([args22[0], " ", args22[1], " "])); + const args56 = [(f: rs.Formatter) => rs.usizeDisplay(_227, f), (f: rs.Formatter) => rs.usizeDisplay(_232, f)]; + put(out, rs.fmtFormat([args56[0], " ", args56[1], " "])); dropped(out); const _253: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(it()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part5 = tags(rs.iterNth(_253, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - const _246: string = rs.fmtFormat([args24[0], " "]); + const _246: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part5, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); rs.drop(_253); put(out, _246); dropped(out); const last: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it()))), drop$tuple2_dyns_Tagged_dyns_Tagged)); dropped(out); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args26[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); const boxed3: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); const _285: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const nth: [rs.u8, rs.u8] | undefined = tags(rs.iterNth(_285, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); @@ -1500,8 +1448,8 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { dropped(out); const n: rs.usize = rs.ownedCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), drop$tuple2_dyns_Tagged_dyns_Tagged); dropped(out); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(n, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + const args59 = [(f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(n, f)]; + put(out, rs.fmtFormat([args59[0], " ", args59[1], " "])); const boxed4: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); const first: [rs.u8, rs.u8] | undefined = tags(rs.iterToOption(boxed4.next())); const sum2: rs.u32 = rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed4))), 0, (n5: rs.u32, _34: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { @@ -1513,8 +1461,8 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _010; }); dropped(out); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(sum2, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); + const args60 = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(sum2, f)]; + put(out, rs.fmtFormat([args60[0], " ", args60[1], " "])); dropped(out); const n2: rs.u8 = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 0, (n6: rs.u8): rs.u8 => { return rs.u8Rem(n6, 4); @@ -1531,38 +1479,34 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const last2: [rs.u8, rs.u8] | undefined = rs.iterLast(rs.iterBox(logged())); const _351: [rs.u8, rs.u8] | undefined = rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(logged())))); const _354: rs.RefCell = rs.refCellBorrow(seen); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(_351, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; - const _347: string = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); + const args61 = [(f: rs.Formatter) => rs.fmtOption(last2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(_351, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; + const _347: string = rs.fmtFormat([args61[0], " ", args61[1], " ", args61[2], " "]); rs.refRelease(_354); put(out, _347); const part6 = tags(rs.ownedLast(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args34[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); dropped(out); const part7 = rs.ownedCount(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part7, f), " "])); dropped(out); const erased: () => rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = (): rs.Iter<[Tagged.Tagged, Tagged.Tagged]> => { return rs.iterDyn(skipped(data)); }; const _410: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(erased()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part8 = tags(rs.iterNth(_410, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - const _403: string = rs.fmtFormat([args38[0], " "]); + const _403: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); rs.drop(_410); put(out, _403); dropped(out); const _427: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged)); const _432: rs.usize = rs.ownedCount(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_427, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(_432, f)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); + const args65 = [(f: rs.Formatter) => rs.fmtOption(_427, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(_432, f)]; + put(out, rs.fmtFormat([args65[0], " ", args65[1], " "])); dropped(out); const boxed6: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = erased(); const _455: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(boxed6), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part9 = tags(rs.iterNth(_455, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - const _448: string = rs.fmtFormat([args42[0], " "]); + const _448: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); rs.drop(_455); put(out, _448); dropped(out); @@ -1621,8 +1565,8 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _88: rs.RefCell = rs.refCellBorrow(tri.value); const _93: rs.Fmt = (f: rs.Formatter) => rs.fmtList(areas.items, f, rs.u32Debug); const arg = _78.side; - const args2: rs.Fmt[] = [_93, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.u32Display(_84.value, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_88.value, f)]; - const _74: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "]); + const args61 = [_93, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.u32Display(_84.value, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_88.value, f)]; + const _74: string = rs.fmtFormat([args61[0], " ", args61[1], " ", args61[2], " ", args61[3], " "]); rs.refRelease(_88); rs.refRelease(_84); rs.refRelease(_80); @@ -1638,8 +1582,8 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { rs.refRelease(s4); return _02; }), 0); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_114, f), (f: rs.Formatter) => rs.fmtBool(_121, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - const _110: string = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "]); + const args62 = [(f: rs.Formatter) => rs.fmtBool(_114, f), (f: rs.Formatter) => rs.fmtBool(_121, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; + const _110: string = rs.fmtFormat([args62[0], " ", args62[1], " ", args62[2], " "]); drop$Result_cell_RefMut_dyns_Square_cell_BorrowMutError(_123); drop$Result_cell_Ref_dyn_dyns_Shape_cell_BorrowError(_116); put(out, _110); @@ -1649,15 +1593,15 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _155: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(tri.value); const _153: boolean = !_155.ok; const _159: rs.u8 = r.value.sides$Shape(); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.u8Display(_159, f)]; - const _149: string = rs.fmtFormat([args6[0], " ", args6[1], " "]); + const args63 = [(f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.u8Display(_159, f)]; + const _149: string = rs.fmtFormat([args63[0], " ", args63[1], " "]); drop$Result_cell_RefMut_dyns_Tri_cell_BorrowMutError(_155); put(out, _149); rs.refRelease(r); const _175: rs.usize = sq.strong; const _178: rs.usize = shapes.items[rs.idx(shapes.items, 1)].strong; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_175, f), (f: rs.Formatter) => rs.usizeDisplay(_178, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " "])); + const args64 = [(f: rs.Formatter) => rs.usizeDisplay(_175, f), (f: rs.Formatter) => rs.usizeDisplay(_178, f)]; + put(out, rs.fmtFormat([args64[0], " ", args64[1], " "])); const _187: rs.Arc> = new rs.Arc(new rs.RefCell({ tag: "Flat" } as Tri.Tri)); const named: rs.Arc> = new rs.ArcDyn(_187, rs.tailDyn(_187.value, { value: (value5: rs.RefCell) => new ofPlace$dyns_Tri(rs.valuePlace(value5)) })); const _193: rs.RefCell = rs.refCellBorrowMut(named.value); @@ -1672,14 +1616,13 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _214: string = _217.value.label$Named(); const _224: rs.RefCell = rs.refCellBorrow(upcast.value); const _221: rs.u32 = _224.value.area$Shape(); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), (f: rs.Formatter) => rs.fmtPad(f, _214), (f: rs.Formatter) => rs.u32Display(_221, f)]; - const _209: string = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "]); + const args65 = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), (f: rs.Formatter) => rs.fmtPad(f, _214), (f: rs.Formatter) => rs.u32Display(_221, f)]; + const _209: string = rs.fmtFormat([args65[0], " ", args65[1], " ", args65[2], " "]); rs.refRelease(_224); rs.refRelease(_217); put(out, _209); const _held: rs.RefCell = rs.refCellBorrowMut(named.value); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f))]; - put(out, rs.fmtFormat([args12[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), " "])); rs.refMutRelease(_held); const noisy: rs.Arc> = new rs.Arc(new rs.RefCell(new Noisy.Noisy(c, rs.arcClone(log)))); const _254: rs.Arc> = rs.arcClone(noisy); @@ -1694,23 +1637,22 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { s5[Symbol.dispose](); return _03; }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_268.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_272, f, rs.u32Debug)]; - const _264: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const args67 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_268.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_272, f, rs.u32Debug)]; + const _264: string = rs.fmtFormat([args67[0], " ", args67[1], " "]); rs.refRelease(_268); put(out, _264); shape[Symbol.dispose](); const _289: rs.RefCell = rs.refCellBorrow(log.value); const _295: rs.Arc> | undefined = rs.weakUpgrade(weak); const _293: boolean = _295 === undefined; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_289.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_293, f)]; - const _285: string = rs.fmtFormat([args16[0], " ", args16[1], " "]); + const args68 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_289.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_293, f)]; + const _285: string = rs.fmtFormat([args68[0], " ", args68[1], " "]); rs.drop(_295); rs.refRelease(_289); put(out, _285); rs.dropVec(shapes); const _311: rs.RefCell = rs.refCellBorrow(log.value); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug)]; - const _307: string = rs.fmtFormat([args18[0], " "]); + const _307: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug), " "]); rs.refRelease(_311); put(out, _307); const _321: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -1725,8 +1667,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _guard: rs.Mutex = rs.mutexLock(m.value); const _351: rs.Result, rs.TryLockError>> = rs.mutexTryLock(locked.value); const part = !_351.ok; - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - const _345: string = rs.fmtFormat([args20[0], " "]); + const _345: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part, f), " "]); drop$Result_sync_MutexGuard_dyn_dyns_Shape_sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_351); put(out, _345); rs.mutexUnlock(_guard); @@ -1740,8 +1681,8 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { }); const _372: rs.Mutex = rs.mutexLock(m.value); const _377: rs.usize = m.strong; - const args22: rs.Fmt[] = [(f: rs.Formatter) => Tri.fmt$fmt_Debug(_372.value, f), (f: rs.Formatter) => rs.fmtOption(area, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_377, f)]; - const _368: string = rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " "]); + const args71 = [(f: rs.Formatter) => Tri.fmt$fmt_Debug(_372.value, f), (f: rs.Formatter) => rs.fmtOption(area, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_377, f)]; + const _368: string = rs.fmtFormat([args71[0], " ", args71[1], " ", args71[2], " "]); rs.mutexUnlock(_372); put(out, _368); const rw: rs.Arc> = new rs.Arc(new rs.RefCell(c as rs.u32)); @@ -1755,15 +1696,14 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _411: boolean = !_413.ok; const _420: rs.RefCell = rs.rwLockRead(lock.value); const _417: rs.u32 = _420.value.area$Shape(); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_411, f), (f: rs.Formatter) => rs.u32Display(_417, f)]; - const _407: string = rs.fmtFormat([args24[0], " ", args24[1], " "]); + const args72 = [(f: rs.Formatter) => rs.fmtBool(_411, f), (f: rs.Formatter) => rs.u32Display(_417, f)]; + const _407: string = rs.fmtFormat([args72[0], " ", args72[1], " "]); rs.refRelease(_420); drop$Result_sync_RwLockWriteGuard_dyn_dyns_Shape_sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_413); put(out, _407); rs.refRelease(_read); const _437: rs.RefCell = rs.rwLockRead(rw.value); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_437.value, f)]; - const _433: string = rs.fmtFormat([args26[0], " "]); + const _433: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_437.value, f), " "]); rs.refRelease(_437); put(out, _433); const t: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rs.arcClone(log)), c as rs.u32); @@ -1777,8 +1717,8 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _472: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg3, f); const _473: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_465, f); const arg4 = t.value; - const args28: rs.Fmt[] = [_470, _471, _472, _473, (f: rs.Formatter) => rs.u32Display(arg4, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " "])); + const args74 = [_470, _471, _472, _473, (f: rs.Formatter) => rs.u32Display(arg4, f)]; + put(out, rs.fmtFormat([args74[0], " ", args74[1], " ", args74[2], " ", args74[3], " ", args74[4], " "])); const cell: rs.Arc>> = new rs.Arc(new rs.RefCell(new Tail.Tail(b, new Noisy.Noisy(a, rs.arcClone(log)), { side: b as rs.u16 }))); const _486: rs.Arc>> = rs.arcClone(cell); const nested: rs.Arc>> = new rs.ArcDyn(_486, rs.tailDyn(_486.value, { value: (value14: rs.RefCell>) => rs.tailDyn(value14.value, { value: (value15: Tail.Tail) => new of$dyns_Square(value15.value) }) }, rs.drop)); @@ -1793,27 +1733,24 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const arg5 = _502.count; const _516: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg5, f); const arg6 = _508.value.side; - const args30: rs.Fmt[] = [_515, _516, (f: rs.Formatter) => rs.u16Display(arg6, f)]; - const _498: string = rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); + const args75 = [_515, _516, (f: rs.Formatter) => rs.u16Display(arg6, f)]; + const _498: string = rs.fmtFormat([args75[0], " ", args75[1], " ", args75[2], " "]); rs.refRelease(_510); rs.refRelease(_504); put(out, _498); cell[Symbol.dispose](); t[Symbol.dispose](); const _531: rs.RefCell = rs.refCellBorrow(log.value); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_531.value), f, rs.u8Debug)]; - const _527: string = rs.fmtFormat([args32[0], " "]); + const _527: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_531.value), f, rs.u8Debug), " "]); rs.refRelease(_531); put(out, _527); nested[Symbol.dispose](); const boxed: Tail.Tail = rs.tailDyn(new Tail.Tail(c, new Noisy.Noisy(c, rs.arcClone(log)), new Noisy.Noisy(rs.u8WrappingAdd(c, 1), rs.arcClone(log))), { value: (value17: Tail.Tail) => new of$dyns_Noisy(value17.value) }, rs.drop); const part2 = boxed.value.area$Shape(); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - put(out, rs.fmtFormat([args34[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part2, f), " "])); boxed[Symbol.dispose](); const _572: rs.RefCell = rs.refCellBorrow(log.value); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_572.value), f, rs.u8Debug)]; - const _568: string = rs.fmtFormat([args36[0], " "]); + const _568: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_572.value), f, rs.u8Debug), " "]); rs.refRelease(_572); put(out, _568); const pinned: Tail.Tail = rs.tailDyn(new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), { tag: "Tall", _0: b } as Tri.Tri), { value: (value19: Tail.Tail) => new ofPlace$dyns_Tri(rs.place(() => value19.value, (value20) => value19.value = value20)) }, rs.drop); @@ -1834,14 +1771,13 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _618: rs.RefCell = rs.refCellBorrow(own.value); const _622: rs.usize = weak4.arc.strong; const arg7 = _610.count; - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg7, f), (f: rs.Formatter) => rs.u32Display(_613, f), (f: rs.Formatter) => rs.u32Display(_618.value, f), (f: rs.Formatter) => rs.usizeDisplay(_622, f)]; - const _606: string = rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " ", args38[3], " "]); + const args79 = [(f: rs.Formatter) => rs.u8Display(arg7, f), (f: rs.Formatter) => rs.u32Display(_613, f), (f: rs.Formatter) => rs.u32Display(_618.value, f), (f: rs.Formatter) => rs.usizeDisplay(_622, f)]; + const _606: string = rs.fmtFormat([args79[0], " ", args79[1], " ", args79[2], " ", args79[3], " "]); rs.refRelease(_618); put(out, _606); pinned[Symbol.dispose](); const _640: rs.RefCell = rs.refCellBorrow(log.value); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_640.value), f, rs.u8Debug)]; - const _636: string = rs.fmtFormat([args40[0], " "]); + const _636: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_640.value), f, rs.u8Debug), " "]); rs.refRelease(_640); put(out, _636); const shared3: rs.Arc> = new rs.Arc(rs.tailDyn(new rs.RefCell(new Noisy.Noisy(b, rs.arcClone(log))), { value: (value22: rs.RefCell) => new of$dyns_Noisy(value22.value) }, rs.drop)); @@ -1853,15 +1789,14 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _674: rs.RefCell = rs.refCellBorrow(again.value); const _671: rs.u32 = _674.value.area$Shape(); const _678: rs.RefCell = rs.refCellBorrow(log.value); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_671, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_678.value), f, rs.u8Debug)]; - const _667: string = rs.fmtFormat([args42[0], " ", args42[1], " "]); + const args81 = [(f: rs.Formatter) => rs.u32Display(_671, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_678.value), f, rs.u8Debug)]; + const _667: string = rs.fmtFormat([args81[0], " ", args81[1], " "]); rs.refRelease(_678); rs.refRelease(_674); put(out, _667); again[Symbol.dispose](); const _695: rs.RefCell = rs.refCellBorrow(log.value); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_695.value), f, rs.u8Debug)]; - const _691: string = rs.fmtFormat([args44[0], " "]); + const _691: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_695.value), f, rs.u8Debug), " "]); rs.refRelease(_695); put(out, _691); const guarded: rs.Vec> = rs.vecFrom([rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(a, rs.arcClone(log)) } as Held.Held), { value: (value23: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value23.value, (value24) => value23.value = value24)) }, drop$dyns_Guarded_dyns_Held), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), new Noisy.Noisy(b, rs.arcClone(log))), { value: (value25: Guarded.Guarded) => new of$dyns_Noisy(value25.value) }, drop$dyns_Guarded_dyns_Noisy), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Empty" } as Held.Held), { value: (value27: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value27.value, (value28) => value27.value = value28)) }, drop$dyns_Guarded_dyns_Held)]); @@ -1875,8 +1810,8 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 4, true); const _761: rs.RefCell> = rs.refCellBorrow(cell2.value); const _757: rs.u32 = _761.value.value.area$Shape(); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(areas2.items, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_757, f)]; - const _753: string = rs.fmtFormat([args46[0], " ", args46[1], " "]); + const args83 = [(f: rs.Formatter) => rs.fmtList(areas2.items, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_757, f)]; + const _753: string = rs.fmtFormat([args83[0], " ", args83[1], " "]); rs.refRelease(_761); put(out, _753); const _773: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -1884,14 +1819,12 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { rs.refMutRelease(_773); rs.dropVec(guarded, drop$boxed_Box_dyns_Guarded_dyn_dyns_Shape); const _785: rs.RefCell = rs.refCellBorrow(log.value); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_785.value), f, rs.u8Debug)]; - const _781: string = rs.fmtFormat([args48[0], " "]); + const _781: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_785.value), f, rs.u8Debug), " "]); rs.refRelease(_785); put(out, _781); rs.arcDrop(cell2, drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape); const _801: rs.RefCell = rs.refCellBorrow(log.value); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_801.value), f, rs.u8Debug)]; - const _797: string = rs.fmtFormat([args50[0], " "]); + const _797: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_801.value), f, rs.u8Debug), " "]); rs.refRelease(_801); put(out, _797); const t2: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), b as rs.u32); @@ -1916,8 +1849,8 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _867: boolean = rs.arcPtrEq(r2, s2); const _871: boolean = rs.arcPtrEq(r2, other); const _875: boolean = rs.arcPtrEq(u.arc, v.arc); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_859, f), (f: rs.Formatter) => rs.fmtBool(_863, f), (f: rs.Formatter) => rs.fmtBool(_867, f), (f: rs.Formatter) => rs.fmtBool(_871, f), (f: rs.Formatter) => rs.fmtBool(_875, f)]; - put(out, rs.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " ", args52[4], " "])); + const args86 = [(f: rs.Formatter) => rs.fmtBool(_859, f), (f: rs.Formatter) => rs.fmtBool(_863, f), (f: rs.Formatter) => rs.fmtBool(_867, f), (f: rs.Formatter) => rs.fmtBool(_871, f), (f: rs.Formatter) => rs.fmtBool(_875, f)]; + put(out, rs.fmtFormat([args86[0], " ", args86[1], " ", args86[2], " ", args86[3], " ", args86[4], " "])); v[Symbol.dispose](); u[Symbol.dispose](); other[Symbol.dispose](); @@ -1954,8 +1887,8 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _946: boolean = any.value instanceof of$u8 || any.value instanceof ofPlace$u8; const _952: rs.Mutex> = rs.mutexLock(it.value); const _949: rs.u8 | undefined = rs.iterToOption(_952.value.next()); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.refCellDebug(shown, f, (value: rs.Fmt, f: rs.Formatter) => value(f)), (f: rs.Formatter) => rs.fmtOption(_943, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_946, f), (f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_949, f, rs.u8Debug)]; - const _939: string = rs.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "]); + const args87 = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.refCellDebug(shown, f, (value: rs.Fmt, f: rs.Formatter) => value(f)), (f: rs.Formatter) => rs.fmtOption(_943, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_946, f), (f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_949, f, rs.u8Debug)]; + const _939: string = rs.fmtFormat([args87[0], " ", args87[1], " ", args87[2], " ", args87[3], " ", args87[4], " ", args87[5], " "]); rs.mutexUnlock(_952); put(out, _939); const _968: rs.u8 | undefined = option_map$1yjmt5m(rs.byteSliceFirst(rs.byteSliceRange(data, 3)), (x3: rs.u8): rs.u8 => { @@ -1979,8 +1912,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const dynamic2: rs.Arc> = new rs.ArcDyn(_984, rs.tailDyn(_984.value, { value: (value46: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value46)) })); const _held2: rs.RefCell = rs.refCellBorrowMut(dynamic2.value); const _997: rs.RefCell = rs.refCellBorrow(n.value); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_997.value, f)]; - const _993: string = rs.fmtFormat([args56[0]]); + const _993: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_997.value, f)]); rs.refRelease(_997); put(out, _993); rs.refMutRelease(_held2); @@ -1991,8 +1923,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _guard2: rs.Mutex = rs.mutexLock(m.value); const _1019: rs.Mutex = rs.mutexLock(locked.value); const part3 = _1019.value.area$Shape(); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _1012: string = rs.fmtFormat([args58[0]]); + const _1012: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part3, f)]); rs.mutexUnlock(_1019); put(out, _1012); rs.mutexUnlock(_guard2); @@ -2000,8 +1931,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { } } const _1034: rs.RefCell = rs.refCellBorrow(n.value); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1034.value, f)]; - const _1030: string = rs.fmtFormat([args60[0]]); + const _1030: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_1034.value, f)]); rs.refRelease(_1034); put(out, _1030); } @@ -2075,22 +2005,21 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _64: Tri.Tri = copy$dyns_Tri(tri.v); const _68: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_58, f); const arg = _61.side; - const args2: rs.Fmt[] = [_68, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_64, f), (f: rs.Formatter) => rs.u32Display(area, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "])); + const args41 = [_68, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_64, f), (f: rs.Formatter) => rs.u32Display(area, f)]; + put(out, rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " ", args41[3], " "])); const noisy: rs.Arc> = new rs.Arc(new rs.Cell(new Noisy.Noisy(a, rs.arcClone(log)))); const _80: rs.Arc> = rs.arcClone(noisy); const cell: rs.Arc> = new rs.ArcDyn(_80, rs.tailDyn(_80.value, { v: (value5: rs.Cell) => new of$dyns_Noisy(value5.v) }, rs.drop)); const area2: rs.u32 = growRaw(cell.value.v, b); noisy[Symbol.dispose](); const _95: rs.RefCell = rs.refCellBorrow(log.value); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(area2, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_95.value), f, rs.u8Debug)]; - const _91: string = rs.fmtFormat([args4[0], " ", args4[1], " "]); + const args42 = [(f: rs.Formatter) => rs.u32Display(area2, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_95.value), f, rs.u8Debug)]; + const _91: string = rs.fmtFormat([args42[0], " ", args42[1], " "]); rs.refRelease(_95); put(out, _91); cell[Symbol.dispose](); const _113: rs.RefCell = rs.refCellBorrow(log.value); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_113.value), f, rs.u8Debug)]; - const _109: string = rs.fmtFormat([args6[0], " "]); + const _109: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_113.value), f, rs.u8Debug), " "]); rs.refRelease(_113); put(out, _109); const _123: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -2105,12 +2034,11 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, boxed.v.grow$Shape(a); const _158: Tri.Tri = copy$dyns_Tri(u.value.v); const _163: rs.u32 = boxed.v.area$Shape(); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(area3, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_158, f), (f: rs.Formatter) => rs.u32Display(_163, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "])); + const args44 = [(f: rs.Formatter) => rs.u32Display(area3, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_158, f), (f: rs.Formatter) => rs.u32Display(_163, f)]; + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "])); boxed[Symbol.dispose](); const _183: rs.RefCell = rs.refCellBorrow(log.value); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_183.value), f, rs.u8Debug)]; - const _179: string = rs.fmtFormat([args10[0], " "]); + const _179: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_183.value), f, rs.u8Debug), " "]); rs.refRelease(_183); put(out, _179); const _193: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -2124,24 +2052,22 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, t.grow$Shape(a); const _218: rs.u32 = m.area$Shape(); const _222: rs.u32 = t.area$Shape(); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_218, f), (f: rs.Formatter) => rs.u32Display(_222, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " "])); + const args46 = [(f: rs.Formatter) => rs.u32Display(_218, f), (f: rs.Formatter) => rs.u32Display(_222, f)]; + put(out, rs.fmtFormat([args46[0], " ", args46[1], " "])); const _244: rs.u32 = new of$dyns_Noisy(new Noisy.Noisy(b, rs.arcClone(log))).area$Shape(); const _248: Noisy.Noisy = kept; const _250: Tri.Tri = held; const _253: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_244, f); const arg2 = _248._0; - const args14: rs.Fmt[] = [_253, (f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_250, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); + const args47 = [_253, (f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_250, f)]; + put(out, rs.fmtFormat([args47[0], " ", args47[1], " ", args47[2], " "])); const _267: rs.RefCell = rs.refCellBorrow(log.value); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_267.value), f, rs.u8Debug)]; - const _263: string = rs.fmtFormat([args16[0], " "]); + const _263: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_267.value), f, rs.u8Debug), " "]); rs.refRelease(_267); put(out, _263); rs.drop(new of$dyns_Noisy(kept)); const _285: rs.RefCell = rs.refCellBorrow(log.value); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_285.value), f, rs.u8Debug)]; - const _281: string = rs.fmtFormat([args18[0], " "]); + const _281: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_285.value), f, rs.u8Debug), " "]); rs.refRelease(_285); put(out, _281); const _295: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -2157,14 +2083,13 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const rest: [rs.u8, rs.u8 | undefined] = pollTail(future.value, 8); ticks[Symbol.dispose](); const _332: rs.RefCell = rs.refCellBorrow(log.value); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(first[0], f), (f: rs.Formatter) => rs.fmtOption(first[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Display(polls, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(rest[0], f), (f: rs.Formatter) => rs.fmtOption(rest[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_332.value), f, rs.u8Debug)]; - const _328: string = rs.fmtFormat([args20[0], " ", args20[1], " ", args20[2], " ", args20[3], " "]); + const args50 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(first[0], f), (f: rs.Formatter) => rs.fmtOption(first[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Display(polls, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(rest[0], f), (f: rs.Formatter) => rs.fmtOption(rest[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_332.value), f, rs.u8Debug)]; + const _328: string = rs.fmtFormat([args50[0], " ", args50[1], " ", args50[2], " ", args50[3], " "]); rs.refRelease(_332); put(out, _328); future[Symbol.dispose](); const _354: rs.RefCell = rs.refCellBorrow(log.value); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; - const _350: string = rs.fmtFormat([args22[0], " "]); + const _350: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug), " "]); rs.refRelease(_354); put(out, _350); const _364: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -2185,14 +2110,13 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, rs.refMutRelease(borrowed); block[Symbol.dispose](); const _398: rs.RefCell = rs.refCellBorrow(log.value); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(ready, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_398.value), f, rs.u8Debug)]; - const _394: string = rs.fmtFormat([args24[0], " ", args24[1], " "]); + const args52 = [(f: rs.Formatter) => rs.fmtOption(ready, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_398.value), f, rs.u8Debug)]; + const _394: string = rs.fmtFormat([args52[0], " ", args52[1], " "]); rs.refRelease(_398); put(out, _394); erased[Symbol.dispose](); const _416: rs.RefCell = rs.refCellBorrow(log.value); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_416.value), f, rs.u8Debug)]; - const _412: string = rs.fmtFormat([args26[0], " "]); + const _412: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_416.value), f, rs.u8Debug), " "]); rs.refRelease(_416); put(out, _412); const _426: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -2217,12 +2141,11 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const arg4 = t2.count; const _475: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg4, f); const arg5 = t2.value; - const args28: rs.Fmt[] = [_471, _472, _473, _474, _475, (f: rs.Formatter) => Tri.fmt$fmt_Debug(arg5, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " ", args28[5], " "])); + const args54 = [_471, _472, _473, _474, _475, (f: rs.Formatter) => Tri.fmt$fmt_Debug(arg5, f)]; + put(out, rs.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "])); t2[Symbol.dispose](); const _489: rs.RefCell = rs.refCellBorrow(log.value); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_489.value), f, rs.u8Debug)]; - const _485: string = rs.fmtFormat([args30[0], " "]); + const _485: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_489.value), f, rs.u8Debug), " "]); rs.refRelease(_489); put(out, _485); let sq2: rs.Cell = new rs.Cell({ side: c as rs.u16 }); @@ -2241,8 +2164,8 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _534: rs.RefCell = rs.refCellBorrow(tri2); const _538: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(areas2[0], f), (f: rs.Formatter) => rs.u32Debug(areas2[1], f)], f); const arg6 = _531.side; - const args32: rs.Fmt[] = [_538, (f: rs.Formatter) => rs.u16Display(arg6, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_534.value, f)]; - const _527: string = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); + const args56 = [_538, (f: rs.Formatter) => rs.u16Display(arg6, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_534.value, f)]; + const _527: string = rs.fmtFormat([args56[0], " ", args56[1], " ", args56[2], " "]); rs.refRelease(_534); put(out, _527); const _546: [Ticks.Ticks, Noisy.Noisy, Tail.Tail] = [new Ticks.Ticks(rs.u8Rem(b, 3), 0, rs.arcClone(log)), new Noisy.Noisy(a, rs.arcClone(log)), new Tail.Tail(b, new Noisy.Noisy(b, rs.arcClone(log)), new Noisy.Noisy(c, rs.arcClone(log)))]; @@ -2259,8 +2182,8 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, rs.drop(noisy3); tail3[Symbol.dispose](); const _599: rs.RefCell = rs.refCellBorrow(log.value); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(polled, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_599.value), f, rs.u8Debug)]; - const _595: string = rs.fmtFormat([args34[0], " ", args34[1], " "]); + const args57 = [(f: rs.Formatter) => rs.fmtBool(polled, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_599.value), f, rs.u8Debug)]; + const _595: string = rs.fmtFormat([args57[0], " ", args57[1], " "]); rs.refRelease(_599); put(out, _595); const _611: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -2273,8 +2196,8 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _632: rs.Mutex> = rs.mutexLock(locked.value); const second: rs.u8 | undefined = rs.iterToOption(_632.value.next()); rs.mutexUnlock(_632); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args36[0], " ", args36[1], " "])); + const args58 = [(f: rs.Formatter) => rs.fmtOption(first2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args58[0], " ", args58[1], " "])); cell2[Symbol.dispose](); dropped(out); locked[Symbol.dispose](); @@ -2287,12 +2210,12 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, wide.v.v.grow$Shape(b); const area5: rs.u32 = wide.v.v.area$Shape(); const _677: rs.u32 = slot.v; - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(null_, f), (f: rs.Formatter) => rs.u32Display(area5, f), (f: rs.Formatter) => rs.u32Display(_677, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "])); + const args59 = [(f: rs.Formatter) => rs.fmtBool(null_, f), (f: rs.Formatter) => rs.u32Display(area5, f), (f: rs.Formatter) => rs.u32Display(_677, f)]; + put(out, rs.fmtFormat([args59[0], " ", args59[1], " ", args59[2], " "])); const shown: rs.Fmt = rs.rawUnsize(side, (p13) => rs.fmtOwned(p13, (value: Square.Square, f: rs.Formatter) => Square.fmt$fmt_Debug(value, f))); const _703: boolean = rs.rawUnsize(rs.NULL, (p14) => new of$dyns_Square(p14)) === rs.NULL; - const args40: rs.Fmt[] = [(f: rs.Formatter) => shown(f), (f: rs.Formatter) => rs.fmtBool(_703, f)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1]])); + const args60 = [(f: rs.Formatter) => shown(f), (f: rs.Formatter) => rs.fmtBool(_703, f)]; + put(out, rs.fmtFormat([args60[0], " ", args60[1]])); owned[Symbol.dispose](); shape[Symbol.dispose](); u[Symbol.dispose](); @@ -2357,8 +2280,7 @@ export function take$dyns_Source_u8(self: rs.Place): string | undefined { const _2: rs.u8 | undefined = rs.u8CheckedSub(self.v, 1); if (_2 !== undefined) { self.v = _2; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(self.v, f)]; - return rs.fmtFormat(["<", args2[0], ">"]); + return rs.fmtFormat(["<", (f: rs.Formatter) => rs.u8Display(self.v, f), ">"]); } return undefined; } @@ -2372,8 +2294,7 @@ export function taken$String(s: Source.Source): string { while (true) { const _3: string | undefined = s.take$Source(); if (_3 !== undefined) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(_3, f)]; - const _8: string = rs.fmtFormat([args2[0]]); + const _8: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(_3, f)]); taken.items.push(_8); } else { break; @@ -2387,8 +2308,7 @@ export function taken$u32(s: Source.Source): string { while (true) { const _3: rs.u32 | undefined = s.take$Source(); if (_3 !== undefined) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(_3, f)]; - const _8: string = rs.fmtFormat([args2[0]]); + const _8: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(_3, f)]); taken.items.push(_8); } else { break; @@ -2423,20 +2343,18 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { named.bump$Scaled(rs.place(() => s, (value3) => s = value3) as rs.Ptr); const _57: rs.u8 = narrow.scale$Scaled(b); const _59: rs.u16 = wide.scale$Scaled(rs.u16Mul(c as rs.u16, 300)); - const args3: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f)]; - const _65: string = named.scale$Scaled(rs.fmtFormat([args3[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => rs.u16Display(_59, f), (f: rs.Formatter) => rs.fmtPad(f, _65), (f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u16Display(w, f), (f: rs.Formatter) => rs.fmtPad(f, s)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " "])); + const _65: string = named.scale$Scaled(rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(a, f)])); + const args34 = [(f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => rs.u16Display(_59, f), (f: rs.Formatter) => rs.fmtPad(f, _65), (f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u16Display(w, f), (f: rs.Formatter) => rs.fmtPad(f, s)]; + put(out, rs.fmtFormat([args34[0], " ", args34[1], " ", args34[2], " ", args34[3], " ", args34[4], " ", args34[5], " "])); const _90: string = "ab"; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(c, f)]; - const _89: [string, string] = [_90, rs.fmtFormat([args6[0]])]; + const _89: [string, string] = [_90, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(c, f)])]; const x: string = _90; const y: string = _89[1]; const _108: rs.u8 = narrow.pick$Scaled(b as rs.Ptr, c as rs.Ptr) as rs.u8; const _112: rs.u16 = wide.pick$Scaled((a as rs.u16) as rs.Ptr, w as rs.Ptr) as rs.u16; const _118: string = named.pick$Scaled(x as rs.Ptr, y as rs.Ptr) as string; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_108, f), (f: rs.Formatter) => rs.u16Display(_112, f), (f: rs.Formatter) => rs.fmtPad(f, _118)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "])); + const args36 = [(f: rs.Formatter) => rs.u8Display(_108, f), (f: rs.Formatter) => rs.u16Display(_112, f), (f: rs.Formatter) => rs.fmtPad(f, _118)]; + put(out, rs.fmtFormat([args36[0], " ", args36[1], " ", args36[2], " "])); const paired: Paired.Paired = new of$dyns_Many({ _0: b }); const up: Scaled.Scaled = paired as Scaled.Scaled; const v: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 3)); @@ -2445,8 +2363,8 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const picked: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(up.pick$Scaled(v as rs.Ptr, _138 as rs.Ptr) as rs.ByteVec)); const _150: [rs.u8, rs.u8] = paired.pair$Paired(c); const _152: rs.ByteVec = up.scale$Scaled(rs.byteSliceToByteVec(rs.byteSliceRange(data, 3))); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_150[0], f), (f: rs.Formatter) => rs.u8Debug(_150[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_152), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(picked), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " "])); + const args37 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_150[0], f), (f: rs.Formatter) => rs.u8Debug(_150[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_152), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(picked), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args37[0], " ", args37[1], " ", args37[2], " ", args37[3], " "])); const _164: rs.Arc = new rs.Arc({ _0: c }); const shared: rs.Arc> = new rs.ArcDyn(_164, new of$dyns_Many(_164.value)); const up2: rs.Arc> = rs.arcClone(shared) as rs.Arc>; @@ -2454,8 +2372,8 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { up2.value.bump$Scaled(v2 as rs.Ptr); const _183: [rs.u8, rs.u8] = shared.value.pair$Paired(b); const _187: rs.usize = up2.strong; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_183[0], f), (f: rs.Formatter) => rs.u8Debug(_183[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v2), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "])); + const args38 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_183[0], f), (f: rs.Formatter) => rs.u8Debug(_183[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v2), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; + put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "])); const weak2: rs.Weak> = new rs.Weak(shared) as rs.Weak>; up2[Symbol.dispose](); const scaled: rs.ByteVec | undefined = option_map$00ac22d(rs.weakUpgrade(weak2), (s2: rs.Arc>): rs.ByteVec => { @@ -2466,30 +2384,29 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { shared[Symbol.dispose](); const _217: rs.Arc> | undefined = rs.weakUpgrade(weak2); const _215: boolean = _217 === undefined; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(scaled, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtBool(_215, f)]; - const _211: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const args39 = [(f: rs.Formatter) => rs.fmtOption(scaled, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtBool(_215, f)]; + const _211: string = rs.fmtFormat([args39[0], " ", args39[1], " "]); rs.drop(_217); put(out, _211); const nest: Nest.Nest = new of$dyns_Leaf({ _0: c }); const _236: boolean = (nest.next$Nest() as Nest.Nest | undefined) === undefined; const _240: rs.u8 = nest.depth$Nest(); const _242: rs.u8 = narrow.apply$Scaled(doubled as (a0: rs.Ptr) => rs.u8, c); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_236, f), (f: rs.Formatter) => rs.u8Display(_240, f), (f: rs.Formatter) => rs.u8Display(_242, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "])); + const args40 = [(f: rs.Formatter) => rs.fmtBool(_236, f), (f: rs.Formatter) => rs.u8Display(_240, f), (f: rs.Formatter) => rs.u8Display(_242, f)]; + put(out, rs.fmtFormat([args40[0], " ", args40[1], " ", args40[2], " "])); const owned: Source.Source = new of$dyns_Drained(new Drained.Drained(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_2: rs.u8): Noisy.Noisy => { return new Noisy.Noisy(_2, rs.arcClone(log)); }), undefined, 8, true))); const first: Noisy.Noisy | undefined = owned.take$Source(); const _268: rs.usize = owned.left$Source(); const _271: rs.RefCell = rs.refCellBorrow(log.value); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_268, f), (f: rs.Formatter) => rs.fmtOption(first, f, (value: Noisy.Noisy, f: rs.Formatter) => Noisy.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_271.value), f, rs.u8Debug)]; - const _264: string = rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); + const args41 = [(f: rs.Formatter) => rs.usizeDisplay(_268, f), (f: rs.Formatter) => rs.fmtOption(first, f, (value: Noisy.Noisy, f: rs.Formatter) => Noisy.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_271.value), f, rs.u8Debug)]; + const _264: string = rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " "]); rs.refRelease(_271); put(out, _264); rs.drop(first); const _290: rs.RefCell = rs.refCellBorrow(log.value); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_290.value), f, rs.u8Debug)]; - const _286: string = rs.fmtFormat([args20[0], " "]); + const _286: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_290.value), f, rs.u8Debug), " "]); rs.refRelease(_290); put(out, _286); if (rs.u8Rem(a, 2) === 0) { @@ -2497,8 +2414,7 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.drop(owned); const _311: rs.RefCell = rs.refCellBorrow(log.value); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug)]; - const _307: string = rs.fmtFormat([args22[0], " "]); + const _307: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug), " "]); rs.refRelease(_311); put(out, _307); const steps: Steps.Steps = { _0: rs.u8Rem(a, 6) as rs.u32, _1: b as rs.u32 }; @@ -2506,17 +2422,17 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const next: rs.u32 | undefined = counted.take$Source(); const _334: rs.usize = counted.left$Source(); const _337: rs.u32 = counted.total$Counted(); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2], " "])); + const args44 = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "])); const _354: string = taken$u32(counted as Source.Source); const _358: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, _354); const arg = steps._1; - const args26: rs.Fmt[] = [_358, (f: rs.Formatter) => rs.u32Display(arg, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " "])); + const args45 = [_358, (f: rs.Formatter) => rs.u32Display(arg, f)]; + put(out, rs.fmtFormat([args45[0], " ", args45[1], " "])); let left: rs.u8 = rs.u8Rem(c, 5); const _372: string = taken$String(new ofPlace$u8(rs.place(() => left, (value4) => left = value4))); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _372), (f: rs.Formatter) => rs.u8Display(left, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + const args46 = [(f: rs.Formatter) => rs.fmtPad(f, _372), (f: rs.Formatter) => rs.u8Display(left, f)]; + put(out, rs.fmtFormat([args46[0], " ", args46[1], " "])); const tasks: rs.Vec> = rs.vecFrom([new of$dyns_Steps({ _0: 1, _1: a as rs.u32 })]); const square: Task.Task = new of$dyns_Square({ side: c as rs.u16 }); tasks.items[rs.idx(tasks.items, 0)].run$Task(); @@ -2524,8 +2440,8 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { t.v.run$Task(); })); const _408: rs.u32 = square.run$Task(); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(ran, f), (f: rs.Formatter) => rs.u32Display(_408, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); + const args47 = [(f: rs.Formatter) => rs.usizeDisplay(ran, f), (f: rs.Formatter) => rs.u32Display(_408, f)]; + put(out, rs.fmtFormat([args47[0], " ", args47[1], " "])); const over: Over.Over = new Over.Over(new of$dyns_Tri(copy$dyns_Tri(tri)), new of$u8(rs.u8Rem(a, 4))); const runs: rs.Vec = new rs.Vec(); while (true) { @@ -2537,8 +2453,8 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { } } const _439: rs.usize = over.source.left$Source(); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(runs.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(_439, f)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1]])); + const args48 = [(f: rs.Formatter) => rs.fmtList(runs.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(_439, f)]; + put(out, rs.fmtFormat([args48[0], " ", args48[1]])); over[Symbol.dispose](); rs.drop(square); rs.dropVec(tasks); diff --git a/ts/fixtures/lang/dyns/expected/harness.ts b/ts/fixtures/lang/dyns/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/dyns/expected/harness.ts +++ b/ts/fixtures/lang/dyns/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/dyns/expected/stds.ts b/ts/fixtures/lang/dyns/expected/stds.ts index c07a26e5b..f3563010f 100644 --- a/ts/fixtures/lang/dyns/expected/stds.ts +++ b/ts/fixtures/lang/dyns/expected/stds.ts @@ -54,12 +54,11 @@ export function hashInto(h: Hasher.Hasher, data: rs.ByteSlice, keys: rs.Slice { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - if (w.writeFmt$Write(["[", args2[0]]).ok) { + if (w.writeFmt$Write(["[", (f: rs.Formatter) => rs.u8Display(n, f)]).ok) { if (w.writeChar$Write(233).ok) { if (w.writeStr$Write(s).ok) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.u8LowerHex(n, f)]; - if (w.writeFmt$Write([rs.fmtSpec({ align: ">", width: 5 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[1]), "]"]).ok) { + const args6 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.u8LowerHex(n, f)]; + if (w.writeFmt$Write([rs.fmtSpec({ align: ">", width: 5 }, args6[0]), "|", rs.fmtSpec({ alternate: true }, args6[1]), "]"]).ok) { return w.writeFmt$Write(["!"]); } return rs.Err(new rs.FmtError()); @@ -106,8 +105,8 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const _71: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_53, f); const _72: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_59, f); const arg = sum._0; - const args2: rs.Fmt[] = [_70, _71, _72, (f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_66.value), f, rs.u8Debug)]; - const _43: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "]); + const args17 = [_70, _71, _72, (f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_66.value), f, rs.u8Debug)]; + const _43: string = rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", args17[4], " "]); rs.refRelease(_66); put(out, _43); const _79: rs.u8 = rs.u8Rem(a, 3); @@ -134,18 +133,16 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const _128: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_121, f); const _129: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_124, f); const arg2 = sum2._0; - const args4: rs.Fmt[] = [_128, _129, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "])); + const args18 = [_128, _129, (f: rs.Formatter) => rs.u32Display(arg2, f)]; + put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "])); rs.drop(boxed); const _143: rs.RefCell = rs.refCellBorrow(log.value); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_143.value), f, rs.u8Debug)]; - const _139: string = rs.fmtFormat([args6[0], " "]); + const _139: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_143.value), f, rs.u8Debug), " "]); rs.refRelease(_143); put(out, _139); fnv[Symbol.dispose](); const _160: rs.RefCell = rs.refCellBorrow(log.value); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_160.value), f, rs.u8Debug)]; - const _156: string = rs.fmtFormat([args8[0], " "]); + const _156: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_160.value), f, rs.u8Debug), " "]); rs.refRelease(_160); put(out, _156); const _170: rs.RefCell = rs.refCellBorrowMut(log.value); @@ -168,14 +165,14 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const _230: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, arg3); const _231: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(failed, f, rs.fmtUnit, rs.fmtErrorDebug); const arg4 = counter._0; - const args10: rs.Fmt[] = [_228, _229, _230, _231, (f: rs.Formatter) => rs.usizeDisplay(arg4, f), (f: rs.Formatter) => rs.fmtResult(counted, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtResult(again2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_219.value), f, rs.u8Debug)]; - const _213: string = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4], " ", args10[5], " ", args10[6], " ", args10[7], " "]); + const args21 = [_228, _229, _230, _231, (f: rs.Formatter) => rs.usizeDisplay(arg4, f), (f: rs.Formatter) => rs.fmtResult(counted, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtResult(again2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_219.value), f, rs.u8Debug)]; + const _213: string = rs.fmtFormat([args21[0], " ", args21[1], " ", args21[2], " ", args21[3], " ", args21[4], " ", args21[5], " ", args21[6], " ", args21[7], " "]); rs.refRelease(_219); put(out, _213); const _246: Rendered.Rendered = { _0: a }; const _248: Rendered.Rendered = { _0: b }; - const args12: rs.Fmt[] = [(f: rs.Formatter) => Rendered.fmt$fmt_Display(_246, f), (f: rs.Formatter) => Rendered.fmt$fmt_Display(_248, f)]; - put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ align: ">", width: 12 }, args12[1]), " "])); + const args22 = [(f: rs.Formatter) => Rendered.fmt$fmt_Display(_246, f), (f: rs.Formatter) => Rendered.fmt$fmt_Display(_248, f)]; + put(out, rs.fmtFormat([args22[0], " ", rs.fmtSpec({ align: ">", width: 12 }, args22[1]), " "])); if (rs.u8Rem(b, 2) === 0) { _255 = new of$stds_Counter({ _0: a as rs.usize }); } else { @@ -185,14 +182,13 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const written2: rs.Result = render(boxed2, b, "b"); rs.drop(boxed2); const _278: rs.RefCell = rs.refCellBorrow(log.value); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(written2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_278.value), f, rs.u8Debug)]; - const _274: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + const args23 = [(f: rs.Formatter) => rs.fmtResult(written2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_278.value), f, rs.u8Debug)]; + const _274: string = rs.fmtFormat([args23[0], " ", args23[1], " "]); rs.refRelease(_278); put(out, _274); upper[Symbol.dispose](); const _297: rs.RefCell = rs.refCellBorrow(log.value); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_297.value), f, rs.u8Debug)]; - const _293: string = rs.fmtFormat([args16[0]]); + const _293: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_297.value), f, rs.u8Debug)]); rs.refRelease(_297); put(out, _293); log[Symbol.dispose](); diff --git a/ts/fixtures/lang/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index d708e7eea..0083f2797 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -55,15 +55,15 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_8 === 0) { const v: rs.Vec = rs.vecFrom(words.items.slice()); const seen: rs.Vec = new rs.Vec(); - rs.vecRetain(v, (_227: rs.u16): boolean => { - const x4: rs.u16 = _227; + rs.vecRetain(v, (_233: rs.u16): boolean => { + const x4: rs.u16 = _233; seen.items.push(x4); return rs.u16Rem(x4, 4) !== 0; }); putU16s(out, rs.sliceFrom(seen.items)); putU16s(out, rs.sliceFrom(v.items)); - const pairs: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_229: rs.u16): [rs.u16, rs.u16] => { - return [_229, 0] as [rs.u16, rs.u16]; + const pairs: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_237: rs.u16): [rs.u16, rs.u16] => { + return [_237, 0] as [rs.u16, rs.u16]; }), undefined, 4, true); rs.vecRetain(pairs, (p3: [rs.u16, rs.u16]): boolean => { p3[1] = rs.u16Div(p3[0], 2); @@ -72,8 +72,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _33 of pairs.items) { putU16s(out, rs.sliceFrom([_33[0], _33[1]])); } - const names: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_233: rs.u8): string => { - return text(rs.byteSliceFrom(Uint8Array.of(_233))); + const names: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_238: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(_238))); }), undefined, 12, true); rs.vecRetain(names, (s3: string): boolean => { return rs.stringLen(s3) > 1; @@ -109,23 +109,22 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const part8 = rs.usizeSaturatingSub(data.length, 1); const stop: rs.u16 = rs.u16Mul(at(part8) as rs.u16, 3); if ((kind & 128) !== 0) { - rs.vecRetain(v2, (_237: rs.u16): boolean => { - const x6: rs.u16 = _237; + rs.vecRetain(v2, (_240: rs.u16): boolean => { + const x6: rs.u16 = _240; if (!(x6 === stop)) { return true; } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(x6, f)]; - rs.panicFmt(["retain stopped at ", args4[0]]); + rs.panicFmt(["retain stopped at ", (f: rs.Formatter) => rs.u16Display(x6, f)]); }); } } else if (_8 === 1) { - const v3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_223: rs.u8): rs.u16 => { - return rs.u8Rem(_223, 4) as rs.u16; + const v3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_224: rs.u8): rs.u16 => { + return rs.u8Rem(_224, 4) as rs.u16; }), undefined, 2, true); rs.vecDedupBy(v3, rs.same); putU16s(out, rs.sliceFrom(v3.items)); - const keyed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_224: rs.u16): Named.Named => { - return _104(_224); + const keyed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_225: rs.u16): Named.Named => { + return _104(_225); }), undefined, 16, true); rs.vecDedupByKey(keyed, (n3: Named.Named): rs.u16 => { return rs.u16Div(n3.id, 24); @@ -133,8 +132,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _117 of keyed.items) { putU16s(out, rs.sliceFrom([_117.id])); } - const tested: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_225: rs.u16): Named.Named => { - return _104(_225); + const tested: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_226: rs.u16): Named.Named => { + return _104(_226); }), undefined, 16, true); const seen2: rs.Vec = new rs.Vec(); rs.vecDedupBy(tested, (a3: Named.Named, b10: Named.Named): boolean => { @@ -146,8 +145,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _144 of tested.items) { put(out, _144.name); } - const names2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_226: rs.u8): string => { - return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_226, 3)))); + const names2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_227: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_227, 3)))); }), undefined, 12, true); rs.vecDedupBy(names2, rs.same); rs.byteVecPush(out, names2.items.length & 0xff); @@ -160,8 +159,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.cmp(b6, a); }), 2, true, true); putU16s(out, rs.sliceFrom(v5.items)); - const pairs2: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(words.items)), (_216: [rs.usize, rs.u16]): [rs.u16, rs.u16] => { - return [rs.u16Rem(_216[1], 5), _216[0] & 0xffff] as [rs.u16, rs.u16]; + const pairs2: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(words.items)), (_218: [rs.usize, rs.u16]): [rs.u16, rs.u16] => { + return [rs.u16Rem(_218[1], 5), _218[0] & 0xffff] as [rs.u16, rs.u16]; }), undefined, 4, true); rs.sliceSort(rs.sliceFrom(pairs2.items), rs.keyLt((p2: [rs.u16, rs.u16]): rs.u16 => { return p2[0]; @@ -169,9 +168,9 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _188 of pairs2.items) { putU16s(out, rs.sliceFrom([_188[0], _188[1]])); } - rs.sliceSortUnstable(rs.sliceFrom(pairs2.items), rs.keyLt((_218: [rs.u16, rs.u16]): [rs.u16, rs.u16, rs.u16] => { - const a2: rs.u16 = _218[0]; - const b7: rs.u16 = _218[1]; + rs.sliceSortUnstable(rs.sliceFrom(pairs2.items), rs.keyLt((_220: [rs.u16, rs.u16]): [rs.u16, rs.u16, rs.u16] => { + const a2: rs.u16 = _220[0]; + const b7: rs.u16 = _220[1]; return [rs.u16Rem(b7, 3), a2, b7] as [rs.u16, rs.u16, rs.u16]; }, rs.cmpLt(rs.cmpTuple<[rs.u16, rs.u16, rs.u16], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))), 4, true, true); for (const _205 of pairs2.items) { @@ -183,8 +182,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _222 of pairs2.items) { putU16s(out, rs.sliceFrom([_222[0], _222[1]])); } - const options: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_220: rs.u16): rs.u16 | undefined => { - const w8: rs.u16 = _220; + const options: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_221: rs.u16): rs.u16 | undefined => { + const w8: rs.u16 = _221; if (!(rs.u16Rem(w8, 2) === 0)) { return w8; } @@ -196,8 +195,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return o; })])); } - const names3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_221: rs.u8): string => { - const b8: rs.u8 = _221; + const names3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_223: rs.u8): string => { + const b8: rs.u8 = _223; return text(rs.byteSliceFrom(Uint8Array.of(b8, rs.u8Div(b8, 16)))); }), undefined, 12, true); rs.sliceSort(rs.sliceFrom(names3.items), rs.cmpLt(rs.cmpStr), 12, true); @@ -223,8 +222,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.sliceReverse(rs.sliceFrom(v6.items)); putU16s(out, rs.sliceFrom(v6.items)); - const named: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_212: rs.u16): Named.Named => { - const w6: rs.u16 = _212; + const named: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_216: rs.u16): Named.Named => { + const w6: rs.u16 = _216; return { id: w6, name: text(rs.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; }), undefined, 16, true); const probe: Named.Named = { id: rs.u16Mul(at(1) as rs.u16, 3), name: text(rs.byteSliceFrom(Uint8Array.of(rs.u8WrappingMul(at(1), 3)))) }; @@ -372,8 +371,7 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_764, 0); rs.byteVecPush(out, _764.data[_764.start]); const part6 = rs.fromUtf8ErrorClone(rs.resultUnwrapErr(rs.stringFromUtf8(rs.byteVecFrom(Uint8Array.of(97, 255, at(6)))), rs.fmtStr)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(part6, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(part6, f)])); rs.byteVecPush(out, 16 & 0xff); rs.byteVecPush(out, 16 & 0xff); rs.byteVecPush(out, 4 & 0xff); @@ -1104,9 +1102,9 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _288: { end: rs.usize } = { end: rs.usizeDiv(tuples.items.length, 2) }; rs.vecExtendFromWithin(tuples, _288, 4, copy$tuple2_u8_u16); const moved: rs.Vec = rs.vecSplitOff(pairs, rs.usizeDiv(pairs.items.length, 2)); - const iter4: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterChain(rs.iterSlice(pairs.items), rs.iterSlice(moved.items))); + const iter4: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterChain(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom), rs.iterLend(rs.iterSlice(moved.items), rs.sliceFrom))); while (true) { - const _309: [rs.usize, rs.u16[]] | rs.Done = iter4.next(); + const _309: [rs.usize, rs.Slice] | rs.Done = iter4.next(); if (_309 === rs.DONE) { break; } @@ -1115,7 +1113,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (!(_315 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _315); } - _309[1][_315] = rs.u16Add(_309[1][_315], i2 & 0xffff); + _309[1].data[_309[1].start + _315] = rs.u16Add(_309[1].data[_309[1].start + _315], i2 & 0xffff); } const iter5: rs.Iter<[rs.u8, rs.u16]> = rs.iterStepBy(rs.iterSlice(tuples.items), 2); while (true) { @@ -1126,7 +1124,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void _325[1] = rs.u16Add(_325[1], 10); } rs.vecAppend(pairs, moved, 4); - const iter6: rs.Iter = rs.iterFlatten(rs.iterSlice(pairs.items), (value: rs.u16[]) => rs.iterSlice(value), true, 2); + const iter6: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); while (true) { const _339: rs.u16 | rs.Done = iter6.next(); if (_339 === rs.DONE) { @@ -1356,9 +1354,9 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _837: rs.u16[] = [7, 7]; rs.dequeResize(pairs2, _831, _837, copy$array_u16); const moved2: rs.VecDeque = rs.dequeSplitOff(pairs2, rs.usizeDiv(pairs2.n, 2)); - const iter15: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterChain(rs.dequeIter(pairs2), rs.dequeIter(moved2))); + const iter15: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterChain(rs.iterLend(rs.dequeIter(pairs2), rs.sliceFrom), rs.iterLend(rs.dequeIter(moved2), rs.sliceFrom))); while (true) { - const _852: [rs.usize, rs.u16[]] | rs.Done = iter15.next(); + const _852: [rs.usize, rs.Slice] | rs.Done = iter15.next(); if (_852 === rs.DONE) { break; } @@ -1367,10 +1365,10 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (!(_858 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _858); } - _852[1][_858] = rs.u16Add(_852[1][_858], i5 & 0xffff); + _852[1].data[_852[1].start + _858] = rs.u16Add(_852[1].data[_852[1].start + _858], i5 & 0xffff); } rs.dequeAppend(pairs2, moved2); - const iter16: rs.Iter = rs.iterFlatten(rs.iterSlice(rs.dequeToVec(pairs2).items), (value: rs.u16[]) => rs.iterSlice(value), true, 2); + const iter16: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.dequeToVec(pairs2).items), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); while (true) { const _873: rs.u16 | rs.Done = iter16.next(); if (_873 === rs.DONE) { @@ -1562,9 +1560,9 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const r: rs.Range = within(at(0), at(1), v.items.length); const captured2 = tracked(224); const it: rs.Iter = rs.vecExtractIf(v, r, rs.closure((t5: Tracked.Tracked): boolean => { - const _715: rs.RefCell = rs.refCellBorrowMut(captured2.log); - rs.iterExtendBytes(_715.value, rs.iterSlice(Uint8Array.of(225, t5.id)), undefined, true); - rs.refMutRelease(_715); + const _716: rs.RefCell = rs.refCellBorrowMut(captured2.log); + rs.iterExtendBytes(_716.value, rs.iterSlice(Uint8Array.of(225, t5.id)), undefined, true); + rs.refMutRelease(_716); t5.copies = rs.u8Add(t5.copies, 1); return rs.u8Rem(t5.id, 3) === rs.u8Rem(captured2.id, 3); }, (): void => { @@ -1597,8 +1595,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 3; while (iterStart2++ < iterEnd2) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecExtractIf(it2, f, rs.u16Debug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecExtractIf(it2, f, rs.u16Debug)])))), undefined, true); it2.next(); } rs.drop(it2); @@ -1628,8 +1625,8 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return rs.u8Rem(b13.v, 3) === 0; }); const first: rs.u8 | undefined = rs.iterToOption(it3.next()); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecExtractIf(it3, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]])))), undefined, true); + const args27 = [(f: rs.Formatter) => rs.fmtVecExtractIf(it3, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args27[0], args27[1]])))), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(it3, "next"))); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); rs.vecExtractIfMut(w, undefined, (x2: rs.Place): boolean => { @@ -1658,9 +1655,9 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const n: rs.u8 = rs.u8Rem(at(2), 6); const captured = owned2; const make: (a0: rs.u8) => Tracked.Tracked = rs.closure((i6: rs.u8): Tracked.Tracked => { - const _713: rs.RefCell = rs.refCellBorrowMut(captured.log); - rs.iterExtendBytes(_713.value, rs.iterSlice(Uint8Array.of(225, i6)), undefined, true); - rs.refMutRelease(_713); + const _715: rs.RefCell = rs.refCellBorrowMut(captured.log); + rs.iterExtendBytes(_715.value, rs.iterSlice(Uint8Array.of(225, i6)), undefined, true); + rs.refMutRelease(_715); return new Tracked.Tracked(rs.u8Add(176, i6), 0, captured.log); }, (): void => { captured[Symbol.dispose](); @@ -1709,19 +1706,21 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_216: rs.u8): rs.u16[] => { return [_216 as rs.u16, 0]; }), undefined, 4, true); - const fill: rs.u16[] = [7, 8]; const r4: rs.Range = within(at(4), at(5), pairs.items.length); - const _337: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(at(6), 4)), (_219: rs.u8): rs.u16[] => { - return copy$array_u16(fill); + const fill: rs.u16[] = [7, 8]; + const _338: rs.Range = new rs.Range(0, rs.u8Rem(at(6), 4)); + const _345: rs.Slice = rs.sliceFrom(fill); + const _337: rs.Iter = rs.iterMap(_338, (_219: rs.u8): rs.u16[] => { + return rs.sliceToArray(_345); }); const s: rs.Iter = rs.spliceFrom(rs.vecSplice(pairs, r4, 4), _337, true); const first3: rs.u16[] | undefined = rs.iterToOption(s.next()); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))), (f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args6[0], args6[1]])))), undefined, true); + const args23 = [(f: rs.Formatter) => rs.fmtVecSplice(s, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))), (f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args23[0], args23[1]])))), undefined, true); const removed: rs.Vec = rs.iterToVec(rs.iterChain(rs.iterOption(copy$Option_array2_u16(first3)), s), "next", 4); - const iter5: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterSlice(pairs.items)); + const iter5: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom)); while (true) { - const _372: [rs.usize, rs.u16[]] | rs.Done = iter5.next(); + const _372: [rs.usize, rs.Slice] | rs.Done = iter5.next(); if (_372 === rs.DONE) { break; } @@ -1730,9 +1729,9 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (!(_378 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _378); } - _372[1][_378] = rs.u16Add(_372[1][_378], i & 0xffff); + _372[1].data[_372[1].start + _378] = rs.u16Add(_372[1].data[_372[1].start + _378], i & 0xffff); } - const iter6: rs.Iter = rs.iterFlatten(rs.iterChain(rs.iterSlice(pairs.items), rs.iterSlice(removed.items)), (value: rs.u16[]) => rs.iterSlice(value), true, 2); + const iter6: rs.Iter = rs.iterFlatten(rs.iterChain(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom), rs.iterLend(rs.iterSlice(removed.items), rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); while (true) { const _390: rs.u16 | rs.Done = iter6.next(); if (_390 === rs.DONE) { @@ -1747,8 +1746,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }); const s2: rs.Iter = rs.spliceFrom(rs.byteVecSplice(bytes2, r5), _409); const back: rs.u8 | undefined = rs.iterToOption(s2.nextBack()); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s2, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtCounted(value, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args8[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecSplice(s2, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtCounted(value, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))])))), undefined, true); rs.drop(s2); rs.iterExtendBytes(out, rs.iterOption(back), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes2)); @@ -1756,8 +1754,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _453: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at(10) as rs.usize, rs.usizeAdd(tail.length, 1)), rs.usizeStep); const _454: Uint8Array = Uint8Array.of(170, 187); const s3: rs.Iter = rs.spliceFrom(rs.byteVecSplice(tail, _453), rs.iterSlice(_454), true); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s3, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"]))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args10[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecSplice(s3, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"]))])))), undefined, true); rs.iterExtendBytes(out, rs.iterRev(s3), "next"); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(tail)); const hints: rs.RefCell = new rs.RefCell(new rs.ByteVec()); @@ -1872,11 +1869,9 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return new Tracked.Tracked(t3.id, 9, t3.log); }, Tracked.cmp$cmp_Ord, rs.drop); mark(240); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(found, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args12[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(found, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); const part3 = rs.dequeBinarySearch(q, probe, Tracked.cmp$cmp_Ord); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part3, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args14[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part3, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); rs.byteVecPush(out, rs.dequePartitionPoint(q, (t4: Tracked.Tracked): boolean => { return t4.id < probe.id; }) & 0xff); @@ -1974,14 +1969,12 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part = rs.dequeBinarySearchBy(named4, (n5: Named.Named): rs.Ordering => { return rs.cmp(n5.id, probe2); }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args16[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); const _947: string = text(rs.byteSliceFrom(Uint8Array.of(at(3)))); const found4: rs.Result = rs.dequeBinarySearchByKey(named4, _947, (n6: Named.Named): string => { return n6.name; }, rs.cmpStr); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(found4, f, rs.usizeDebug, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args18[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(found4, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); rs.byteVecPush(out, rs.dequePartitionPoint(named4, (n7: Named.Named): boolean => { return n7.id <= probe2; }) & 0xff); diff --git a/ts/fixtures/lang/edits/expected/harness.ts b/ts/fixtures/lang/edits/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/edits/expected/harness.ts +++ b/ts/fixtures/lang/edits/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/elements/expected/elements.Inline.ts b/ts/fixtures/lang/elements/expected/elements.Inline.ts index 3b758b765..17097915a 100644 --- a/ts/fixtures/lang/elements/expected/elements.Inline.ts +++ b/ts/fixtures/lang/elements/expected/elements.Inline.ts @@ -26,19 +26,19 @@ export function new$sync_Arc_u8(): Inline> { } export function ptr$Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>): rs.Place<[rs.u8, rs.u8] | undefined> { - return rs.arrayAsPtr(self.items as Array<[rs.u8, rs.u8] | undefined>); + return rs.sliceAsPtr(rs.sliceFrom(self.items as Array<[rs.u8, rs.u8] | undefined>)); } export function ptr$sync_Arc_u8(self: Inline>): rs.Place> { - return rs.arrayAsPtr(self.items as rs.Arc[]); + return rs.sliceAsPtr(rs.sliceFrom(self.items as rs.Arc[])); } export function asSlice$Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>): rs.Slice<[rs.u8, rs.u8] | undefined> { - return rs.ptrSlice(rs.arrayAsPtr(self.items as Array<[rs.u8, rs.u8] | undefined>), self.len); + return rs.ptrSlice(rs.sliceAsPtr(rs.sliceFrom(self.items as Array<[rs.u8, rs.u8] | undefined>)), self.len); } export function asSlice$sync_Arc_u8(self: Inline>): rs.Slice> { - return rs.ptrSlice(rs.arrayAsPtr(self.items as rs.Arc[]), self.len); + return rs.ptrSlice(rs.sliceAsPtr(rs.sliceFrom(self.items as rs.Arc[])), self.len); } export function insert$Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>, at: rs.usize, value: [rs.u8, rs.u8] | undefined): void { diff --git a/ts/fixtures/lang/elements/expected/elements.ts b/ts/fixtures/lang/elements/expected/elements.ts index accf91674..a26fbaabb 100644 --- a/ts/fixtures/lang/elements/expected/elements.ts +++ b/ts/fixtures/lang/elements/expected/elements.ts @@ -60,7 +60,7 @@ export function arrays(data: rs.ByteSlice, out: rs.ByteVec): void { } const at: rs.Place = rs.arrayAsPtr(a, i); at.v = 99; - const whole: rs.Place = rs.arrayAsPtr(a); + const whole: rs.Place = rs.sliceAsPtr(rs.sliceFrom(a)); const _18: rs.Place = rs.ptrAdd(whole, rs.usizeAdd(i, 1)); _18.v = rs.u16Add(_18.v, 10); const _22: rs.u16 = n as rs.u16; @@ -307,15 +307,15 @@ export function edges(data: rs.ByteSlice, out: rs.ByteVec): void { const wide2: rs.Slice = rs.ptrSlice(rs.DANGLING, 0); rs.byteVecPush(out, rs.ptrWrappingAdd(rs.sliceAsPtr(rs.sliceRange(wide2, 0, 0)), -1, 2, 2) === rs.NULL ? 1 : 0); rs.byteVecPush(out, rs.ptrWrappingAdd(rs.sliceAsPtr(rs.optionUnwrap(rs.sliceGetRange(wide2, 0, 0))), -1, 2, 2) === rs.NULL ? 1 : 0); - rs.byteVecPush(out, new rs.RawSlice(rs.arrayAsPtr(rs.NULL), 3).ptr === rs.NULL ? 1 : 0); + rs.byteVecPush(out, new rs.RawSlice(rs.sliceAsPtr(rs.NULL), 3).ptr === rs.NULL ? 1 : 0); const row: rs.u32[] = [n as rs.u32, 9, 10]; - const unsizedLanes: rs.RawSlice = new rs.RawSlice(rs.arrayAsPtr(row), 3); + const unsizedLanes: rs.RawSlice = new rs.RawSlice(rs.sliceAsPtr(rs.sliceFrom(row)), 3); rs.byteVecPush(out, unsizedLanes.ptr === rs.NULL ? 1 : 0); rs.byteVecPush(out, rs.ptrAdd(unsizedLanes.ptr, 2).v & 0xff); rs.byteVecPush(out, rs.ptrWrappingAdd(new rs.RawSlice(rs.ptrWrappingAdd(rs.NULL, rs.usizeAdd(rs.u8Rem(n, 3) as rs.usize, 1), 4, 4), 0).ptr, -rs.usizeAdd(rs.u8Rem(n, 3) as rs.usize, 1), 4, 4) === rs.NULL ? 1 : 0); - rs.byteVecPush(out, rs.arrayAsPtr(rs.NULL) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.sliceAsPtr(rs.NULL) === rs.NULL ? 1 : 0); rs.byteVecPush(out, rs.ptrWrappingAdd(rs.byteSliceAsPtr(rs.NULL), n as rs.usize, 1, 1) === rs.NULL ? 1 : 0); - rs.byteVecPush(out, rs.ptrWrappingAdd(rs.arrayAsPtr(rs.DANGLING), -1, 2, 2) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.sliceAsPtr(rs.DANGLING), -1, 2, 2) === rs.NULL ? 1 : 0); } const bytes2: Uint8Array = Uint8Array.of(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 1, 2, 3, 4, 5); const s: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(bytes2), 1); @@ -417,7 +417,7 @@ export function rawSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const slice11 = raw.deref(); slice11.data[slice11.start + 2] = 8; emit(raw.deref(), out); - const whole2: rs.RawSlice = new rs.RawSlice(rs.arrayAsPtr(short), 2); + const whole2: rs.RawSlice = new rs.RawSlice(rs.sliceAsPtr(rs.sliceFrom(short)), 2); const ofRef: rs.RawSlice = rs.rawSliceOf(rs.sliceRange(rs.sliceFrom(v.items), 1, 3)); rs.byteVecPush(out, rs.usizeAdd(whole2.length, ofRef.length) & 0xff); rs.idx(ofRef, 1); @@ -477,9 +477,9 @@ export function emptyParts(data: rs.ByteSlice, out: rs.ByteVec): void { }), (part11: rs.Slice): rs.u8 => { return null_(rs.sliceAsPtr(part11)); }), "next"); - const part13 = rs.sliceAsPtr(rs.sliceFrom(rs.optionUnwrap(rs.sliceFirstChunk(_23[0], 0)))); + const part13 = rs.sliceAsPtr(rs.optionUnwrap(rs.sliceGetRange(_23[0], 0, 0))); rs.byteVecPush(out, null_(part13)); - const part14 = rs.sliceAsPtr(rs.sliceFrom(rs.optionUnwrap(rs.sliceLastChunk(_23[0], 0)))); + const part14 = rs.sliceAsPtr(rs.optionUnwrap(rs.sliceLastChunk(_23[0], 0))); rs.byteVecPush(out, null_(part14)); const part15 = rs.sliceAsPtr(rs.optionUnwrap(_23[0])); rs.byteVecPush(out, null_(part15)); diff --git a/ts/fixtures/lang/elements/expected/harness.ts b/ts/fixtures/lang/elements/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/elements/expected/harness.ts +++ b/ts/fixtures/lang/elements/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/ends/expected/ends.ts b/ts/fixtures/lang/ends/expected/ends.ts index 45ed8e289..a910e3006 100644 --- a/ts/fixtures/lang/ends/expected/ends.ts +++ b/ts/fixtures/lang/ends/expected/ends.ts @@ -639,8 +639,8 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r if (!(k < 15)) { if (!(b21 !== 2)) { const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; - rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args3[0], " after ", args3[1]]); } } return rs.u8WrappingMul(a15, 3) ^ b21; @@ -885,8 +885,8 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: if (!(k < 15)) { if (!(b21 !== 2)) { const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; - rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args3[0], " after ", args3[1]]); } } return rs.u8WrappingMul(a15, 3) ^ b21; @@ -1131,8 +1131,8 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rs.u8, k: rs.usiz if (!(k < 15)) { if (!(b21 !== 2)) { const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; - rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args3[0], " after ", args3[1]]); } } return rs.u8WrappingMul(a15, 3) ^ b21; @@ -1376,8 +1376,8 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: r if (!(k < 15)) { if (!(b21 !== 2)) { const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; - rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args3[0], " after ", args3[1]]); } } return rs.u8WrappingMul(a15, 3) ^ b21; @@ -1621,8 +1621,8 @@ export function folded$ends_Run(it: Run.Run, pick: rs.u8, k: rs.usize, log: rs.R if (!(k < 15)) { if (!(b21 !== 2)) { const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; - rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args3[0], " after ", args3[1]]); } } return rs.u8WrappingMul(a15, 3) ^ b21; diff --git a/ts/fixtures/lang/ends/expected/harness.ts b/ts/fixtures/lang/ends/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/ends/expected/harness.ts +++ b/ts/fixtures/lang/ends/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/errors/expected/core/num.ts b/ts/fixtures/lang/errors/expected/core/num.ts index b0f1424aa..0af97a826 100644 --- a/ts/fixtures/lang/errors/expected/core/num.ts +++ b/ts/fixtures/lang/errors/expected/core/num.ts @@ -32,16 +32,15 @@ export function canNotOverflow$09fz75c(radix: rs.u32, isSignedTy: boolean, _digi } export function fromAsciiBytesRadixPanic(radix: rs.u32): never { - doPanic$16ya8t2(radix); + doPanic$1tugyvz(radix); } -export function doPanic$16ya8t2(radix: rs.u32): never { - runtime$0o4i17s(radix); +export function doPanic$1tugyvz(radix: rs.u32): never { + runtime$09k496w(radix); } -export function runtime$0o4i17s(radix: rs.u32): never { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(radix, f)]; - rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); +export function runtime$09k496w(radix: rs.u32): never { + rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", (f: rs.Formatter) => rs.u32Display(radix, f)]); } export function fromAsciiBytesRadixImpl$1r0rye7(src: rs.ByteSlice, radix: rs.u32): rs.Result { diff --git a/ts/fixtures/lang/errors/expected/errors.Failure.ts b/ts/fixtures/lang/errors/expected/errors.Failure.ts index a5b9d67ff..52454ee5a 100644 --- a/ts/fixtures/lang/errors/expected/errors.Failure.ts +++ b/ts/fixtures/lang/errors/expected/errors.Failure.ts @@ -30,8 +30,7 @@ export type Failure = export function fmt$fmt_Display(self: Failure, f: rs.Formatter): rs.Result { if (self.tag === "Short") { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - return rs.fmtWriteFmt(f, ["short by ", args2[0]]); + return rs.fmtWriteFmt(f, ["short by ", (f: rs.Formatter) => rs.u8Display(arg, f)]); } if (self.tag === "Wrapped") { return rs.fmtWriteStr(f, "wrapped"); diff --git a/ts/fixtures/lang/errors/expected/errors.Leaf.ts b/ts/fixtures/lang/errors/expected/errors.Leaf.ts index adc7a56e9..746e026ce 100644 --- a/ts/fixtures/lang/errors/expected/errors.Leaf.ts +++ b/ts/fixtures/lang/errors/expected/errors.Leaf.ts @@ -26,8 +26,7 @@ export class Leaf { export function fmt$fmt_Display(self: Leaf, f: rs.Formatter): rs.Result { const arg = self.code; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - return rs.fmtWriteFmt(f, ["leaf ", args2[0]]); + return rs.fmtWriteFmt(f, ["leaf ", (f: rs.Formatter) => rs.u8Display(arg, f)]); } export function drop$ops_Drop(self: Leaf): void { diff --git a/ts/fixtures/lang/errors/expected/errors.ts b/ts/fixtures/lang/errors/expected/errors.ts index ff1e038e3..a9ead37f7 100644 --- a/ts/fixtures/lang/errors/expected/errors.ts +++ b/ts/fixtures/lang/errors/expected/errors.ts @@ -599,14 +599,14 @@ export function DROPPED$init(): rs.Cell { /** Each error in the chain, by `Display` and `Debug`. */ export function chain(e: Error.Error): string { - const args2: rs.Fmt[] = [(f: rs.Formatter) => e.fmt$Display(f), (f: rs.Formatter) => e.fmt$Debug(f)]; - let s: string = rs.fmtFormat([args2[0], " ", args2[1]]); + const args5 = [(f: rs.Formatter) => e.fmt$Display(f), (f: rs.Formatter) => e.fmt$Debug(f)]; + let s: string = rs.fmtFormat([args5[0], " ", args5[1]]); let cur: Error.Error | undefined = e.source$Error(); while (true) { if (cur !== undefined) { const c: Error.Error = cur; - const args4: rs.Fmt[] = [(f: rs.Formatter) => c.fmt$Display(f), (f: rs.Formatter) => c.fmt$Debug(f)]; - const _17: string = rs.fmtFormat([" <- ", args4[0], " ", args4[1]]); + const args6 = [(f: rs.Formatter) => c.fmt$Display(f), (f: rs.Formatter) => c.fmt$Debug(f)]; + const _17: string = rs.fmtFormat([" <- ", args6[0], " ", args6[1]]); s = s + _17; cur = c.source$Error(); } else { @@ -633,8 +633,8 @@ export function failure(kind: rs.u8, n: rs.u8): Failure.Failure { /** `?` boxes a `Failure` as a `dyn Error`, as does `into`. */ export function checked(kind: rs.u8, n: rs.u8): rs.Result { if (!(rs.u8Rem(n, 4) === 0)) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - const _8: rs.Result = result_mapErr$09oysgi(num_fromStr$1t58fis(rs.fmtFormat([args2[0], args2[0]])), (a0: rs.ParseIntError): Failure.Failure => { + const args3 = [(f: rs.Formatter) => rs.u8Display(n, f)]; + const _8: rs.Result = result_mapErr$09oysgi(num_fromStr$1t58fis(rs.fmtFormat([args3[0], args3[0]])), (a0: rs.ParseIntError): Failure.Failure => { return { tag: "Parse", _0: a0 }; }); if (_8.ok) { @@ -664,34 +664,33 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const _21: string = chain(new of$errors_Failure(_24)); const _29: Leaf.Leaf = new Leaf.Leaf(a); const _26: string = chain(new of$errors_Leaf(_29)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _21), (f: rs.Formatter) => rs.fmtPad(f, _26)]; - const _17: string = rs.fmtFormat([args2[0], " | ", args2[1], " | "]); + const args41 = [(f: rs.Formatter) => rs.fmtPad(f, _21), (f: rs.Formatter) => rs.fmtPad(f, _26)]; + const _17: string = rs.fmtFormat([args41[0], " | ", args41[1], " | "]); _29[Symbol.dispose](); drop$errors_Failure(_24); put(out, _17); const part = chain(new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - put(out, rs.fmtFormat([args4[0], " | "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " | "])); const reserved: Error.Error = rs.resultUnwrapErr(reserve(a), rs.fmtUnit); const _63: string = chain(reserved); const _66: boolean = reserved instanceof of$collections_TryReserveError || reserved instanceof ofPlace$collections_TryReserveError; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _63), (f: rs.Formatter) => reserved.fmt$Debug(f), (f: rs.Formatter) => rs.fmtBool(_66, f)]; - put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1]), " ", args6[2], " | "])); + const args43 = [(f: rs.Formatter) => rs.fmtPad(f, _63), (f: rs.Formatter) => reserved.fmt$Debug(f), (f: rs.Formatter) => rs.fmtBool(_66, f)]; + put(out, rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[1]), " ", args43[2], " | "])); const held: Failure.Failure = failure(a, b); const _86: string = chain(new of$boxed_Box_errors_Failure(held)); const _90: string = chain(new of$ref_errors_Failure(held)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _86), (f: rs.Formatter) => rs.fmtPad(f, _90)]; - put(out, rs.fmtFormat([args8[0], " | ", args8[1], " | "])); + const args44 = [(f: rs.Formatter) => rs.fmtPad(f, _86), (f: rs.Formatter) => rs.fmtPad(f, _90)]; + put(out, rs.fmtFormat([args44[0], " | ", args44[1], " | "])); const coded: Coded.Coded = new of$errors_Failure(failure(b, a)); const up: Error.Error = coded; const _111: rs.u8 = coded.code$Coded(); const _114: string = chain(up); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_111, f), (f: rs.Formatter) => rs.fmtPad(f, _114)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " | "])); + const args45 = [(f: rs.Formatter) => rs.u8Display(_111, f), (f: rs.Formatter) => rs.fmtPad(f, _114)]; + put(out, rs.fmtFormat([args45[0], " ", args45[1], " | "])); const boxed: Transported.Transported = new Transported.Transported(coded); const _129: string = chain(new of$errors_Transported(boxed)); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; - put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[1]), " | "])); + const args46 = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; + put(out, rs.fmtFormat([args46[0], " ", rs.fmtSpec({ alternate: true }, args46[1]), " | "])); set$1ljkjlf(DROPPED, 0); const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): rs.Result => { const n: rs.u8 = _2; @@ -700,41 +699,33 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number for (const _149 of results.items) { if (_149.ok) { const arg = _149.value; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f), " "])); } else { const part2 = chain(_149.error); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2)]; - put(out, rs.fmtFormat([args16[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part2), " "])); } } rs.dropVec(results, drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send); const part3 = get$0q7640n(DROPPED); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - put(out, rs.fmtFormat(["| ", args18[0], " "])); + put(out, rs.fmtFormat(["| ", (f: rs.Formatter) => rs.u32Display(part3, f), " "])); set$1ljkjlf(DROPPED, 0); const leaf: Leaf.Leaf = new Leaf.Leaf(b); const borrowed: Error.Error = new of$ref_errors_Leaf(leaf); const part4 = chain(borrowed); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; - put(out, rs.fmtFormat([args20[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part4), " "])); rs.drop(borrowed); const part5 = get$0q7640n(DROPPED); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - put(out, rs.fmtFormat([args22[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part5, f), " "])); leaf[Symbol.dispose](); const part6 = get$0q7640n(DROPPED); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - put(out, rs.fmtFormat([args24[0], " | "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part6, f), " | "])); const coded2: Coded.Coded = new of$errors_Failure(failure(a, b)); const part7 = downcast(coded2); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part7)]; - put(out, rs.fmtFormat([args26[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part7), " "])); const errors: rs.Vec = rs.vecFrom([coded2, new of$errors_Leaf(new Leaf.Leaf(a)), new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))]); for (const _277 of errors.items) { const part8 = downcast(_277); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part8)]; - put(out, rs.fmtFormat([args28[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part8), " "])); } const leaf2: Leaf.Leaf = new Leaf.Leaf(a); const e: Error.Error = new of$errors_Leaf(leaf2); @@ -743,8 +734,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number _298.code = rs.u8WrappingAdd(_298.code, b); } const arg2 = leaf2.code; - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f)]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg2, f), " "])); set$1ljkjlf(DROPPED, 0); for (const e2 of errors.items) { const _324: rs.Result = e2 instanceof of$errors_Failure ? rs.Ok(e2.v) : rs.Err(e2); @@ -752,8 +742,8 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number f = _324.value; const _334: rs.u8 = Failure.code$errors_Coded(f); const _337: rs.u32 = get$0q7640n(DROPPED); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; - put(out, rs.fmtFormat(["failure ", args32[0], " ", args32[1], " "])); + const args58 = [(f: rs.Formatter) => rs.u8Display(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; + put(out, rs.fmtFormat(["failure ", args58[0], " ", args58[1], " "])); drop$errors_Failure(f); } else { const e3: Error.Error = _324.error; @@ -762,20 +752,18 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const l: Leaf.Leaf = _345.value; const _356: rs.u32 = get$0q7640n(DROPPED); const arg3 = l.code; - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg3, f), (f: rs.Formatter) => rs.u32Display(_356, f)]; - put(out, rs.fmtFormat(["leaf ", args34[0], " ", args34[1], " "])); + const args57 = [(f: rs.Formatter) => rs.u8Display(arg3, f), (f: rs.Formatter) => rs.u32Display(_356, f)]; + put(out, rs.fmtFormat(["leaf ", args57[0], " ", args57[1], " "])); l[Symbol.dispose](); } else { const e4: Error.Error = _345.error; - const args36: rs.Fmt[] = [(f: rs.Formatter) => e4.fmt$Display(f)]; - put(out, rs.fmtFormat([args36[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => e4.fmt$Display(f), " "])); rs.drop(e4); } } } const part9 = get$0q7640n(DROPPED); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; - put(out, rs.fmtFormat([args38[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part9, f), " "])); const part10 = result_mapErr$1scmdah(result_mapErr$0ka0di9(checked(b, rs.u8WrappingMul(a, 4)), (e5: Error.Error): rs.Result => { return result_map$18dk705(e5 instanceof of$errors_Failure ? rs.Ok(e5.v) : rs.Err(e5), (f2: Failure.Failure): rs.u8 => { const _03: rs.u8 = Failure.code$errors_Coded(f2); @@ -789,8 +777,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number return _05; }); }); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part10, f, rs.u8Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part10, f, rs.u8Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))])); leaf2[Symbol.dispose](); boxed[Symbol.dispose](); drop$errors_Failure(held); @@ -809,8 +796,8 @@ export function downcast(e: Error.Error): string { const _12: rs.u8 | undefined = option_map$0jqf1o0(e instanceof of$errors_Failure ? e.v : e instanceof ofPlace$errors_Failure ? e.v.v : undefined, (f: Failure.Failure): rs.u8 => { return Failure.code$errors_Coded(f); }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(is[0], f), (f: rs.Formatter) => rs.fmtBool(is[1], f), (f: rs.Formatter) => rs.fmtBool(is[2], f)], f), (f: rs.Formatter) => rs.fmtOption(source, f, (value: [boolean, rs.IntErrorKind | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, (value: rs.IntErrorKind, f: rs.Formatter) => rs.fmtWriteStr(f, value))], f)), (f: rs.Formatter) => rs.fmtOption(_12, f, rs.u8Debug)]; - return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(is[0], f), (f: rs.Formatter) => rs.fmtBool(is[1], f), (f: rs.Formatter) => rs.fmtBool(is[2], f)], f), (f: rs.Formatter) => rs.fmtOption(source, f, (value: [boolean, rs.IntErrorKind | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, (value: rs.IntErrorKind, f: rs.Formatter) => rs.fmtWriteStr(f, value))], f)), (f: rs.Formatter) => rs.fmtOption(_12, f, rs.u8Debug)]; + return rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2]]); } //# sourceMappingURL=errors.ts.map diff --git a/ts/fixtures/lang/errors/expected/harness.ts b/ts/fixtures/lang/errors/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/errors/expected/harness.ts +++ b/ts/fixtures/lang/errors/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/fields/expected/fields.ts b/ts/fixtures/lang/fields/expected/fields.ts index 99bb6eaad..2c706c473 100644 --- a/ts/fixtures/lang/fields/expected/fields.ts +++ b/ts/fixtures/lang/fields/expected/fields.ts @@ -95,13 +95,12 @@ export function fields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { p.headLen = _119.length; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(p.headLen & 0xff, q.headLen & 0xff, Couple.eq$cmp_PartialEq(p, q) ? 1 : 0))); rs.byteVecExtendFromSlice(out, new rs.ByteSlice(q.wordData, q.wordStart, q.wordLen)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Couple.fmt$fmt_Debug(p, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Couple.fmt$fmt_Debug(p, f)]))); } const _148: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 3)); const open: Exposed.Exposed = { buf: _148, at: kind }; - const args4: rs.Fmt[] = [(f: rs.Formatter) => Exposed.fmt$fmt_Debug(open, f), (f: rs.Formatter) => Scanner.fmt$fmt_Debug(r2, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]]))); + const args8 = [(f: rs.Formatter) => Exposed.fmt$fmt_Debug(open, f), (f: rs.Formatter) => Scanner.fmt$fmt_Debug(r2, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], args8[1]]))); rs.byteVecPush(out, kind ^ (_148.length & 0xff)); if (!(rs.u8Rem(kind, 2) === 0)) { const _175: Glued.Glued = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; @@ -109,8 +108,7 @@ export function fields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { two = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; } - const args6: rs.Fmt[] = [(f: rs.Formatter) => Glued.fmt$fmt_Debug(two, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Glued.fmt$fmt_Debug(two, f)]))); rs.byteVecPush(out, rs.usizeAdd(two._0Len, two._1Len) & 0xff); const _195: Scanner.Scanner = SCANNER; rs.byteVecExtendFromSlice(out, new rs.ByteSlice(_195.bufData, _195.bufStart, _195.bufLen)); diff --git a/ts/fixtures/lang/fields/expected/harness.ts b/ts/fixtures/lang/fields/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/fields/expected/harness.ts +++ b/ts/fixtures/lang/fields/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/floats/expected/floats.ts b/ts/fixtures/lang/floats/expected/floats.ts index 3344cb76f..9c97c0b47 100644 --- a/ts/fixtures/lang/floats/expected/floats.ts +++ b/ts/fixtures/lang/floats/expected/floats.ts @@ -42,8 +42,8 @@ export function putSecs(out: rs.ByteVec, d: rs.Result rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const args3 = [(f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", rs.fmtSpec({ alternate: true }, args3[1])])); } } @@ -245,8 +245,7 @@ export function floats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const v2: rs.f64[] = [a, b, 0.5]; putF64(out, rs.iterSum(rs.iterSlice(v2), rs.f64Add, -0.0)); putF64(out, rs.iterProduct(rs.iterSlice(v2), rs.f64Mul, 1.0)); - const _403: rs.f64[] = []; - putF64(out, rs.iterSum(rs.iterSlice(_403), rs.f64Add, -0.0)); + putF64(out, rs.iterSum(rs.iterSlice([]), rs.f64Add, -0.0)); putF64(out, rs.iterSum(rs.iterSlice([-0.0, -0.0]), rs.f64Add, -0.0)); putF64(out, 0.0); const g: Gauge.Gauge = { level: a, peak: b }; @@ -388,14 +387,14 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const w: rs.usize = rs.usizeDiv(p, 4); const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args4[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args4[4]) }, args4[2])])); + const args17 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(p)]; + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])])); + const args18 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ debugHex: "x" }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args18[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args18[4]) }, args18[2])])); put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f))); } else if (_13 === 1) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args6[0]), " ", rs.fmtSpec({ precision: 800 }, args6[1]), " ", rs.fmtSpec({ precision: 1100 }, args6[2]), " ", rs.fmtSpec({ precision: 65535 }, args6[0])])); + const args16 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args16[0]), " ", rs.fmtSpec({ precision: 800 }, args16[1]), " ", rs.fmtSpec({ precision: 1100 }, args16[2]), " ", rs.fmtSpec({ precision: 65535 }, args16[0])])); } else if (_13 === 2) { const _72: [rs.f64, rs.ByteSlice] = take(_6[1]); const b: rs.f64 = _72[0]; @@ -405,16 +404,16 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _78: rs.f64 | undefined = a * 0.5; const _80: rs.Vec = rs.vecFrom([a, -0.0, 1e-7, 1e16, NaN]); const part = { level: a, peak: _78, history: _80 }; - const args8: rs.Fmt[] = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); + const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0]), "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])])); } else { let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); let iterStart: rs.i32 = 0; const iterEnd: rs.i32 = 64; while (iterStart++ < iterEnd) { const x: rs.f64 = rs.f64FromBits(step(rs.place(() => state, (value) => state = value))); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); + const args13 = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f)]; + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]])); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 64; @@ -424,8 +423,8 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } const r2: rs.u64 = step(rs.place(() => state, (value2) => state = value2)); const x2: rs.f64 = rs.u64ToF64(rs.u64Shr(r2, 11)) / rs.u64ToF64(rs.u64Shl(1, rs.u64Add(rs.u64Rem(r2, 24), 1))); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Debug(x2, f), (f: rs.Formatter) => rs.f64LowerExp(x2, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + const args14 = [(f: rs.Formatter) => rs.f64Debug(x2, f), (f: rs.Formatter) => rs.f64LowerExp(x2, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1]])); } } } @@ -475,8 +474,8 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { s2 = s2 + String.fromCodePoint(_69); } const _85: rs.i64 = rs.i64Sub(rs.i64Cast(rs.u64Rem(rs.u64Shr(r, 16), 700)), 350); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_85, f)]; - one(rs.fmtFormat([args2[0], "e", args2[1]]), out); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_85, f)]; + one(rs.fmtFormat([args3[0], "e", args3[1]]), out); } } } @@ -488,12 +487,11 @@ export function one(s: string, out: rs.ByteVec): void { if (_4.ok) { const v: rs.f64 = _4.value; putF64(out, v); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Debug(v, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.f64Debug(v, f)])); } else { const e: rs.ParseFloatError = _4.error; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|", rs.fmtSpec({ precision: 7 }, args4[0])])); + const args5 = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; + put(out, rs.fmtFormat([args5[0], "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", rs.fmtSpec({ align: ">", width: 30 }, args5[0]), "|", rs.fmtSpec({ precision: 7 }, args5[0])])); } rs.byteVecPush(out, rs.f64FromStr(s).ok ? 1 : 0); } diff --git a/ts/fixtures/lang/floats/expected/harness.ts b/ts/fixtures/lang/floats/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/floats/expected/harness.ts +++ b/ts/fixtures/lang/floats/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/folds/expected/folds.ts b/ts/fixtures/lang/folds/expected/folds.ts index 000d41739..a1ef6c514 100644 --- a/ts/fixtures/lang/folds/expected/folds.ts +++ b/ts/fixtures/lang/folds/expected/folds.ts @@ -11,8 +11,8 @@ export function state$i64_Option_i64(out: rs.ByteVec, v: rs.i64 | undefined, r: const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.i64Debug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.i64Debug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -20,8 +20,8 @@ export function state$i64_Option_tuple2_i64_usize(out: rs.ByteVec, v: [rs.i64, r const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.i64, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.i64, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -29,8 +29,8 @@ export function state$i64_Option_tuple2_usize_i64(out: rs.ByteVec, v: [rs.usize, const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.i64], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.i64Debug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.i64], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.i64Debug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -38,8 +38,8 @@ export function state$i64_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -47,8 +47,8 @@ export function state$i64_Result_usize_unit(out: rs.ByteVec, v: rs.Result rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -56,8 +56,8 @@ export function state$i64_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -65,8 +65,8 @@ export function state$i64_tuple2_Option_i64_Option_i64(out: rs.ByteVec, v: [rs.i const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.i64Debug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.i64Debug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -74,8 +74,8 @@ export function state$i64_tuple2_Option_i64_Option_usize(out: rs.ByteVec, v: [rs const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -83,8 +83,8 @@ export function state$i64_tuple2_Option_i64_usize(out: rs.ByteVec, v: [rs.i64 | const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -92,8 +92,8 @@ export function state$i64_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusi const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -101,8 +101,8 @@ export function state$i64_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusi const _12: rs.i64 = rs.rangeInclusiveStart(r); const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -110,8 +110,8 @@ export function state$u8_Option_tuple2_u8_usize(out: rs.ByteVec, v: [rs.u8, rs.u const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.u8, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.u8, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -119,8 +119,8 @@ export function state$u8_Option_tuple2_usize_u8(out: rs.ByteVec, v: [rs.usize, r const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -128,8 +128,8 @@ export function state$u8_Option_u8(out: rs.ByteVec, v: rs.u8 | undefined, r: rs. const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -137,8 +137,8 @@ export function state$u8_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -146,8 +146,8 @@ export function state$u8_Result_usize_unit(out: rs.ByteVec, v: rs.Result rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -155,8 +155,8 @@ export function state$u8_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive< const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -164,8 +164,8 @@ export function state$u8_tuple2_Option_u8_Option_u8(out: rs.ByteVec, v: [rs.u8 | const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -173,8 +173,8 @@ export function state$u8_tuple2_Option_u8_Option_usize(out: rs.ByteVec, v: [rs.u const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -182,8 +182,8 @@ export function state$u8_tuple2_Option_u8_usize(out: rs.ByteVec, v: [rs.u8 | und const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -191,8 +191,8 @@ export function state$u8_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusiv const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** `r`'s state after `v`, what read it returned. */ @@ -200,8 +200,8 @@ export function state$u8_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusiv const _12: rs.u8 = rs.rangeInclusiveStart(r); const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); + const args3 = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); } /** diff --git a/ts/fixtures/lang/folds/expected/harness.ts b/ts/fixtures/lang/folds/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/folds/expected/harness.ts +++ b/ts/fixtures/lang/folds/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/futures/expected/futures.ts b/ts/fixtures/lang/futures/expected/futures.ts index 9ab2c274a..a26a374af 100644 --- a/ts/fixtures/lang/futures/expected/futures.ts +++ b/ts/fixtures/lang/futures/expected/futures.ts @@ -79,114 +79,86 @@ export function pollOnce$futures_readies_closure0(f: rs.Future): rs.Poll< /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Pending_futures_Logged(out: rs.ByteVec, _value: rs.Future): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtWriteStr(f, "Pending"))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_PollFn_futures_pendings_closure0(out: rs.ByteVec, _value: rs.Future): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn"))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_Option_Option_u8(out: rs.ByteVec, value: rs.Ready): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_Option_u8(out: rs.ByteVec, value: rs.Ready): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_String(out: rs.ByteVec, value: rs.Ready): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtStr)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtStr)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.fmtStr)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.fmtStr))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_u8(out: rs.ByteVec, value: rs.Ready): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.u8Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.u8Debug)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.u8Debug))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_unit(out: rs.ByteVec, value: rs.Ready): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtUnit)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtUnit)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.fmtUnit)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.fmtUnit))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_Option_u8(out: rs.ByteVec, value: rs.Poll): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_Result_u8_String(out: rs.ByteVec, value: rs.Poll>): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr)))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_String(out: rs.ByteVec, value: rs.Poll): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_array2_u8(out: rs.ByteVec, value: rs.Poll): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_task_Poll_u8(out: rs.ByteVec, value: rs.Poll | rs.OuterPending): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_u8(out: rs.ByteVec, value: rs.Poll): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug))])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_unit(out: rs.ByteVec, value: rs.Poll): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit))])); } /** @@ -475,8 +447,8 @@ export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { } debug$task_Poll_u8(out, p); debug$task_Poll_u8(out, q); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(q, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtPoll(p, f, rs.u8Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[1])])); + const args3 = [(f: rs.Formatter) => rs.fmtPoll(q, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtPoll(p, f, rs.u8Debug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 4 }, args3[0]), "|", rs.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args3[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args3[1])])); debug$task_Poll_Option_u8(out, poll_map$1jzbsum(b as rs.Poll, (o: rs.u8 | undefined): rs.u8 | undefined => { return filter$0hq86nl(o, (v: rs.u8): boolean => { return rs.u8Rem(v, 2) === 0; @@ -584,8 +556,9 @@ export function wakers(data: rs.ByteSlice, out: rs.ByteVec): void { maybe = rs.optionCloneFrom(maybe, from, (a0: rs.Waker): rs.Waker => { return a0.clone(); }, rs.drop, rs.wakerCloneFromFn()); + const _51: rs.Slice = rs.sliceFrom(pair); const _53: rs.Waker[] = [w.clone(), source.clone()]; - rs.arrayCloneFrom(pair, _53, (a02: rs.Waker): rs.Waker => { + rs.sliceCloneFromSlice(_51, rs.sliceFrom(_53), (a02: rs.Waker): rs.Waker => { return a02.clone(); }, rs.drop, rs.wakerCloneFromFn()); rs.dropAll(_53); diff --git a/ts/fixtures/lang/futures/expected/harness.ts b/ts/fixtures/lang/futures/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/futures/expected/harness.ts +++ b/ts/fixtures/lang/futures/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/hashes/expected/harness.ts b/ts/fixtures/lang/hashes/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/hashes/expected/harness.ts +++ b/ts/fixtures/lang/hashes/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/hashes/expected/hashes.ts b/ts/fixtures/lang/hashes/expected/hashes.ts index 5b69e73ef..a81a33848 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.ts @@ -95,7 +95,7 @@ export function digest$array0_u8(value: rs.ByteSlice, out: rs.ByteVec): void { } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array2_hashes_Dir(value: Dir.Dir[], out: rs.ByteVec): void { +export function digest$array2_hashes_Dir(value: rs.Slice, out: rs.ByteVec): void { const h: rs.Hasher = rs.hasher(); rs.hashSlice(Dir.hash$Hash_hash_DefaultHasher as (a0: Dir.Dir, a1: rs.Hasher) => undefined)(value, h); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); @@ -109,7 +109,7 @@ export function digest$array2_u8(value: rs.ByteSlice, out: rs.ByteVec): void { } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array3_u32(value: rs.u32[], out: rs.ByteVec): void { +export function digest$array3_u32(value: rs.Slice, out: rs.ByteVec): void { const h: rs.Hasher = rs.hasher(); rs.hashInts(4)(value, h); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); @@ -410,7 +410,7 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { digest$Vec_u16(words, out); const part = rs.usizeDiv(words.items.length, 2); digest$slice_u16(rs.sliceRange(rs.sliceFrom(words.items), part), out); - digest$array3_u32([n, (n ^ 1) >>> 0, n >>> 3], out); + digest$array3_u32(rs.sliceFrom([n, (n ^ 1) >>> 0, n >>> 3]), out); digest$cmp_Ordering(rs.cmp(n & 0xff, rs.u128Low(w(4, 1)) & 0xff), out); digest$time_Duration(rs.durationNew(rs.u64Cast(w(0, 6)), rs.u32Rem(n, 1000000000)), out); digest$cmp_Reverse_u16(n & 0xffff, out); @@ -429,7 +429,7 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { shape = { tag: "Rect", w: (rs.u64Low(n2) << 16) >> 16, h: (rs.u64Low(rs.u64Shr(n2, 16)) << 16) >> 16 } as Shape.Shape; } digest$hashes_Shape(shape, out); - digest$array2_hashes_Dir(["Up" as Dir.Dir, "Down" as Dir.Dir], out); + digest$array2_hashes_Dir(rs.sliceFrom(["Up" as Dir.Dir, "Down" as Dir.Dir]), out); digest$tuple2_hashes_Small_hashes_Small(["Low" as Small.Small, "High" as Small.Small], out); digest$hashes_Nibble({ _0: rs.u64Low(n2) & 0xff }, out); } else { @@ -650,17 +650,17 @@ export function hashInto$hashes_Bare(h: Bare.Bare, data: rs.ByteSlice): void { const part = rs.usizeDiv(words.items.length, 2); const _111: rs.Slice = rs.sliceRange(rs.sliceFrom(words.items), part); rs.hashInts(2)(_111, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; - rs.hashInts(8)(_120, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; - rs.hashInts(16)(_128, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; - rs.hashInts(4)(_135, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; - rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; - rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _119: rs.Slice = rs.sliceFrom([b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]); + rs.hashInts(8)(_119, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _127: rs.Slice = rs.sliceFrom([rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]); + rs.hashInts(16)(_127, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _134: rs.Slice = rs.sliceFrom([rs.u128Low(a) | 0, -1]); + rs.hashInts(4)(_134, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _138: rs.Slice = rs.sliceFrom([rs.u128And(a, 1) === 0, true]); + rs.hashSlice(rs.hash8)(_138, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)(rs.sliceFrom([233, 120]), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _145: rs.Slice = rs.sliceFrom([rs.u128Low(a) & 0xffff, 3]); + rs.hashSlice(rs.hash16)(_145, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); @@ -677,7 +677,7 @@ export function hashInto$hashes_Bare(h: Bare.Bare, data: rs.ByteSlice): void { const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Bare({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Bare({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Bare as (a0: Dir.Dir, a1: Bare.Bare) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Bare as (a0: Dir.Dir, a1: Bare.Bare) => undefined))(rs.sliceFrom(["Up" as Dir.Dir, "Down" as Dir.Dir]), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Bare as (a0: Small.Small, a1: Bare.Bare) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Bare as (a0: Small.Small, a1: Bare.Bare) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); Nibble.hash$Hash_hashes_Bare({ _0: rs.u128Low(a) & 0xff }, h); rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); @@ -730,17 +730,17 @@ export function hashInto$hashes_Full(h: Full.Full, data: rs.ByteSlice): void { const part = rs.usizeDiv(words.items.length, 2); const _111: rs.Slice = rs.sliceRange(rs.sliceFrom(words.items), part); rs.hashInts(2)(_111, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; - rs.hashInts(8)(_120, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; - rs.hashInts(16)(_128, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; - rs.hashInts(4)(_135, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; - rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; - rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _119: rs.Slice = rs.sliceFrom([b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]); + rs.hashInts(8)(_119, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _127: rs.Slice = rs.sliceFrom([rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]); + rs.hashInts(16)(_127, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _134: rs.Slice = rs.sliceFrom([rs.u128Low(a) | 0, -1]); + rs.hashInts(4)(_134, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _138: rs.Slice = rs.sliceFrom([rs.u128And(a, 1) === 0, true]); + rs.hashSlice(rs.hash8)(_138, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)(rs.sliceFrom([233, 120]), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _145: rs.Slice = rs.sliceFrom([rs.u128Low(a) & 0xffff, 3]); + rs.hashSlice(rs.hash16)(_145, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); @@ -757,7 +757,7 @@ export function hashInto$hashes_Full(h: Full.Full, data: rs.ByteSlice): void { const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Full({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Full({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Full as (a0: Dir.Dir, a1: Full.Full) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Full as (a0: Dir.Dir, a1: Full.Full) => undefined))(rs.sliceFrom(["Up" as Dir.Dir, "Down" as Dir.Dir]), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Full as (a0: Small.Small, a1: Full.Full) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Full as (a0: Small.Small, a1: Full.Full) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Full.hasher$hash_Hasher)); Nibble.hash$Hash_hashes_Full({ _0: rs.u128Low(a) & 0xff }, h); Full.writeI32$hash_Hasher(h, rs.u128Low(a) | 0); @@ -810,17 +810,17 @@ export function hashInto$hashes_Partial(h: Partial.Partial, data: rs.ByteSlice): const part = rs.usizeDiv(words.items.length, 2); const _111: rs.Slice = rs.sliceRange(rs.sliceFrom(words.items), part); rs.hashInts(2)(_111, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; - rs.hashInts(8)(_120, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; - rs.hashInts(16)(_128, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; - rs.hashInts(4)(_135, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; - rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; - rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _119: rs.Slice = rs.sliceFrom([b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]); + rs.hashInts(8)(_119, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _127: rs.Slice = rs.sliceFrom([rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]); + rs.hashInts(16)(_127, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _134: rs.Slice = rs.sliceFrom([rs.u128Low(a) | 0, -1]); + rs.hashInts(4)(_134, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _138: rs.Slice = rs.sliceFrom([rs.u128And(a, 1) === 0, true]); + rs.hashSlice(rs.hash8)(_138, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)(rs.sliceFrom([233, 120]), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _145: rs.Slice = rs.sliceFrom([rs.u128Low(a) & 0xffff, 3]); + rs.hashSlice(rs.hash16)(_145, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); @@ -837,7 +837,7 @@ export function hashInto$hashes_Partial(h: Partial.Partial, data: rs.ByteSlice): const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Partial({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Partial({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Partial as (a0: Dir.Dir, a1: Partial.Partial) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Partial as (a0: Dir.Dir, a1: Partial.Partial) => undefined))(rs.sliceFrom(["Up" as Dir.Dir, "Down" as Dir.Dir]), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Partial as (a0: Small.Small, a1: Partial.Partial) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Partial as (a0: Small.Small, a1: Partial.Partial) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); Nibble.hash$Hash_hashes_Partial({ _0: rs.u128Low(a) & 0xff }, h); rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); @@ -890,17 +890,17 @@ export function hashInto$hashes_Switch(h: rs.Place, data: rs.Byte const part = rs.usizeDiv(words.items.length, 2); const _111: rs.Slice = rs.sliceRange(rs.sliceFrom(words.items), part); rs.hashInts(2)(_111, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; - rs.hashInts(8)(_120, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; - rs.hashInts(16)(_128, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; - rs.hashInts(4)(_135, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; - rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; - rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _119: rs.Slice = rs.sliceFrom([b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]); + rs.hashInts(8)(_119, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _127: rs.Slice = rs.sliceFrom([rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]); + rs.hashInts(16)(_127, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _134: rs.Slice = rs.sliceFrom([rs.u128Low(a) | 0, -1]); + rs.hashInts(4)(_134, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _138: rs.Slice = rs.sliceFrom([rs.u128And(a, 1) === 0, true]); + rs.hashSlice(rs.hash8)(_138, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)(rs.sliceFrom([233, 120]), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _145: rs.Slice = rs.sliceFrom([rs.u128Low(a) & 0xffff, 3]); + rs.hashSlice(rs.hash16)(_145, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); @@ -917,7 +917,7 @@ export function hashInto$hashes_Switch(h: rs.Place, data: rs.Byte const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Switch({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Switch({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Switch as (a0: Dir.Dir, a1: rs.Place) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Switch as (a0: Dir.Dir, a1: rs.Place) => undefined))(rs.sliceFrom(["Up" as Dir.Dir, "Down" as Dir.Dir]), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Switch as (a0: Small.Small, a1: rs.Place) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Switch as (a0: Small.Small, a1: rs.Place) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); Nibble.hash$Hash_hashes_Switch({ _0: rs.u128Low(a) & 0xff }, h); rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); @@ -1376,8 +1376,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, cloned) ? 1 : 0); const _36: Tallied.Tallied = Tallied.default$Default(); rs.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, _36) ? 1 : 0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), (f: rs.Formatter) => rs.fmtOption(undefined, f, (_value: undefined, f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), rs.None), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(cloned, f), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(held, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3])])); + const args5 = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), (f: rs.Formatter) => rs.fmtOption(undefined, f, (_value: undefined, f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), rs.None), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(cloned, f), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(held, f)]; + put(out, rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", rs.fmtSpec({ alternate: true }, args5[3])])); const word: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "✓"); const n: rs.u16 = rs.u128Low(wide(data, 0, 2)) & 0xffff; const built: Tally.Tally = Tally.default$Default(); @@ -1437,8 +1437,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { return undefined; }); rs.byteVecPush(out, rs.hashEq(rs.same)(keyed, _195) ? 1 : 0); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault")]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault")])); const _212: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.u8 => { return rs.u8Rem(b2, 4); }); diff --git a/ts/fixtures/lang/heap/expected/harness.ts b/ts/fixtures/lang/heap/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/heap/expected/harness.ts +++ b/ts/fixtures/lang/heap/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/heap/expected/heap.ts b/ts/fixtures/lang/heap/expected/heap.ts index 5eb04c223..bf2b24fad 100644 --- a/ts/fixtures/lang/heap/expected/heap.ts +++ b/ts/fixtures/lang/heap/expected/heap.ts @@ -166,25 +166,22 @@ export function layouts(data: rs.ByteSlice, out: rs.ByteVec): void { align = rs.usizeShl(1, rs.u8Rem(b, 32)); } const made: rs.Result = rs.layoutFromSizeAlign(size, align); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(made, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(made, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)])), undefined, true); if (!made.ok) { rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(rs.LAYOUT_ERROR, f))), undefined, true); } const part3 = rs.layoutArray(rs.usizeShr(size, rs.u8Rem(b, 8)), 8, 8); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part3, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part3, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)])), undefined, true); const unit: rs.Layout = rs.resultUnwrap(rs.layoutArray(size, 0, 1), rs.fmtLayoutErrorDebug); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(unit.size & 0xff, unit.align & 0xff)), undefined, true); } const _92: Fault.Fault = { tag: "Alloc", layout: { size: 16, align: 8 } }; const _94: rs.Layout = { size: 4, align: 4 }; - const args6: rs.Fmt[] = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(_92, f), (f: rs.Formatter) => rs.fmtLayoutDebug(_94, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args11 = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(_92, f), (f: rs.Formatter) => rs.fmtLayoutDebug(_94, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args11[0], " ", args11[1]])), undefined, true); rs.byteVecPush(out, 8 & 0xff); const arg = { tag: "Overflow" } as Fault.Fault; - const args8: rs.Fmt[] = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(arg, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => Fault.fmt$fmt_Debug(arg, f)])), undefined, true); } //# sourceMappingURL=heap.ts.map diff --git a/ts/fixtures/lang/hints/expected/harness.ts b/ts/fixtures/lang/hints/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/hints/expected/harness.ts +++ b/ts/fixtures/lang/hints/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/hints/expected/hints.ts b/ts/fixtures/lang/hints/expected/hints.ts index cbfef7d04..34b0774f0 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -2236,9 +2236,9 @@ export function typed$array275_u32_hints_reserves_closure5(kind: rs.u8, data: rs } else if (shape === 1) { fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rs.iterSkip(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5_hints_typed_closure2_array275_u32_hints_reserves_closure5(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), (_2: rs.u32[]): boolean => { + fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5_hints_typed_closure2_array275_u32_hints_reserves_closure5(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), rs.lending((_2: rs.Slice): boolean => { return true; - }), seed, out); + }, (f3) => (held2) => f3(rs.sliceFrom(held2)))), seed, out); } else if (shape === 3) { fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } else { @@ -2617,19 +2617,19 @@ export function fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hi rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + const v2: rs.Vec = rs.vecFromElem(seed.slice(), 2, undefined); rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed.slice(), 2, undefined), 1100) as rs.VecDeque; rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed.slice(), 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { @@ -2686,19 +2686,19 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + const v2: rs.Vec = rs.vecFromElem(seed.slice(), 2, undefined); rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed.slice(), 2, undefined), 1100) as rs.VecDeque; rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed.slice(), 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { @@ -2755,19 +2755,19 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + const v2: rs.Vec = rs.vecFromElem(seed.slice(), 2, undefined); rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed.slice(), 2, undefined), 1100) as rs.VecDeque; rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed.slice(), 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { @@ -2824,19 +2824,19 @@ export function fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rs.iterExtend(v, items, undefined, 1100, true); len = v.items.length; } else if (coll === 2) { - const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + const v2: rs.Vec = rs.vecFromElem(seed.slice(), 2, undefined); rs.iterExtend(v2, items, undefined, 1100, true); len = v2.items.length; } else if (coll === 3) { len = (rs.dequeFromVec(rs.iterToVec(items, undefined, 1100, true), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed.slice(), 2, undefined), 1100) as rs.VecDeque; rs.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rs.heapFrom(rs.iterToVec(items, undefined, 1100, true), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed.slice(), 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), undefined, 1100, true); len = h.items.length; } else if (coll === 7) { @@ -2893,19 +2893,19 @@ export function fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hint rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + const v2: rs.Vec = rs.vecFromElem(seed.slice(), 2, undefined); rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed.slice(), 2, undefined), 1100) as rs.VecDeque; rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed.slice(), 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { diff --git a/ts/fixtures/lang/holds/expected/harness.ts b/ts/fixtures/lang/holds/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/holds/expected/harness.ts +++ b/ts/fixtures/lang/holds/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/ints/expected/core/num.ts b/ts/fixtures/lang/ints/expected/core/num.ts index c2f2b4ec3..bcdd51e4d 100644 --- a/ts/fixtures/lang/ints/expected/core/num.ts +++ b/ts/fixtures/lang/ints/expected/core/num.ts @@ -39,16 +39,15 @@ export function canNotOverflow$0bdyog2(radix: rs.u32, isSignedTy: boolean, _digi } export function fromAsciiBytesRadixPanic(radix: rs.u32): never { - doPanic$16ya8t2(radix); + doPanic$1tugyvz(radix); } -export function doPanic$16ya8t2(radix: rs.u32): never { - runtime$0o4i17s(radix); +export function doPanic$1tugyvz(radix: rs.u32): never { + runtime$09k496w(radix); } -export function runtime$0o4i17s(radix: rs.u32): never { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(radix, f)]; - rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); +export function runtime$09k496w(radix: rs.u32): never { + rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", (f: rs.Formatter) => rs.u32Display(radix, f)]); } export function fromAsciiBytesRadixImpl$1r0rye7(src: rs.ByteSlice, radix: rs.u32): rs.Result { diff --git a/ts/fixtures/lang/ints/expected/harness.ts b/ts/fixtures/lang/ints/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/ints/expected/harness.ts +++ b/ts/fixtures/lang/ints/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/ints/expected/ints.ts b/ts/fixtures/lang/ints/expected/ints.ts index be74894f5..5212c863e 100644 --- a/ts/fixtures/lang/ints/expected/ints.ts +++ b/ts/fixtures/lang/ints/expected/ints.ts @@ -2799,37 +2799,20 @@ export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32) const _7: [string, string] = [digits(max, radix), succ(digits(max, radix), radix)]; const top: string = _7[0]; const past: string = _7[1]; - const _15: string = top; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; - const _17: string = rs.fmtFormat(["+", args2[0]]); - const _26: string = past; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past)]; - const _28: string = rs.fmtFormat(["+", args4[0]]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; - const all: rs.Vec = rs.vecFrom([_15, _17, _26, _28, rs.fmtFormat(["000", args6[0]])]); + const all: rs.Vec = rs.vecFrom([top, rs.fmtFormat(["+", (f: rs.Formatter) => rs.fmtPad(f, top)]), past, rs.fmtFormat(["+", (f: rs.Formatter) => rs.fmtPad(f, past)]), rs.fmtFormat(["000", (f: rs.Formatter) => rs.fmtPad(f, top)])]); const upper: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.strBytes(top), (b: rs.u8): rs.u8 => { if (!(b > 57)) { return b; } return rs.u8Sub(b, 32); }), undefined, true); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; - const _54: string = rs.fmtFormat(["-", args8[0]]); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past)]; - const _53: string[] = [_54, rs.fmtFormat(["000", args10[0]]), rs.resultUnwrap(rs.stringFromUtf8(upper), rs.fmtFromUtf8ErrorDebug)]; + const _53: string[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, top)]), rs.fmtFormat(["000", (f: rs.Formatter) => rs.fmtPad(f, past)]), rs.resultUnwrap(rs.stringFromUtf8(upper), rs.fmtFromUtf8ErrorDebug)]; rs.iterExtend(all, rs.iterSlice(_53), undefined, 12, true); if (rs.u128Gt(min, 0)) { const _77: [string, string] = [digits(min, radix), succ(digits(min, radix), radix)]; const bottom: string = _77[0]; const below: string = _77[1]; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom)]; - const _86: string = rs.fmtFormat(["-", args12[0]]); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below)]; - const _95: string = rs.fmtFormat(["-", args14[0]]); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom)]; - const _104: string = rs.fmtFormat(["-000", args16[0]]); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below)]; - const _85: string[] = [_86, _95, _104, rs.fmtFormat(["-00", args18[0]])]; + const _85: string[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, bottom)]), rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, below)]), rs.fmtFormat(["-000", (f: rs.Formatter) => rs.fmtPad(f, bottom)]), rs.fmtFormat(["-00", (f: rs.Formatter) => rs.fmtPad(f, below)])]; rs.iterExtend(all, rs.iterSlice(_85), undefined, 12, true); } const unchecked: rs.usize = rs.usizeSub(rs.usizeDiv(bits, 4), rs.u128Gt(min, 0) ? 1 : 0); @@ -2853,8 +2836,7 @@ export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32) while (iterStart++ < iterEnd) { run = run + String.fromCodePoint(high); } - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, run)]; - const _158: string[] = [rs.fmtFormat(["-", args20[0]]), run]; + const _158: string[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, run)]), run]; rs.iterExtend(all, rs.iterSlice(_158), undefined, 12, true); } const _172: rs.usize = rs.usizeRem(radix as rs.usize, 36); @@ -2871,10 +2853,7 @@ export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32) } all.items.push(_193); } - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]; - const _203: string = rs.fmtFormat(["1", args22[0]]); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]; - const _202: string[] = [_203, rs.fmtFormat([args24[0]])]; + const _202: string[] = [rs.fmtFormat(["1", (f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]), rs.fmtFormat([(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)])]; rs.iterExtend(all, rs.iterSlice(_202), undefined, 12, true); return all; } @@ -3064,8 +3043,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _40: rs.Result = num_fromStrRadix$1osjin2(_19.value, radix2); if (_40.ok) { const arg48 = _40.value; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg48, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg48, f)])); } else { const e: rs.ParseIntError = _40.error; const _56: rs.IntErrorKind = e.kind; @@ -3086,8 +3064,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over = true; } const _76: rs.IntErrorKind = e.kind; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _76), (f: rs.Formatter) => rs.i32Display(kind2, f), (f: rs.Formatter) => rs.fmtBool(over, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]])); + const args287 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _76), (f: rs.Formatter) => rs.i32Display(kind2, f), (f: rs.Formatter) => rs.fmtBool(over, f)]; + put(out, rs.fmtFormat([args287[0], "|", args287[1], "|", args287[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args287[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args287[0]), "|", args287[3], "|", args287[4]])); } if (radix2 === 10) { const parsed: rs.Result = parse$1brosjp(_19.value); @@ -3113,8 +3091,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _131: rs.Result = num_fromStrRadix$1osjin2(_128, radix3); if (_131.ok) { const arg47 = _131.value; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg47, f)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg47, f)])); } else { const e2: rs.ParseIntError = _131.error; const _147: rs.IntErrorKind = e2.kind; @@ -3135,8 +3112,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over2 = true; } const _167: rs.IntErrorKind = e2.kind; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _167), (f: rs.Formatter) => rs.i32Display(kind3, f), (f: rs.Formatter) => rs.fmtBool(over2, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]])); + const args285 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _167), (f: rs.Formatter) => rs.i32Display(kind3, f), (f: rs.Formatter) => rs.fmtBool(over2, f)]; + put(out, rs.fmtFormat([args285[0], "|", args285[1], "|", args285[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args285[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args285[0]), "|", args285[3], "|", args285[4]])); } if (radix3 === 10) { const parsed2: rs.Result = parse$1brosjp(_128); @@ -3162,8 +3139,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _218: rs.Result = num_fromStrRadix$1osjin2(_207, radix5); if (_218.ok) { const arg46 = _218.value; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg46, f)]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg46, f)])); } else { const e3: rs.ParseIntError = _218.error; const _234: rs.IntErrorKind = e3.kind; @@ -3184,8 +3160,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over3 = true; } const _254: rs.IntErrorKind = e3.kind; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e3, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e3, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _254), (f: rs.Formatter) => rs.i32Display(kind4, f), (f: rs.Formatter) => rs.fmtBool(over3, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]])); + const args283 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e3, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e3, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _254), (f: rs.Formatter) => rs.i32Display(kind4, f), (f: rs.Formatter) => rs.fmtBool(over3, f)]; + put(out, rs.fmtFormat([args283[0], "|", args283[1], "|", args283[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args283[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args283[0]), "|", args283[3], "|", args283[4]])); } if (radix5 === 10) { const parsed3: rs.Result = parse$1brosjp(_207); @@ -3216,8 +3192,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _315: rs.Result = num_fromStrRadix$1osjin2(_310, radix7); if (_315.ok) { const arg45 = _315.value; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg45, f)]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg45, f)])); } else { const e4: rs.ParseIntError = _315.error; const _331: rs.IntErrorKind = e4.kind; @@ -3238,8 +3213,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over4 = true; } const _351: rs.IntErrorKind = e4.kind; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _351), (f: rs.Formatter) => rs.i32Display(kind5, f), (f: rs.Formatter) => rs.fmtBool(over4, f)]; - put(out, rs.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]])); + const args281 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _351), (f: rs.Formatter) => rs.i32Display(kind5, f), (f: rs.Formatter) => rs.fmtBool(over4, f)]; + put(out, rs.fmtFormat([args281[0], "|", args281[1], "|", args281[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args281[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args281[0]), "|", args281[3], "|", args281[4]])); } if (radix7 === 10) { const parsed4: rs.Result = parse$1brosjp(_310); @@ -3274,8 +3249,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _414: rs.Result = num_fromStrRadix$1wu02v6(_393.value, radix9); if (_414.ok) { const arg44 = _414.value; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg44, f)]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg44, f)])); } else { const e5: rs.ParseIntError = _414.error; const _430: rs.IntErrorKind = e5.kind; @@ -3296,8 +3270,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over5 = true; } const _450: rs.IntErrorKind = e5.kind; - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _450), (f: rs.Formatter) => rs.i32Display(kind6, f), (f: rs.Formatter) => rs.fmtBool(over5, f)]; - put(out, rs.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]])); + const args279 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _450), (f: rs.Formatter) => rs.i32Display(kind6, f), (f: rs.Formatter) => rs.fmtBool(over5, f)]; + put(out, rs.fmtFormat([args279[0], "|", args279[1], "|", args279[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args279[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args279[0]), "|", args279[3], "|", args279[4]])); } if (radix9 === 10) { const parsed5: rs.Result = parse$0un0sth(_393.value); @@ -3323,8 +3297,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _505: rs.Result = num_fromStrRadix$1wu02v6(_502, radix10); if (_505.ok) { const arg43 = _505.value; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg43, f)]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg43, f)])); } else { const e6: rs.ParseIntError = _505.error; const _521: rs.IntErrorKind = e6.kind; @@ -3345,8 +3318,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over6 = true; } const _541: rs.IntErrorKind = e6.kind; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e6, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e6, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _541), (f: rs.Formatter) => rs.i32Display(kind7, f), (f: rs.Formatter) => rs.fmtBool(over6, f)]; - put(out, rs.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]])); + const args277 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e6, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e6, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _541), (f: rs.Formatter) => rs.i32Display(kind7, f), (f: rs.Formatter) => rs.fmtBool(over6, f)]; + put(out, rs.fmtFormat([args277[0], "|", args277[1], "|", args277[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args277[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args277[0]), "|", args277[3], "|", args277[4]])); } if (radix10 === 10) { const parsed6: rs.Result = parse$0un0sth(_502); @@ -3372,8 +3345,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _592: rs.Result = num_fromStrRadix$1wu02v6(_581, radix12); if (_592.ok) { const arg42 = _592.value; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg42, f)]; - put(out, rs.fmtFormat([args26[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg42, f)])); } else { const e7: rs.ParseIntError = _592.error; const _608: rs.IntErrorKind = e7.kind; @@ -3394,8 +3366,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over7 = true; } const _628: rs.IntErrorKind = e7.kind; - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _628), (f: rs.Formatter) => rs.i32Display(kind8, f), (f: rs.Formatter) => rs.fmtBool(over7, f)]; - put(out, rs.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]])); + const args275 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _628), (f: rs.Formatter) => rs.i32Display(kind8, f), (f: rs.Formatter) => rs.fmtBool(over7, f)]; + put(out, rs.fmtFormat([args275[0], "|", args275[1], "|", args275[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args275[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args275[0]), "|", args275[3], "|", args275[4]])); } if (radix12 === 10) { const parsed7: rs.Result = parse$0un0sth(_581); @@ -3426,8 +3398,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _689: rs.Result = num_fromStrRadix$1wu02v6(_684, radix14); if (_689.ok) { const arg41 = _689.value; - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg41, f)]; - put(out, rs.fmtFormat([args30[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg41, f)])); } else { const e8: rs.ParseIntError = _689.error; const _705: rs.IntErrorKind = e8.kind; @@ -3448,8 +3419,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over8 = true; } const _725: rs.IntErrorKind = e8.kind; - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _725), (f: rs.Formatter) => rs.i32Display(kind9, f), (f: rs.Formatter) => rs.fmtBool(over8, f)]; - put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]])); + const args273 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _725), (f: rs.Formatter) => rs.i32Display(kind9, f), (f: rs.Formatter) => rs.fmtBool(over8, f)]; + put(out, rs.fmtFormat([args273[0], "|", args273[1], "|", args273[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args273[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args273[0]), "|", args273[3], "|", args273[4]])); } if (radix14 === 10) { const parsed8: rs.Result = parse$0un0sth(_684); @@ -3484,8 +3455,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _788: rs.Result = num_fromStrRadix$1ftrr55(_767.value, radix16); if (_788.ok) { const arg40 = _788.value; - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg40, f)]; - put(out, rs.fmtFormat([args34[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg40, f)])); } else { const e9: rs.ParseIntError = _788.error; const _804: rs.IntErrorKind = e9.kind; @@ -3506,8 +3476,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over9 = true; } const _824: rs.IntErrorKind = e9.kind; - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e9, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e9, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _824), (f: rs.Formatter) => rs.i32Display(kind10, f), (f: rs.Formatter) => rs.fmtBool(over9, f)]; - put(out, rs.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]])); + const args271 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e9, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e9, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _824), (f: rs.Formatter) => rs.i32Display(kind10, f), (f: rs.Formatter) => rs.fmtBool(over9, f)]; + put(out, rs.fmtFormat([args271[0], "|", args271[1], "|", args271[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args271[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args271[0]), "|", args271[3], "|", args271[4]])); } if (radix16 === 10) { const parsed9: rs.Result = parse$069xxen(_767.value); @@ -3533,8 +3503,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _879: rs.Result = num_fromStrRadix$1ftrr55(_876, radix17); if (_879.ok) { const arg39 = _879.value; - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg39, f)]; - put(out, rs.fmtFormat([args38[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg39, f)])); } else { const e10: rs.ParseIntError = _879.error; const _895: rs.IntErrorKind = e10.kind; @@ -3555,8 +3524,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over10 = true; } const _915: rs.IntErrorKind = e10.kind; - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _915), (f: rs.Formatter) => rs.i32Display(kind11, f), (f: rs.Formatter) => rs.fmtBool(over10, f)]; - put(out, rs.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]])); + const args269 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _915), (f: rs.Formatter) => rs.i32Display(kind11, f), (f: rs.Formatter) => rs.fmtBool(over10, f)]; + put(out, rs.fmtFormat([args269[0], "|", args269[1], "|", args269[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args269[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args269[0]), "|", args269[3], "|", args269[4]])); } if (radix17 === 10) { const parsed10: rs.Result = parse$069xxen(_876); @@ -3582,8 +3551,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _966: rs.Result = num_fromStrRadix$1ftrr55(_955, radix19); if (_966.ok) { const arg38 = _966.value; - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg38, f)]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg38, f)])); } else { const e11: rs.ParseIntError = _966.error; const _982: rs.IntErrorKind = e11.kind; @@ -3604,8 +3572,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over11 = true; } const _1002: rs.IntErrorKind = e11.kind; - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1002), (f: rs.Formatter) => rs.i32Display(kind12, f), (f: rs.Formatter) => rs.fmtBool(over11, f)]; - put(out, rs.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]])); + const args267 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1002), (f: rs.Formatter) => rs.i32Display(kind12, f), (f: rs.Formatter) => rs.fmtBool(over11, f)]; + put(out, rs.fmtFormat([args267[0], "|", args267[1], "|", args267[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args267[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args267[0]), "|", args267[3], "|", args267[4]])); } if (radix19 === 10) { const parsed11: rs.Result = parse$069xxen(_955); @@ -3636,8 +3604,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1063: rs.Result = num_fromStrRadix$1ftrr55(_1058, radix21); if (_1063.ok) { const arg37 = _1063.value; - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg37, f)]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg37, f)])); } else { const e12: rs.ParseIntError = _1063.error; const _1079: rs.IntErrorKind = e12.kind; @@ -3658,8 +3625,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over12 = true; } const _1099: rs.IntErrorKind = e12.kind; - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e12, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e12, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1099), (f: rs.Formatter) => rs.i32Display(kind13, f), (f: rs.Formatter) => rs.fmtBool(over12, f)]; - put(out, rs.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]])); + const args265 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e12, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e12, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1099), (f: rs.Formatter) => rs.i32Display(kind13, f), (f: rs.Formatter) => rs.fmtBool(over12, f)]; + put(out, rs.fmtFormat([args265[0], "|", args265[1], "|", args265[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args265[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args265[0]), "|", args265[3], "|", args265[4]])); } if (radix21 === 10) { const parsed12: rs.Result = parse$069xxen(_1058); @@ -3694,8 +3661,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1162: rs.Result = num_fromStrRadix$0al5jri(_1141.value, radix23); if (_1162.ok) { const arg36 = _1162.value; - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg36, f)]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg36, f)])); } else { const e13: rs.ParseIntError = _1162.error; const _1178: rs.IntErrorKind = e13.kind; @@ -3716,8 +3682,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over13 = true; } const _1198: rs.IntErrorKind = e13.kind; - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1198), (f: rs.Formatter) => rs.i32Display(kind14, f), (f: rs.Formatter) => rs.fmtBool(over13, f)]; - put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", args52[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", args52[3], "|", args52[4]])); + const args263 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1198), (f: rs.Formatter) => rs.i32Display(kind14, f), (f: rs.Formatter) => rs.fmtBool(over13, f)]; + put(out, rs.fmtFormat([args263[0], "|", args263[1], "|", args263[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args263[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args263[0]), "|", args263[3], "|", args263[4]])); } if (radix23 === 10) { const parsed13: rs.Result = parse$092epd5(_1141.value); @@ -3743,8 +3709,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1253: rs.Result = num_fromStrRadix$0al5jri(_1250, radix24); if (_1253.ok) { const arg35 = _1253.value; - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg35, f)]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg35, f)])); } else { const e14: rs.ParseIntError = _1253.error; const _1269: rs.IntErrorKind = e14.kind; @@ -3765,8 +3730,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over14 = true; } const _1289: rs.IntErrorKind = e14.kind; - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1289), (f: rs.Formatter) => rs.i32Display(kind15, f), (f: rs.Formatter) => rs.fmtBool(over14, f)]; - put(out, rs.fmtFormat([args56[0], "|", args56[1], "|", args56[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args56[0]), "|", args56[3], "|", args56[4]])); + const args261 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1289), (f: rs.Formatter) => rs.i32Display(kind15, f), (f: rs.Formatter) => rs.fmtBool(over14, f)]; + put(out, rs.fmtFormat([args261[0], "|", args261[1], "|", args261[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args261[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args261[0]), "|", args261[3], "|", args261[4]])); } if (radix24 === 10) { const parsed14: rs.Result = parse$092epd5(_1250); @@ -3792,8 +3757,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1340: rs.Result = num_fromStrRadix$0al5jri(_1329, radix26); if (_1340.ok) { const arg34 = _1340.value; - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg34, f)]; - put(out, rs.fmtFormat([args58[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg34, f)])); } else { const e15: rs.ParseIntError = _1340.error; const _1356: rs.IntErrorKind = e15.kind; @@ -3814,8 +3778,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over15 = true; } const _1376: rs.IntErrorKind = e15.kind; - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e15, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e15, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1376), (f: rs.Formatter) => rs.i32Display(kind16, f), (f: rs.Formatter) => rs.fmtBool(over15, f)]; - put(out, rs.fmtFormat([args60[0], "|", args60[1], "|", args60[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args60[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args60[0]), "|", args60[3], "|", args60[4]])); + const args259 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e15, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e15, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1376), (f: rs.Formatter) => rs.i32Display(kind16, f), (f: rs.Formatter) => rs.fmtBool(over15, f)]; + put(out, rs.fmtFormat([args259[0], "|", args259[1], "|", args259[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args259[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args259[0]), "|", args259[3], "|", args259[4]])); } if (radix26 === 10) { const parsed15: rs.Result = parse$092epd5(_1329); @@ -3846,8 +3810,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1437: rs.Result = num_fromStrRadix$0al5jri(_1432, radix28); if (_1437.ok) { const arg33 = _1437.value; - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg33, f)]; - put(out, rs.fmtFormat([args62[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg33, f)])); } else { const e16: rs.ParseIntError = _1437.error; const _1453: rs.IntErrorKind = e16.kind; @@ -3868,8 +3831,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over16 = true; } const _1473: rs.IntErrorKind = e16.kind; - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1473), (f: rs.Formatter) => rs.i32Display(kind17, f), (f: rs.Formatter) => rs.fmtBool(over16, f)]; - put(out, rs.fmtFormat([args64[0], "|", args64[1], "|", args64[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args64[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args64[0]), "|", args64[3], "|", args64[4]])); + const args257 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1473), (f: rs.Formatter) => rs.i32Display(kind17, f), (f: rs.Formatter) => rs.fmtBool(over16, f)]; + put(out, rs.fmtFormat([args257[0], "|", args257[1], "|", args257[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args257[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args257[0]), "|", args257[3], "|", args257[4]])); } if (radix28 === 10) { const parsed16: rs.Result = parse$092epd5(_1432); @@ -3904,8 +3867,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1536: rs.Result = num_fromStrRadix$09i2k2a(_1515.value, radix30); if (_1536.ok) { const arg32 = _1536.value; - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg32, f)]; - put(out, rs.fmtFormat([args66[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg32, f)])); } else { const e17: rs.ParseIntError = _1536.error; const _1552: rs.IntErrorKind = e17.kind; @@ -3926,8 +3888,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over17 = true; } const _1572: rs.IntErrorKind = e17.kind; - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1572), (f: rs.Formatter) => rs.i32Display(kind18, f), (f: rs.Formatter) => rs.fmtBool(over17, f)]; - put(out, rs.fmtFormat([args68[0], "|", args68[1], "|", args68[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args68[0]), "|", args68[3], "|", args68[4]])); + const args255 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1572), (f: rs.Formatter) => rs.i32Display(kind18, f), (f: rs.Formatter) => rs.fmtBool(over17, f)]; + put(out, rs.fmtFormat([args255[0], "|", args255[1], "|", args255[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args255[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args255[0]), "|", args255[3], "|", args255[4]])); } if (radix30 === 10) { const parsed17: rs.Result = parse$11owssr(_1515.value); @@ -3953,8 +3915,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1627: rs.Result = num_fromStrRadix$09i2k2a(_1624, radix31); if (_1627.ok) { const arg31 = _1627.value; - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg31, f)]; - put(out, rs.fmtFormat([args70[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg31, f)])); } else { const e18: rs.ParseIntError = _1627.error; const _1643: rs.IntErrorKind = e18.kind; @@ -3975,8 +3936,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over18 = true; } const _1663: rs.IntErrorKind = e18.kind; - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e18, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e18, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1663), (f: rs.Formatter) => rs.i32Display(kind19, f), (f: rs.Formatter) => rs.fmtBool(over18, f)]; - put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", args72[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", args72[3], "|", args72[4]])); + const args253 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e18, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e18, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1663), (f: rs.Formatter) => rs.i32Display(kind19, f), (f: rs.Formatter) => rs.fmtBool(over18, f)]; + put(out, rs.fmtFormat([args253[0], "|", args253[1], "|", args253[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args253[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args253[0]), "|", args253[3], "|", args253[4]])); } if (radix31 === 10) { const parsed18: rs.Result = parse$11owssr(_1624); @@ -4002,8 +3963,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1702, radix33); if (_1713.ok) { const arg30 = _1713.value; - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg30, f)]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg30, f)])); } else { const e19: rs.ParseIntError = _1713.error; const _1729: rs.IntErrorKind = e19.kind; @@ -4024,8 +3984,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over19 = true; } const _1749: rs.IntErrorKind = e19.kind; - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1749), (f: rs.Formatter) => rs.i32Display(kind20, f), (f: rs.Formatter) => rs.fmtBool(over19, f)]; - put(out, rs.fmtFormat([args76[0], "|", args76[1], "|", args76[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args76[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args76[0]), "|", args76[3], "|", args76[4]])); + const args251 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1749), (f: rs.Formatter) => rs.i32Display(kind20, f), (f: rs.Formatter) => rs.fmtBool(over19, f)]; + put(out, rs.fmtFormat([args251[0], "|", args251[1], "|", args251[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args251[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args251[0]), "|", args251[3], "|", args251[4]])); } if (radix33 === 10) { const parsed19: rs.Result = parse$11owssr(_1702); @@ -4056,8 +4016,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1810: rs.Result = num_fromStrRadix$09i2k2a(_1805, radix35); if (_1810.ok) { const arg29 = _1810.value; - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg29, f)]; - put(out, rs.fmtFormat([args78[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg29, f)])); } else { const e20: rs.ParseIntError = _1810.error; const _1826: rs.IntErrorKind = e20.kind; @@ -4078,8 +4037,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over20 = true; } const _1846: rs.IntErrorKind = e20.kind; - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1846), (f: rs.Formatter) => rs.i32Display(kind21, f), (f: rs.Formatter) => rs.fmtBool(over20, f)]; - put(out, rs.fmtFormat([args80[0], "|", args80[1], "|", args80[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args80[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args80[0]), "|", args80[3], "|", args80[4]])); + const args249 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1846), (f: rs.Formatter) => rs.i32Display(kind21, f), (f: rs.Formatter) => rs.fmtBool(over20, f)]; + put(out, rs.fmtFormat([args249[0], "|", args249[1], "|", args249[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args249[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args249[0]), "|", args249[3], "|", args249[4]])); } if (radix35 === 10) { const parsed20: rs.Result = parse$11owssr(_1805); @@ -4114,8 +4073,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1909: rs.Result = num_fromStrRadix$1479ec4(_1888.value, radix37); if (_1909.ok) { const arg28 = _1909.value; - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg28, f)]; - put(out, rs.fmtFormat([args82[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg28, f)])); } else { const e21: rs.ParseIntError = _1909.error; const _1925: rs.IntErrorKind = e21.kind; @@ -4136,8 +4094,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over21 = true; } const _1945: rs.IntErrorKind = e21.kind; - const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e21, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e21, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1945), (f: rs.Formatter) => rs.i32Display(kind22, f), (f: rs.Formatter) => rs.fmtBool(over21, f)]; - put(out, rs.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]])); + const args247 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e21, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e21, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1945), (f: rs.Formatter) => rs.i32Display(kind22, f), (f: rs.Formatter) => rs.fmtBool(over21, f)]; + put(out, rs.fmtFormat([args247[0], "|", args247[1], "|", args247[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args247[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args247[0]), "|", args247[3], "|", args247[4]])); } if (radix37 === 10) { const parsed21: rs.Result = parse$07zoymb(_1888.value); @@ -4163,8 +4121,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2000: rs.Result = num_fromStrRadix$1479ec4(_1997, radix38); if (_2000.ok) { const arg27 = _2000.value; - const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg27, f)]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg27, f)])); } else { const e22: rs.ParseIntError = _2000.error; const _2016: rs.IntErrorKind = e22.kind; @@ -4185,8 +4142,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over22 = true; } const _2036: rs.IntErrorKind = e22.kind; - const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2036), (f: rs.Formatter) => rs.i32Display(kind23, f), (f: rs.Formatter) => rs.fmtBool(over22, f)]; - put(out, rs.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]])); + const args245 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2036), (f: rs.Formatter) => rs.i32Display(kind23, f), (f: rs.Formatter) => rs.fmtBool(over22, f)]; + put(out, rs.fmtFormat([args245[0], "|", args245[1], "|", args245[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args245[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args245[0]), "|", args245[3], "|", args245[4]])); } if (radix38 === 10) { const parsed22: rs.Result = parse$07zoymb(_1997); @@ -4212,8 +4169,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2087: rs.Result = num_fromStrRadix$1479ec4(_2076, radix40); if (_2087.ok) { const arg26 = _2087.value; - const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg26, f)]; - put(out, rs.fmtFormat([args90[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg26, f)])); } else { const e23: rs.ParseIntError = _2087.error; const _2103: rs.IntErrorKind = e23.kind; @@ -4234,8 +4190,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over23 = true; } const _2123: rs.IntErrorKind = e23.kind; - const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2123), (f: rs.Formatter) => rs.i32Display(kind24, f), (f: rs.Formatter) => rs.fmtBool(over23, f)]; - put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]])); + const args243 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2123), (f: rs.Formatter) => rs.i32Display(kind24, f), (f: rs.Formatter) => rs.fmtBool(over23, f)]; + put(out, rs.fmtFormat([args243[0], "|", args243[1], "|", args243[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args243[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args243[0]), "|", args243[3], "|", args243[4]])); } if (radix40 === 10) { const parsed23: rs.Result = parse$07zoymb(_2076); @@ -4266,8 +4222,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2184: rs.Result = num_fromStrRadix$1479ec4(_2179, radix42); if (_2184.ok) { const arg25 = _2184.value; - const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg25, f)]; - put(out, rs.fmtFormat([args94[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg25, f)])); } else { const e24: rs.ParseIntError = _2184.error; const _2200: rs.IntErrorKind = e24.kind; @@ -4288,8 +4243,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over24 = true; } const _2220: rs.IntErrorKind = e24.kind; - const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e24, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e24, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2220), (f: rs.Formatter) => rs.i32Display(kind25, f), (f: rs.Formatter) => rs.fmtBool(over24, f)]; - put(out, rs.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]])); + const args241 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e24, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e24, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2220), (f: rs.Formatter) => rs.i32Display(kind25, f), (f: rs.Formatter) => rs.fmtBool(over24, f)]; + put(out, rs.fmtFormat([args241[0], "|", args241[1], "|", args241[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args241[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args241[0]), "|", args241[3], "|", args241[4]])); } if (radix42 === 10) { const parsed24: rs.Result = parse$07zoymb(_2179); @@ -4324,8 +4279,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2283: rs.Result = num_fromStrRadix$0qyezqs(_2262.value, radix44); if (_2283.ok) { const arg24 = _2283.value; - const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg24, f)]; - put(out, rs.fmtFormat([args98[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg24, f)])); } else { const e25: rs.ParseIntError = _2283.error; const _2299: rs.IntErrorKind = e25.kind; @@ -4346,8 +4300,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over25 = true; } const _2319: rs.IntErrorKind = e25.kind; - const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2319), (f: rs.Formatter) => rs.i32Display(kind26, f), (f: rs.Formatter) => rs.fmtBool(over25, f)]; - put(out, rs.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]])); + const args239 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2319), (f: rs.Formatter) => rs.i32Display(kind26, f), (f: rs.Formatter) => rs.fmtBool(over25, f)]; + put(out, rs.fmtFormat([args239[0], "|", args239[1], "|", args239[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args239[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args239[0]), "|", args239[3], "|", args239[4]])); } if (radix44 === 10) { const parsed25: rs.Result = parse$02m1946(_2262.value); @@ -4373,8 +4327,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2374: rs.Result = num_fromStrRadix$0qyezqs(_2371, radix45); if (_2374.ok) { const arg23 = _2374.value; - const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg23, f)]; - put(out, rs.fmtFormat([args102[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg23, f)])); } else { const e26: rs.ParseIntError = _2374.error; const _2390: rs.IntErrorKind = e26.kind; @@ -4395,8 +4348,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over26 = true; } const _2410: rs.IntErrorKind = e26.kind; - const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2410), (f: rs.Formatter) => rs.i32Display(kind27, f), (f: rs.Formatter) => rs.fmtBool(over26, f)]; - put(out, rs.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]])); + const args237 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2410), (f: rs.Formatter) => rs.i32Display(kind27, f), (f: rs.Formatter) => rs.fmtBool(over26, f)]; + put(out, rs.fmtFormat([args237[0], "|", args237[1], "|", args237[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args237[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args237[0]), "|", args237[3], "|", args237[4]])); } if (radix45 === 10) { const parsed26: rs.Result = parse$02m1946(_2371); @@ -4422,8 +4375,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2453, radix47); if (_2464.ok) { const arg22 = _2464.value; - const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg22, f)]; - put(out, rs.fmtFormat([args106[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg22, f)])); } else { const e27: rs.ParseIntError = _2464.error; const _2480: rs.IntErrorKind = e27.kind; @@ -4444,8 +4396,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over27 = true; } const _2500: rs.IntErrorKind = e27.kind; - const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e27, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e27, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2500), (f: rs.Formatter) => rs.i32Display(kind28, f), (f: rs.Formatter) => rs.fmtBool(over27, f)]; - put(out, rs.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]])); + const args235 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e27, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e27, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2500), (f: rs.Formatter) => rs.i32Display(kind28, f), (f: rs.Formatter) => rs.fmtBool(over27, f)]; + put(out, rs.fmtFormat([args235[0], "|", args235[1], "|", args235[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args235[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args235[0]), "|", args235[3], "|", args235[4]])); } if (radix47 === 10) { const parsed27: rs.Result = parse$02m1946(_2453); @@ -4476,8 +4428,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2561: rs.Result = num_fromStrRadix$0qyezqs(_2556, radix49); if (_2561.ok) { const arg21 = _2561.value; - const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg21, f)]; - put(out, rs.fmtFormat([args110[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg21, f)])); } else { const e28: rs.ParseIntError = _2561.error; const _2577: rs.IntErrorKind = e28.kind; @@ -4498,8 +4449,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over28 = true; } const _2597: rs.IntErrorKind = e28.kind; - const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2597), (f: rs.Formatter) => rs.i32Display(kind29, f), (f: rs.Formatter) => rs.fmtBool(over28, f)]; - put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]])); + const args233 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2597), (f: rs.Formatter) => rs.i32Display(kind29, f), (f: rs.Formatter) => rs.fmtBool(over28, f)]; + put(out, rs.fmtFormat([args233[0], "|", args233[1], "|", args233[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args233[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args233[0]), "|", args233[3], "|", args233[4]])); } if (radix49 === 10) { const parsed28: rs.Result = parse$02m1946(_2556); @@ -4534,8 +4485,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2660: rs.Result = num_fromStrRadix$19vdb8q(_2639.value, radix51); if (_2660.ok) { const arg20 = _2660.value; - const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg20, f)]; - put(out, rs.fmtFormat([args114[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg20, f)])); } else { const e29: rs.ParseIntError = _2660.error; const _2676: rs.IntErrorKind = e29.kind; @@ -4556,8 +4506,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over29 = true; } const _2696: rs.IntErrorKind = e29.kind; - const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2696), (f: rs.Formatter) => rs.i32Display(kind30, f), (f: rs.Formatter) => rs.fmtBool(over29, f)]; - put(out, rs.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]])); + const args231 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2696), (f: rs.Formatter) => rs.i32Display(kind30, f), (f: rs.Formatter) => rs.fmtBool(over29, f)]; + put(out, rs.fmtFormat([args231[0], "|", args231[1], "|", args231[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args231[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args231[0]), "|", args231[3], "|", args231[4]])); } if (radix51 === 10) { const parsed29: rs.Result = parse$00ajhlu(_2639.value); @@ -4583,8 +4533,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2751: rs.Result = num_fromStrRadix$19vdb8q(_2748, radix52); if (_2751.ok) { const arg19 = _2751.value; - const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg19, f)]; - put(out, rs.fmtFormat([args118[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg19, f)])); } else { const e30: rs.ParseIntError = _2751.error; const _2767: rs.IntErrorKind = e30.kind; @@ -4605,8 +4554,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over30 = true; } const _2787: rs.IntErrorKind = e30.kind; - const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e30, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e30, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2787), (f: rs.Formatter) => rs.i32Display(kind31, f), (f: rs.Formatter) => rs.fmtBool(over30, f)]; - put(out, rs.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]])); + const args229 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e30, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e30, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2787), (f: rs.Formatter) => rs.i32Display(kind31, f), (f: rs.Formatter) => rs.fmtBool(over30, f)]; + put(out, rs.fmtFormat([args229[0], "|", args229[1], "|", args229[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args229[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args229[0]), "|", args229[3], "|", args229[4]])); } if (radix52 === 10) { const parsed30: rs.Result = parse$00ajhlu(_2748); @@ -4632,8 +4581,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2830, radix54); if (_2841.ok) { const arg18 = _2841.value; - const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg18, f)]; - put(out, rs.fmtFormat([args122[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg18, f)])); } else { const e31: rs.ParseIntError = _2841.error; const _2857: rs.IntErrorKind = e31.kind; @@ -4654,8 +4602,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over31 = true; } const _2877: rs.IntErrorKind = e31.kind; - const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2877), (f: rs.Formatter) => rs.i32Display(kind32, f), (f: rs.Formatter) => rs.fmtBool(over31, f)]; - put(out, rs.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]])); + const args227 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2877), (f: rs.Formatter) => rs.i32Display(kind32, f), (f: rs.Formatter) => rs.fmtBool(over31, f)]; + put(out, rs.fmtFormat([args227[0], "|", args227[1], "|", args227[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args227[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args227[0]), "|", args227[3], "|", args227[4]])); } if (radix54 === 10) { const parsed31: rs.Result = parse$00ajhlu(_2830); @@ -4686,8 +4634,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2938: rs.Result = num_fromStrRadix$19vdb8q(_2933, radix56); if (_2938.ok) { const arg17 = _2938.value; - const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg17, f)]; - put(out, rs.fmtFormat([args126[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg17, f)])); } else { const e32: rs.ParseIntError = _2938.error; const _2954: rs.IntErrorKind = e32.kind; @@ -4708,8 +4655,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over32 = true; } const _2974: rs.IntErrorKind = e32.kind; - const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2974), (f: rs.Formatter) => rs.i32Display(kind33, f), (f: rs.Formatter) => rs.fmtBool(over32, f)]; - put(out, rs.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]])); + const args225 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2974), (f: rs.Formatter) => rs.i32Display(kind33, f), (f: rs.Formatter) => rs.fmtBool(over32, f)]; + put(out, rs.fmtFormat([args225[0], "|", args225[1], "|", args225[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args225[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args225[0]), "|", args225[3], "|", args225[4]])); } if (radix56 === 10) { const parsed32: rs.Result = parse$00ajhlu(_2933); @@ -4744,8 +4691,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3037: rs.Result = num_fromStrRadix$1ct8u92(_3016.value, radix58); if (_3037.ok) { const arg16 = _3037.value; - const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg16, f)]; - put(out, rs.fmtFormat([args130[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg16, f)])); } else { const e33: rs.ParseIntError = _3037.error; const _3053: rs.IntErrorKind = e33.kind; @@ -4766,8 +4712,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over33 = true; } const _3073: rs.IntErrorKind = e33.kind; - const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e33, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e33, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3073), (f: rs.Formatter) => rs.i32Display(kind34, f), (f: rs.Formatter) => rs.fmtBool(over33, f)]; - put(out, rs.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]])); + const args223 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e33, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e33, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3073), (f: rs.Formatter) => rs.i32Display(kind34, f), (f: rs.Formatter) => rs.fmtBool(over33, f)]; + put(out, rs.fmtFormat([args223[0], "|", args223[1], "|", args223[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args223[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args223[0]), "|", args223[3], "|", args223[4]])); } if (radix58 === 10) { const parsed33: rs.Result = parse$14v13am(_3016.value); @@ -4793,8 +4739,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3128: rs.Result = num_fromStrRadix$1ct8u92(_3125, radix59); if (_3128.ok) { const arg15 = _3128.value; - const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg15, f)]; - put(out, rs.fmtFormat([args134[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg15, f)])); } else { const e34: rs.ParseIntError = _3128.error; const _3144: rs.IntErrorKind = e34.kind; @@ -4815,8 +4760,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over34 = true; } const _3164: rs.IntErrorKind = e34.kind; - const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3164), (f: rs.Formatter) => rs.i32Display(kind35, f), (f: rs.Formatter) => rs.fmtBool(over34, f)]; - put(out, rs.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]])); + const args221 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3164), (f: rs.Formatter) => rs.i32Display(kind35, f), (f: rs.Formatter) => rs.fmtBool(over34, f)]; + put(out, rs.fmtFormat([args221[0], "|", args221[1], "|", args221[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args221[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args221[0]), "|", args221[3], "|", args221[4]])); } if (radix59 === 10) { const parsed34: rs.Result = parse$14v13am(_3125); @@ -4842,8 +4787,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3207, radix61); if (_3218.ok) { const arg14 = _3218.value; - const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg14, f)]; - put(out, rs.fmtFormat([args138[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg14, f)])); } else { const e35: rs.ParseIntError = _3218.error; const _3234: rs.IntErrorKind = e35.kind; @@ -4864,8 +4808,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over35 = true; } const _3254: rs.IntErrorKind = e35.kind; - const args140: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3254), (f: rs.Formatter) => rs.i32Display(kind36, f), (f: rs.Formatter) => rs.fmtBool(over35, f)]; - put(out, rs.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]])); + const args219 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3254), (f: rs.Formatter) => rs.i32Display(kind36, f), (f: rs.Formatter) => rs.fmtBool(over35, f)]; + put(out, rs.fmtFormat([args219[0], "|", args219[1], "|", args219[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args219[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args219[0]), "|", args219[3], "|", args219[4]])); } if (radix61 === 10) { const parsed35: rs.Result = parse$14v13am(_3207); @@ -4896,8 +4840,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3315: rs.Result = num_fromStrRadix$1ct8u92(_3310, radix63); if (_3315.ok) { const arg13 = _3315.value; - const args142: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg13, f)]; - put(out, rs.fmtFormat([args142[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg13, f)])); } else { const e36: rs.ParseIntError = _3315.error; const _3331: rs.IntErrorKind = e36.kind; @@ -4918,8 +4861,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over36 = true; } const _3351: rs.IntErrorKind = e36.kind; - const args144: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e36, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e36, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3351), (f: rs.Formatter) => rs.i32Display(kind37, f), (f: rs.Formatter) => rs.fmtBool(over36, f)]; - put(out, rs.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]])); + const args217 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e36, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e36, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3351), (f: rs.Formatter) => rs.i32Display(kind37, f), (f: rs.Formatter) => rs.fmtBool(over36, f)]; + put(out, rs.fmtFormat([args217[0], "|", args217[1], "|", args217[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args217[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args217[0]), "|", args217[3], "|", args217[4]])); } if (radix63 === 10) { const parsed36: rs.Result = parse$14v13am(_3310); @@ -4954,8 +4897,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3414: rs.Result = num_fromStrRadix$04fc4zz(_3393.value, radix65); if (_3414.ok) { const arg12 = _3414.value; - const args146: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg12, f)]; - put(out, rs.fmtFormat([args146[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg12, f)])); } else { const e37: rs.ParseIntError = _3414.error; const _3430: rs.IntErrorKind = e37.kind; @@ -4976,8 +4918,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over37 = true; } const _3450: rs.IntErrorKind = e37.kind; - const args148: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3450), (f: rs.Formatter) => rs.i32Display(kind38, f), (f: rs.Formatter) => rs.fmtBool(over37, f)]; - put(out, rs.fmtFormat([args148[0], "|", args148[1], "|", args148[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args148[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args148[0]), "|", args148[3], "|", args148[4]])); + const args215 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3450), (f: rs.Formatter) => rs.i32Display(kind38, f), (f: rs.Formatter) => rs.fmtBool(over37, f)]; + put(out, rs.fmtFormat([args215[0], "|", args215[1], "|", args215[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args215[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args215[0]), "|", args215[3], "|", args215[4]])); } if (radix65 === 10) { const parsed37: rs.Result = parse$0px1msj(_3393.value); @@ -5003,8 +4945,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3505: rs.Result = num_fromStrRadix$04fc4zz(_3502, radix66); if (_3505.ok) { const arg11 = _3505.value; - const args150: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg11, f)]; - put(out, rs.fmtFormat([args150[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg11, f)])); } else { const e38: rs.ParseIntError = _3505.error; const _3521: rs.IntErrorKind = e38.kind; @@ -5025,8 +4966,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over38 = true; } const _3541: rs.IntErrorKind = e38.kind; - const args152: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e38, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3541), (f: rs.Formatter) => rs.i32Display(kind39, f), (f: rs.Formatter) => rs.fmtBool(over38, f)]; - put(out, rs.fmtFormat([args152[0], "|", args152[1], "|", args152[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args152[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args152[0]), "|", args152[3], "|", args152[4]])); + const args213 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e38, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3541), (f: rs.Formatter) => rs.i32Display(kind39, f), (f: rs.Formatter) => rs.fmtBool(over38, f)]; + put(out, rs.fmtFormat([args213[0], "|", args213[1], "|", args213[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args213[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args213[0]), "|", args213[3], "|", args213[4]])); } if (radix66 === 10) { const parsed38: rs.Result = parse$0px1msj(_3502); @@ -5052,8 +4993,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3584, radix68); if (_3595.ok) { const arg10 = _3595.value; - const args154: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg10, f)]; - put(out, rs.fmtFormat([args154[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg10, f)])); } else { const e39: rs.ParseIntError = _3595.error; const _3611: rs.IntErrorKind = e39.kind; @@ -5074,8 +5014,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over39 = true; } const _3631: rs.IntErrorKind = e39.kind; - const args156: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e39, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e39, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3631), (f: rs.Formatter) => rs.i32Display(kind40, f), (f: rs.Formatter) => rs.fmtBool(over39, f)]; - put(out, rs.fmtFormat([args156[0], "|", args156[1], "|", args156[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args156[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args156[0]), "|", args156[3], "|", args156[4]])); + const args211 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e39, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e39, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3631), (f: rs.Formatter) => rs.i32Display(kind40, f), (f: rs.Formatter) => rs.fmtBool(over39, f)]; + put(out, rs.fmtFormat([args211[0], "|", args211[1], "|", args211[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args211[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args211[0]), "|", args211[3], "|", args211[4]])); } if (radix68 === 10) { const parsed39: rs.Result = parse$0px1msj(_3584); @@ -5106,8 +5046,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3692: rs.Result = num_fromStrRadix$04fc4zz(_3687, radix70); if (_3692.ok) { const arg9 = _3692.value; - const args158: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg9, f)]; - put(out, rs.fmtFormat([args158[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg9, f)])); } else { const e40: rs.ParseIntError = _3692.error; const _3708: rs.IntErrorKind = e40.kind; @@ -5128,8 +5067,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over40 = true; } const _3728: rs.IntErrorKind = e40.kind; - const args160: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e40, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e40, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3728), (f: rs.Formatter) => rs.i32Display(kind41, f), (f: rs.Formatter) => rs.fmtBool(over40, f)]; - put(out, rs.fmtFormat([args160[0], "|", args160[1], "|", args160[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args160[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args160[0]), "|", args160[3], "|", args160[4]])); + const args209 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e40, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e40, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3728), (f: rs.Formatter) => rs.i32Display(kind41, f), (f: rs.Formatter) => rs.fmtBool(over40, f)]; + put(out, rs.fmtFormat([args209[0], "|", args209[1], "|", args209[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args209[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args209[0]), "|", args209[3], "|", args209[4]])); } if (radix70 === 10) { const parsed40: rs.Result = parse$0px1msj(_3687); @@ -5164,8 +5103,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3791: rs.Result = num_fromStrRadix$0cysu2u(_3770.value, radix72); if (_3791.ok) { const arg8 = _3791.value; - const args162: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg8, f)]; - put(out, rs.fmtFormat([args162[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg8, f)])); } else { const e41: rs.ParseIntError = _3791.error; const _3807: rs.IntErrorKind = e41.kind; @@ -5186,8 +5124,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over41 = true; } const _3827: rs.IntErrorKind = e41.kind; - const args164: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e41, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e41, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3827), (f: rs.Formatter) => rs.i32Display(kind42, f), (f: rs.Formatter) => rs.fmtBool(over41, f)]; - put(out, rs.fmtFormat([args164[0], "|", args164[1], "|", args164[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args164[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", args164[3], "|", args164[4]])); + const args207 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e41, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e41, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3827), (f: rs.Formatter) => rs.i32Display(kind42, f), (f: rs.Formatter) => rs.fmtBool(over41, f)]; + put(out, rs.fmtFormat([args207[0], "|", args207[1], "|", args207[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args207[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args207[0]), "|", args207[3], "|", args207[4]])); } if (radix72 === 10) { const parsed41: rs.Result = parse$1kyj9pm(_3770.value); @@ -5213,8 +5151,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3882: rs.Result = num_fromStrRadix$0cysu2u(_3879, radix73); if (_3882.ok) { const arg7 = _3882.value; - const args166: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg7, f)]; - put(out, rs.fmtFormat([args166[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg7, f)])); } else { const e42: rs.ParseIntError = _3882.error; const _3898: rs.IntErrorKind = e42.kind; @@ -5235,8 +5172,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over42 = true; } const _3918: rs.IntErrorKind = e42.kind; - const args168: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e42, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e42, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3918), (f: rs.Formatter) => rs.i32Display(kind43, f), (f: rs.Formatter) => rs.fmtBool(over42, f)]; - put(out, rs.fmtFormat([args168[0], "|", args168[1], "|", args168[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args168[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args168[0]), "|", args168[3], "|", args168[4]])); + const args205 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e42, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e42, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3918), (f: rs.Formatter) => rs.i32Display(kind43, f), (f: rs.Formatter) => rs.fmtBool(over42, f)]; + put(out, rs.fmtFormat([args205[0], "|", args205[1], "|", args205[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args205[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args205[0]), "|", args205[3], "|", args205[4]])); } if (radix73 === 10) { const parsed42: rs.Result = parse$1kyj9pm(_3879); @@ -5262,8 +5199,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3961, radix75); if (_3972.ok) { const arg6 = _3972.value; - const args170: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg6, f)]; - put(out, rs.fmtFormat([args170[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg6, f)])); } else { const e43: rs.ParseIntError = _3972.error; const _3988: rs.IntErrorKind = e43.kind; @@ -5284,8 +5220,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over43 = true; } const _4008: rs.IntErrorKind = e43.kind; - const args172: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e43, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e43, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4008), (f: rs.Formatter) => rs.i32Display(kind44, f), (f: rs.Formatter) => rs.fmtBool(over43, f)]; - put(out, rs.fmtFormat([args172[0], "|", args172[1], "|", args172[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args172[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args172[0]), "|", args172[3], "|", args172[4]])); + const args203 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e43, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e43, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4008), (f: rs.Formatter) => rs.i32Display(kind44, f), (f: rs.Formatter) => rs.fmtBool(over43, f)]; + put(out, rs.fmtFormat([args203[0], "|", args203[1], "|", args203[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args203[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args203[0]), "|", args203[3], "|", args203[4]])); } if (radix75 === 10) { const parsed43: rs.Result = parse$1kyj9pm(_3961); @@ -5316,8 +5252,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4069: rs.Result = num_fromStrRadix$0cysu2u(_4064, radix77); if (_4069.ok) { const arg5 = _4069.value; - const args174: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg5, f)]; - put(out, rs.fmtFormat([args174[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg5, f)])); } else { const e44: rs.ParseIntError = _4069.error; const _4085: rs.IntErrorKind = e44.kind; @@ -5338,8 +5273,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over44 = true; } const _4105: rs.IntErrorKind = e44.kind; - const args176: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e44, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e44, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4105), (f: rs.Formatter) => rs.i32Display(kind45, f), (f: rs.Formatter) => rs.fmtBool(over44, f)]; - put(out, rs.fmtFormat([args176[0], "|", args176[1], "|", args176[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args176[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args176[0]), "|", args176[3], "|", args176[4]])); + const args201 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e44, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e44, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4105), (f: rs.Formatter) => rs.i32Display(kind45, f), (f: rs.Formatter) => rs.fmtBool(over44, f)]; + put(out, rs.fmtFormat([args201[0], "|", args201[1], "|", args201[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args201[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args201[0]), "|", args201[3], "|", args201[4]])); } if (radix77 === 10) { const parsed44: rs.Result = parse$1kyj9pm(_4064); @@ -5374,8 +5309,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4168: rs.Result = num_fromStrRadix$1nys6eo(_4147.value, radix79); if (_4168.ok) { const arg4 = _4168.value; - const args178: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg4, f)]; - put(out, rs.fmtFormat([args178[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg4, f)])); } else { const e45: rs.ParseIntError = _4168.error; const _4184: rs.IntErrorKind = e45.kind; @@ -5396,8 +5330,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over45 = true; } const _4204: rs.IntErrorKind = e45.kind; - const args180: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e45, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e45, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4204), (f: rs.Formatter) => rs.i32Display(kind46, f), (f: rs.Formatter) => rs.fmtBool(over45, f)]; - put(out, rs.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]])); + const args199 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e45, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e45, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4204), (f: rs.Formatter) => rs.i32Display(kind46, f), (f: rs.Formatter) => rs.fmtBool(over45, f)]; + put(out, rs.fmtFormat([args199[0], "|", args199[1], "|", args199[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args199[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args199[0]), "|", args199[3], "|", args199[4]])); } if (radix79 === 10) { const parsed45: rs.Result = parse$1g90yxu(_4147.value); @@ -5423,8 +5357,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4259: rs.Result = num_fromStrRadix$1nys6eo(_4256, radix80); if (_4259.ok) { const arg3 = _4259.value; - const args182: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg3, f)]; - put(out, rs.fmtFormat([args182[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg3, f)])); } else { const e46: rs.ParseIntError = _4259.error; const _4275: rs.IntErrorKind = e46.kind; @@ -5445,8 +5378,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over46 = true; } const _4295: rs.IntErrorKind = e46.kind; - const args184: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e46, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e46, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4295), (f: rs.Formatter) => rs.i32Display(kind47, f), (f: rs.Formatter) => rs.fmtBool(over46, f)]; - put(out, rs.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]])); + const args197 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e46, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e46, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4295), (f: rs.Formatter) => rs.i32Display(kind47, f), (f: rs.Formatter) => rs.fmtBool(over46, f)]; + put(out, rs.fmtFormat([args197[0], "|", args197[1], "|", args197[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args197[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args197[0]), "|", args197[3], "|", args197[4]])); } if (radix80 === 10) { const parsed46: rs.Result = parse$1g90yxu(_4256); @@ -5472,8 +5405,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4338, radix82); if (_4349.ok) { const arg2 = _4349.value; - const args186: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]; - put(out, rs.fmtFormat([args186[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)])); } else { const e47: rs.ParseIntError = _4349.error; const _4365: rs.IntErrorKind = e47.kind; @@ -5494,8 +5426,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over47 = true; } const _4385: rs.IntErrorKind = e47.kind; - const args188: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e47, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e47, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4385), (f: rs.Formatter) => rs.i32Display(kind48, f), (f: rs.Formatter) => rs.fmtBool(over47, f)]; - put(out, rs.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]])); + const args195 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e47, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e47, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4385), (f: rs.Formatter) => rs.i32Display(kind48, f), (f: rs.Formatter) => rs.fmtBool(over47, f)]; + put(out, rs.fmtFormat([args195[0], "|", args195[1], "|", args195[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args195[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args195[0]), "|", args195[3], "|", args195[4]])); } if (radix82 === 10) { const parsed47: rs.Result = parse$1g90yxu(_4338); @@ -5526,8 +5458,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4446: rs.Result = num_fromStrRadix$1nys6eo(_4441, radix84); if (_4446.ok) { const arg = _4446.value; - const args190: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg, f)]; - put(out, rs.fmtFormat([args190[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg, f)])); } else { const e48: rs.ParseIntError = _4446.error; const _4462: rs.IntErrorKind = e48.kind; @@ -5548,8 +5479,8 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat over48 = true; } const _4482: rs.IntErrorKind = e48.kind; - const args192: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e48, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e48, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4482), (f: rs.Formatter) => rs.i32Display(kind49, f), (f: rs.Formatter) => rs.fmtBool(over48, f)]; - put(out, rs.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]])); + const args193 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e48, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e48, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4482), (f: rs.Formatter) => rs.i32Display(kind49, f), (f: rs.Formatter) => rs.fmtBool(over48, f)]; + put(out, rs.fmtFormat([args193[0], "|", args193[1], "|", args193[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args193[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args193[0]), "|", args193[3], "|", args193[4]])); } if (radix84 === 10) { const parsed48: rs.Result = parse$1g90yxu(_4441); diff --git a/ts/fixtures/lang/iters/expected/harness.ts b/ts/fixtures/lang/iters/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/iters/expected/harness.ts +++ b/ts/fixtures/lang/iters/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index b37962345..a6b5eeba6 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -506,12 +506,11 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.eqSlice(rs.same)(a013, a19); }); rs.byteVecPush(out, _158(part14)); - const part15 = rs.peekableNextIfEq(it7, [512, 512], (a014: rs.Vec, a110: rs.u16[]): boolean => { + const part15 = rs.peekableNextIfEq(it7, [512, 512], (a, b) => ((a014: rs.Vec, a110: rs.Slice): boolean => { return rs.eqSlice(rs.same)(a014, a110); - }); + })(a, rs.sliceFrom(b))); rs.byteVecPush(out, _158(part15)); - const _189: rs.u16[] = []; - const _188: rs.Slice = rs.sliceFrom(_189); + const _188: rs.Slice = rs.sliceFrom([]); const part16 = rs.peekableNextIfEq(it7, _188, (a015: rs.Vec, a111: rs.Slice): boolean => { return rs.eqSlice(rs.same)(a015, a111); }); @@ -1737,8 +1736,8 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { const _34: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 2)); const _31: Doubled.Doubled = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; const _33: Doubled.Doubled = { _0Data: _34.data, _0Start: _34.start, _0Len: _34.length }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => Doubled.fmt$fmt_Debug(_31, f), (f: rs.Formatter) => Doubled.fmt$fmt_Debug(_33, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1])]))); + const args3 = [(f: rs.Formatter) => Doubled.fmt$fmt_Debug(_31, f), (f: rs.Formatter) => Doubled.fmt$fmt_Debug(_33, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1])]))); const tags: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tag.Tag => { const b3: rs.u8 = _2; return { bytes: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(b3, ~b3 & 0xff))) }; @@ -6755,15 +6754,14 @@ export function bounded$char(table: rs.Slice, at: rs.usize[], out: rs.B const _109: { end: rs.char; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.char, rs.char] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_111[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_113[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_111[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_113[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.char }, { end: rs.char; inclusive: true }] = [new rs.RangeFrom(a, rs.charStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.char } = _137[1]; const through: { end: rs.char; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.fmtCharDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.fmtCharDebug))])), undefined, true); return [a, b] as [rs.char, rs.char]; } @@ -6825,15 +6823,14 @@ export function bounded$f32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.f32; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.f32, rs.f32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_111[0], f), (f: rs.Formatter) => rs.f32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_113[0], f), (f: rs.Formatter) => rs.f32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_111[0], f), (f: rs.Formatter) => rs.f32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_113[0], f), (f: rs.Formatter) => rs.f32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.f32 }, { end: rs.f32; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.f32 } = _137[1]; const through: { end: rs.f32; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f32Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f32Debug))])), undefined, true); return [a, b] as [rs.f32, rs.f32]; } @@ -6895,15 +6892,14 @@ export function bounded$f64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.f64; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.f64, rs.f64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_111[0], f), (f: rs.Formatter) => rs.f64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_113[0], f), (f: rs.Formatter) => rs.f64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_111[0], f), (f: rs.Formatter) => rs.f64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_113[0], f), (f: rs.Formatter) => rs.f64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.f64 }, { end: rs.f64; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.f64 } = _137[1]; const through: { end: rs.f64; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f64Debug))])), undefined, true); return [a, b] as [rs.f64, rs.f64]; } @@ -6965,15 +6961,14 @@ export function bounded$i128(table: rs.Slice, at: rs.usize[], out: rs.B const _109: { end: rs.i128; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.i128, rs.i128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_111[0], f), (f: rs.Formatter) => rs.i128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_113[0], f), (f: rs.Formatter) => rs.i128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_111[0], f), (f: rs.Formatter) => rs.i128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_113[0], f), (f: rs.Formatter) => rs.i128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.i128 }, { end: rs.i128; inclusive: true }] = [new rs.RangeFrom(a, rs.i128Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i128 } = _137[1]; const through: { end: rs.i128; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i128Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i128Debug))])), undefined, true); return [a, b] as [rs.i128, rs.i128]; } @@ -7035,15 +7030,14 @@ export function bounded$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.i16; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.i16, rs.i16] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_111[0], f), (f: rs.Formatter) => rs.i16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_113[0], f), (f: rs.Formatter) => rs.i16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_111[0], f), (f: rs.Formatter) => rs.i16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_113[0], f), (f: rs.Formatter) => rs.i16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.i16 }, { end: rs.i16; inclusive: true }] = [new rs.RangeFrom(a, rs.i16Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i16 } = _137[1]; const through: { end: rs.i16; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i16Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i16Debug))])), undefined, true); return [a, b] as [rs.i16, rs.i16]; } @@ -7105,15 +7099,14 @@ export function bounded$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.i32, rs.i32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_111[0], f), (f: rs.Formatter) => rs.i32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_113[0], f), (f: rs.Formatter) => rs.i32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_111[0], f), (f: rs.Formatter) => rs.i32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_113[0], f), (f: rs.Formatter) => rs.i32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.i32 }, { end: rs.i32; inclusive: true }] = [new rs.RangeFrom(a, rs.i32Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i32 } = _137[1]; const through: { end: rs.i32; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i32Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i32Debug))])), undefined, true); return [a, b] as [rs.i32, rs.i32]; } @@ -7175,15 +7168,14 @@ export function bounded$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.i64; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.i64, rs.i64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_111[0], f), (f: rs.Formatter) => rs.i64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_113[0], f), (f: rs.Formatter) => rs.i64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_111[0], f), (f: rs.Formatter) => rs.i64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_113[0], f), (f: rs.Formatter) => rs.i64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.i64 }, { end: rs.i64; inclusive: true }] = [new rs.RangeFrom(a, rs.i64Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i64 } = _137[1]; const through: { end: rs.i64; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i64Debug))])), undefined, true); return [a, b] as [rs.i64, rs.i64]; } @@ -7245,15 +7237,14 @@ export function bounded$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const _109: { end: rs.i8; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.i8, rs.i8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_111[0], f), (f: rs.Formatter) => rs.i8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_113[0], f), (f: rs.Formatter) => rs.i8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_111[0], f), (f: rs.Formatter) => rs.i8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_113[0], f), (f: rs.Formatter) => rs.i8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.i8 }, { end: rs.i8; inclusive: true }] = [new rs.RangeFrom(a, rs.i8Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i8 } = _137[1]; const through: { end: rs.i8; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i8Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i8Debug))])), undefined, true); return [a, b] as [rs.i8, rs.i8]; } @@ -7315,15 +7306,14 @@ export function bounded$isize(table: rs.Slice, at: rs.usize[], out: rs const _109: { end: rs.isize; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.isize, rs.isize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_111[0], f), (f: rs.Formatter) => rs.isizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_113[0], f), (f: rs.Formatter) => rs.isizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_111[0], f), (f: rs.Formatter) => rs.isizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_113[0], f), (f: rs.Formatter) => rs.isizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.isize }, { end: rs.isize; inclusive: true }] = [new rs.RangeFrom(a, rs.isizeStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.isize } = _137[1]; const through: { end: rs.isize; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.isizeDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.isizeDebug))])), undefined, true); return [a, b] as [rs.isize, rs.isize]; } @@ -7385,15 +7375,14 @@ export function bounded$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const _109: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u128, rs.u128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u128 } = _137[1]; const through: { end: rs.u128; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))])), undefined, true); return [a, b] as [rs.u128, rs.u128]; } @@ -7455,15 +7444,14 @@ export function bounded$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const _109: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u64, rs.u64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u64 } = _137[1]; const through: { end: rs.u64; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))])), undefined, true); return [a, b] as [rs.u64, rs.u64]; } @@ -7525,15 +7513,14 @@ export function bounded$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const _109: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u8, rs.u8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u8 } = _137[1]; const through: { end: rs.u8; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))])), undefined, true); return [a, b] as [rs.u8, rs.u8]; } @@ -7595,15 +7582,14 @@ export function bounded$num_NonZero_usize(table: rs.Slice, at: rs.usiz const _109: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.usize, rs.usize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.usize } = _137[1]; const through: { end: rs.usize; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))])), undefined, true); return [a, b] as [rs.usize, rs.usize]; } @@ -7665,15 +7651,14 @@ export function bounded$u128(table: rs.Slice, at: rs.usize[], out: rs.B const _109: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u128, rs.u128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.u128Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u128 } = _137[1]; const through: { end: rs.u128; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))])), undefined, true); return [a, b] as [rs.u128, rs.u128]; } @@ -7735,15 +7720,14 @@ export function bounded$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.u16; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u16, rs.u16] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_111[0], f), (f: rs.Formatter) => rs.u16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_113[0], f), (f: rs.Formatter) => rs.u16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_111[0], f), (f: rs.Formatter) => rs.u16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_113[0], f), (f: rs.Formatter) => rs.u16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u16 }, { end: rs.u16; inclusive: true }] = [new rs.RangeFrom(a, rs.u16Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u16 } = _137[1]; const through: { end: rs.u16; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u16Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u16Debug))])), undefined, true); return [a, b] as [rs.u16, rs.u16]; } @@ -7805,15 +7789,14 @@ export function bounded$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.u32; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u32, rs.u32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_111[0], f), (f: rs.Formatter) => rs.u32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_113[0], f), (f: rs.Formatter) => rs.u32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_111[0], f), (f: rs.Formatter) => rs.u32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_113[0], f), (f: rs.Formatter) => rs.u32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u32 }, { end: rs.u32; inclusive: true }] = [new rs.RangeFrom(a, rs.u32Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u32 } = _137[1]; const through: { end: rs.u32; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u32Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u32Debug))])), undefined, true); return [a, b] as [rs.u32, rs.u32]; } @@ -7875,15 +7858,14 @@ export function bounded$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _109: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u64, rs.u64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.u64Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u64 } = _137[1]; const through: { end: rs.u64; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))])), undefined, true); return [a, b] as [rs.u64, rs.u64]; } @@ -7945,15 +7927,14 @@ export function bounded$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const _109: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.u8, rs.u8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.u8Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u8 } = _137[1]; const through: { end: rs.u8; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))])), undefined, true); return [a, b] as [rs.u8, rs.u8]; } @@ -8015,15 +7996,14 @@ export function bounded$usize(table: rs.Slice, at: rs.usize[], out: rs const _109: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; const _111: [rs.usize, rs.usize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.usizeStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.usize } = _137[1]; const through: { end: rs.usize; inclusive: true } = _137[2]; - const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))])), undefined, true); return [a, b] as [rs.usize, rs.usize]; } @@ -8661,12 +8641,12 @@ export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.B const end: rs.char = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.fmtCharDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.fmtCharDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8686,8 +8666,8 @@ export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.B const _140: [rs.char, rs.char] = rs.rangeInclusiveIntoInner(r); const start2: rs.char = _140[0]; const end2: rs.char = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(start2, f), (f: rs.Formatter) => rs.fmtCharDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.fmtCharDebug(start2, f), (f: rs.Formatter) => rs.fmtCharDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -8755,12 +8735,12 @@ export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.B const end: rs.i128 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI128), rs.rangeEq(rs.i128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i128Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); const _111: boolean = rs.rangeEq(rs.i128Eq)(r, _114); @@ -8780,8 +8760,8 @@ export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.B const _140: [rs.i128, rs.i128] = rs.rangeInclusiveIntoInner(r); const start2: rs.i128 = _140[0]; const end2: rs.i128 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Debug(start2, f), (f: rs.Formatter) => rs.i128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.i128Debug(start2, f), (f: rs.Formatter) => rs.i128Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -8849,12 +8829,12 @@ export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const end: rs.i16 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i16Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i16Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8874,8 +8854,8 @@ export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _140: [rs.i16, rs.i16] = rs.rangeInclusiveIntoInner(r); const start2: rs.i16 = _140[0]; const end2: rs.i16 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Debug(start2, f), (f: rs.Formatter) => rs.i16Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.i16Debug(start2, f), (f: rs.Formatter) => rs.i16Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -8943,12 +8923,12 @@ export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const end: rs.i32 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i32Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i32Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8968,8 +8948,8 @@ export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _140: [rs.i32, rs.i32] = rs.rangeInclusiveIntoInner(r); const start2: rs.i32 = _140[0]; const end2: rs.i32 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Debug(start2, f), (f: rs.Formatter) => rs.i32Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.i32Debug(start2, f), (f: rs.Formatter) => rs.i32Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9037,12 +9017,12 @@ export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const end: rs.i64 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI64), rs.rangeEq(rs.i64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i64Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); const _111: boolean = rs.rangeEq(rs.i64Eq)(r, _114); @@ -9062,8 +9042,8 @@ export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _140: [rs.i64, rs.i64] = rs.rangeInclusiveIntoInner(r); const start2: rs.i64 = _140[0]; const end2: rs.i64 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Debug(start2, f), (f: rs.Formatter) => rs.i64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.i64Debug(start2, f), (f: rs.Formatter) => rs.i64Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9131,12 +9111,12 @@ export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const end: rs.i8 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i8Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9156,8 +9136,8 @@ export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const _140: [rs.i8, rs.i8] = rs.rangeInclusiveIntoInner(r); const start2: rs.i8 = _140[0]; const end2: rs.i8 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Debug(start2, f), (f: rs.Formatter) => rs.i8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.i8Debug(start2, f), (f: rs.Formatter) => rs.i8Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9225,12 +9205,12 @@ export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs const end: rs.isize = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashIsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.isizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.isizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.isizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.isizeDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9250,8 +9230,8 @@ export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs const _140: [rs.isize, rs.isize] = rs.rangeInclusiveIntoInner(r); const start2: rs.isize = _140[0]; const end2: rs.isize = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDebug(start2, f), (f: rs.Formatter) => rs.isizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.isizeDebug(start2, f), (f: rs.Formatter) => rs.isizeDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9319,12 +9299,12 @@ export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const end: rs.u128 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); @@ -9344,8 +9324,8 @@ export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const _140: [rs.u128, rs.u128] = rs.rangeInclusiveIntoInner(r); const start2: rs.u128 = _140[0]; const end2: rs.u128 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9413,12 +9393,12 @@ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const end: rs.u64 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); @@ -9438,8 +9418,8 @@ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const _140: [rs.u64, rs.u64] = rs.rangeInclusiveIntoInner(r); const start2: rs.u64 = _140[0]; const end2: rs.u64 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9507,12 +9487,12 @@ export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const end: rs.u8 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9532,8 +9512,8 @@ export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const _140: [rs.u8, rs.u8] = rs.rangeInclusiveIntoInner(r); const start2: rs.u8 = _140[0]; const end2: rs.u8 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9601,12 +9581,12 @@ export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usiz const end: rs.usize = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9626,8 +9606,8 @@ export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usiz const _140: [rs.usize, rs.usize] = rs.rangeInclusiveIntoInner(r); const start2: rs.usize = _140[0]; const end2: rs.usize = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9695,12 +9675,12 @@ export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.B const end: rs.u128 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); @@ -9720,8 +9700,8 @@ export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.B const _140: [rs.u128, rs.u128] = rs.rangeInclusiveIntoInner(r); const start2: rs.u128 = _140[0]; const end2: rs.u128 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9789,12 +9769,12 @@ export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const end: rs.u16 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u16Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u16Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9814,8 +9794,8 @@ export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _140: [rs.u16, rs.u16] = rs.rangeInclusiveIntoInner(r); const start2: rs.u16 = _140[0]; const end2: rs.u16 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Debug(start2, f), (f: rs.Formatter) => rs.u16Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u16Debug(start2, f), (f: rs.Formatter) => rs.u16Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9883,12 +9863,12 @@ export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const end: rs.u32 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u32Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u32Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9908,8 +9888,8 @@ export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _140: [rs.u32, rs.u32] = rs.rangeInclusiveIntoInner(r); const start2: rs.u32 = _140[0]; const end2: rs.u32 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(start2, f), (f: rs.Formatter) => rs.u32Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u32Debug(start2, f), (f: rs.Formatter) => rs.u32Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -9977,12 +9957,12 @@ export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const end: rs.u64 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); @@ -10002,8 +9982,8 @@ export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _140: [rs.u64, rs.u64] = rs.rangeInclusiveIntoInner(r); const start2: rs.u64 = _140[0]; const end2: rs.u64 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -10071,12 +10051,12 @@ export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const end: rs.u8 = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -10096,8 +10076,8 @@ export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const _140: [rs.u8, rs.u8] = rs.rangeInclusiveIntoInner(r); const start2: rs.u8 = _140[0]; const end2: rs.u8 = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } @@ -10165,12 +10145,12 @@ export function stepped$usize(table: rs.Slice, at: rs.usize[], out: rs const end: rs.usize = _54[1]; const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -10190,8 +10170,8 @@ export function stepped$usize(table: rs.Slice, at: rs.usize[], out: rs const _140: [rs.usize, rs.usize] = rs.rangeInclusiveIntoInner(r); const start2: rs.usize = _140[0]; const end2: rs.usize = _140[1]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + const args9 = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); } } diff --git a/ts/fixtures/lang/joins/expected/harness.ts b/ts/fixtures/lang/joins/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/joins/expected/harness.ts +++ b/ts/fixtures/lang/joins/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/joins/expected/joins.Sentinel.ts b/ts/fixtures/lang/joins/expected/joins.Sentinel.ts index 2d397f8b7..63ed6c863 100644 --- a/ts/fixtures/lang/joins/expected/joins.Sentinel.ts +++ b/ts/fixtures/lang/joins/expected/joins.Sentinel.ts @@ -9,8 +9,7 @@ export interface Sentinel { export function clone$Clone(self: Sentinel): Sentinel { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - rs.panicFmt(["clone sentinel ", args2[0]]); + rs.panicFmt(["clone sentinel ", (f: rs.Formatter) => rs.u8Display(arg, f)]); } //# sourceMappingURL=joins.Sentinel.ts.map diff --git a/ts/fixtures/lang/joins/expected/joins.ts b/ts/fixtures/lang/joins/expected/joins.ts index 658173157..6279d10b2 100644 --- a/ts/fixtures/lang/joins/expected/joins.ts +++ b/ts/fixtures/lang/joins/expected/joins.ts @@ -256,8 +256,7 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const sep5: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 1 << 16), (i: rs.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; }), undefined, 1, true); - const _597: Sentinel.Sentinel[] = []; - rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(_597), rs.usizeAdd(1 << 16, 1), undefined).items), 1, rs.sliceFrom(sep5.items), undefined, Sentinel.clone$Clone); + rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom([]), rs.usizeAdd(1 << 16, 1), undefined).items), 1, rs.sliceFrom(sep5.items), undefined, Sentinel.clone$Clone); } } } diff --git a/ts/fixtures/lang/keys/expected/core/option.ts b/ts/fixtures/lang/keys/expected/core/option.ts index b28c301ee..bb7b11dce 100644 --- a/ts/fixtures/lang/keys/expected/core/option.ts +++ b/ts/fixtures/lang/keys/expected/core/option.ts @@ -132,6 +132,13 @@ export function mapOr$0g5x999(self: rs.ByteVec | undefined, default_: rs.u8, f: return f(self); } +export function mapOr$0r2ws9g(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$172961h(self: rs.ByteSlice | undefined, default_: Uint8Array, f: (a0: rs.ByteSlice) => Uint8Array): Uint8Array { if (self === undefined) { return default_; @@ -139,6 +146,55 @@ export function mapOr$172961h(self: rs.ByteSlice | undefined, default_: Uint8Arr return f(self); } +export function mapOr$15qsvnl(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0w88gc1(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0qgenra(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0oo8ioj(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0gci25e(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$08ocq2w(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0a6g3kb(self: rs.Slice | undefined, default_: rs.u8, f: (a0: rs.Slice) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1lwzqm5(self: rs.ByteSlice | undefined, default_: rs.u8, f: (a0: rs.ByteSlice) => rs.u8): rs.u8 { if (self === undefined) { return default_; @@ -216,6 +272,62 @@ export function mapOr$1p2t4pe(self: [rs.u64[], rs.u8] | undefined, default_: rs. return f(self); } +export function mapOr$0qu2hwg(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0vyyv4s(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$1ouyteb(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$1rpdnva(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$01nqgi0(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0ikljzh(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0m53wfw(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$1wah0ak(self: [rs.Slice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Slice, rs.u8]) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$09t7mex(self: [rs.ByteSlice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.ByteSlice, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/keys/expected/harness.ts b/ts/fixtures/lang/keys/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/keys/expected/harness.ts +++ b/ts/fixtures/lang/keys/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/keys/expected/keys.Touchy.ts b/ts/fixtures/lang/keys/expected/keys.Touchy.ts index 2ac8359d7..3c3b49e21 100644 --- a/ts/fixtures/lang/keys/expected/keys.Touchy.ts +++ b/ts/fixtures/lang/keys/expected/keys.Touchy.ts @@ -13,14 +13,12 @@ export function hash$Hash_hash_DefaultHasher(self: Touchy, state: rs.Hasher): vo export function eq$cmp_PartialEq(self: Touchy, _2: Touchy): boolean { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - rs.panicFmt(["compared ", args2[0]]); + rs.panicFmt(["compared ", (f: rs.Formatter) => rs.u8Display(arg, f)]); } export function cmp$cmp_Ord(self: Touchy, _2: Touchy): rs.Ordering { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - rs.panicFmt(["ordered ", args2[0]]); + rs.panicFmt(["ordered ", (f: rs.Formatter) => rs.u8Display(arg, f)]); } //# sourceMappingURL=keys.Touchy.ts.map diff --git a/ts/fixtures/lang/keys/expected/keys.ts b/ts/fixtures/lang/keys/expected/keys.ts index 99f668b18..720a57a3f 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { copy$Option_array2_keys_Hop, copy$Option_array2_u8, copy$Option_keys_Hop, copy$array_keys_Hop, copy$array_u8, copy$keys_Hop, copy$keys_Horizon, copy$tuple2_u8_keys_Horizon, drop$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided } from "./lib.ts"; import { thenSome$0rsp0eu, then$1hbi99k, then$0t1jhx5, then$1ghn4qd, then$0wesa0o, then$05rk6io, then$1c9ust9, then$1ko5lpm, then$0zrkb72, then$05y10ww } from "./core/bool.ts"; -import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1n6u2ar as option_map$1n6u2ar, map$174onvc as option_map$174onvc, map$0lcwx9x as option_map$0lcwx9x, map$0bzc4vz as option_map$0bzc4vz, mapOr$18799n0 as option_mapOr$18799n0, mapOr$182mz1d as option_mapOr$182mz1d, mapOr$0ucpmcy as option_mapOr$0ucpmcy, mapOr$0187me0 as option_mapOr$0187me0, mapOr$19cu5pi as option_mapOr$19cu5pi, mapOr$0kbx53k as option_mapOr$0kbx53k, mapOr$13ci3um as option_mapOr$13ci3um, mapOr$07qfnm1 as option_mapOr$07qfnm1, mapOr$0iqhkrm as option_mapOr$0iqhkrm, mapOr$1afu7tt as option_mapOr$1afu7tt, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$172961h as option_mapOr$172961h, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$188iunt as option_mapOr$188iunt, mapOr$0ohpdps as option_mapOr$0ohpdps, mapOr$1rph82m as option_mapOr$1rph82m, mapOr$1ruj5y1 as option_mapOr$1ruj5y1, mapOr$03xawqj as option_mapOr$03xawqj, mapOr$1r07wd5 as option_mapOr$1r07wd5, mapOr$03hkgbr as option_mapOr$03hkgbr, mapOr$0uf63ye as option_mapOr$0uf63ye, mapOr$1p2t4pe as option_mapOr$1p2t4pe, mapOr$09t7mex as option_mapOr$09t7mex } from "./core/option.ts"; +import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1n6u2ar as option_map$1n6u2ar, map$174onvc as option_map$174onvc, map$0lcwx9x as option_map$0lcwx9x, map$0bzc4vz as option_map$0bzc4vz, mapOr$18799n0 as option_mapOr$18799n0, mapOr$182mz1d as option_mapOr$182mz1d, mapOr$0ucpmcy as option_mapOr$0ucpmcy, mapOr$0187me0 as option_mapOr$0187me0, mapOr$19cu5pi as option_mapOr$19cu5pi, mapOr$0kbx53k as option_mapOr$0kbx53k, mapOr$13ci3um as option_mapOr$13ci3um, mapOr$07qfnm1 as option_mapOr$07qfnm1, mapOr$0iqhkrm as option_mapOr$0iqhkrm, mapOr$1afu7tt as option_mapOr$1afu7tt, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$0r2ws9g as option_mapOr$0r2ws9g, mapOr$172961h as option_mapOr$172961h, mapOr$15qsvnl as option_mapOr$15qsvnl, mapOr$0w88gc1 as option_mapOr$0w88gc1, mapOr$0qgenra as option_mapOr$0qgenra, mapOr$0oo8ioj as option_mapOr$0oo8ioj, mapOr$0gci25e as option_mapOr$0gci25e, mapOr$08ocq2w as option_mapOr$08ocq2w, mapOr$0a6g3kb as option_mapOr$0a6g3kb, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$188iunt as option_mapOr$188iunt, mapOr$0ohpdps as option_mapOr$0ohpdps, mapOr$1rph82m as option_mapOr$1rph82m, mapOr$1ruj5y1 as option_mapOr$1ruj5y1, mapOr$03xawqj as option_mapOr$03xawqj, mapOr$1r07wd5 as option_mapOr$1r07wd5, mapOr$03hkgbr as option_mapOr$03hkgbr, mapOr$0uf63ye as option_mapOr$0uf63ye, mapOr$1p2t4pe as option_mapOr$1p2t4pe, mapOr$0qu2hwg as option_mapOr$0qu2hwg, mapOr$0vyyv4s as option_mapOr$0vyyv4s, mapOr$1ouyteb as option_mapOr$1ouyteb, mapOr$1rpdnva as option_mapOr$1rpdnva, mapOr$01nqgi0 as option_mapOr$01nqgi0, mapOr$0ikljzh as option_mapOr$0ikljzh, mapOr$0m53wfw as option_mapOr$0m53wfw, mapOr$1wah0ak as option_mapOr$1wah0ak, mapOr$09t7mex as option_mapOr$09t7mex } from "./core/option.ts"; import * as Dropped from "./keys.Dropped.ts"; import * as Hop from "./keys.Hop.ts"; import * as Horizon from "./keys.Horizon.ts"; @@ -1675,8 +1675,9 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rs.ByteSlice, make: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: Array = make(b); rs.byteVecPush(out, option_mapOr$182mz1d(rs.hashInsert(values, _51, _53), 204, (old: Array): rs.u8 => { - const _6: Array = make(b); - return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.same)(_4, _5) ? 1 : 0; })); const _62: Array = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -1685,9 +1686,9 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rs.ByteSlice, make: const _67: rs.Entry, rs.u8> = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry, rs.u8> = _67; - const _82: Array = rs.entryKey(v); - const _85: Array = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -1709,72 +1710,88 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rs.ByteSlice, make: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$1rph82m(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [Array, rs.u8]): rs.u8 => { - return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$0vyyv4s(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$1rph82m(rs.btreeGetKeyValue(tree, key), 221, (_22: [Array, rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0vyyv4s(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.same)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$182mz1d(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: Array): rs.u8 => { - return rs.eqSlice(rs.same)(k, key) ? 1 : 0; - }), option_mapOr$182mz1d(rs.hashGet(values, b2), 221, (v2: Array): rs.u8 => { - return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$15qsvnl(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(k, _150) ? 1 : 0; + }), option_mapOr$15qsvnl(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: Array } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: Array } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: Array): rs.u8 => { - const order = rs.cmpSlice(rs.cmpOption(rs.cmp))(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmpOption(rs.cmp))(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec> = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice> | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: Array = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmpOption(rs.cmp))(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: Array = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: Array = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmpOption(rs.cmp))(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmpOption(rs.cmp))(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$1rph82m(rs.btreeFirst(tree), 221, (_24: [Array, rs.u8]): rs.u8 => { - const _83: Array | undefined = _24[0]; - const _102: Array | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$0vyyv4s(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$182mz1d(rs.btreeFirstKey(ordered, true), 221, (k3: Array): rs.u8 => { - const _57: Array | undefined = k3; - const _84: Array | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$15qsvnl(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.same))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: Array = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$1rph82m(rs.hashRemoveEntry(map, probe), 238, (_26: [Array, rs.u8]): rs.u8 => { const k4: Array = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.same)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -1782,18 +1799,19 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rs.ByteSlice, make: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$182mz1d(rs.btreePopKey(ordered), 221, (k5: Array): rs.u8 => { - return rs.cmpSlice(rs.cmpOption(rs.cmp))(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmpOption(rs.cmp))(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: Array, v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmpOption(rs.cmp))(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmpOption(rs.cmp))(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -1822,23 +1840,25 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rs.ByteSlice, make: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[Array, rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[Array, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmpOption(rs.cmp)), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [Array, rs.u8]): rs.u8 => { - const k7: Array = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmpOption(rs.cmp)), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet> = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet> = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: Array): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmpOption(rs.cmp))(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmpOption(rs.cmp))(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, Array], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, Array], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmpOption(rs.cmp))])) as rs.BTreeMap<[rs.u8, Array], rs.u8>; @@ -1874,7 +1894,8 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rs.ByteSlice, make: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: Array = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: Array | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -1930,8 +1951,9 @@ export function keyed$bool_2_keys_arrays_closure4(data: rs.ByteSlice, make: (a0: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: boolean[] = make(b); rs.byteVecPush(out, option_mapOr$0ucpmcy(rs.hashInsert(values, _51, _53), 204, (old: boolean[]): rs.u8 => { - const _6: boolean[] = make(b); - return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.same)(_4, _5) ? 1 : 0; })); const _62: boolean[] = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -1940,9 +1962,9 @@ export function keyed$bool_2_keys_arrays_closure4(data: rs.ByteSlice, make: (a0: const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: boolean[] = rs.entryKey(v); - const _85: boolean[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -1964,72 +1986,88 @@ export function keyed$bool_2_keys_arrays_closure4(data: rs.ByteSlice, make: (a0: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$1ruj5y1(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [boolean[], rs.u8]): rs.u8 => { - return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$1ouyteb(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$1ruj5y1(rs.btreeGetKeyValue(tree, key), 221, (_22: [boolean[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$1ouyteb(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.same)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0ucpmcy(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: boolean[]): rs.u8 => { - return rs.eqSlice(rs.same)(k, key) ? 1 : 0; - }), option_mapOr$0ucpmcy(rs.hashGet(values, b2), 221, (v2: boolean[]): rs.u8 => { - return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0w88gc1(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(k, _150) ? 1 : 0; + }), option_mapOr$0w88gc1(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: boolean[] } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: boolean[] } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: boolean[]): rs.u8 => { - const order = rs.cmpSlice(rs.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: boolean[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: boolean[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: boolean[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$1ruj5y1(rs.btreeFirst(tree), 221, (_24: [boolean[], rs.u8]): rs.u8 => { - const _83: boolean[] | undefined = _24[0]; - const _102: boolean[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$1ouyteb(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$0ucpmcy(rs.btreeFirstKey(ordered, true), 221, (k3: boolean[]): rs.u8 => { - const _57: boolean[] | undefined = k3; - const _84: boolean[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0w88gc1(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.same))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: boolean[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$1ruj5y1(rs.hashRemoveEntry(map, probe), 238, (_26: [boolean[], rs.u8]): rs.u8 => { const k4: boolean[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.same)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -2037,18 +2075,19 @@ export function keyed$bool_2_keys_arrays_closure4(data: rs.ByteSlice, make: (a0: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$0ucpmcy(rs.btreePopKey(ordered), 221, (k5: boolean[]): rs.u8 => { - return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmp)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: boolean[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmp)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmp)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -2077,23 +2116,25 @@ export function keyed$bool_2_keys_arrays_closure4(data: rs.ByteSlice, make: (a0: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[boolean[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[boolean[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [boolean[], rs.u8]): rs.u8 => { - const k7: boolean[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: boolean[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmp)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmp)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, boolean[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, boolean[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, boolean[]], rs.u8>; @@ -2129,7 +2170,8 @@ export function keyed$bool_2_keys_arrays_closure4(data: rs.ByteSlice, make: (a0: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: boolean[] = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: boolean[] | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -2185,8 +2227,9 @@ export function keyed$char_2_keys_arrays_closure3(data: rs.ByteSlice, make: (a0: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: rs.char[] = make(b); rs.byteVecPush(out, option_mapOr$0187me0(rs.hashInsert(values, _51, _53), 204, (old: rs.char[]): rs.u8 => { - const _6: rs.char[] = make(b); - return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.same)(_4, _5) ? 1 : 0; })); const _62: rs.char[] = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -2195,9 +2238,9 @@ export function keyed$char_2_keys_arrays_closure3(data: rs.ByteSlice, make: (a0: const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: rs.char[] = rs.entryKey(v); - const _85: rs.char[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -2219,72 +2262,88 @@ export function keyed$char_2_keys_arrays_closure3(data: rs.ByteSlice, make: (a0: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$03xawqj(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [rs.char[], rs.u8]): rs.u8 => { - return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$1rpdnva(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$03xawqj(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.char[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$1rpdnva(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.same)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0187me0(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: rs.char[]): rs.u8 => { - return rs.eqSlice(rs.same)(k, key) ? 1 : 0; - }), option_mapOr$0187me0(rs.hashGet(values, b2), 221, (v2: rs.char[]): rs.u8 => { - return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0qgenra(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(k, _150) ? 1 : 0; + }), option_mapOr$0qgenra(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: rs.char[] } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: rs.char[] } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.char[]): rs.u8 => { - const order = rs.cmpSlice(rs.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: rs.char[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: rs.char[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: rs.char[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$03xawqj(rs.btreeFirst(tree), 221, (_24: [rs.char[], rs.u8]): rs.u8 => { - const _83: rs.char[] | undefined = _24[0]; - const _102: rs.char[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$1rpdnva(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$0187me0(rs.btreeFirstKey(ordered, true), 221, (k3: rs.char[]): rs.u8 => { - const _57: rs.char[] | undefined = k3; - const _84: rs.char[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0qgenra(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.same))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: rs.char[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$03xawqj(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.char[], rs.u8]): rs.u8 => { const k4: rs.char[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.same)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -2292,18 +2351,19 @@ export function keyed$char_2_keys_arrays_closure3(data: rs.ByteSlice, make: (a0: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$0187me0(rs.btreePopKey(ordered), 221, (k5: rs.char[]): rs.u8 => { - return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmp)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: rs.char[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmp)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmp)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -2332,23 +2392,25 @@ export function keyed$char_2_keys_arrays_closure3(data: rs.ByteSlice, make: (a0: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[rs.char[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.char[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.char[], rs.u8]): rs.u8 => { - const k7: rs.char[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.char[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmp)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmp)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, rs.char[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.char[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.char[]], rs.u8>; @@ -2384,7 +2446,8 @@ export function keyed$char_2_keys_arrays_closure3(data: rs.ByteSlice, make: (a0: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: rs.char[] = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: rs.char[] | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -2440,8 +2503,9 @@ export function keyed$i32_2_keys_arrays_closure2(data: rs.ByteSlice, make: (a0: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: rs.i32[] = make(b); rs.byteVecPush(out, option_mapOr$19cu5pi(rs.hashInsert(values, _51, _53), 204, (old: rs.i32[]): rs.u8 => { - const _6: rs.i32[] = make(b); - return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.same)(_4, _5) ? 1 : 0; })); const _62: rs.i32[] = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -2450,9 +2514,9 @@ export function keyed$i32_2_keys_arrays_closure2(data: rs.ByteSlice, make: (a0: const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: rs.i32[] = rs.entryKey(v); - const _85: rs.i32[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -2474,72 +2538,88 @@ export function keyed$i32_2_keys_arrays_closure2(data: rs.ByteSlice, make: (a0: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$1r07wd5(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [rs.i32[], rs.u8]): rs.u8 => { - return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$01nqgi0(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$1r07wd5(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.i32[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$01nqgi0(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.same)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$19cu5pi(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: rs.i32[]): rs.u8 => { - return rs.eqSlice(rs.same)(k, key) ? 1 : 0; - }), option_mapOr$19cu5pi(rs.hashGet(values, b2), 221, (v2: rs.i32[]): rs.u8 => { - return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0oo8ioj(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(k, _150) ? 1 : 0; + }), option_mapOr$0oo8ioj(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: rs.i32[] } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: rs.i32[] } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.i32[]): rs.u8 => { - const order = rs.cmpSlice(rs.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: rs.i32[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: rs.i32[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: rs.i32[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$1r07wd5(rs.btreeFirst(tree), 221, (_24: [rs.i32[], rs.u8]): rs.u8 => { - const _83: rs.i32[] | undefined = _24[0]; - const _102: rs.i32[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$01nqgi0(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$19cu5pi(rs.btreeFirstKey(ordered, true), 221, (k3: rs.i32[]): rs.u8 => { - const _57: rs.i32[] | undefined = k3; - const _84: rs.i32[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0oo8ioj(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.same))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: rs.i32[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$1r07wd5(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.i32[], rs.u8]): rs.u8 => { const k4: rs.i32[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.same)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -2547,18 +2627,19 @@ export function keyed$i32_2_keys_arrays_closure2(data: rs.ByteSlice, make: (a0: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$19cu5pi(rs.btreePopKey(ordered), 221, (k5: rs.i32[]): rs.u8 => { - return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmp)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: rs.i32[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmp)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmp)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -2587,23 +2668,25 @@ export function keyed$i32_2_keys_arrays_closure2(data: rs.ByteSlice, make: (a0: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[rs.i32[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.i32[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.i32[], rs.u8]): rs.u8 => { - const k7: rs.i32[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.i32[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmp)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmp)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, rs.i32[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.i32[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.i32[]], rs.u8>; @@ -2639,7 +2722,8 @@ export function keyed$i32_2_keys_arrays_closure2(data: rs.ByteSlice, make: (a0: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: rs.i32[] = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: rs.i32[] | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -2695,8 +2779,9 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rs.ByteSlice, make: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: Hop.Hop[] = copy$array_keys_Hop(make(b)); rs.byteVecPush(out, option_mapOr$0kbx53k(rs.hashInsert(values, _51, _53), 204, (old: Hop.Hop[]): rs.u8 => { - const _6: Hop.Hop[] = make(b); - return rs.eqSlice(Hop.eq$cmp_PartialEq)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(Hop.eq$cmp_PartialEq)(_4, _5) ? 1 : 0; })); const _62: Hop.Hop[] = copy$array_keys_Hop(make(rs.u8Div(b, 2))); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -2705,9 +2790,9 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rs.ByteSlice, make: const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: Hop.Hop[] = rs.entryKey(v); - const _85: Hop.Hop[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(Hop.eq$cmp_PartialEq)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(Hop.eq$cmp_PartialEq)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -2729,72 +2814,88 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rs.ByteSlice, make: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$03hkgbr(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [Hop.Hop[], rs.u8]): rs.u8 => { - return rs.eqSlice(Hop.eq$cmp_PartialEq)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$0ikljzh(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(Hop.eq$cmp_PartialEq)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$03hkgbr(rs.btreeGetKeyValue(tree, key), 221, (_22: [Hop.Hop[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(Hop.eq$cmp_PartialEq)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0ikljzh(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(Hop.eq$cmp_PartialEq)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0kbx53k(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: Hop.Hop[]): rs.u8 => { - return rs.eqSlice(Hop.eq$cmp_PartialEq)(k, key) ? 1 : 0; - }), option_mapOr$0kbx53k(rs.hashGet(values, b2), 221, (v2: Hop.Hop[]): rs.u8 => { - return rs.eqSlice(Hop.eq$cmp_PartialEq)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0gci25e(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(Hop.eq$cmp_PartialEq)(k, _150) ? 1 : 0; + }), option_mapOr$0gci25e(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(Hop.eq$cmp_PartialEq)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: Hop.Hop[] } = { end: copy$array_keys_Hop(copy$array_keys_Hop(key)) }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); + const _162: { end: Hop.Hop[] } = { end: copy$array_keys_Hop(rs.sliceToArray(rs.sliceFrom(key), copy$keys_Hop)) }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd))), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key), rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd))), (k2: Hop.Hop[]): rs.u8 => { - const order = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd))), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key)), rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd))), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: Hop.Hop[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: Hop.Hop[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: Hop.Hop[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(Hop.cmp$cmp_Ord)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(Hop.cmp$cmp_Ord)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$03hkgbr(rs.btreeFirst(tree), 221, (_24: [Hop.Hop[], rs.u8]): rs.u8 => { - const _83: Hop.Hop[] | undefined = _24[0]; - const _102: Hop.Hop[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$0ikljzh(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(Hop.eq$cmp_PartialEq))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$0kbx53k(rs.btreeFirstKey(ordered, true), 221, (k3: Hop.Hop[]): rs.u8 => { - const _57: Hop.Hop[] | undefined = k3; - const _84: Hop.Hop[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(Hop.eq$cmp_PartialEq))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0gci25e(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(Hop.eq$cmp_PartialEq))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: Hop.Hop[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$03hkgbr(rs.hashRemoveEntry(map, probe), 238, (_26: [Hop.Hop[], rs.u8]): rs.u8 => { const k4: Hop.Hop[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(Hop.eq$cmp_PartialEq)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(Hop.eq$cmp_PartialEq)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -2802,18 +2903,19 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rs.ByteSlice, make: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$0kbx53k(rs.btreePopKey(ordered), 221, (k5: Hop.Hop[]): rs.u8 => { - return rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: Hop.Hop[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -2842,23 +2944,25 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rs.ByteSlice, make: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[Hop.Hop[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[Hop.Hop[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [Hop.Hop[], rs.u8]): rs.u8 => { - const k7: Hop.Hop[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, copy$array_keys_Hop, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: Hop.Hop[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, Hop.Hop[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, Hop.Hop[]], rs.Ordering>([rs.cmp, rs.cmpSlice(Hop.cmp$cmp_Ord)])) as rs.BTreeMap<[rs.u8, Hop.Hop[]], rs.u8>; @@ -2894,7 +2998,7 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rs.ByteSlice, make: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: Hop.Hop[] = make(_513); - const _526: Hop.Hop[] | undefined = copy$array_keys_Hop(key2); + const _526: Hop.Hop[] | undefined = rs.sliceToArray(rs.sliceFrom(key2), copy$keys_Hop); const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); @@ -2951,8 +3055,9 @@ export function keyed$u16_2_keys_arrays_closure0(data: rs.ByteSlice, make: (a0: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: rs.u16[] = make(b); rs.byteVecPush(out, option_mapOr$13ci3um(rs.hashInsert(values, _51, _53), 204, (old: rs.u16[]): rs.u8 => { - const _6: rs.u16[] = make(b); - return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.same)(_4, _5) ? 1 : 0; })); const _62: rs.u16[] = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -2961,9 +3066,9 @@ export function keyed$u16_2_keys_arrays_closure0(data: rs.ByteSlice, make: (a0: const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: rs.u16[] = rs.entryKey(v); - const _85: rs.u16[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -2985,72 +3090,88 @@ export function keyed$u16_2_keys_arrays_closure0(data: rs.ByteSlice, make: (a0: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$0uf63ye(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [rs.u16[], rs.u8]): rs.u8 => { - return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$0m53wfw(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$0uf63ye(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u16[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0m53wfw(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.same)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$13ci3um(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: rs.u16[]): rs.u8 => { - return rs.eqSlice(rs.same)(k, key) ? 1 : 0; - }), option_mapOr$13ci3um(rs.hashGet(values, b2), 221, (v2: rs.u16[]): rs.u8 => { - return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$08ocq2w(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(k, _150) ? 1 : 0; + }), option_mapOr$08ocq2w(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: rs.u16[] } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: rs.u16[] } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u16[]): rs.u8 => { - const order = rs.cmpSlice(rs.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: rs.u16[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: rs.u16[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: rs.u16[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$0uf63ye(rs.btreeFirst(tree), 221, (_24: [rs.u16[], rs.u8]): rs.u8 => { - const _83: rs.u16[] | undefined = _24[0]; - const _102: rs.u16[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$0m53wfw(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$13ci3um(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u16[]): rs.u8 => { - const _57: rs.u16[] | undefined = k3; - const _84: rs.u16[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$08ocq2w(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.same))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: rs.u16[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$0uf63ye(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u16[], rs.u8]): rs.u8 => { const k4: rs.u16[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.same)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -3058,18 +3179,19 @@ export function keyed$u16_2_keys_arrays_closure0(data: rs.ByteSlice, make: (a0: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$13ci3um(rs.btreePopKey(ordered), 221, (k5: rs.u16[]): rs.u8 => { - return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmp)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: rs.u16[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmp)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmp)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -3098,23 +3220,25 @@ export function keyed$u16_2_keys_arrays_closure0(data: rs.ByteSlice, make: (a0: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[rs.u16[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.u16[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u16[], rs.u8]): rs.u8 => { - const k7: rs.u16[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u16[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmp)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmp)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, rs.u16[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u16[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u16[]], rs.u8>; @@ -3150,7 +3274,8 @@ export function keyed$u16_2_keys_arrays_closure0(data: rs.ByteSlice, make: (a0: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: rs.u16[] = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: rs.u16[] | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -3206,8 +3331,9 @@ export function keyed$u32_0_keys_arrays_closure7(data: rs.ByteSlice, make: (a0: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: rs.u32[] = make(b); rs.byteVecPush(out, option_mapOr$18799n0(rs.hashInsert(values, _51, _53), 204, (old: rs.u32[]): rs.u8 => { - const _6: rs.u32[] = make(b); - return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.same)(_4, _5) ? 1 : 0; })); const _62: rs.u32[] = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -3216,9 +3342,9 @@ export function keyed$u32_0_keys_arrays_closure7(data: rs.ByteSlice, make: (a0: const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: rs.u32[] = rs.entryKey(v); - const _85: rs.u32[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -3240,72 +3366,88 @@ export function keyed$u32_0_keys_arrays_closure7(data: rs.ByteSlice, make: (a0: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$0ohpdps(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [rs.u32[], rs.u8]): rs.u8 => { - return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$0qu2hwg(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$0ohpdps(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u32[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0qu2hwg(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.same)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$18799n0(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: rs.u32[]): rs.u8 => { - return rs.eqSlice(rs.same)(k, key) ? 1 : 0; - }), option_mapOr$18799n0(rs.hashGet(values, b2), 221, (v2: rs.u32[]): rs.u8 => { - return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0r2ws9g(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(k, _150) ? 1 : 0; + }), option_mapOr$0r2ws9g(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: rs.u32[] } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: rs.u32[] } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u32[]): rs.u8 => { - const order = rs.cmpSlice(rs.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: rs.u32[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: rs.u32[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: rs.u32[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$0ohpdps(rs.btreeFirst(tree), 221, (_24: [rs.u32[], rs.u8]): rs.u8 => { - const _83: rs.u32[] | undefined = _24[0]; - const _102: rs.u32[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$0qu2hwg(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$18799n0(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u32[]): rs.u8 => { - const _57: rs.u32[] | undefined = k3; - const _84: rs.u32[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0r2ws9g(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.same))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: rs.u32[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$0ohpdps(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u32[], rs.u8]): rs.u8 => { const k4: rs.u32[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.same)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -3313,18 +3455,19 @@ export function keyed$u32_0_keys_arrays_closure7(data: rs.ByteSlice, make: (a0: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$18799n0(rs.btreePopKey(ordered), 221, (k5: rs.u32[]): rs.u8 => { - return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmp)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: rs.u32[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmp)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmp)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -3353,23 +3496,25 @@ export function keyed$u32_0_keys_arrays_closure7(data: rs.ByteSlice, make: (a0: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.u32[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u32[], rs.u8]): rs.u8 => { - const k7: rs.u32[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u32[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmp)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmp)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8>; @@ -3405,7 +3550,8 @@ export function keyed$u32_0_keys_arrays_closure7(data: rs.ByteSlice, make: (a0: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: rs.u32[] = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: rs.u32[] | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -3461,8 +3607,9 @@ export function keyed$u32_275_keys_arrays_closure8(data: rs.ByteSlice, make: (a0 const _51: rs.u8 = rs.u8Rem(b, 4); const _53: rs.u32[] = make(b); rs.byteVecPush(out, option_mapOr$18799n0(rs.hashInsert(values, _51, _53), 204, (old: rs.u32[]): rs.u8 => { - const _6: rs.u32[] = make(b); - return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.same)(_4, _5) ? 1 : 0; })); const _62: rs.u32[] = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -3471,9 +3618,9 @@ export function keyed$u32_275_keys_arrays_closure8(data: rs.ByteSlice, make: (a0 const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: rs.u32[] = rs.entryKey(v); - const _85: rs.u32[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -3495,72 +3642,88 @@ export function keyed$u32_275_keys_arrays_closure8(data: rs.ByteSlice, make: (a0 const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$0ohpdps(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [rs.u32[], rs.u8]): rs.u8 => { - return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$0qu2hwg(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$0ohpdps(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u32[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0qu2hwg(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.same)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$18799n0(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: rs.u32[]): rs.u8 => { - return rs.eqSlice(rs.same)(k, key) ? 1 : 0; - }), option_mapOr$18799n0(rs.hashGet(values, b2), 221, (v2: rs.u32[]): rs.u8 => { - return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0r2ws9g(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(k, _150) ? 1 : 0; + }), option_mapOr$0r2ws9g(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.same)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: rs.u32[] } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: rs.u32[] } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u32[]): rs.u8 => { - const order = rs.cmpSlice(rs.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: rs.u32[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: rs.u32[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: rs.u32[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$0ohpdps(rs.btreeFirst(tree), 221, (_24: [rs.u32[], rs.u8]): rs.u8 => { - const _83: rs.u32[] | undefined = _24[0]; - const _102: rs.u32[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$0qu2hwg(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$18799n0(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u32[]): rs.u8 => { - const _57: rs.u32[] | undefined = k3; - const _84: rs.u32[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0r2ws9g(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.same))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: rs.u32[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$0ohpdps(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u32[], rs.u8]): rs.u8 => { const k4: rs.u32[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.same)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -3568,18 +3731,19 @@ export function keyed$u32_275_keys_arrays_closure8(data: rs.ByteSlice, make: (a0 const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$18799n0(rs.btreePopKey(ordered), 221, (k5: rs.u32[]): rs.u8 => { - return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmp)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: rs.u32[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmp)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmp)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -3608,23 +3772,25 @@ export function keyed$u32_275_keys_arrays_closure8(data: rs.ByteSlice, make: (a0 _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.u32[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u32[], rs.u8]): rs.u8 => { - const k7: rs.u32[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u32[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmp)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmp)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8>; @@ -3660,7 +3826,8 @@ export function keyed$u32_275_keys_arrays_closure8(data: rs.ByteSlice, make: (a0 const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: rs.u32[] = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: rs.u32[] | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -3716,8 +3883,9 @@ export function keyed$u64_2_keys_arrays_closure1(data: rs.ByteSlice, make: (a0: const _51: rs.u8 = rs.u8Rem(b, 4); const _53: rs.u64[] = make(b); rs.byteVecPush(out, option_mapOr$07qfnm1(rs.hashInsert(values, _51, _53), 204, (old: rs.u64[]): rs.u8 => { - const _6: rs.u64[] = make(b); - return rs.eqSlice(rs.u64Eq)(old, _6) ? 1 : 0; + const _4: rs.Slice = rs.sliceFrom(old); + const _5: rs.Slice = rs.sliceFrom(make(b)); + return rs.eqSlice(rs.u64Eq)(_4, _5) ? 1 : 0; })); const _62: rs.u64[] = make(rs.u8Div(b, 2)); const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); @@ -3726,9 +3894,9 @@ export function keyed$u64_2_keys_arrays_closure1(data: rs.ByteSlice, make: (a0: const _67: rs.Entry = rs.entry(tree, _69); if (!rs.entryOccupied(_67)) { const v: rs.Entry = _67; - const _82: rs.u64[] = rs.entryKey(v); - const _85: rs.u64[] = make(rs.u8Div(b, 2)); - rs.byteVecPush(out, rs.eqSlice(rs.u64Eq)(_82, _85) ? 1 : 0); + const _82: rs.Slice = rs.sliceFrom(rs.entryKey(v)); + const _84: rs.Slice = rs.sliceFrom(make(rs.u8Div(b, 2))); + rs.byteVecPush(out, rs.eqSlice(rs.u64Eq)(_82, _84) ? 1 : 0); rs.entryOrInsertMut(v, i2); } else { const _76: rs.Place = rs.entryGetMut(_67); @@ -3750,72 +3918,88 @@ export function keyed$u64_2_keys_arrays_closure1(data: rs.ByteSlice, make: (a0: const _129: rs.Slice = rs.sliceFrom(key); const _126: rs.u8 = rs.btreeContains(ordered, rs.sliceItems(_129)) ? 1 : 0; const _134: rs.Slice = rs.sliceFrom(key); - const _131: rs.u8 = option_mapOr$1p2t4pe(rs.hashGetKeyValue(map, rs.sliceItems(_134)), 221, (_2: [rs.u64[], rs.u8]): rs.u8 => { - return rs.eqSlice(rs.u64Eq)(_2[0], key) ? 1 : 0; + const _137: rs.Slice = rs.sliceFrom(key); + const _143: rs.Slice = rs.sliceFrom(key); + const _131: rs.u8 = option_mapOr$1wah0ak(rs.optionMap(rs.hashGetKeyValue(map, rs.sliceItems(_134)), (held2): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held2[0]), held2[1]]; + }), 221, (_2: [rs.Slice, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.u64Eq)(_2[0], _137) ? 1 : 0; }); - const _138: rs.u8 = option_mapOr$1p2t4pe(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u64[], rs.u8]): rs.u8 => { - const _5: rs.Slice = rs.sliceFrom(_22[0]); - const _63: rs.Slice = rs.sliceFrom(key); - return rs.eqSlice(rs.u64Eq)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$1wah0ak(rs.optionMap(rs.btreeGetKeyValue(tree, key), (held3): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held3[0]), held3[1]]; + }), 221, (_22: [rs.Slice, rs.u8]): rs.u8 => { + const _54: rs.Slice = _22[0]; + return rs.eqSlice(rs.u64Eq)(_54, _143) ? 1 : 0; }); const _147: rs.Slice = rs.sliceFrom(key); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$07qfnm1(rs.hashKey(set, rs.sliceItems(_147)), 221, (k: rs.u64[]): rs.u8 => { - return rs.eqSlice(rs.u64Eq)(k, key) ? 1 : 0; - }), option_mapOr$07qfnm1(rs.hashGet(values, b2), 221, (v2: rs.u64[]): rs.u8 => { - return rs.eqSlice(rs.u64Eq)(v2, key) ? 1 : 0; + const _150: rs.Slice = rs.sliceFrom(key); + const _156: rs.Slice = rs.sliceFrom(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0a6g3kb(rs.optionMap(rs.hashKey(set, rs.sliceItems(_147)), rs.sliceFrom), 221, (k: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.u64Eq)(k, _150) ? 1 : 0; + }), option_mapOr$0a6g3kb(rs.optionMap(rs.hashGet(values, b2), rs.sliceFrom), 221, (v2: rs.Slice): rs.u8 => { + return rs.eqSlice(rs.u64Eq)(v2, _156) ? 1 : 0; }))), undefined, true); - const _162: { end: rs.u64[] } = { end: key }; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _162: { end: rs.u64[] } = { end: key.slice() }; + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _162), (held4): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held4[0]), held4[1]]; + })) & 0xff); const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceFrom(key) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u64[]): rs.u8 => { - const order = rs.cmpSlice(rs.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRange(tree, _170), (held5): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held5[0]), held5[1]]; + })) & 0xff); + const _183: rs.Slice = rs.sliceFrom(key); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterLend(rs.btreeRangeKeys(ordered, new rs.RangeFrom(rs.sliceFrom(key))), rs.sliceFrom), (k2: rs.Slice): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, _183); return order !== undefined && order >= 0 ? 1 : 0; }), rs.u8Add, 0)); const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceFrom(key) } as rs.RangeBound>]; - rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeRangeKeys(ordered, _189), rs.sliceFrom)) & 0xff); } rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); - const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); - const iter3: rs.Iter> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); + const keys: rs.Vec> = rs.iterToVec(rs.iterLend(rs.btreeKeys(ordered), rs.sliceFrom), undefined, 4, true); + const iter3: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(keys.items), 2); while (true) { - const _206: rs.Slice | rs.Done = iter3.next(); + const _206: rs.Slice> | rs.Done = iter3.next(); if (_206 === rs.DONE) { break; } rs.idx(_206, 0); rs.idx(_206, 1); - const _594: rs.u64[] = _206.data[_206.start + 1]; + const _594: rs.Slice = _206.data[_206.start + 1]; const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206.data[_206.start], _594) === -1 ? 1 : 0; rs.idx(_206, 0); - const _595: rs.u64[] = _206.data[_206.start]; + const _595: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _596: rs.u64[] = _206.data[_206.start + 1]; + const _596: rs.Slice = _206.data[_206.start + 1]; const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); rs.idx(_206, 0); - const _236: rs.Slice = rs.sliceFrom(_206.data[_206.start]); + const _236: rs.Slice = _206.data[_206.start]; rs.idx(_206, 1); - const _240: rs.Slice = rs.sliceFrom(_206.data[_206.start + 1]); + const _240: rs.Slice = _206.data[_206.start + 1]; rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); } - rs.byteVecPush(out, option_mapOr$1p2t4pe(rs.btreeFirst(tree), 221, (_24: [rs.u64[], rs.u8]): rs.u8 => { - const _83: rs.u64[] | undefined = _24[0]; - const _102: rs.u64[] | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); + rs.byteVecPush(out, option_mapOr$1wah0ak(rs.optionMap(rs.btreeFirst(tree), (held6): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held6[0]), held6[1]]; + }), 221, (_24: [rs.Slice, rs.u8]): rs.u8 => { + const _83: rs.Slice | undefined = _24[0]; + const _102: rs.Slice | undefined = rs.sliceFirst(rs.sliceFrom(keys.items)); return (rs.eqOption(rs.eqSlice(rs.u64Eq))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rs.byteVecPush(out, option_mapOr$07qfnm1(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u64[]): rs.u8 => { - const _57: rs.u64[] | undefined = k3; - const _84: rs.u64[] | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); - return rs.eqOption(rs.eqSlice(rs.u64Eq))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0a6g3kb(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.sliceFrom), 221, (k3: rs.Slice): rs.u8 => { + const _58: rs.Slice | undefined = k3; + const _86: rs.Slice | undefined = rs.sliceLast(rs.sliceFrom(keys.items)); + return rs.eqOption(rs.eqSlice(rs.u64Eq))(_58, _86) ? 1 : 0; })); const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: rs.u64[] = make(part10); const _268: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, rs.sliceItems(_268)), 238)); + const _276: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$1p2t4pe(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u64[], rs.u8]): rs.u8 => { const k4: rs.u64[] = _26[0]; const v3: rs.u8 = _26[1]; - return (rs.eqSlice(rs.u64Eq)(k4, probe) ? 1 : 0) ^ v3; + const _74: rs.Slice = rs.sliceFrom(k4); + return (rs.eqSlice(rs.u64Eq)(_74, _276) ? 1 : 0) ^ v3; })); const _281: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, rs.sliceItems(_281)), 238)); @@ -3823,18 +4007,19 @@ export function keyed$u64_2_keys_arrays_closure1(data: rs.ByteSlice, make: (a0: const _285: rs.u8 = rs.hashDelete(set, rs.sliceItems(_288)) ? 1 : 0; const _293: rs.Slice = rs.sliceFrom(probe); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, rs.sliceItems(_293)) ? 1 : 0)), undefined, true); + const _300: rs.Slice = rs.sliceFrom(probe); rs.byteVecPush(out, option_mapOr$07qfnm1(rs.btreePopKey(ordered), 221, (k5: rs.u64[]): rs.u8 => { - return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; + return rs.cmpSlice(rs.cmp)(rs.sliceFrom(k5), _300) === -1 ? 1 : 0; })); - rs.btreeRetainMut(tree, (k6: rs.u64[], v4: rs.Place): boolean => { - const _512: rs.Slice = rs.sliceFrom(k6); - const _611: rs.Slice = rs.sliceFrom(probe); - const order2 = rs.cmpSlice(rs.cmp)(_512, _611); + const _304: rs.Slice = rs.sliceFrom(probe); + const _303: (a0: rs.Slice, a1: rs.Place) => boolean = (k6: rs.Slice, v4: rs.Place): boolean => { + const order2 = rs.cmpSlice(rs.cmp)(k6, _304); if (!(order2 !== undefined && order2 >= 0)) { return rs.u8Rem(v4.v, 2) === 0; } return true; - }); + }; + rs.btreeRetainMut(tree, (held7, held8) => _303(rs.sliceFrom(held7), held8)); rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); rs.byteSliceView(rs.byteVecSlice(held)).sort(); @@ -3863,23 +4048,25 @@ export function keyed$u64_2_keys_arrays_closure1(data: rs.ByteSlice, make: (a0: _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rs.Vec<[rs.u64[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); - rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.u64[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u64[], rs.u8]): rs.u8 => { - const k7: rs.u64[] = _210[0]; + const lent: rs.Vec<[rs.Slice, rs.u8]> = rs.iterToVec(rs.iterLend(rs.hashIter(counts), (held9): [rs.Slice, rs.u8] => { + return [rs.sliceFrom(held9[0]), held9[1]]; + }), "next", 8); + rs.sliceSort(rs.sliceFrom(lent.items), rs.cmpLt(rs.cmpTuple<[rs.Slice, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.Slice, rs.u8]): rs.u8 => { + const k7: rs.Slice = _210[0]; const v5: rs.u8 = _210[1]; - return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + return (((rs.btreeContains(made, rs.sliceItems(k7)) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterLend(rs.btreeIntersection(made, ordered), rs.sliceFrom)) & 0xff); rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); const _405: rs.Slice = rs.sliceFrom(probe); const lower: rs.BTreeSet = rs.btreeSplitOff(upper, rs.sliceItems(_405)); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); - rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u64[]): boolean => { - const _315: rs.Slice = rs.sliceFrom(k8); - const _411: rs.Slice = rs.sliceFrom(probe); - const order3 = rs.cmpSlice(rs.cmp)(_315, _411); + const _419: rs.Iter> = rs.iterLend(rs.btreeKeys(lower), rs.sliceFrom); + const _422: rs.Slice = rs.sliceFrom(probe); + rs.byteVecPush(out, rs.iterAll(_419, (k8: rs.Slice): boolean => { + const order3 = rs.cmpSlice(rs.cmp)(k8, _422); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); const pairs: rs.BTreeMap<[rs.u8, rs.u64[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u64[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u64[]], rs.u8>; @@ -3915,7 +4102,8 @@ export function keyed$u64_2_keys_arrays_closure1(data: rs.ByteSlice, make: (a0: const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: rs.u64[] = make(_513); - const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _526: rs.u64[] | undefined = key2.slice(); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; const _533: rs.Slice = rs.sliceFrom(key2); const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (rs.sliceItems(_533) as unknown) as rs.Vec), 221); const _538: rs.Slice = rs.sliceFrom(key2); @@ -3965,28 +4153,28 @@ export function byteRefs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: rs.ByteSlice) => Uint8Array, out: rs.ByteVec): void { const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), make), undefined, 0, true); const vec: rs.Vec = new rs.Vec(); - rs.iterExtend(vec, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 0, true); + rs.iterExtend(vec, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (held) => rs.byteSliceToArray(held)), undefined, 0, true); const deque: rs.VecDeque = rs.dequeNew(0) as rs.VecDeque; const _14: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); - rs.dequeExtend(deque, rs.iterMap(_14, rs.byteSliceToArray), undefined, true); + rs.dequeExtend(deque, rs.iterMap(_14, (held2) => rs.byteSliceToArray(held2)), undefined, true); const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; - rs.heapExtend(heap, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes), undefined, 0, true); + rs.heapExtend(heap, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (held3) => rs.byteSliceToArray(held3)), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes), undefined, 0, true); const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet; - rs.hashExtendKeys(set, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, undefined, 536870911); + rs.hashExtendKeys(set, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (held4) => rs.byteSliceToArray(held4)), undefined, undefined, 536870911); const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; const _28: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); - rs.btreeExtendKeys(ordered, rs.iterMap(_28, rs.byteSliceToArray)); + rs.btreeExtendKeys(ordered, rs.iterMap(_28, (held5) => rs.byteSliceToArray(held5))); const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; const _34: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p: rs.ByteSlice): [rs.ByteSlice, rs.ByteSlice] => { return [p, p] as [rs.ByteSlice, rs.ByteSlice]; }); - rs.hashExtend(map, rs.iterMap(_34, (held): [Uint8Array, Uint8Array] => { - return [rs.byteSliceToArray(held[0]), rs.byteSliceToArray(held[1])]; + rs.hashExtend(map, rs.iterMap(_34, (held6): [Uint8Array, Uint8Array] => { + return [((held7) => rs.byteSliceToArray(held7))(held6[0]), ((held8) => rs.byteSliceToArray(held8))(held6[1])]; }), undefined, undefined, undefined, 536870911); const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; const _41: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), [false, false]); - rs.btreeExtend(tree, rs.iterMap(_41, (held2): [Uint8Array, Uint8Array] => { - return [rs.byteSliceToArray(held2[0]), rs.byteSliceToArray(held2[1])]; + rs.btreeExtend(tree, rs.iterMap(_41, (held9): [Uint8Array, Uint8Array] => { + return [((held10) => rs.byteSliceToArray(held10))(held9[0]), ((held11) => rs.byteSliceToArray(held11))(held9[1])]; })); const iter: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); while (true) { @@ -4051,8 +4239,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r rs.sliceSort(rs.sliceFrom(members.items), rs.cmpLt(rs.cmpBytes), 0, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(members.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.btreeKeys(ordered), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); - const entries: rs.Vec<[Uint8Array, Uint8Array]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held3): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held3[0]), rs.byteSliceFrom(held3[1])]; + const entries: rs.Vec<[Uint8Array, Uint8Array]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held12): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held12[0]), rs.byteSliceFrom(held12[1])]; }), (_2: [rs.ByteSlice, rs.ByteSlice]): [Uint8Array, Uint8Array] => { return [rs.byteSliceToArray(_2[0]), rs.byteSliceToArray(_2[1])] as [Uint8Array, Uint8Array]; }), "next", 0); @@ -4062,8 +4250,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r const v: rs.ByteSlice = rs.byteSliceFrom(_155[1]); rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(k)), rs.iterSlice(rs.byteSliceView(v))), undefined, true); } - const iter7: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held4): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held4[0]), rs.byteSliceFrom(held4[1])]; + const iter7: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held13): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held13[0]), rs.byteSliceFrom(held13[1])]; }); while (true) { const _167: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter7.next(); @@ -4077,15 +4265,15 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r })), undefined, true); rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.vecIntoIter(rs.vecFrom(vec.items.map(copy$array_u8))), rs.lending((p2: rs.ByteSlice): boolean => { return rs.byteSliceFirst(p2) !== rs.byteSliceLast(p2); - }, (f2) => (held5) => f2(rs.byteSliceFrom(held5))))) & 0xff); + }, (f2) => (held14) => f2(rs.byteSliceFrom(held14))))) & 0xff); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p3: rs.ByteSlice): boolean => { return rs.iterAny(rs.iterSlice(rs.byteSliceView(p3)), (_22: rs.u8): boolean => { return _22 < 2; }); - }, (f4) => (held6) => f4(rs.byteSliceFrom(held6)))), "next", 0).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + }, (f4) => (held15) => f4(rs.byteSliceFrom(held15)))), "next", 0).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); const rest: rs.Peekable = rs.iterPeekable(rs.iterSkipWhile(rs.dequeIntoIter(rs.dequeClone(deque, copy$array_u8)), rs.lending((p4: rs.ByteSlice): boolean => { return rs.byteSliceFirst(p4) === 64; - }, (f6) => (held7) => f6(rs.byteSliceFrom(held7))))); + }, (f6) => (held16) => f6(rs.byteSliceFrom(held16))))); const _214: rs.ByteSlice | undefined = rs.optionMap(rs.peekablePeek(rest), rs.byteSliceFrom); if (_214 !== undefined) { rs.byteVecExtendFromSlice(out, _214); @@ -4101,38 +4289,38 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r let seen: rs.u8 = 0; const taken: rs.Vec = rs.iterToVec(rs.iterTakeWhile(rs.iterInspect(rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p5: rs.ByteSlice): undefined => { seen = rs.u8WrappingAdd(seen, p5.length & 0xff); - }, (f7) => (held8) => f7(rs.byteSliceFrom(held8)))), rs.lending((p6: rs.ByteSlice): boolean => { + }, (f7) => (held17) => f7(rs.byteSliceFrom(held17)))), rs.lending((p6: rs.ByteSlice): boolean => { return rs.byteSliceLast(p6) !== 35; - }, (f9) => (held9) => f9(rs.byteSliceFrom(held9)))), "next", 0); + }, (f9) => (held18) => f9(rs.byteSliceFrom(held18)))), "next", 0); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(seen, taken.items.length & 0xff)), undefined, true); const _255: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const f10 = (a: rs.ByteSlice, b2: rs.ByteSlice): rs.Ordering => { return rs.cmpBytes(a, b2); }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMaxBy(_255, (held10, held11) => f10(rs.byteSliceFrom(held10), rs.byteSliceFrom(held11)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMaxBy(_255, (held19, held20) => f10(rs.byteSliceFrom(held19), rs.byteSliceFrom(held20)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); const _264: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const f11 = (p7: rs.ByteSlice): rs.u8 => { return rs.iterFold(rs.iterSlice(rs.byteSliceView(p7)), 0, (a2: rs.u8, b3: rs.u8): rs.u8 => { return a2 ^ b3; }); }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMinByKey(_264, (held12) => f11(rs.byteSliceFrom(held12)), rs.lt)), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMinByKey(_264, (held21) => f11(rs.byteSliceFrom(held21)), rs.lt)), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); const _274: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray); const f12 = (p8: rs.ByteSlice): boolean => { return rs.iterSum(rs.iterSlice(rs.byteSliceView(p8)), rs.u8Add, 0) > 18; }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterFind(_274, (held13) => f12(rs.byteSliceFrom(held13)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterFind(_274, (held22) => f12(rs.byteSliceFrom(held22)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); const _281: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const f13 = (a3: rs.ByteSlice, b4: rs.ByteSlice): boolean => { const order = rs.cmpBytes(a3, b4); return order !== undefined && order <= 0; }; - rs.byteVecPush(out, rs.iterIsSortedBy(_281, (held14, held15) => f13(rs.byteSliceFrom(held14), rs.byteSliceFrom(held15))) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(_281, (held23, held24) => f13(rs.byteSliceFrom(held23), rs.byteSliceFrom(held24))) ? 1 : 0); const _291: rs.Iter = rs.iterCopied(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), rs.byteSliceToArray); const f14 = (p9: rs.ByteSlice): boolean => { return rs.cmpBytes(p9, rs.byteSliceFrom(Uint8Array.of())) === -1; }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterRfind(_291, (held16) => f14(rs.byteSliceFrom(held16)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterRfind(_291, (held25) => f14(rs.byteSliceFrom(held25)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const first: Dropped.Dropped = new Dropped.Dropped(1, log); const _299: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); @@ -4145,7 +4333,7 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r return order2 !== undefined && order2 <= 0; }, (): void => { captured[Symbol.dispose](); - }), (f15) => (held17, held18) => f15(rs.byteSliceFrom(held17), rs.byteSliceFrom(held18))), undefined, undefined, rs.drop); + }), (f15) => (held26, held27) => f15(rs.byteSliceFrom(held26), rs.byteSliceFrom(held27))), undefined, undefined, rs.drop); const _307: rs.RefCell = rs.refCellBorrowMut(log); rs.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); rs.refMutRelease(_307); @@ -4161,7 +4349,7 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r captured2[Symbol.dispose](); }); }; - const filtered: rs.Iter = rs.iterFilter(_314, rs.lending(make2(second), (f16) => (held19) => f16(rs.byteSliceFrom(held19)))); + const filtered: rs.Iter = rs.iterFilter(_314, rs.lending(make2(second), (f16) => (held28) => f16(rs.byteSliceFrom(held28)))); const counted: rs.u8 = rs.ownedCount(filtered.clone({ i: { v: copy$array_u8 }, f: rs.closureClone })) & 0xff; const _325: rs.RefCell = rs.refCellBorrowMut(log); rs.byteVecPush(_325.value, counted); @@ -4171,8 +4359,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r rs.byteVecPush(_332.value, counted2); rs.refMutRelease(_332); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(log, new rs.ByteVec())), undefined, true); - const lent: rs.Vec<[rs.ByteSlice, rs.ByteSlice]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held20): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held20[0]), rs.byteSliceFrom(held20[1])]; + const lent: rs.Vec<[rs.ByteSlice, rs.ByteSlice]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held29): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held29[0]), rs.byteSliceFrom(held29[1])]; }), (_23: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.ByteSlice] => { return [_23[0], _23[1]] as [rs.ByteSlice, rs.ByteSlice]; }), "next", 8); @@ -4180,8 +4368,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r for (const _347 of lent.items) { rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_347[0])), rs.iterSlice(rs.byteSliceView(_347[1]))), undefined, true); } - const _357: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterMap(rs.iterLend(rs.btreeIter(tree), (held21): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held21[0]), rs.byteSliceFrom(held21[1])]; + const _357: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterMap(rs.iterLend(rs.btreeIter(tree), (held30): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held30[0]), rs.byteSliceFrom(held30[1])]; }), (_24: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.u8] => { return [_24[0], _24[1].length & 0xff] as [rs.ByteSlice, rs.u8]; }); @@ -4194,8 +4382,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r return [p12, rs.byteSliceToArray(p12)] as [rs.ByteSlice, Uint8Array]; }); const sorted2: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _370, true, undefined, undefined, undefined, 4, true); - const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.hashIter(refs), (held22): [rs.ByteSlice, rs.ByteSlice] => { - return [held22[0], rs.byteSliceFrom(held22[1])]; + const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.hashIter(refs), (held31): [rs.ByteSlice, rs.ByteSlice] => { + return [held31[0], rs.byteSliceFrom(held31[1])]; }); while (true) { const _378: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter9.next(); @@ -4224,8 +4412,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.btreeGet(sorted2, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); - const _429: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.optionMap(rs.hashGetKeyValue(refs, rs.byteSliceFrom(probe)), (held23): [rs.ByteSlice, rs.ByteSlice] => { - return [held23[0], rs.byteSliceFrom(held23[1])]; + const _429: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.optionMap(rs.hashGetKeyValue(refs, rs.byteSliceFrom(probe)), (held32): [rs.ByteSlice, rs.ByteSlice] => { + return [held32[0], rs.byteSliceFrom(held32[1])]; }); if (_429 !== undefined) { rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_429[0])), rs.iterSlice(rs.byteSliceView(_429[1]))), undefined, true); @@ -4237,8 +4425,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r const values: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashValues(refs), rs.byteSliceFrom), rs.byteSliceToArray), "next", 0); rs.sliceSort(rs.sliceFrom(values.items), rs.cmpLt(rs.cmpBytes), 0, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(values.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); - const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(sorted2), (held24): [rs.ByteSlice, rs.ByteSlice] => { - return [held24[0], rs.byteSliceFrom(held24[1])]; + const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(sorted2), (held33): [rs.ByteSlice, rs.ByteSlice] => { + return [held33[0], rs.byteSliceFrom(held33[1])]; }); while (true) { const _476: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter11.next(); @@ -4250,11 +4438,11 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r const f17 = (k2: rs.ByteSlice, v2: rs.ByteSlice): boolean => { return rs.byteSliceFirst(k2) === rs.byteSliceFirst(v2); }; - rs.hashRetain(refs, (held25, held26) => f17(held25, rs.byteSliceFrom(held26))); + rs.hashRetain(refs, (held34, held35) => f17(held34, rs.byteSliceFrom(held35))); const f18 = (k3: rs.ByteSlice, v3: rs.ByteSlice): boolean => { return rs.byteSliceLast(k3) !== rs.byteSliceLast(v3); }; - rs.btreeRetain(sorted2, (held27, held28) => f18(held27, rs.byteSliceFrom(held28))); + rs.btreeRetain(sorted2, (held36, held37) => f18(held36, rs.byteSliceFrom(held37))); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(refs) & 0xff, rs.btreeLen(sorted2) & 0xff)), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.iterToOption(rs.btreeKeys(sorted2).next())), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); rs.iterExtendBytes(out, rs.iterMap(rs.hashValues(refs), (v4: Uint8Array): rs.u8 => { @@ -4266,28 +4454,28 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: rs.ByteSlice) => Uint8Array, out: rs.ByteVec): void { const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), make), undefined, 2, true); const vec: rs.Vec = new rs.Vec(); - rs.iterExtend(vec, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true); + rs.iterExtend(vec, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (held) => rs.byteSliceToArray(held)), undefined, 2, true); const deque: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; const _14: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); - rs.dequeExtend(deque, rs.iterMap(_14, rs.byteSliceToArray), undefined, true); + rs.dequeExtend(deque, rs.iterMap(_14, (held2) => rs.byteSliceToArray(held2)), undefined, true); const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; - rs.heapExtend(heap, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes), undefined, 2, true); + rs.heapExtend(heap, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (held3) => rs.byteSliceToArray(held3)), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes), undefined, 2, true); const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet; - rs.hashExtendKeys(set, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, undefined, 469762048); + rs.hashExtendKeys(set, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (held4) => rs.byteSliceToArray(held4)), undefined, undefined, 469762048); const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; const _28: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); - rs.btreeExtendKeys(ordered, rs.iterMap(_28, rs.byteSliceToArray)); + rs.btreeExtendKeys(ordered, rs.iterMap(_28, (held5) => rs.byteSliceToArray(held5))); const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; const _34: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p: rs.ByteSlice): [rs.ByteSlice, rs.ByteSlice] => { return [p, p] as [rs.ByteSlice, rs.ByteSlice]; }); - rs.hashExtend(map, rs.iterMap(_34, (held): [Uint8Array, Uint8Array] => { - return [rs.byteSliceToArray(held[0]), rs.byteSliceToArray(held[1])]; + rs.hashExtend(map, rs.iterMap(_34, (held6): [Uint8Array, Uint8Array] => { + return [((held7) => rs.byteSliceToArray(held7))(held6[0]), ((held8) => rs.byteSliceToArray(held8))(held6[1])]; }), undefined, undefined, undefined, 234881024); const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; const _41: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), [false, false]); - rs.btreeExtend(tree, rs.iterMap(_41, (held2): [Uint8Array, Uint8Array] => { - return [rs.byteSliceToArray(held2[0]), rs.byteSliceToArray(held2[1])]; + rs.btreeExtend(tree, rs.iterMap(_41, (held9): [Uint8Array, Uint8Array] => { + return [((held10) => rs.byteSliceToArray(held10))(held9[0]), ((held11) => rs.byteSliceToArray(held11))(held9[1])]; })); const iter: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); while (true) { @@ -4352,8 +4540,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r rs.sliceSort(rs.sliceFrom(members.items), rs.cmpLt(rs.cmpBytes), 2, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(members.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.btreeKeys(ordered), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); - const entries: rs.Vec<[Uint8Array, Uint8Array]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held3): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held3[0]), rs.byteSliceFrom(held3[1])]; + const entries: rs.Vec<[Uint8Array, Uint8Array]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held12): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held12[0]), rs.byteSliceFrom(held12[1])]; }), (_2: [rs.ByteSlice, rs.ByteSlice]): [Uint8Array, Uint8Array] => { return [rs.byteSliceToArray(_2[0]), rs.byteSliceToArray(_2[1])] as [Uint8Array, Uint8Array]; }), "next", 4); @@ -4363,8 +4551,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r const v: rs.ByteSlice = rs.byteSliceFrom(_155[1]); rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(k)), rs.iterSlice(rs.byteSliceView(v))), undefined, true); } - const iter7: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held4): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held4[0]), rs.byteSliceFrom(held4[1])]; + const iter7: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held13): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held13[0]), rs.byteSliceFrom(held13[1])]; }); while (true) { const _167: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter7.next(); @@ -4378,15 +4566,15 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r })), undefined, true); rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.vecIntoIter(rs.vecFrom(vec.items.map(copy$array_u8))), rs.lending((p2: rs.ByteSlice): boolean => { return rs.byteSliceFirst(p2) !== rs.byteSliceLast(p2); - }, (f2) => (held5) => f2(rs.byteSliceFrom(held5))))) & 0xff); + }, (f2) => (held14) => f2(rs.byteSliceFrom(held14))))) & 0xff); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p3: rs.ByteSlice): boolean => { return rs.iterAny(rs.iterSlice(rs.byteSliceView(p3)), (_22: rs.u8): boolean => { return _22 < 2; }); - }, (f4) => (held6) => f4(rs.byteSliceFrom(held6)))), "next", 2).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + }, (f4) => (held15) => f4(rs.byteSliceFrom(held15)))), "next", 2).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const rest: rs.Peekable = rs.iterPeekable(rs.iterSkipWhile(rs.dequeIntoIter(rs.dequeClone(deque, copy$array_u8)), rs.lending((p4: rs.ByteSlice): boolean => { return rs.byteSliceFirst(p4) === 64; - }, (f6) => (held7) => f6(rs.byteSliceFrom(held7))))); + }, (f6) => (held16) => f6(rs.byteSliceFrom(held16))))); const _214: rs.ByteSlice | undefined = rs.optionMap(rs.peekablePeek(rest), rs.byteSliceFrom); if (_214 !== undefined) { rs.byteVecExtendFromSlice(out, _214); @@ -4402,38 +4590,38 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r let seen: rs.u8 = 0; const taken: rs.Vec = rs.iterToVec(rs.iterTakeWhile(rs.iterInspect(rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p5: rs.ByteSlice): undefined => { seen = rs.u8WrappingAdd(seen, p5.length & 0xff); - }, (f7) => (held8) => f7(rs.byteSliceFrom(held8)))), rs.lending((p6: rs.ByteSlice): boolean => { + }, (f7) => (held17) => f7(rs.byteSliceFrom(held17)))), rs.lending((p6: rs.ByteSlice): boolean => { return rs.byteSliceLast(p6) !== 35; - }, (f9) => (held9) => f9(rs.byteSliceFrom(held9)))), "next", 2); + }, (f9) => (held18) => f9(rs.byteSliceFrom(held18)))), "next", 2); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(seen, taken.items.length & 0xff)), undefined, true); const _255: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const f10 = (a: rs.ByteSlice, b2: rs.ByteSlice): rs.Ordering => { return rs.cmpBytes(a, b2); }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMaxBy(_255, (held10, held11) => f10(rs.byteSliceFrom(held10), rs.byteSliceFrom(held11)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMaxBy(_255, (held19, held20) => f10(rs.byteSliceFrom(held19), rs.byteSliceFrom(held20)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const _264: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const f11 = (p7: rs.ByteSlice): rs.u8 => { return rs.iterFold(rs.iterSlice(rs.byteSliceView(p7)), 0, (a2: rs.u8, b3: rs.u8): rs.u8 => { return a2 ^ b3; }); }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMinByKey(_264, (held12) => f11(rs.byteSliceFrom(held12)), rs.lt)), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMinByKey(_264, (held21) => f11(rs.byteSliceFrom(held21)), rs.lt)), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const _274: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray); const f12 = (p8: rs.ByteSlice): boolean => { return rs.iterSum(rs.iterSlice(rs.byteSliceView(p8)), rs.u8Add, 0) > 18; }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterFind(_274, (held13) => f12(rs.byteSliceFrom(held13)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterFind(_274, (held22) => f12(rs.byteSliceFrom(held22)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const _281: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const f13 = (a3: rs.ByteSlice, b4: rs.ByteSlice): boolean => { const order = rs.cmpBytes(a3, b4); return order !== undefined && order <= 0; }; - rs.byteVecPush(out, rs.iterIsSortedBy(_281, (held14, held15) => f13(rs.byteSliceFrom(held14), rs.byteSliceFrom(held15))) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(_281, (held23, held24) => f13(rs.byteSliceFrom(held23), rs.byteSliceFrom(held24))) ? 1 : 0); const _291: rs.Iter = rs.iterCopied(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), rs.byteSliceToArray); const f14 = (p9: rs.ByteSlice): boolean => { return rs.cmpBytes(p9, rs.byteSliceFrom(Uint8Array.of(80, 80))) === -1; }; - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterRfind(_291, (held16) => f14(rs.byteSliceFrom(held16)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterRfind(_291, (held25) => f14(rs.byteSliceFrom(held25)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const first: Dropped.Dropped = new Dropped.Dropped(1, log); const _299: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); @@ -4446,7 +4634,7 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r return order2 !== undefined && order2 <= 0; }, (): void => { captured[Symbol.dispose](); - }), (f15) => (held17, held18) => f15(rs.byteSliceFrom(held17), rs.byteSliceFrom(held18))), undefined, undefined, rs.drop); + }), (f15) => (held26, held27) => f15(rs.byteSliceFrom(held26), rs.byteSliceFrom(held27))), undefined, undefined, rs.drop); const _307: rs.RefCell = rs.refCellBorrowMut(log); rs.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); rs.refMutRelease(_307); @@ -4462,7 +4650,7 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r captured2[Symbol.dispose](); }); }; - const filtered: rs.Iter = rs.iterFilter(_314, rs.lending(make2(second), (f16) => (held19) => f16(rs.byteSliceFrom(held19)))); + const filtered: rs.Iter = rs.iterFilter(_314, rs.lending(make2(second), (f16) => (held28) => f16(rs.byteSliceFrom(held28)))); const counted: rs.u8 = rs.ownedCount(filtered.clone({ i: { v: copy$array_u8 }, f: rs.closureClone })) & 0xff; const _325: rs.RefCell = rs.refCellBorrowMut(log); rs.byteVecPush(_325.value, counted); @@ -4472,8 +4660,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r rs.byteVecPush(_332.value, counted2); rs.refMutRelease(_332); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(log, new rs.ByteVec())), undefined, true); - const lent: rs.Vec<[rs.ByteSlice, rs.ByteSlice]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held20): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held20[0]), rs.byteSliceFrom(held20[1])]; + const lent: rs.Vec<[rs.ByteSlice, rs.ByteSlice]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held29): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held29[0]), rs.byteSliceFrom(held29[1])]; }), (_23: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.ByteSlice] => { return [_23[0], _23[1]] as [rs.ByteSlice, rs.ByteSlice]; }), "next", 8); @@ -4481,8 +4669,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r for (const _347 of lent.items) { rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_347[0])), rs.iterSlice(rs.byteSliceView(_347[1]))), undefined, true); } - const _357: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterMap(rs.iterLend(rs.btreeIter(tree), (held21): [rs.ByteSlice, rs.ByteSlice] => { - return [rs.byteSliceFrom(held21[0]), rs.byteSliceFrom(held21[1])]; + const _357: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterMap(rs.iterLend(rs.btreeIter(tree), (held30): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held30[0]), rs.byteSliceFrom(held30[1])]; }), (_24: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.u8] => { return [_24[0], _24[1].length & 0xff] as [rs.ByteSlice, rs.u8]; }); @@ -4495,8 +4683,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r return [p12, rs.byteSliceToArray(p12)] as [rs.ByteSlice, Uint8Array]; }); const sorted2: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _370, true, undefined, undefined, undefined, 8, true); - const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.hashIter(refs), (held22): [rs.ByteSlice, rs.ByteSlice] => { - return [held22[0], rs.byteSliceFrom(held22[1])]; + const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.hashIter(refs), (held31): [rs.ByteSlice, rs.ByteSlice] => { + return [held31[0], rs.byteSliceFrom(held31[1])]; }); while (true) { const _378: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter9.next(); @@ -4525,8 +4713,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.btreeGet(sorted2, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); - const _429: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.optionMap(rs.hashGetKeyValue(refs, rs.byteSliceFrom(probe)), (held23): [rs.ByteSlice, rs.ByteSlice] => { - return [held23[0], rs.byteSliceFrom(held23[1])]; + const _429: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.optionMap(rs.hashGetKeyValue(refs, rs.byteSliceFrom(probe)), (held32): [rs.ByteSlice, rs.ByteSlice] => { + return [held32[0], rs.byteSliceFrom(held32[1])]; }); if (_429 !== undefined) { rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_429[0])), rs.iterSlice(rs.byteSliceView(_429[1]))), undefined, true); @@ -4538,8 +4726,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r const values: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashValues(refs), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); rs.sliceSort(rs.sliceFrom(values.items), rs.cmpLt(rs.cmpBytes), 2, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(values.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); - const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(sorted2), (held24): [rs.ByteSlice, rs.ByteSlice] => { - return [held24[0], rs.byteSliceFrom(held24[1])]; + const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(sorted2), (held33): [rs.ByteSlice, rs.ByteSlice] => { + return [held33[0], rs.byteSliceFrom(held33[1])]; }); while (true) { const _476: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter11.next(); @@ -4551,11 +4739,11 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r const f17 = (k2: rs.ByteSlice, v2: rs.ByteSlice): boolean => { return rs.byteSliceFirst(k2) === rs.byteSliceFirst(v2); }; - rs.hashRetain(refs, (held25, held26) => f17(held25, rs.byteSliceFrom(held26))); + rs.hashRetain(refs, (held34, held35) => f17(held34, rs.byteSliceFrom(held35))); const f18 = (k3: rs.ByteSlice, v3: rs.ByteSlice): boolean => { return rs.byteSliceLast(k3) !== rs.byteSliceLast(v3); }; - rs.btreeRetain(sorted2, (held27, held28) => f18(held27, rs.byteSliceFrom(held28))); + rs.btreeRetain(sorted2, (held36, held37) => f18(held36, rs.byteSliceFrom(held37))); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(refs) & 0xff, rs.btreeLen(sorted2) & 0xff)), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.iterToOption(rs.btreeKeys(sorted2).next())), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); rs.iterExtendBytes(out, rs.iterMap(rs.hashValues(refs), (v4: Uint8Array): rs.u8 => { diff --git a/ts/fixtures/lang/lengths/expected/harness.ts b/ts/fixtures/lang/lengths/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/lengths/expected/harness.ts +++ b/ts/fixtures/lang/lengths/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/lengths/expected/lengths.ts b/ts/fixtures/lang/lengths/expected/lengths.ts index 820f817a8..a711456e3 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.ts @@ -316,24 +316,26 @@ export function retagged$3(rows: rs.Slice, out: rs.ByteVec): void { /** [`retagged`] of a type parameter's values. */ export function recloned$u32_0(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(rows))); + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); while (true) { - const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { break; } const at: rs.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(rs.sliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array0_u32(copy$Option_lengths_Tagged_array0_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array0_u32(copy); const part = rs.place(() => pair[0], (value) => pair[0] = value); const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - rs.sliceReverse(rs.sliceFrom(part.v._0)); + const a: rs.Slice = rs.sliceFrom(part.v._0); + const b: rs.Slice = rs.sliceFrom(part2.v._0); + rs.sliceReverse(a); part2.v._1 = part2.v._1 ^ 255; rs.byteVecPush(out, part2.v._1); - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.sliceItems(a)), rs.iterSlice(rs.sliceItems(b))), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -343,24 +345,26 @@ export function recloned$u32_0(rows: rs.Slice, out: rs.ByteVec): void /** [`retagged`] of a type parameter's values. */ export function recloned$u32_1(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(rows))); + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); while (true) { - const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { break; } const at: rs.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(rs.sliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array1_u32(copy$Option_lengths_Tagged_array1_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array1_u32(copy); const part = rs.place(() => pair[0], (value) => pair[0] = value); const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - rs.sliceReverse(rs.sliceFrom(part.v._0)); + const a: rs.Slice = rs.sliceFrom(part.v._0); + const b: rs.Slice = rs.sliceFrom(part2.v._0); + rs.sliceReverse(a); part2.v._1 = part2.v._1 ^ 255; rs.byteVecPush(out, part2.v._1); - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.sliceItems(a)), rs.iterSlice(rs.sliceItems(b))), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -370,24 +374,26 @@ export function recloned$u32_1(rows: rs.Slice, out: rs.ByteVec): void /** [`retagged`] of a type parameter's values. */ export function recloned$u32_17(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(rows))); + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); while (true) { - const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { break; } const at: rs.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(rs.sliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array17_u32(copy$Option_lengths_Tagged_array17_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array17_u32(copy); const part = rs.place(() => pair[0], (value) => pair[0] = value); const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - rs.sliceReverse(rs.sliceFrom(part.v._0)); + const a: rs.Slice = rs.sliceFrom(part.v._0); + const b: rs.Slice = rs.sliceFrom(part2.v._0); + rs.sliceReverse(a); part2.v._1 = part2.v._1 ^ 255; rs.byteVecPush(out, part2.v._1); - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.sliceItems(a)), rs.iterSlice(rs.sliceItems(b))), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -397,24 +403,26 @@ export function recloned$u32_17(rows: rs.Slice, out: rs.ByteVec): void /** [`retagged`] of a type parameter's values. */ export function recloned$u32_3(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(rows))); + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); while (true) { - const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { break; } const at: rs.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(rs.sliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array3_u32(copy$Option_lengths_Tagged_array3_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array3_u32(copy); const part = rs.place(() => pair[0], (value) => pair[0] = value); const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - rs.sliceReverse(rs.sliceFrom(part.v._0)); + const a: rs.Slice = rs.sliceFrom(part.v._0); + const b: rs.Slice = rs.sliceFrom(part2.v._0); + rs.sliceReverse(a); part2.v._1 = part2.v._1 ^ 255; rs.byteVecPush(out, part2.v._1); - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.sliceItems(a)), rs.iterSlice(rs.sliceItems(b))), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1939,16 +1947,18 @@ export function put$lengths_Put_array3_u8(self: rs.ByteSlice, out: rs.ByteVec): * either changes. */ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.u32[], rs.Slice] | undefined = rs.sliceSplitFirst(rows); + const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { + return [rs.sliceFrom(held[0]), held[1]]; + }); b0: { if (_6 !== undefined) { - const item = copy$array_u32(copy$array_u32(_6[0])); + const item = copy$array_u32(rs.sliceToArray(_6[0])); const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); + const _9: rs.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); if (_9 !== undefined) { - const next: rs.u32[] = copy$array_u32(_9); + const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); } const iterS: Uint8Array = rs.byteSliceView(data); @@ -1977,7 +1987,7 @@ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Slice, out: _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 0)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 0)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1990,16 +2000,18 @@ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Slice, out: * either changes. */ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.u32[], rs.Slice] | undefined = rs.sliceSplitFirst(rows); + const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { + return [rs.sliceFrom(held[0]), held[1]]; + }); b0: { if (_6 !== undefined) { - const item = copy$array_u32(copy$array_u32(_6[0])); + const item = copy$array_u32(rs.sliceToArray(_6[0])); const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); + const _9: rs.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); if (_9 !== undefined) { - const next: rs.u32[] = copy$array_u32(_9); + const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); } const iterS: Uint8Array = rs.byteSliceView(data); @@ -2028,7 +2040,7 @@ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Slice, out: _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 1)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 1)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2041,16 +2053,18 @@ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Slice, out: * either changes. */ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.u32[], rs.Slice] | undefined = rs.sliceSplitFirst(rows); + const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { + return [rs.sliceFrom(held[0]), held[1]]; + }); b0: { if (_6 !== undefined) { - const item = copy$array_u32(copy$array_u32(_6[0])); + const item = copy$array_u32(rs.sliceToArray(_6[0])); const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); + const _9: rs.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); if (_9 !== undefined) { - const next: rs.u32[] = copy$array_u32(_9); + const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); } const iterS: Uint8Array = rs.byteSliceView(data); @@ -2079,7 +2093,7 @@ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Slice, out _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 17)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 17)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2092,16 +2106,18 @@ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Slice, out * either changes. */ export function swapped$u32_3(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.u32[], rs.Slice] | undefined = rs.sliceSplitFirst(rows); + const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { + return [rs.sliceFrom(held[0]), held[1]]; + }); b0: { if (_6 !== undefined) { - const item = copy$array_u32(copy$array_u32(_6[0])); + const item = copy$array_u32(rs.sliceToArray(_6[0])); const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); + const _9: rs.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); if (_9 !== undefined) { - const next: rs.u32[] = copy$array_u32(_9); + const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); } const iterS: Uint8Array = rs.byteSliceView(data); @@ -2130,7 +2146,7 @@ export function swapped$u32_3(data: rs.ByteSlice, rows: rs.Slice, out: _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 3)), (_2: rs.u32): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 3)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } diff --git a/ts/fixtures/lang/lists/expected/harness.ts b/ts/fixtures/lang/lists/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/lists/expected/harness.ts +++ b/ts/fixtures/lang/lists/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/lists/expected/lists.ts b/ts/fixtures/lang/lists/expected/lists.ts index 57172ba0c..cfe5f4333 100644 --- a/ts/fixtures/lang/lists/expected/lists.ts +++ b/ts/fixtures/lang/lists/expected/lists.ts @@ -241,8 +241,8 @@ export function printed(l: rs.LinkedList, m: rs.LinkedList, out: r rs.iterToOption(owned.nextBack()); const lent: rs.Iter> = rs.listIterMut(rs.listClone(m, undefined)); lent.next(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.listIter(l), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.listIter(m), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtListIter(it, f, rs.u8Debug, rs.usizeDebug, "Iter"), (f: rs.Formatter) => rs.fmtIter(owned, f, rs.u8Debug, ["IntoIter"]), (f: rs.Formatter) => rs.fmtListIter(lent, f, rs.u8Debug, rs.usizeDebug, "IterMut")]; - text = rs.fmtWriteString(text, [args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ debugHex: "x" }, args2[2]), "|", rs.fmtSpec({ alternate: true }, args2[2]), "|", args2[3], "|", args2[4]]).s; + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.listIter(l), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.listIter(m), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtListIter(it, f, rs.u8Debug, rs.usizeDebug, "Iter"), (f: rs.Formatter) => rs.fmtIter(owned, f, rs.u8Debug, ["IntoIter"]), (f: rs.Formatter) => rs.fmtListIter(lent, f, rs.u8Debug, rs.usizeDebug, "IterMut")]; + text = rs.fmtWriteString(text, [args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ debugHex: "x" }, args3[2]), "|", rs.fmtSpec({ alternate: true }, args3[2]), "|", args3[3], "|", args3[4]]).s; rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); } @@ -296,10 +296,10 @@ export function tallies(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.u64Eq(hashOf$collections_LinkedList_lists_Tally(taken), hashOf$collections_LinkedList_lists_Tally(rest)) ? 1 : 0); let text: string = ""; const part = rs.iterToVec(rs.iterTake(rs.iterRev(rs.listIter(rest)), 2), undefined, 4, true); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part.items, f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rs.fmtWriteString(text, [args2[0]]).s; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.listIter(taken), f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rs.fmtWriteString(text, [rs.fmtSpec({ alternate: true }, args4[0])]).s; + const args5 = [(f: rs.Formatter) => rs.fmtList(part.items, f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; + text = rs.fmtWriteString(text, [args5[0]]).s; + const args6 = [(f: rs.Formatter) => rs.fmtList(rs.listIter(taken), f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; + text = rs.fmtWriteString(text, [rs.fmtSpec({ alternate: true }, args6[0])]).s; rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); } diff --git a/ts/fixtures/lang/locals/expected/harness.ts b/ts/fixtures/lang/locals/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/locals/expected/harness.ts +++ b/ts/fixtures/lang/locals/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/locks/expected/harness.ts b/ts/fixtures/lang/locks/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/locks/expected/harness.ts +++ b/ts/fixtures/lang/locks/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/locks/expected/locks.Probe.ts b/ts/fixtures/lang/locks/expected/locks.Probe.ts index e45fc208b..aa0c50b41 100644 --- a/ts/fixtures/lang/locks/expected/locks.Probe.ts +++ b/ts/fixtures/lang/locks/expected/locks.Probe.ts @@ -43,8 +43,8 @@ export function fmt$fmt_Debug(self: Probe, f: rs.Formatter): rs.Result rs.fmtOption(mutex, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtOption(written, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtBool(_15, f)]; - return rs.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); + const args3 = [(f: rs.Formatter) => rs.fmtOption(mutex, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtOption(written, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtBool(_15, f)]; + return rs.fmtWriteFmt(f, [args3[0], " ", args3[1], " ", args3[2], " ", args3[3]]); } //# sourceMappingURL=locks.Probe.ts.map diff --git a/ts/fixtures/lang/locks/expected/locks.ts b/ts/fixtures/lang/locks/expected/locks.ts index dff9664af..2d5d506f3 100644 --- a/ts/fixtures/lang/locks/expected/locks.ts +++ b/ts/fixtures/lang/locks/expected/locks.ts @@ -75,14 +75,12 @@ export function locks(data: rs.ByteSlice, out: rs.ByteVec): void { const _107: rs.Mutex = rs.mutexLock(lock._0); _107.value = rs.u32Add(_107.value, _104); rs.mutexUnlock(_107); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; - const free: string = rs.fmtFormat([args2[0]]); + const free: string = rs.fmtFormat([(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]); const guard: rs.Result, rs.TryLockError>> = rs.mutexTryLock(lock._0); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; - const held3: string = rs.fmtFormat([args4[0]]); + const held3: string = rs.fmtFormat([(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]); const _139: boolean = guard.ok; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, held3), (f: rs.Formatter) => rs.fmtBool(_139, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, held3), (f: rs.Formatter) => rs.fmtBool(_139, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args9[0], " ", args9[1], " ", args9[2]]))); drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(guard); } else if (_18 === 6) { rs.byteVecPush(out, false ? 1 : 0); @@ -620,34 +618,32 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { const mutex: rs.Mutex<[rs.u8, string]> = new rs.Mutex([data.length & 0xff, text] as [rs.u8, string]); const lock: rs.RefCell<[rs.ByteVec, string]> = new rs.RefCell([rs.byteSliceToByteVec(data), text] as [rs.ByteVec, string]); const guard: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(guard.value[0], f), (f: rs.Formatter) => rs.fmtStr(guard.value[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0])]))); + const args21 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(guard.value[0], f), (f: rs.Formatter) => rs.fmtStr(guard.value[1], f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args21[0], " ", rs.fmtSpec({ alternate: true }, args21[0])]))); const n: rs.Mutex = rs.mutexMap(guard, ((t: [rs.u8, string]): rs.Place => { return rs.place(() => t[0], (value) => t[0] = value); })(guard.value)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n.value, f), (f: rs.Formatter) => rs.u8Debug(n.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", rs.fmtSpec({ align: ">", width: 4 }, args4[0]), " ", rs.fmtSpec({ zero: true, width: 4 }, args4[0])]))); + const args22 = [(f: rs.Formatter) => rs.u8Display(n.value, f), (f: rs.Formatter) => rs.u8Debug(n.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ align: ">", width: 4 }, args22[0]), " ", rs.fmtSpec({ zero: true, width: 4 }, args22[0])]))); const n2: rs.Mutex = rs.mutexMap(n, ((n3: rs.Place): rs.Place => { return n3; })(rs.valuePlace(n))); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat(["[", rs.fmtSpec({ align: "<", width: 3 }, args6[0]), "]"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat(["[", rs.fmtSpec({ align: "<", width: 3 }, (f: rs.Formatter) => rs.u8Display(n2.value, f)), "]"]))); rs.mutexUnlock(n2); const _58: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); const text2: rs.Mutex = rs.mutexMap(_58, ((t2: [rs.u8, string]): rs.Place => { return rs.place(() => t2[1], (value2) => t2[1] = value2); })(_58.value)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text2.value), (f: rs.Formatter) => rs.fmtStr(text2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], " ", args8[1], " [", rs.fmtSpec({ align: "^", width: 9 }, args8[0]), "]"]))); + const args24 = [(f: rs.Formatter) => rs.fmtPad(f, text2.value), (f: rs.Formatter) => rs.fmtStr(text2.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args24[0], " ", args24[1], " [", rs.fmtSpec({ align: "^", width: 9 }, args24[0]), "]"]))); rs.mutexUnlock(text2); const read: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(read.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(read.value[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(read.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(read.value[1], f)], f)]))); const bytes: rs.RefCell = rs.refMap(read, ((t3: [rs.ByteVec, string]): rs.ByteVec => { return t3[0]; })(read.value)); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes.value), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]))); + const args26 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes.value), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0])]))); const _104: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); const text3: rs.RefCell = rs.refMap(_104, ((t4: [rs.ByteVec, string]): string => { return t4[1]; @@ -655,25 +651,23 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { const first: rs.RefCell = rs.refMap(text3, ((t5: string): string => { return option_unwrapOr$1iemzn8(rs.strGet(t5, 0, 1), "-"); })(text3.value)); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, first.value), (f: rs.Formatter) => rs.fmtStr(first.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ align: ">", width: 3 }, args14[0])]))); + const args27 = [(f: rs.Formatter) => rs.fmtPad(f, first.value), (f: rs.Formatter) => rs.fmtStr(first.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args27[0], " ", args27[1], " ", rs.fmtSpec({ align: ">", width: 3 }, args27[0])]))); rs.refRelease(first); rs.refRelease(bytes); const write: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockWrite(lock); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(write.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(write.value[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args16[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(write.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(write.value[1], f)], f)]))); const text4: rs.RefCell = rs.refMutMap(write, ((t6: [rs.ByteVec, string]): rs.Place => { return rs.place(() => t6[1], (value3) => t6[1] = value3); })(write.value)); text4.value = text4.value + "!"; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text4.value), (f: rs.Formatter) => rs.fmtStr(text4.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args18[0], " ", args18[1]]))); + const args29 = [(f: rs.Formatter) => rs.fmtPad(f, text4.value), (f: rs.Formatter) => rs.fmtStr(text4.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args29[0], " ", args29[1]]))); const _154: rs.RefCell = text4; const text5: rs.RefCell = rs.refMutMap(_154, ((t7: rs.Place): rs.Place => { return t7; })(rs.valuePlace(_154))); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text5.value)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([rs.fmtSpec({ align: ">", width: 12 }, args20[0])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([rs.fmtSpec({ align: ">", width: 12 }, (f: rs.Formatter) => rs.fmtPad(f, text5.value))]))); rs.refMutRelease(text5); } @@ -877,53 +871,51 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { const _22: rs.Mutex = rs.mutexLock(mutex.value); _22.value = v; rs.mutexUnlock(_22); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; - const free: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); + const args26 = [(f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; + const free: string = rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args26[0])]); const _held: rs.Mutex = rs.mutexLock(mutex.value); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; - text = rs.fmtFormat([args4[0], " ", args4[1], " ", rs.fmtSpec({ alternate: true }, args4[1]), " ", rs.fmtSpec({ align: ">", width: 12 }, args4[1])]); + const args27 = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; + text = rs.fmtFormat([args27[0], " ", args27[1], " ", rs.fmtSpec({ alternate: true }, args27[1]), " ", rs.fmtSpec({ align: ">", width: 12 }, args27[1])]); rs.mutexUnlock(_held); } else if (_18 === 1) { const _52: rs.RefCell>> = rs.rwLockWrite(lock); const _55: rs.Mutex = new rs.Mutex(rs.u8Add(97, rs.u8Rem(v, 26)) as rs.char); _52.value.items.push(_55); rs.refMutRelease(_52); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; - const free2: string = rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[0])]); + const args23 = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + const free2: string = rs.fmtFormat([args23[0], " ", rs.fmtSpec({ alternate: true }, args23[0])]); const read: rs.RefCell>> = rs.rwLockRead(lock); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; - const shared: string = rs.fmtFormat([args8[0]]); + const shared: string = rs.fmtFormat([(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]); const _85: rs.Vec> = read.value; const _held2: rs.Mutex = rs.mutexLock(_85.items[rs.idx(_85.items, 0)]); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.fmtPad(f, shared), (f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; - text = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", rs.fmtSpec({ alternate: true }, args10[2])]); + const args25 = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.fmtPad(f, shared), (f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + text = rs.fmtFormat([args25[0], " ", args25[1], " ", args25[2], " ", rs.fmtSpec({ alternate: true }, args25[2])]); rs.mutexUnlock(_held2); rs.refRelease(read); } else if (_18 === 2) { const _held3: rs.RefCell>> = rs.rwLockWrite(lock); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; - text = rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args12[0])]); + const args22 = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + text = rs.fmtFormat([args22[0], " ", rs.fmtSpec({ alternate: true }, args22[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args22[0])]); rs.refMutRelease(_held3); } else if (_18 === 3) { if (!(rs.u8Rem(v, 2) === 0)) { const lock2: rs.Arc>> = rs.arcNewCyclic((me2: rs.Weak>>): rs.RefCell> => { return new rs.RefCell(new rs.Mutex(new Probe.Probe(new rs.Weak(), rs.weakClone(me2)))); }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock2.value, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f)))]; - text = rs.fmtFormat([args16[0], " ", rs.fmtSpec({ alternate: true }, args16[0])]); + const args21 = [(f: rs.Formatter) => rs.rwLockDebug(lock2.value, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f)))]; + text = rs.fmtFormat([args21[0], " ", rs.fmtSpec({ alternate: true }, args21[0])]); lock2[Symbol.dispose](); } else { const mutex2: rs.Arc> = rs.arcNewCyclic((me: rs.Weak>): rs.Mutex => { return new rs.Mutex(new Probe.Probe(rs.weakClone(me), new rs.Weak())); }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.mutexDebug(mutex2.value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f))]; - text = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0])]); + const args20 = [(f: rs.Formatter) => rs.mutexDebug(mutex2.value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f))]; + text = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])]); mutex2[Symbol.dispose](); } } else { const part = new rs.RefCell(new rs.Mutex("s")); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(part, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtStr))]; - text = rs.fmtFormat([args18[0]]); + text = rs.fmtFormat([(f: rs.Formatter) => rs.rwLockDebug(part, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtStr))]); } rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } diff --git a/ts/fixtures/lang/manual/expected/harness.ts b/ts/fixtures/lang/manual/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/manual/expected/harness.ts +++ b/ts/fixtures/lang/manual/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/manual/expected/uninit.ts b/ts/fixtures/lang/manual/expected/uninit.ts index 7166db829..5741386ce 100644 --- a/ts/fixtures/lang/manual/expected/uninit.ts +++ b/ts/fixtures/lang/manual/expected/uninit.ts @@ -55,9 +55,9 @@ export function uninits(data: rs.ByteSlice, out: rs.ByteVec): void { }); const k: rs.usize = rs.min(wide.items.length, rs.sliceFrom(words).length); const _88: rs.Slice = rs.sliceRange(rs.sliceFrom(words), 0, k); - const slice2 = rs.sliceFrom(wide.items); + const slice = rs.sliceFrom(wide.items); const dst2 = _88; - rs.sliceCopyFromSlice(dst2, rs.sliceRange(slice2, 0, k)); + rs.sliceCopyFromSlice(dst2, rs.sliceRange(slice, 0, k)); const _86: rs.Place | undefined = rs.sliceFirstMut(dst2); if (_86 !== undefined) { _86.v = _86.v ^ 257; @@ -91,9 +91,9 @@ export function uninits(data: rs.ByteSlice, out: rs.ByteVec): void { dst5; } else if (_155 === 255) { const _164: rs.Slice = rs.sliceRange(rs.sliceFrom(words), 0, 1); - const slice5 = rs.sliceFrom(wide.items); + const slice2 = rs.sliceFrom(wide.items); const dst4 = _164; - rs.sliceCopyFromSlice(dst4, rs.sliceRange(slice5, 0, 0)); + rs.sliceCopyFromSlice(dst4, rs.sliceRange(slice2, 0, 0)); dst4; } } diff --git a/ts/fixtures/lang/methods/expected/harness.ts b/ts/fixtures/lang/methods/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/methods/expected/harness.ts +++ b/ts/fixtures/lang/methods/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/nested/expected/harness.ts b/ts/fixtures/lang/nested/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/nested/expected/harness.ts +++ b/ts/fixtures/lang/nested/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/nested/expected/nested.ts b/ts/fixtures/lang/nested/expected/nested.ts index 25a450bcf..d14668725 100644 --- a/ts/fixtures/lang/nested/expected/nested.ts +++ b/ts/fixtures/lang/nested/expected/nested.ts @@ -122,8 +122,8 @@ export function made(data: rs.ByteSlice, out: rs.ByteVec): void { const _106: rs.Ordering = rs.cmp(b, 128); const tagged: Tagged.Tagged = new Tagged.Tagged(u, _106); rs.byteVecPush(out, (tagged.value !== rs.None ? 1 : 0) | ((order(tagged.order) << 1) & 0xff)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(o, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(u, f, rs.fmtUnit, rs.None)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + const args3 = [(f: rs.Formatter) => rs.fmtOption(o, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(u, f, rs.fmtUnit, rs.None)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1]]))); } } @@ -779,8 +779,8 @@ export function units(data: rs.ByteSlice, out: rs.ByteVec): void { const r: rs.Result = result_map$1gelxzx(option_okOr$1j8owgb(rs.byteSliceFirst(data), 238), (_210: rs.u8): undefined => {}); const e: rs.Result = result_mapErr$136pgpq(option_okOr$06f2ml7(rs.byteSliceFirst(data), undefined), (_: undefined): undefined => {}); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(o !== rs.None ? 1 : 0, none !== rs.None ? 1 : 0, r.ok ? 1 : 0, !e.ok ? 1 : 0)), undefined, true); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtOption(o, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtUnit, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(e, f, rs.u8Debug, rs.fmtUnit)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])))), undefined, true); + const args3 = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtOption(o, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtUnit, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(e, f, rs.u8Debug, rs.fmtUnit)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])))), undefined, true); } //# sourceMappingURL=nested.ts.map diff --git a/ts/fixtures/lang/objects/expected/harness.ts b/ts/fixtures/lang/objects/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/objects/expected/harness.ts +++ b/ts/fixtures/lang/objects/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/objects/expected/objects.ts b/ts/fixtures/lang/objects/expected/objects.ts index 988fad41f..9dfda98b8 100644 --- a/ts/fixtures/lang/objects/expected/objects.ts +++ b/ts/fixtures/lang/objects/expected/objects.ts @@ -139,10 +139,11 @@ export function swapIn(v: rs.Vec>, with_: rs.Arc): rs.Vec, to: rs.u16): rs.u16[] { const captured = to; return ((): rs.u16[] => { - return rs.replaceIn(a, [captured, rs.u16WrappingAdd(captured, 1)]); + const _2: rs.u16[] = [captured, rs.u16WrappingAdd(captured, 1)]; + return rs.replaceIn(rs.sliceView(a), _2); })(); } @@ -162,11 +163,11 @@ export function repinAll(v: rs.Vec>, with_: rs.Arc, n: rs.u } /** An array of objects, assigned whole through a parameter. */ -export function reset(a: rs.Arc[], with_: rs.Arc): void { +export function reset(a: rs.Slice>, with_: rs.Arc): void { const _3: rs.Arc = rs.arcClone(with_); const _4: rs.Arc = new rs.Arc(with_.value); rs.dropAll(a); - Object.assign(a, [_3, _4]); + rs.sliceSet(a, [_3, _4]); } export function takeAll(v: rs.Vec>): rs.Vec> { @@ -435,7 +436,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { counts(out, rs.sliceFrom([one, two]), rs.sliceFrom(pinnedAll.items)); rs.dropVec(pinnedAll); const pair: rs.Arc[] = [rs.arcClone(one), rs.arcClone(two)]; - reset(pair, two); + reset(rs.sliceFrom(pair), two); counts(out, rs.sliceFrom([one, two]), rs.sliceFrom(pair)); rs.dropAll(pair); rs.byteVecPush(out, w.start); @@ -467,7 +468,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { if (rs.u8Rem(x, 2) === 0) { swapWindows(a, b7); } - const old2: rs.u16[] = replaceCaptured(array, x as rs.u16); + const old2: rs.u16[] = replaceCaptured(rs.sliceFrom(array), x as rs.u16); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(old2[0] & 0xff, old2[1] & 0xff))); } rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a.start, a.held.items.length & 0xff, b7.start, b7.held.items.length & 0xff))); diff --git a/ts/fixtures/lang/operators/expected/harness.ts b/ts/fixtures/lang/operators/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/operators/expected/harness.ts +++ b/ts/fixtures/lang/operators/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/orders/expected/harness.ts b/ts/fixtures/lang/orders/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/orders/expected/harness.ts +++ b/ts/fixtures/lang/orders/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/orders/expected/orders.ts b/ts/fixtures/lang/orders/expected/orders.ts index be86b3a23..61cbd61a7 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -383,8 +383,7 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { rs.heapPush(bytes, data.length & 0xff, rs.le); rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.from(bytes.items)))), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapIntoSortedVec(rs.heapClone(bytes, undefined), rs.le, rs.ge, rs.lt))), undefined, true); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(bytes.items, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(bytes.items, f, rs.u8Debug)])), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(bytes)), undefined, true); const least: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { return _2; @@ -427,8 +426,8 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { return [rs.u8Rem(b5, 4), rs.u8Div(b5, 64)] as [rs.u8, rs.u8]; }); rs.heapExtend(pairs, _73, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), undefined, 2, true); - const _78: [rs.u8, rs.u8][] = [[rs.u8Rem(data.length & 0xff, 4), 9] as [rs.u8, rs.u8]]; - rs.heapExtend(pairs, rs.iterMap(rs.iterSlice(_78), copy$tuple2_u8_u8), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), undefined, 2, true); + const _77: rs.Slice<[rs.u8, rs.u8]> = rs.sliceFrom([[rs.u8Rem(data.length & 0xff, 4), 9] as [rs.u8, rs.u8]]); + rs.heapExtend(pairs, rs.iterMap(rs.iterSlice(rs.sliceItems(_77)), copy$tuple2_u8_u8), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), undefined, 2, true); const _84: rs.PeekMut<[rs.u8, rs.u8]> | undefined = rs.heapPeekMut(pairs, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); if (_84 !== undefined) { const top: rs.PeekMut<[rs.u8, rs.u8]> = _84; @@ -652,9 +651,9 @@ export function tuples(data: rs.ByteSlice, out: rs.ByteVec): void { return a0 ? 1 : 0; })), undefined, true); flush(out); - const _146: [Part.Part, rs.u8][] = [[part_, x] as [Part.Part, rs.u8]]; - const _149: [Part.Part, rs.u8][] = [[part2, y] as [Part.Part, rs.u8]]; - const _144: rs.Ordering = rs.cmpSlice(rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmp]))(_146, _149); + const _145: rs.Slice<[Part.Part, rs.u8]> = rs.sliceFrom([[part_, x] as [Part.Part, rs.u8]]); + const _148: rs.Slice<[Part.Part, rs.u8]> = rs.sliceFrom([[part2, y] as [Part.Part, rs.u8]]); + const _144: rs.Ordering = rs.cmpSlice(rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmp]))(_145, _148); const _153: rs.Vec<[rs.u8, Part.Part]> = rs.vecFrom([[x, part_] as [rs.u8, Part.Part]]); const _157: rs.Vec<[rs.u8, Part.Part]> = rs.vecFrom([[y, part2] as [rs.u8, Part.Part]]); const _151: rs.Ordering = rs.cmpSlice(rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering>([rs.cmp, Part.cmp$cmp_Ord]))(_153, _157); @@ -924,9 +923,9 @@ export function held(data: rs.ByteSlice, out: rs.ByteVec): void { const _80: [rs.Result] = [a]; const _83: [rs.Result] = [b]; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_69, rs.cmpTuple<[rs.Result], rs.Ordering>([result_cmp$13u97s2])(_80, _83) & 0xff)), undefined, true); - const _91: rs.Result[] = [a, b]; - const _95: rs.Result[] = [b, a]; - const _89: boolean = rs.cmpSlice(result_partialCmp$0rzsy3r)(_91, _95) === -1; + const _90: rs.Slice> = rs.sliceFrom([a, b]); + const _94: rs.Slice> = rs.sliceFrom([b, a]); + const _89: boolean = rs.cmpSlice(result_partialCmp$0rzsy3r)(_90, _94) === -1; const _100: rs.Vec> = rs.vecFrom([a]); const _104: rs.Vec> = rs.vecFrom([b]); const order3 = rs.cmpSlice(result_partialCmp$0rzsy3r)(_100, _104); diff --git a/ts/fixtures/lang/panics/expected/harness.ts b/ts/fixtures/lang/panics/expected/harness.ts index adfa38b8e..c64676b77 100644 --- a/ts/fixtures/lang/panics/expected/harness.ts +++ b/ts/fixtures/lang/panics/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/panics/expected/located.ts b/ts/fixtures/lang/panics/expected/located.ts index 2ff7e7c61..6b5e8aa46 100644 --- a/ts/fixtures/lang/panics/expected/located.ts +++ b/ts/fixtures/lang/panics/expected/located.ts @@ -72,8 +72,7 @@ export function generic$u8(t: rs.u8): rs.Location { /** Each location's `Display`, a line each. */ export function lines(out: rs.ByteVec, at: rs.Slice): void { for (const _5 of rs.sliceItems(at)) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f), "\n"]))); } } @@ -130,8 +129,8 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const wide: string = "é😀　"; const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], args3[1], args3[0], args3[2]]))); } } @@ -148,12 +147,12 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _18: string = a.file; const _20: rs.u32 = a.line; const _22: rs.u32 = a.col; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; - const written = rs.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; + const written = rs.fmtWriteString(s, [args8[0], "|", args8[1], "|", args8[2], "|"]); s = written.s; rs.resultUnwrap(written.result, rs.fmtErrorDebug); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; - const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]); + const args9 = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; + const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[2]), "|", rs.fmtSpec({ debugHex: "x" }, args9[2])]); s = written2.s; rs.resultUnwrap(written2.result, rs.fmtErrorDebug); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); @@ -190,8 +189,8 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }); const held: Held$read.Held = { at: a, maybe: _117 }; const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; - const args6: rs.Fmt[] = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]))); + const args7 = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], "|", args7[1]]))); } } @@ -218,8 +217,7 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void export function check$panicked(ok: boolean, caller: rs.Location): void { if (!ok) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(caller, f)]; - rs.panicFmt(["failed at ", args2[0]]); + rs.panicFmt(["failed at ", (f: rs.Formatter) => rs.fmtLocationDisplay(caller, f)]); } } diff --git a/ts/fixtures/lang/panics/expected/panics.ts b/ts/fixtures/lang/panics/expected/panics.ts index 4cfc59f49..3a048f957 100644 --- a/ts/fixtures/lang/panics/expected/panics.ts +++ b/ts/fixtures/lang/panics/expected/panics.ts @@ -135,8 +135,8 @@ export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; const _144: [rs.u8, string] = [first, "a"]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]))); + const args3 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ width: 5 }, args3[3]), "|", args3[4], "|", rs.fmtSpec({ alternate: true }, args3[5])]))); } else if (_7 === 4) { const d: rs.u8 = 0; const s2: string = ""; @@ -231,8 +231,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f)]; - return rs.fmtFormat([args6[0]]); + return rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(first, f)]); }))); } else if (_10 === 3) { rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { @@ -284,8 +283,8 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _120: rs.u8 = result_mapOr$171qvtg(asRef$11fb4n1(r4), 0, (n2: rs.u8): rs.u8 => { return n2; }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + const args6 = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); @@ -294,8 +293,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return first; } const part = owned3._0; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; - rs.panicFmt(["caught ", args4[0]]); + rs.panicFmt(["caught ", (f: rs.Formatter) => rs.u8Display(part, f)]); })()); owned3[Symbol.dispose](); const _147: rs.RefCell = rs.refCellBorrow(_8); @@ -524,8 +522,8 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const boxed: Any.Any = new of$u8(first); new of$u8(first); const synced: Any.Any = new of$String(""); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); + const args3 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args3[2]), "|", args3[3]]))); rs.drop(synced); rs.drop(boxed); } diff --git a/ts/fixtures/lang/panics/hook/expected/bytes.ts b/ts/fixtures/lang/panics/hook/expected/bytes.ts index b34d1bcd2..be64a50ee 100644 --- a/ts/fixtures/lang/panics/hook/expected/bytes.ts +++ b/ts/fixtures/lang/panics/hook/expected/bytes.ts @@ -7,8 +7,8 @@ export function panicAdvance(errorInfo: TryGetError.TryGetError): never { const arg = errorInfo.available; const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg, f); const arg2 = errorInfo.requested; - const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; - rs.panicFmt(["advance out of bounds: the len is ", args2[0], " but advancing by ", args2[1]], { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }); + const args3 = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; + rs.panicFmt(["advance out of bounds: the len is ", args3[0], " but advancing by ", args3[1]], { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }); } //# sourceMappingURL=bytes.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/harness.ts b/ts/fixtures/lang/panics/hook/expected/harness.ts index ba815243a..35368b25b 100644 --- a/ts/fixtures/lang/panics/hook/expected/harness.ts +++ b/ts/fixtures/lang/panics/hook/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"], { file: "fixtures/lang/panics/src/../../harness.rs", line: 28, col: 14 }); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"], { file: "fixtures/lang/panics/src/../../harness.rs", line: 28, col: 14 }); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]], { file: "fixtures/lang/panics/src/../../harness.rs", line: 23, col: 9 }); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)], { file: "fixtures/lang/panics/src/../../harness.rs", line: 23, col: 9 }); } } diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts index 2bc072f77..27407d09c 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts @@ -13,8 +13,7 @@ export interface Shown { export function fmt$fmt_Display(self: Shown, f: rs.Formatter): rs.Result { const part = rs.panicking(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - const line: string = rs.fmtFormat(["shown ", args2[0], "\n"]); + const line: string = rs.fmtFormat(["shown ", (f: rs.Formatter) => rs.fmtBool(part, f), "\n"]); rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { note.v = note.v + line; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.ts b/ts/fixtures/lang/panics/hook/expected/hooked.ts index b255c77d8..ad03caa95 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.ts @@ -23,8 +23,7 @@ export function record(info: rs.PanicHookInfo): void { if (!(payload instanceof of$String || payload instanceof ofPlace$String)) { const _8: rs.u32 | undefined = payload instanceof of$u32 ? payload.v : payload instanceof ofPlace$u32 ? payload.v.v : undefined; if (_8 !== undefined) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_8, f)]; - kind = rs.fmtFormat(["u32 ", args2[0]]); + kind = rs.fmtFormat(["u32 ", (f: rs.Formatter) => rs.u32Display(_8, f)]); } else { kind = "other"; } @@ -41,8 +40,8 @@ export function record(info: rs.PanicHookInfo): void { const _42: rs.u32 = at.line; const _44: rs.u32 = at.col; const _46: boolean = rs.panicking(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _27), (f: rs.Formatter) => rs.fmtPad(f, kind), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtPad(f, _39), (f: rs.Formatter) => rs.u32Display(_42, f), (f: rs.Formatter) => rs.u32Display(_44, f), (f: rs.Formatter) => rs.fmtBool(_46, f)]; - const line: string = rs.fmtFormat([args4[0], "\n", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], "\n"]); + const args6 = [(f: rs.Formatter) => rs.fmtPad(f, _27), (f: rs.Formatter) => rs.fmtPad(f, kind), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtPad(f, _39), (f: rs.Formatter) => rs.u32Display(_42, f), (f: rs.Formatter) => rs.u32Display(_44, f), (f: rs.Formatter) => rs.fmtBool(_46, f)]; + const line: string = rs.fmtFormat([args6[0], "\n", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", args6[6], "\n"]); rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { note.v = note.v + line; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); @@ -64,8 +63,7 @@ export function stdNamed(file: string): string { } } const part = _2[1]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - return rs.fmtFormat(["/library/", args2[0]]); + return rs.fmtFormat(["/library/", (f: rs.Formatter) => rs.fmtPad(f, part)]); } } return file; @@ -83,8 +81,7 @@ export function hook(): void { } export function tracked(n: rs.u8, caller: rs.Location): rs.u8 { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["tracked ", args2[0]], caller); + rs.panicFmt(["tracked ", (f: rs.Formatter) => rs.u8Display(n, f)], caller); } /** One panic, by `kind`, with a hook set. `data`'s first byte varies its operands. */ @@ -96,8 +93,7 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_10 === 0) { rs.panicFmt(["literal"], { file: "fixtures/lang/panics/src/hooked.rs", line: 85, col: 14 }); } else if (_10 === 1) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["formatted ", args2[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 86, col: 14 }); + rs.panicFmt(["formatted ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 86, col: 14 }); } else if (_10 === 2) { rs.byteVecPush(out, v.data[rs.idx(v, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 25 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 24 })]); } else if (_10 === 3) { @@ -137,8 +133,7 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_10 === 15) { rs.panicAny(new of$u32(n as rs.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 15 }); } else if (_10 === 16) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panic(rs.fmtFormat(["any ", args4[0]]), { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); + rs.panic(rs.fmtFormat(["any ", (f: rs.Formatter) => rs.u8Display(n, f)]), { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); } else if (_10 === 17) { const _104: rs.u8 = rs.u8WrappingAdd(n, 1); if (!(n === _104)) { @@ -178,8 +173,7 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.assertFailed("!=", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(n, f), undefined as rs.Arguments | undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 119, col: 15 }); } } else if (_10 === 31) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["not implemented: not ", args6[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 120, col: 15 }); + rs.panicFmt(["not implemented: not ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 120, col: 15 }); } else { rs.byteVecPush(out, rs.hashLen(rs.hashWithCapacity(4294967295, 469762048) as rs.HashMap) & 0xff); } @@ -211,11 +205,10 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 159, col: 11 }); if (_13 === 3 || _13 === 4) { const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 56 }) === 4 }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Shown.fmt$fmt_Display(_19, f)]; - rs.panicFmt(["first ", args2[0], " ", args2[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 18 }); + const args6 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Shown.fmt$fmt_Display(_19, f)]; + rs.panicFmt(["first ", args6[0], " ", args6[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 18 }); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["first ", args4[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 161, col: 14 }); + rs.panicFmt(["first ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 161, col: 14 }); } } @@ -548,9 +541,9 @@ export function compared(kind: rs.u8, n: rs.u8): rs.u8 { const _57: rs.RefCell = b; _0 = rs.cmpReverse(rs.refCellBy(rs.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 }))(_54, _57) ? 1 : 0; } else { - const _61: rs.RefCell[] = [a]; - const _64: rs.RefCell[] = [b]; - _0 = rs.eqSlice(rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 }))(_61, _64) ? 1 : 0; + const _60: rs.Slice> = rs.sliceFrom([a]); + const _63: rs.Slice> = rs.sliceFrom([b]); + _0 = rs.eqSlice(rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 }))(_60, _63) ? 1 : 0; } rs.refMutRelease(_held); return _0; @@ -574,8 +567,8 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _10: string = at2.file; const _126: rs.u32 = at2.line; const _14: rs.u32 = at2.col; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _10), (f: rs.Formatter) => rs.u32Display(_126, f), (f: rs.Formatter) => rs.u32Display(_14, f)]; - const line: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, _10), (f: rs.Formatter) => rs.u32Display(_126, f), (f: rs.Formatter) => rs.u32Display(_14, f)]; + const line: string = rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], "\n"]); rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { note.v = note.v + line; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); diff --git a/ts/fixtures/lang/panics/hook/expected/located.ts b/ts/fixtures/lang/panics/hook/expected/located.ts index 153d6277d..ffee6f930 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.ts @@ -72,8 +72,7 @@ export function generic$u8(t: rs.u8): rs.Location { /** Each location's `Display`, a line each. */ export function lines(out: rs.ByteVec, at: rs.Slice): void { for (const _5 of rs.sliceItems(at)) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f), "\n"]))); } } @@ -130,8 +129,8 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const wide: string = "é😀　"; const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], args3[1], args3[0], args3[2]]))); } } @@ -148,12 +147,12 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _18: string = a.file; const _20: rs.u32 = a.line; const _22: rs.u32 = a.col; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; - const written = rs.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; + const written = rs.fmtWriteString(s, [args8[0], "|", args8[1], "|", args8[2], "|"]); s = written.s; rs.resultUnwrap(written.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 202, col: 68 }); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; - const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]); + const args9 = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; + const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[2]), "|", rs.fmtSpec({ debugHex: "x" }, args9[2])]); s = written2.s; rs.resultUnwrap(written2.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 203, col: 54 }); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); @@ -190,8 +189,8 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }); const held: Held$read.Held = { at: a, maybe: _117 }; const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; - const args6: rs.Fmt[] = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]))); + const args7 = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], "|", args7[1]]))); } } @@ -218,8 +217,7 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void export function check$panicked(ok: boolean, caller: rs.Location): void { if (!ok) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(caller, f)]; - rs.panicFmt(["failed at ", args2[0]], caller); + rs.panicFmt(["failed at ", (f: rs.Formatter) => rs.fmtLocationDisplay(caller, f)], caller); } } diff --git a/ts/fixtures/lang/panics/hook/expected/panics.ts b/ts/fixtures/lang/panics/hook/expected/panics.ts index 0086a8cf1..fa2a8dba8 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.ts @@ -135,8 +135,8 @@ export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; const _144: [rs.u8, string] = [first, "a"]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]))); + const args3 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ width: 5 }, args3[3]), "|", args3[4], "|", rs.fmtSpec({ alternate: true }, args3[5])]))); } else if (_7 === 4) { const d: rs.u8 = 0; const s2: string = ""; @@ -231,8 +231,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f)]; - return rs.fmtFormat([args6[0]]); + return rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(first, f)]); }))); } else if (_10 === 3) { rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { @@ -284,8 +283,8 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _120: rs.u8 = result_mapOr$171qvtg(asRef$11fb4n1(r4), 0, (n2: rs.u8): rs.u8 => { return n2; }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + const args6 = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); @@ -294,8 +293,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return first; } const part = owned3._0; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; - rs.panicFmt(["caught ", args4[0]], { file: "fixtures/lang/panics/src/panics.rs", line: 206, col: 21 }); + rs.panicFmt(["caught ", (f: rs.Formatter) => rs.u8Display(part, f)], { file: "fixtures/lang/panics/src/panics.rs", line: 206, col: 21 }); })()), (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 210, col: 24 })); owned3[Symbol.dispose](); const _147: rs.RefCell = rs.refCellBorrow(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 212, col: 28 }); @@ -523,8 +521,8 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const boxed: Any.Any = new of$u8(first); new of$u8(first); const synced: Any.Any = new of$String(""); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); + const args3 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args3[2]), "|", args3[3]]))); rs.drop(synced); rs.drop(boxed); } diff --git a/ts/fixtures/lang/pointers/expected/harness.ts b/ts/fixtures/lang/pointers/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/pointers/expected/harness.ts +++ b/ts/fixtures/lang/pointers/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/pointers/expected/lib.ts b/ts/fixtures/lang/pointers/expected/lib.ts index 7c169c6d1..e38684560 100644 --- a/ts/fixtures/lang/pointers/expected/lib.ts +++ b/ts/fixtures/lang/pointers/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { lists, shared, places, unchecked, nested, copies, sentinels, cells, rebound, lapsed, writers, made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken, bytes, loaded, reattached, partWritten, aimed, distinct, rawArcs, rawPlaces } from "./pointers.ts"; +import { lists, shared, places, unchecked, nested, copies, sentinels, cells, rebound, lapsed, writers, made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken, bytes, loaded, reattached, partWritten, aimed, distinct, rawArcs, rawPlaces, arrays } from "./pointers.ts"; import type * as Aimed from "./pointers.Aimed.ts"; import * as Bin from "./pointers.Bin.ts"; import type * as ByCall from "./pointers.ByCall.ts"; @@ -27,6 +27,10 @@ export function copy$Option_tuple2_u16_u8(v: [rs.u16, rs.u8] | undefined): [rs.u return v === undefined ? v : copy$tuple2_u16_u8(v); } +export function copy$array_array2_u32(v: rs.u32[][]): rs.u32[][] { + return v.map(copy$array_u32); +} + export function copy$array_ptr_array4_u8(v: rs.ByteSlice[]): rs.ByteSlice[] { return v.slice(); } @@ -43,10 +47,6 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$array_unit(v: undefined[]): undefined[] { - return v.slice(); -} - export function copy$mem_MaybeUninit_array_u32(v: rs.u32[]): rs.u32[] { if (v === undefined) { return v; @@ -73,7 +73,7 @@ export function copy$pointers_Aimed_Cell_u8(v: Aimed.Aimed>): Aim } export function copy$pointers_Aimed_array2_u16(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rs.u16[], seen: v.seen as rs.u16[], held: v.held as rs.u16[], maybe: v.maybe as rs.u16[] | undefined, tagged: copy$tuple2_mutPtr_array2_u16_u8(v.tagged as [rs.u16[], rs.u8]), to: v.to, read: (v.read as (a0: rs.u16[]) => rs.u8) as (a0: rs.Ptr) => rs.u8 }; + return { at: v.at as rs.Slice, seen: v.seen as rs.Slice, held: v.held as rs.Slice, maybe: v.maybe as rs.Slice | undefined, tagged: copy$tuple2_mutPtr_array2_u16_u8(v.tagged as [rs.Slice, rs.u8]), to: v.to, read: (v.read as (a0: rs.Slice) => rs.u8) as (a0: rs.Ptr) => rs.u8 }; } export function copy$pointers_Aimed_array4_u8(v: Aimed.Aimed): Aimed.Aimed { @@ -144,7 +144,7 @@ export function copy$tuple2_mutPtr_Cell_u8_u8(v: [rs.Place>, rs.u return [v[0], v[1]]; } -export function copy$tuple2_mutPtr_array2_u16_u8(v: [rs.u16[], rs.u8]): [rs.u16[], rs.u8] { +export function copy$tuple2_mutPtr_array2_u16_u8(v: [rs.Slice, rs.u8]): [rs.Slice, rs.u8] { return [v[0], v[1]]; } @@ -287,6 +287,8 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By rawArcs(data25, out25); }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::raw_places", (_235: rs.u8, data26: rs.ByteSlice, out26: rs.ByteVec): undefined => { rawPlaces(data26, out26); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::arrays", (_236: rs.u8, data27: rs.ByteSlice, out27: rs.ByteVec): undefined => { + arrays(data27, out27); }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Holder.ts b/ts/fixtures/lang/pointers/expected/pointers.Holder.ts new file mode 100644 index 000000000..1d96074c3 --- /dev/null +++ b/ts/fixtures/lang/pointers/expected/pointers.Holder.ts @@ -0,0 +1,10 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; + +/** What holds an array in a field. */ +export interface Holder { + arr: rs.u32[]; +} + +//# sourceMappingURL=pointers.Holder.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index 2f6d348aa..0c7318344 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { copy$Option_pointers_Pair, copy$Option_tuple2_u16_u8, copy$array_ptr_array4_u8, copy$array_u16, copy$array_u8, copy$array_unit, copy$mem_MaybeUninit_array_u32, copy$mem_MaybeUninit_array_u8, copy$mem_MaybeUninit_tuple2_u8_u8, copy$pointers_Aimed_Cell_u8, copy$pointers_Aimed_array2_u16, copy$pointers_Aimed_array4_u8, copy$pointers_Aimed_pointers_Housed_u8, copy$pointers_Aimed_pointers_Leaning, copy$pointers_Aimed_pointers_Paired, copy$pointers_Aimed_u8, copy$pointers_ByCall, copy$pointers_ByClosure, copy$pointers_ByObject, copy$pointers_Duo, copy$pointers_Halves, copy$pointers_Outer, copy$pointers_Pair, copy$pointers_Spot, copy$pointers_Twin, copy$tuple2_array2_u32_u8, copy$tuple2_u16_u8, copy$tuple2_u32_u32, copy$tuple2_u8_u8, drop$pointers_List_String, drop$pointers_List_sync_Arc_u8, drop$tuple2_sync_Arc_pointers_Twin_Rc_pointers_Twin, drop$tuple3_sync_Arc_u32_Rc_pointers_Duo_sync_Arc_unit, drop$tuple4_sync_Arc_pointers_Twin_sync_Arc_pointers_Twin_Rc_pointers_Twin_Rc_pointers_Twin, of$pointers_Bin_pointers_ByObject } from "./lib.ts"; +import { copy$Option_pointers_Pair, copy$Option_tuple2_u16_u8, copy$array_array2_u32, copy$array_ptr_array4_u8, copy$array_u16, copy$array_u32, copy$array_u8, copy$mem_MaybeUninit_array_u32, copy$mem_MaybeUninit_array_u8, copy$mem_MaybeUninit_tuple2_u8_u8, copy$pointers_Aimed_Cell_u8, copy$pointers_Aimed_array2_u16, copy$pointers_Aimed_array4_u8, copy$pointers_Aimed_pointers_Housed_u8, copy$pointers_Aimed_pointers_Leaning, copy$pointers_Aimed_pointers_Paired, copy$pointers_Aimed_u8, copy$pointers_ByCall, copy$pointers_ByClosure, copy$pointers_ByObject, copy$pointers_Duo, copy$pointers_Halves, copy$pointers_Outer, copy$pointers_Pair, copy$pointers_Spot, copy$pointers_Twin, copy$tuple2_array2_u32_u8, copy$tuple2_u16_u8, copy$tuple2_u32_u32, copy$tuple2_u8_u8, drop$pointers_List_String, drop$pointers_List_sync_Arc_u8, drop$tuple2_sync_Arc_pointers_Twin_Rc_pointers_Twin, drop$tuple3_sync_Arc_u32_Rc_pointers_Duo_sync_Arc_unit, drop$tuple4_sync_Arc_pointers_Twin_sync_Arc_pointers_Twin_Rc_pointers_Twin_Rc_pointers_Twin, of$pointers_Bin_pointers_ByObject } from "./lib.ts"; import { then$0bgt67i, then$1a5xgoh, then$0jw3xip } from "./core/bool.ts"; import { isSomeAnd$1s2u5lz, isSomeAnd$1nosv3e, isSomeAnd$07atiew, unwrapOr$0mkoact as option_unwrapOr$0mkoact, unwrapOr$179xo1w as option_unwrapOr$179xo1w, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1cfrse5 as option_map$1cfrse5, mapOr$078vnqn as option_mapOr$078vnqn, mapOr$00zno7m as option_mapOr$00zno7m, mapOr$173j2gr as option_mapOr$173j2gr, filter$0wvwd70 } from "./core/option.ts"; import type * as Aimed from "./pointers.Aimed.ts"; @@ -15,6 +15,7 @@ import type * as Enclosed from "./pointers.Enclosed.ts"; import type * as Gauge from "./pointers.Gauge.ts"; import type * as Halves from "./pointers.Halves.ts"; import * as Held from "./pointers.Held.ts"; +import type * as Holder from "./pointers.Holder.ts"; import * as Housed from "./pointers.Housed.ts"; import type * as Inner from "./pointers.Inner.ts"; import * as Leaning from "./pointers.Leaning.ts"; @@ -336,13 +337,13 @@ export function copies(data: rs.ByteSlice, out: rs.ByteVec): void { const x: rs.u32[] = copy$mem_MaybeUninit_array_u32(Array.from({ length: 4 }, (): rs.u32 => { return v; })); - const y: rs.u32[] = copy$mem_MaybeUninit_array_u32(x); + const y: rs.u32[] = copy$mem_MaybeUninit_array_u32(copy$mem_MaybeUninit_array_u32(x)); const _16: rs.u32 = (v ^ 1) >>> 0; const uninit = x; rs.ptrWrite(uninit, Array.from({ length: 4 }, (): rs.u32 => { return _16; })); - uninit; + rs.sliceFrom(uninit); const h: Halves.Halves = ({ at0: [v, rs.u32Add(v, 1)] } as unknown) as Halves.Halves; const g: Halves.Halves = copy$pointers_Halves(h); g.at0[0] = rs.u32Add(v, 2); @@ -355,7 +356,7 @@ export function copies(data: rs.ByteSlice, out: rs.ByteVec): void { const _35: [rs.u8, rs.u8] = snapshot(v); const before: rs.u8 = _35[0]; const after: rs.u8 = _35[1]; - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(y[0] & 0xff, x[0] & 0xff, h.at0[0] & 0xff, g.at0[0] & 0xff, option_mapOr$078vnqn(old, 0, (o: Pair.Pair): rs.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(y[0] & 0xff, copy$mem_MaybeUninit_array_u32(x)[0] & 0xff, h.at0[0] & 0xff, g.at0[0] & 0xff, option_mapOr$078vnqn(old, 0, (o: Pair.Pair): rs.u8 => { return o.a & 0xff; }), option_mapOr$078vnqn(copy$Option_pointers_Pair(held), 0, (o2: Pair.Pair): rs.u8 => { return o2.a & 0xff; @@ -400,10 +401,10 @@ export function sentinels(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _19); const pointer2 = p; rs.byteVecPush(out, (pointer2 === rs.NULL ? rs.None : pointer2.v) === rs.None ? 1 : 0); - const units: undefined[] = (new Array(2) as unknown) as undefined[]; - copy$array_unit(units); + const units: rs.Slice = rs.sliceFrom((new Array(2) as unknown) as undefined[]); + rs.sliceToArray(units); rs.byteVecPush(out, rs.iterCount(rs.iterSlice([undefined, undefined])) & 0xff); - rs.byteVecPush(out, rs.sliceFrom(units).length & 0xff); + rs.byteVecPush(out, units.length & 0xff); } } @@ -1198,7 +1199,7 @@ export function held(n: rs.u8): Uint8Array { const _20: [rs.ByteSlice, rs.i32] = [p, 1]; const _22: [rs.ByteSlice, rs.i32] = [q, 1]; const _17: rs.u8 = rs.eqTuple([rs.byteSliceSame, rs.same])(_20, _22) ? 1 : 0; - const _23: rs.u8 = rs.eqSlice(rs.byteSliceSame)([p], [r]) ? 1 : 0; + const _23: rs.u8 = rs.eqSlice(rs.byteSliceSame)(rs.sliceFrom([p]), rs.sliceFrom([r])) ? 1 : 0; const _29: rs.u8 = rs.sliceContains(rs.sliceFrom(rs.vecFrom(copy$array_ptr_array4_u8([r, p])).items), q, rs.byteSliceSame) ? 1 : 0; const _39: rs.ByteSlice | undefined = p; const _41: rs.ByteSlice | undefined = q; @@ -1345,14 +1346,16 @@ export function reattached(data: rs.ByteSlice, out: rs.ByteVec): void { const slot: Window.Window = { at: rs.NULL }; let pair: Reattached.Reattached = { _0: 0, _1: 0 }; for (const n of rs.byteSliceView(data)) { - const _17: rs.u16[] = buf; - attach$array4_u16(rs.place(() => window.at as rs.u16[], (value) => (window.at as rs.u16[]) = value), _17); + const _17: rs.Slice = rs.sliceFrom(buf); + attach$array4_u16(rs.place(() => window.at as rs.Slice, (value) => (window.at as rs.Slice) = value), _17); const _18: rs.u16 = ((n as rs.u16) << 7) & 0xffff; const _22: rs.usize = rs.u8Rem(n, 4) as rs.usize; if (!(_22 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _22); } - (window.at as rs.u16[])[_22] = (window.at as rs.u16[])[_22] ^ _18; + const _45: rs.Slice = window.at as rs.Slice; + const _46: rs.Slice = window.at as rs.Slice; + _45.data[_45.start + _22] = _46.data[_46.start + _22] ^ _18; rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(buf, (b: rs.u16): rs.u8 => { return (b >> 4) & 0xff; })), undefined, true); @@ -1372,7 +1375,7 @@ export function reattached(data: rs.ByteSlice, out: rs.ByteVec): void { })), undefined, true); } -export function attach$array4_u16(at: rs.Place, to: rs.u16[]): void { +export function attach$array4_u16(at: rs.Place>, to: rs.Slice): void { at.v = to; } @@ -1446,7 +1449,7 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { let _103!: To.To; let _124!: rs.Place> | undefined; let _129!: To.To>; - let _154!: rs.u16[] | undefined; + let _154!: rs.Slice | undefined; let _159!: To.To; let _180!: Housed.Housed | undefined; let _185!: To.To>; @@ -1608,25 +1611,25 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return _144; }); - const at6: rs.u16[] = wide; + const at6: rs.Slice = rs.sliceFrom(wide); const pointer6 = at6; - const held6: rs.u16[] = rs.optionUnwrap(pointer6 === rs.NULL ? undefined : pointer6); - const _153: rs.u16[] = at6; + const held6: rs.Slice = rs.optionUnwrap(pointer6 === rs.NULL ? undefined : pointer6); + const _153: rs.Slice = at6; if (!(rs.u8Rem(n, 2) === 0)) { _154 = undefined; } else { _154 = held6; } - const _158: [rs.u16[], rs.u8] = [at6, n]; + const _158: [rs.Slice, rs.u8] = [at6, n]; if (!(rs.u8Rem(n, 3) === 0)) { _159 = { tag: "Nowhere" } as To.To; } else { _159 = { tag: "At", _0: at6 } as To.To; } through$array2_u16({ inner: { at: at6, seen: _153, held: held6, maybe: _154, tagged: _158, to: _159, read: readThrough$array2_u16 as (a0: rs.Ptr) => rs.u8 } }, n, out); - swappedIn$array2_u16(wide, n, out); - lend$array2_u16(wide, n, out); - rs.byteVecPush(out, get$pointers_Aim_array2_u16(wide)); + swappedIn$array2_u16(rs.sliceFrom(wide), n, out); + lend$array2_u16(rs.sliceFrom(wide), n, out); + rs.byteVecPush(out, get$pointers_Aim_array2_u16(rs.sliceFrom(wide))); const wrap: Housed.Housed = new Housed.Housed(n); const at7: Housed.Housed = wrap; const pointer7 = at7; @@ -1724,12 +1727,10 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { const _289: boolean = (nest8.inner.maybe as Paired.Paired | undefined) !== nest8.inner.held as Paired.Paired; const pointer11 = other2; const optional: boolean[] = [_284, _289, (nest8.inner.maybe as Paired.Paired | undefined) === (pointer11 === rs.NULL ? undefined : pointer11), (nest8.inner.maybe as Paired.Paired | undefined) === none, none === undefined, (nest8.inner.seen as Paired.Paired) === nest8.inner.at as Paired.Paired, (nest8.inner.seen as Paired.Paired) !== null_, null_ === rs.NULL]; - const part = rs.sliceFrom(same); - const _323: rs.u8 = _322(part); - const part2 = rs.sliceFrom(apart); - const _328: rs.u8 = _322(part2); - const part3 = rs.sliceFrom(optional); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_323, _328, _322(part3))), undefined, true); + const _323: rs.u8 = _322(rs.sliceFrom(same)); + const _328: rs.u8 = _322(rs.sliceFrom(apart)); + const part = rs.sliceFrom(optional); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_323, _328, _322(part))), undefined, true); const other3: rs.ByteSlice = rs.byteSliceFrom(otherBytes); const at10: rs.ByteSlice = rs.byteSliceFrom(bytes); const pointer12 = at10; @@ -1813,12 +1814,10 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { const _437: boolean = rs.eqOption(rs.byteSliceSame)(_439, _442); const _447: rs.ByteSlice | undefined = nest9.inner.seen as rs.ByteSlice; const optional2: boolean[] = [_417, _422, _427, _431, _434, _437, !rs.eqOption(rs.byteSliceSame)(_447, null_2), rs.eqOption(rs.byteSliceSame)(null_2, rs.NULL)]; - const part4 = rs.sliceFrom(same2); - const _456: rs.u8 = _455(part4); - const part5 = rs.sliceFrom(apart2); - const _461: rs.u8 = _455(part5); - const part6 = rs.sliceFrom(optional2); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_456, _461, _455(part6))), undefined, true); + const _456: rs.u8 = _455(rs.sliceFrom(same2)); + const _461: rs.u8 = _455(rs.sliceFrom(apart2)); + const part2 = rs.sliceFrom(optional2); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_456, _461, _455(part2))), undefined, true); const other4: Housed.Housed = otherWrap; const at12: Housed.Housed = wrap; const pointer16 = at12; @@ -1893,12 +1892,10 @@ export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { const _555: boolean = (nest10.inner.maybe as Housed.Housed | undefined) !== nest10.inner.held as Housed.Housed; const pointer19 = other4; const optional3: boolean[] = [_550, _555, (nest10.inner.maybe as Housed.Housed | undefined) === (pointer19 === rs.NULL ? undefined : pointer19), (nest10.inner.maybe as Housed.Housed | undefined) === none3, none3 === undefined, (nest10.inner.seen as Housed.Housed) === nest10.inner.at as Housed.Housed, (nest10.inner.seen as Housed.Housed) !== null_3, null_3 === rs.NULL]; - const part7 = rs.sliceFrom(same3); - const _589: rs.u8 = _588(part7); - const part8 = rs.sliceFrom(apart3); - const _594: rs.u8 = _588(part8); - const part9 = rs.sliceFrom(optional3); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_589, _594, _588(part9))), undefined, true); + const _589: rs.u8 = _588(rs.sliceFrom(same3)); + const _594: rs.u8 = _588(rs.sliceFrom(apart3)); + const part3 = rs.sliceFrom(optional3); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_589, _594, _588(part3))), undefined, true); } } @@ -1947,17 +1944,17 @@ export function made$pointers_Aim_array2_u16(n: rs.u8): rs.u16[] { return [((n as rs.u16) << 4) & 0xffff, (((~n & 0xff) as rs.u16) << 4) & 0xffff]; } -export function get$pointers_Aim_array2_u16(self: rs.u16[]): rs.u8 { - return ((self[0] ^ self[1]) >> 4) & 0xff; +export function get$pointers_Aim_array2_u16(self: rs.Slice): rs.u8 { + return ((self.data[self.start] ^ self.data[self.start + 1]) >> 4) & 0xff; } -export function put$pointers_Aim_array2_u16(self: rs.u16[], n: rs.u8): void { +export function put$pointers_Aim_array2_u16(self: rs.Slice, n: rs.u8): void { const _3: rs.u16 = ((n as rs.u16) << 4) & 0xffff; const _7: rs.usize = rs.u8Rem(n, 2) as rs.usize; if (!(_7 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _7); } - self[_7] = self[_7] ^ _3; + self.data[self.start + _7] = self.data[self.start + _7] ^ _3; } /** @@ -2005,23 +2002,23 @@ export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rs.u export function through$array2_u16(nest: Enclosed.Enclosed, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_array2_u16(nest.inner); - (copy.tagged as [rs.u16[], rs.u8])[1] = (copy.tagged as [rs.u16[], rs.u8])[1] ^ 64; - const _8: [rs.u16[], rs.u8] = tagged$array2_u16(copy); - const at: rs.u16[] = _8[0]; + (copy.tagged as [rs.Slice, rs.u8])[1] = (copy.tagged as [rs.Slice, rs.u8])[1] ^ 64; + const _8: [rs.Slice, rs.u8] = tagged$array2_u16(copy); + const at: rs.Slice = _8[0]; const tag: rs.u8 = _8[1]; - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [rs.u16[], rs.u8])[1], tag)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [rs.Slice, rs.u8])[1], tag)), undefined, true); put$pointers_Aim_array2_u16(at, tag); - rs.byteVecPush(out, (nest.inner.read as (a0: rs.u16[]) => rs.u8)(nest.inner.seen as rs.u16[])); - put$pointers_Aim_array2_u16(nest.inner.at as rs.u16[], n); - rs.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.held as rs.u16[])); - if ((nest.inner.maybe as rs.u16[] | undefined) !== undefined) { - put$pointers_Aim_array2_u16((nest.inner.maybe as rs.u16[] | undefined) as rs.u16[], n ^ 3); + rs.byteVecPush(out, (nest.inner.read as (a0: rs.Slice) => rs.u8)(nest.inner.seen as rs.Slice)); + put$pointers_Aim_array2_u16(nest.inner.at as rs.Slice, n); + rs.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.held as rs.Slice)); + if ((nest.inner.maybe as rs.Slice | undefined) !== undefined) { + put$pointers_Aim_array2_u16((nest.inner.maybe as rs.Slice | undefined) as rs.Slice, n ^ 3); } - put$pointers_Aim_array2_u16((nest.inner.tagged as [rs.u16[], rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [rs.u16[], rs.u8])[1])); + put$pointers_Aim_array2_u16((nest.inner.tagged as [rs.Slice, rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [rs.Slice, rs.u8])[1])); if (nest.inner.to.tag === "At") { - put$pointers_Aim_array2_u16(nest.inner.to._0 as rs.u16[], ~n & 0xff); + put$pointers_Aim_array2_u16(nest.inner.to._0 as rs.Slice, ~n & 0xff); } - const _43: rs.u8 = (((nest.inner.maybe as rs.u16[] | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as rs.Slice | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { @@ -2029,9 +2026,9 @@ export function through$array2_u16(nest: Enclosed.Enclosed, n: rs.u8, } rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); if (rs.u8Rem(n, 5) === 0) { - rs.ptrWrite(nest.inner.at as rs.u16[], copy$array_u16(made$pointers_Aim_array2_u16(n))); + rs.sliceSet(nest.inner.at as rs.Slice, copy$array_u16(made$pointers_Aim_array2_u16(n))); } - rs.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rs.u16[])); + rs.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rs.Slice)); } /** @@ -2222,7 +2219,7 @@ export function readThrough$Cell_u8(at: rs.Place>): rs.u8 { } /** What `at` points at, read as a byte. */ -export function readThrough$array2_u16(at: rs.u16[]): rs.u8 { +export function readThrough$array2_u16(at: rs.Slice): rs.u8 { return get$pointers_Aim_array2_u16(at); } @@ -2257,8 +2254,8 @@ export function tagged$Cell_u8(a: Aimed.Aimed>): [rs.Place): [rs.u16[], rs.u8] { - return [(a.tagged as [rs.u16[], rs.u8])[0], (a.tagged as [rs.u16[], rs.u8])[1]] as [rs.u16[], rs.u8]; +export function tagged$array2_u16(a: Aimed.Aimed): [rs.Slice, rs.u8] { + return [(a.tagged as [rs.Slice, rs.u8])[0], (a.tagged as [rs.Slice, rs.u8])[1]] as [rs.Slice, rs.u8]; } /** `a`'s tagged pointer and tag, taken apart. */ @@ -2298,14 +2295,14 @@ export function swappedIn$Cell_u8(to: rs.Place>, n: rs.u8, out: r } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$array2_u16(to: rs.u16[], n: rs.u8, out: rs.ByteVec): void { +export function swappedIn$array2_u16(to: rs.Slice, n: rs.u8, out: rs.ByteVec): void { const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; - rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic, 4) === rs.NULL ? 1 : 0); - rs.atomicStore(shared.at as rs.Atomic, to, 4); - const at: rs.u16[] = rs.atomicLoad(shared.at as rs.Atomic, 4); + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic>, to, 4); + const at: rs.Slice = rs.atomicLoad(shared.at as rs.Atomic>, 4); put$pointers_Aim_array2_u16(at, n); rs.byteVecPush(out, get$pointers_Aim_array2_u16(at)); - rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic, rs.NULL, 4) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic>, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ @@ -2371,10 +2368,10 @@ export function lend$Cell_u8(to: rs.Cell, n: rs.u8, out: rs.ByteVec): voi } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$array2_u16(to: rs.u16[], n: rs.u8, out: rs.ByteVec): void { - const made: rs.u16[] = made$pointers_Aim_array2_u16(n); +export function lend$array2_u16(to: rs.Slice, n: rs.u8, out: rs.ByteVec): void { + const _6: rs.Slice = rs.sliceFrom(made$pointers_Aim_array2_u16(n)); put$pointers_Aim_array2_u16(to, n >> 1); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(get$pointers_Aim_array2_u16(to), get$pointers_Aim_array2_u16(made))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(get$pointers_Aim_array2_u16(to), get$pointers_Aim_array2_u16(_6))), undefined, true); } /** Reads and writes `to` through references to it and to another `T`. */ @@ -2855,4 +2852,132 @@ export function rawPlaces(data: rs.ByteSlice, out: rs.ByteVec): void { num[Symbol.dispose](); } +/** + * Pointers to arrays of other values than bytes, made of the array, of references to it + * and its parts, by `first_chunk`, `split_first_chunk`, a subslice pattern, and + * `array::from_mut`: compared where they point, and written through. + */ +export function arrays(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const n of rs.byteSliceView(data)) { + const w: rs.u32 = rs.u32Mul(n as rs.u32, 257); + const a: rs.u32[] = [w, (w ^ 1) >>> 0, (w ^ 2) >>> 0, (w ^ 3) >>> 0]; + const b: rs.u32[] = copy$array_u32(a); + const p: rs.Slice = rs.sliceFrom(a); + const first: rs.Slice = rs.optionUnwrap(rs.sliceGetRange(rs.sliceFrom(a), 0, 2)); + const again: rs.Slice = rs.optionUnwrap(rs.sliceGetRange(rs.sliceRange(rs.sliceFrom(a), 0, 3), 0, 2)); + const middle: rs.Slice = rs.optionUnwrap(rs.sliceGetRange(rs.optionUnwrap(rs.sliceSplitAtChecked(rs.sliceFrom(a), 1))[1], 0, 2)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceSame(p, rs.sliceFrom(a)) ? 1 : 0, rs.sliceSame(p, rs.sliceFrom(b)) ? 1 : 0, rs.sliceSame(first, again) ? 1 : 0, rs.sliceSame(first, middle) ? 1 : 0, rs.sliceSame(p, rs.NULL) ? 1 : 0)), undefined, true); + const chunk: rs.Slice = rs.optionUnwrap(rs.sliceGetRange(rs.sliceFrom(a), 0, 2)); + chunk.data[chunk.start + 1] = (chunk.data[chunk.start + 1] ^ 32768) >>> 0; + const made: rs.Slice = chunk; + rs.byteVecPush(out, (rs.sliceSame(made, first) ? 1 : 0) | (((rs.sliceSame(made, middle) ? 1 : 0) << 1) & 0xff)); + const _71: rs.Slice = rs.sliceFrom(a); + _71.data[_71.start] = (_71.data[_71.start] ^ 1) >>> 0; + const swapped = _71.data[_71.start]; + _71.data[_71.start] = _71.data[_71.start + 3]; + _71.data[_71.start + 3] = swapped; + const borrowed = a; + const one: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[2], (value) => borrowed[2] = value)); + one.data[one.start] = (one.data[one.start] ^ 16) >>> 0; + rs.byteVecPush(out, rs.sliceSame(rs.sliceFrom(a), p) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(a), (_2: rs.u32): rs.u8 => { + const x: rs.u32 = _2; + return ((x ^ (x >>> 8)) >>> 0) & 0xff; + }), undefined, true); + const nested: rs.u32[][] = [[w, 1], [2, 3]]; + const read: rs.u32[][] = copy$array_array2_u32(rs.sliceToArray(rs.sliceFrom(nested), copy$array_u32)); + read[0][0] = (read[0][0] ^ 255) >>> 0; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(nested[0][0] & 0xff, read[0][0] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(runs(n)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(lent(n)), undefined, true); + } +} + +/** Pointers to arrays in a `Vec`, compared where they point. */ +export function runs(n: rs.u8): Uint8Array { + const v: rs.Vec = rs.vecFrom([rs.arrayMap(Uint8Array.of(n, n ^ 1), (b: rs.u8): string => { + const _44: rs.char = b as rs.char; + return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_44, f)); + }), ["", "x"]]); + const first: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 0)]); + const last: rs.Slice = rs.optionUnwrap(rs.optionMap(rs.sliceLast(rs.sliceFrom(v.items)), rs.sliceFrom)); + const _20: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); + _20.data[_20.start] = _20.data[_20.start] + "y"; + const _24: rs.u8 = rs.sliceSame(first, rs.sliceFrom(v.items[rs.idx(v.items, 0)])) ? 1 : 0; + const _29: rs.u8 = rs.sliceSame(first, last) ? 1 : 0; + const _31: rs.u8 = rs.sliceSame(last, rs.sliceFrom(v.items[rs.idx(v.items, 1)])) ? 1 : 0; + const _39: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); + return Uint8Array.of(_24, _29, _31, rs.stringLen(_39.data[_39.start]) & 0xff); +} + +/** + * Pointers to arrays each way the language and std lend one, the runs of a shared + * slice's `as_chunks` and `as_rchunks` included, compared where they point. + */ +export function lent(n: rs.u8): rs.ByteVec { + const w: rs.u32 = n as rs.u32; + const a: rs.u32[] = [w, rs.u32Add(w, 1), rs.u32Add(w, 2), rs.u32Add(w, 3)]; + const v: rs.Vec = rs.vecFrom([w, rs.u32Add(w, 1), rs.u32Add(w, 2), rs.u32Add(w, 3)]); + const o: rs.ByteVec = new rs.ByteVec(); + const _25: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.optionMap(rs.sliceFirst(rs.sliceAsChunks(rs.sliceFrom(a), 2)[0]), rs.sliceFrom)), rs.optionUnwrap(rs.sliceGetRange(rs.sliceFrom(a), 0, 2))) ? 1 : 0; + rs.byteVecPush(o, _25); + const _41: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.optionMap(rs.sliceLast(rs.sliceAsRchunks(rs.sliceFrom(a), 2)[1]), rs.sliceFrom)), rs.optionUnwrap(rs.sliceLastChunk(rs.sliceFrom(a), 2))) ? 1 : 0; + rs.byteVecPush(o, _41); + const _57: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.iterNth(rs.iterLend(rs.iterSlice(rs.sliceItems(rs.sliceAsChunks(rs.sliceFrom(v.items), 2)[0])), rs.sliceFrom), 1)), rs.optionUnwrap(rs.sliceLastChunk(rs.sliceFrom(v.items), 2))) ? 1 : 0; + rs.byteVecPush(o, _57); + const _71: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.sliceGetRange(rs.sliceRange(rs.sliceFrom(a), 1, 3), 0, 2)), rs.optionUnwrap(rs.sliceGetRange(rs.sliceRange(rs.sliceFrom(a), 1), 0, 2))) ? 1 : 0; + rs.byteVecPush(o, _71); + const _87: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.sliceGetRange(rs.sliceRange(rs.sliceFrom(v.items), 1, 3), 0, 2)), rs.optionUnwrap(rs.sliceGetRange(rs.sliceRange(rs.sliceFrom(v.items), 1), 0, 2))) ? 1 : 0; + rs.byteVecPush(o, _87); + const _103: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.sliceGetRange(rs.optionUnwrap(rs.iterNth(rs.sliceWindows(rs.sliceFrom(v.items), 2), 1)), 0, 2)), rs.optionUnwrap(rs.sliceGetRange(rs.sliceRange(rs.sliceFrom(v.items), 1), 0, 2))) ? 1 : 0; + rs.byteVecPush(o, _103); + const _122: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.sliceGetRange(rs.optionUnwrap(rs.iterNth(rs.sliceChunks(rs.sliceFrom(v.items), 2), 1)), 0, 2)), rs.optionUnwrap(rs.sliceLastChunk(rs.sliceFrom(v.items), 2))) ? 1 : 0; + rs.byteVecPush(o, _122); + const _140: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.sliceGetRange(rs.optionUnwrap(rs.iterToOption(rs.sliceChunksExact(rs.sliceFrom(a), 2).next())), 0, 2)), rs.optionUnwrap(rs.sliceGetRange(rs.sliceFrom(a), 0, 2))) ? 1 : 0; + rs.byteVecPush(o, _140); + const _162: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.sliceGetRange(rs.sliceSplitAt(rs.sliceFrom(a), 2)[0], 0, 2)), rs.optionUnwrap(rs.sliceGetRange(rs.sliceFrom(a), 0, 2))) ? 1 : 0; + rs.byteVecPush(o, _162); + const pairs: rs.Vec = rs.vecFrom(copy$array_array2_u32([[w, 1], [2, 3]]).map(copy$array_u32)); + const _178: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.iterToOption(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom).next())), rs.optionUnwrap(rs.optionMap(rs.sliceFirst(rs.sliceFrom(pairs.items)), rs.sliceFrom))) ? 1 : 0; + rs.byteVecPush(o, _178); + const boxed: rs.u32[] = [w, 2]; + const _196: rs.u8 = rs.sliceSame(rs.sliceFrom(boxed), rs.sliceFrom(boxed)) ? 1 : 0; + rs.byteVecPush(o, _196); + const opt: rs.u32[] | undefined = [w, 2]; + const _206: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.optionMap(opt, rs.sliceFrom)), rs.optionUnwrap(rs.optionMap(opt, rs.sliceFrom))) ? 1 : 0; + rs.byteVecPush(o, _206); + const rc: rs.Arc = new rs.Arc([w, 2]); + const rc2: rs.Arc = rs.arcClone(rc); + const _222: rs.u8 = rs.sliceSame(rs.sliceFrom(rc.value), rs.sliceFrom(rc2.value)) ? 1 : 0; + rs.byteVecPush(o, _222); + const cell: rs.RefCell = new rs.RefCell([w, 2]); + const _235: rs.RefCell = rs.refCellBorrow(cell); + const p1: rs.Slice = rs.sliceFrom(_235.value); + const _240: rs.RefCell = rs.refCellBorrow(cell); + const _244: rs.u8 = rs.sliceSame(p1, rs.sliceFrom(_240.value)) ? 1 : 0; + rs.byteVecPush(o, _244); + const map: rs.HashMap = rs.hashNew() as rs.HashMap; + rs.hashInsert(map, 1, [w, 2]); + const _252: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.optionMap(rs.hashGet(map, 1), rs.sliceFrom)), rs.optionUnwrap(rs.optionMap(rs.hashGet(map, 1), rs.sliceFrom))) ? 1 : 0; + rs.byteVecPush(o, _252); + const st: Holder.Holder = { arr: [w, 5] }; + const _268: rs.u8 = rs.sliceSame(rs.sliceFrom(st.arr), rs.sliceFrom(st.arr)) ? 1 : 0; + rs.byteVecPush(o, _268); + const held: rs.Arc = new rs.Arc([w, 2]); + const _277: rs.Arc = rs.arcClone(held); + const un: rs.Arc> = new rs.ArcDyn(_277, rs.sliceFrom(_277.value)); + const _281: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.sliceGetRange(un.value, 0, 2)), rs.sliceFrom(held.value)) ? 1 : 0; + rs.byteVecPush(o, _281); + const nested: rs.u32[][] = [[w, 1], [2, 3]]; + const _296: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.optionMap(rs.sliceLast(rs.sliceFrom(nested)), rs.sliceFrom)), rs.optionUnwrap(rs.iterNth(rs.iterLend(rs.iterSlice(nested), rs.sliceFrom), 1))) ? 1 : 0; + rs.byteVecPush(o, _296); + un[Symbol.dispose](); + held[Symbol.dispose](); + rs.refRelease(_240); + rs.refRelease(_235); + rc2[Symbol.dispose](); + rc[Symbol.dispose](); + return o; +} + //# sourceMappingURL=pointers.ts.map diff --git a/ts/fixtures/lang/pointers/src/lib.rs b/ts/fixtures/lang/pointers/src/lib.rs index 6646adfc2..28baff2b1 100644 --- a/ts/fixtures/lang/pointers/src/lib.rs +++ b/ts/fixtures/lang/pointers/src/lib.rs @@ -48,5 +48,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("pointers::distinct", |_, data, out| pointers::distinct(data, out)), ("pointers::raw_arcs", |_, data, out| pointers::raw_arcs(data, out)), ("pointers::raw_places", |_, data, out| pointers::raw_places(data, out)), + ("pointers::arrays", |_, data, out| pointers::arrays(data, out)), ] } diff --git a/ts/fixtures/lang/pointers/src/pointers.rs b/ts/fixtures/lang/pointers/src/pointers.rs index 2065c8438..10bfc8ffd 100644 --- a/ts/fixtures/lang/pointers/src/pointers.rs +++ b/ts/fixtures/lang/pointers/src/pointers.rs @@ -4,7 +4,8 @@ //! and compared; pointers to the parts of a struct kept as objects; the pointers //! `UnsafeCell::get` gives; slots of fresh memory written whole before any pointer //! into them is taken, by index or through std's iterators over them; pointers into -//! nodes that an `AtomicPtr` and memory hold pointers to; pointers to arrays of bytes; a +//! nodes that an `AtomicPtr` and memory hold pointers to; pointers to arrays, compared +//! where they point; a //! pointer into a cell that other functions write whole through a `&mut` to it; //! pointers a generic type holds to its parameter, at each form a pointer takes; and the //! raw pointers of an `Arc` and an `Rc`, counted and taken back. @@ -2271,3 +2272,140 @@ pub fn raw_places(data: &[u8], out: &mut Vec) { /// What holds an `Arc` a reference to it borrows through. struct Shelf(Arc); + +/// Pointers to arrays of other values than bytes, made of the array, of references to it +/// and its parts, by `first_chunk`, `split_first_chunk`, a subslice pattern, and +/// `array::from_mut`: compared where they point, and written through. +pub fn arrays(data: &[u8], out: &mut Vec) { + for &n in data { + let w = u32::from(n) * 257; + let mut a = [w, w ^ 1, w ^ 2, w ^ 3]; + let b = a; + let p: *const [u32; 4] = &a; + let s: &[u32] = &a; + let first: *const [u32; 2] = s.first_chunk().unwrap(); + let again: *const [u32; 2] = a[..3].first_chunk().unwrap(); + let (_, rest) = a.split_first_chunk::<1>().unwrap(); + let middle: *const [u32; 2] = rest.first_chunk().unwrap(); + out.extend([ + u8::from(ptr::eq(p, &a)), + u8::from(ptr::eq(p, &b)), + u8::from(ptr::eq(first, again)), + u8::from(ptr::eq(first, middle)), + u8::from(ptr::eq(p, ptr::null())), + ]); + let chunk = a.first_chunk_mut::<2>().unwrap(); + chunk[1] ^= 0x8000; + let made: *const [u32; 2] = chunk; + out.push(u8::from(ptr::eq(made, first)) | u8::from(ptr::eq(made, middle)) << 1); + if let [x, .., y] = &mut a { + *x ^= 1; + mem::swap(x, y); + } + let one = std::array::from_mut(&mut a[2]); + one[0] ^= 0x10; + let whole: &mut [u32; 4] = &mut a; + let r: *const [u32; 4] = whole; + out.push(u8::from(ptr::eq(r, p))); + out.extend(a.iter().map(|&x| (x ^ x >> 8) as u8)); + // A read through a pointer of arrays of arrays, a value of its own. + let nested = [[w, 1], [2, 3]]; + let mut read = unsafe { ptr::read(&nested) }; + read[0][0] ^= 0xff; + out.extend([nested[0][0] as u8, read[0][0] as u8]); + out.extend(runs(n)); + out.extend(lent(n)); + } +} + +/// Pointers to arrays in a `Vec`, compared where they point. +fn runs(n: u8) -> [u8; 4] { + let mut v = vec![ + [n, n ^ 1].map(|b| char::from(b).to_string()), + [String::new(), String::from("x")], + ]; + let first: *const [String; 2] = &v[0]; + let last: *const [String; 2] = v.last().unwrap(); + v[1][0].push('y'); + [ + u8::from(ptr::eq(first, &v[0])), + u8::from(ptr::eq(first, last)), + u8::from(ptr::eq(last, &v[1])), + v[1][0].len() as u8, + ] +} + +/// Pointers to arrays each way the language and std lend one, the runs of a shared +/// slice's `as_chunks` and `as_rchunks` included, compared where they point. +fn lent(n: u8) -> Vec { + let w = u32::from(n); + let a = [w, w + 1, w + 2, w + 3]; + let v = vec![w, w + 1, w + 2, w + 3]; + let mut o = Vec::new(); + let (chunks, _) = a.as_chunks::<2>(); + o.push(u8::from(ptr::eq( + chunks.first().unwrap(), + a.first_chunk::<2>().unwrap(), + ))); + let (_, back) = a.as_rchunks::<2>(); + o.push(u8::from(ptr::eq(back.last().unwrap(), a.last_chunk::<2>().unwrap()))); + let (vc, _) = v.as_chunks::<2>(); + o.push(u8::from(ptr::eq( + vc.iter().nth(1).unwrap(), + v.last_chunk::<2>().unwrap(), + ))); + o.push(u8::from(ptr::eq( + a[1..3].first_chunk::<2>().unwrap(), + a[1..].first_chunk::<2>().unwrap(), + ))); + o.push(u8::from(ptr::eq( + v[1..3].first_chunk::<2>().unwrap(), + v[1..].first_chunk::<2>().unwrap(), + ))); + o.push(u8::from(ptr::eq( + v.windows(2).nth(1).unwrap().first_chunk::<2>().unwrap(), + v[1..].first_chunk::<2>().unwrap(), + ))); + o.push(u8::from(ptr::eq( + v.chunks(2).nth(1).unwrap().first_chunk::<2>().unwrap(), + v.last_chunk::<2>().unwrap(), + ))); + o.push(u8::from(ptr::eq( + a.chunks_exact(2).next().unwrap().first_chunk::<2>().unwrap(), + a.first_chunk::<2>().unwrap(), + ))); + let (l, _) = a.split_at(2); + o.push(u8::from(ptr::eq( + l.first_chunk::<2>().unwrap(), + a.first_chunk::<2>().unwrap(), + ))); + let pairs = vec![[w, 1], [2, 3]]; + o.push(u8::from(ptr::eq(pairs.iter().next().unwrap(), pairs.first().unwrap()))); + let boxed = Box::new([w, 2]); + o.push(u8::from(ptr::eq(&*boxed, &*boxed))); + let opt = Some([w, 2]); + o.push(u8::from(ptr::eq(opt.as_ref().unwrap(), opt.as_ref().unwrap()))); + let rc = Rc::new([w, 2]); + let rc2 = Rc::clone(&rc); + o.push(u8::from(ptr::eq(&*rc, &*rc2))); + let cell = std::cell::RefCell::new([w, 2]); + let p1: *const [u32; 2] = &*cell.borrow(); + let p2: *const [u32; 2] = &*cell.borrow(); + o.push(u8::from(ptr::eq(p1, p2))); + let mut map = std::collections::HashMap::new(); + map.insert(1u8, [w, 2]); + o.push(u8::from(ptr::eq(map.get(&1).unwrap(), map.get(&1).unwrap()))); + let st = Holder { arr: [w, 5] }; + o.push(u8::from(ptr::eq(&st.arr, &st.arr))); + let held = Arc::new([w, 2]); + let un: Arc<[u32]> = held.clone(); + o.push(u8::from(ptr::eq(un.first_chunk::<2>().unwrap(), &*held))); + let nested = [[w, 1], [2, 3]]; + o.push(u8::from(ptr::eq(nested.last().unwrap(), nested.iter().nth(1).unwrap()))); + o +} + +/// What holds an array in a field. +struct Holder { + arr: [u32; 2], +} diff --git a/ts/fixtures/lang/refs/expected/harness.ts b/ts/fixtures/lang/refs/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/refs/expected/harness.ts +++ b/ts/fixtures/lang/refs/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index e4e42d189..9b3e3bde0 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -151,8 +151,8 @@ export function readThrough(a: rs.Place, b: rs.Place, out: rs.By rs.byteVecPush(out, a.v === b.v ? 1 : 0); rs.byteVecPush(out, a.v < b.v ? 1 : 0); rs.byteVecPush(out, rs.cmp(a.v, b.v) & 0xff); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a.v, f), (f: rs.Formatter) => rs.u32Debug(b.v, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", args2[1]]))); + const args3 = [(f: rs.Formatter) => rs.u32Display(a.v, f), (f: rs.Formatter) => rs.u32Debug(b.v, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", args3[1]]))); } /** A `&mut Box` dereferenced through `DerefMut`, as generic code over it would. */ @@ -526,8 +526,7 @@ export function defaulted(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPop((_31.v as Listing.Listing).listed); } } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(listing, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(listing, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]))); } export function list$defaulted(listing: rs.Place, b: rs.u8): void { @@ -579,8 +578,7 @@ export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { return held.length === 0; }) as rs.u32))); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(held)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(wide.items, f, rs.u32Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(wide.items, f, rs.u32Debug)]))); const pair: [rs.ByteVec, Listing.Listing] = [rs.byteSliceToByteVec(data), Listing.default$Default()]; const swap: (a0: rs.u8) => rs.ByteVec = (b5: rs.u8): rs.ByteVec => { const _36: rs.ByteVec = rs.byteVecOf(b5, rs.u8Rem(b5, 4) as rs.usize); @@ -610,8 +608,7 @@ export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { pair[1].stale = new rs.ByteVec(); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(taken3)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(swapped)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair[0]), f, rs.u8Debug), (f: rs.Formatter) => Listing.fmt$fmt_Debug(pair[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair[0]), f, rs.u8Debug), (f: rs.Formatter) => Listing.fmt$fmt_Debug(pair[1], f)], f)]))); } export function poll$taken_refs_taken_closure1(data: rs.ByteSlice, f: (a0: rs.u8) => boolean): rs.usize { @@ -718,14 +715,14 @@ export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { const grid: rs.u32[][] = Array.from({ length: 3 }, (): rs.u32[] => { return copy$array_u32(item); }); - const iter6: rs.Iter<[rs.u32[], rs.u8]> = rs.iterZip(rs.iterSlice(grid), rs.iterSlice(rs.byteSliceView(data)), [false, false]); + const iter6: rs.Iter<[rs.Slice, rs.u8]> = rs.iterZip(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), rs.iterSlice(rs.byteSliceView(data)), [false, false]); l18: while (true) { - const _133: [rs.u32[], rs.u8] | rs.Done = iter6.next(); + const _133: [rs.Slice, rs.u8] | rs.Done = iter6.next(); if (_133 === rs.DONE) { break; } const b: rs.u8 = _133[1]; - const iter7: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.sliceFrom(_133[0]))); + const iter7: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(_133[0])); while (true) { const _143: [rs.usize, rs.Place] | rs.Done = iter7.next(); if (_143 === rs.DONE) { @@ -741,7 +738,7 @@ export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { for (const _168 of pairs.items) { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_168[0], option_unwrapOr$1fr498u(_168[1], 238)))); } - const iter10: rs.Iter = rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 2); + const iter10: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); while (true) { const _186: rs.u32 | rs.Done = iter10.next(); if (_186 === rs.DONE) { diff --git a/ts/fixtures/lang/results/expected/harness.ts b/ts/fixtures/lang/results/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/results/expected/harness.ts +++ b/ts/fixtures/lang/results/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/returns/expected/harness.ts b/ts/fixtures/lang/returns/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/returns/expected/harness.ts +++ b/ts/fixtures/lang/returns/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/rings/expected/harness.ts b/ts/fixtures/lang/rings/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/rings/expected/harness.ts +++ b/ts/fixtures/lang/rings/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/rings/expected/rings.Big.ts b/ts/fixtures/lang/rings/expected/rings.Big.ts index 9ca0be749..f44c9be3f 100644 --- a/ts/fixtures/lang/rings/expected/rings.Big.ts +++ b/ts/fixtures/lang/rings/expected/rings.Big.ts @@ -27,8 +27,8 @@ export interface Big { export function fmt$fmt_Debug(self: Big, f: rs.Formatter): rs.Result { const part = self.pad[1099]; const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(part, f)]; - return rs.fmtWriteFmt(f, ["B", args2[0], ".", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(part, f)]; + return rs.fmtWriteFmt(f, ["B", args3[0], ".", args3[1]]); } export function make$rings_Item(b: rs.u8): Big { diff --git a/ts/fixtures/lang/rings/expected/rings.ts b/ts/fixtures/lang/rings/expected/rings.ts index 89289b6b3..2e3fa956f 100644 --- a/ts/fixtures/lang/rings/expected/rings.ts +++ b/ts/fixtures/lang/rings/expected/rings.ts @@ -22,8 +22,7 @@ export function bump$rings_Item_u32(self: rs.Place): void { export function make$rings_Item_String(b: rs.u8): string { const part = rs.u8Rem(b, 16); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; - return rs.fmtFormat(["s", args2[0]]); + return rs.fmtFormat(["s", (f: rs.Formatter) => rs.u8Display(part, f)]); } export function bump$rings_Item_String(self: rs.Place): void { @@ -59,218 +58,182 @@ export function put(out: rs.ByteVec, n: rs.usize): void { /** What `{:?}` writes of `value`. */ export function text$Option_ref_String(out: rs.ByteVec, value: string | undefined): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr)]))); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_rings_Big(out: rs.ByteVec, value: Big.Big | undefined): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]))); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_u32(out: rs.ByteVec, value: rs.u32 | undefined): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug)]))); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_u8(out: rs.ByteVec, value: rs.u8 | undefined): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)]))); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_unit(out: rs.ByteVec, value: undefined | rs.None): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None)]))); } /** What `{:?}` writes of `value`. */ export function text$Result_usize_usize(out: rs.ByteVec, value: rs.Result): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(value, f, rs.usizeDebug, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(value, f, rs.usizeDebug, rs.usizeDebug)]))); } /** What `{:?}` writes of `value`. */ export function text$String(out: rs.ByteVec, value: string): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(value, f)]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_String(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_rings_Big(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_u32(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_u8(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_unit(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_String(out: rs.ByteVec, value: rs.Iter>): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "IterMut")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_rings_Big(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_u32(out: rs.ByteVec, value: rs.Iter>): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "IterMut")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_u8(out: rs.ByteVec, value: rs.Iter>): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "IterMut")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_unit(out: rs.ByteVec, value: rs.Iter>): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "IterMut")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "IterMut")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_String(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "Iter")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_rings_Big(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_u32(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "Iter")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_u8(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "Iter")]))); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_unit(out: rs.ByteVec, value: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "Iter")]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "Iter")]))); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_String(out: rs.ByteVec, value: rs.Slice): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtStr)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtStr)]))); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_rings_Big(out: rs.ByteVec, value: rs.Slice): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]))); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_u32(out: rs.ByteVec, value: rs.Slice): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u32Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u32Debug)]))); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_u8(out: rs.ByteVec, value: rs.ByteSlice): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug)]))); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_unit(out: rs.ByteVec, value: rs.Slice): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtUnit)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtUnit)]))); } /** What `{:?}` writes of `value`. */ export function text$rings_Big(out: rs.ByteVec, value: Big.Big): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)]))); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_String_ref_slice_String(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtStr)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtStr)], f)]))); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]))); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_u32_ref_slice_u32(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.u32Debug)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.u32Debug)], f)]))); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_u8_ref_slice_u8(out: rs.ByteVec, value: [rs.ByteSlice, rs.ByteSlice]): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[1]), f, rs.u8Debug)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[1]), f, rs.u8Debug)], f)]))); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_unit_ref_slice_unit(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtUnit)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtUnit)], f)]))); } /** What `{:?}` writes of `value`. */ export function text$u32(out: rs.ByteVec, value: rs.u32): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(value, f)]))); } /** What `{:?}` writes of `value`. */ export function text$u8(out: rs.ByteVec, value: rs.u8): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(value, f)]))); } /** What `{:?}` writes of `value`. */ export function text$unit(out: rs.ByteVec, _value: undefined): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]))); } /** @@ -1694,11 +1657,9 @@ export function searched$String(q: rs.VecDeque, arg: rs.u8, out: rs.Byte text$String(out, y); return rs.cmpStr(y, x); })); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: string): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(x, f)]), (y2: string): string => { text$String(out, y2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(y2, f)]; - return rs.fmtFormat([args4[0]]); + return rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(y2, f)]); }, rs.cmpStr)); put(out, rs.dequePartitionPoint(q, (y3: string): boolean => { text$String(out, y3); @@ -1717,11 +1678,9 @@ export function searched$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs. text$rings_Big(out, y); return Big.cmp$cmp_Ord(y, x); })); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: Big.Big): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(x, f)]), (y2: Big.Big): string => { text$rings_Big(out, y2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(y2, f)]; - return rs.fmtFormat([args4[0]]); + return rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(y2, f)]); }, rs.cmpStr)); put(out, rs.dequePartitionPoint(q, (y3: Big.Big): boolean => { text$rings_Big(out, y3); @@ -1740,11 +1699,9 @@ export function searched$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec text$u32(out, y); return rs.cmp(y, x); })); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u32): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(x, f)]), (y2: rs.u32): string => { text$u32(out, y2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(y2, f)]; - return rs.fmtFormat([args4[0]]); + return rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(y2, f)]); }, rs.cmpStr)); put(out, rs.dequePartitionPoint(q, (y3: rs.u32): boolean => { text$u32(out, y3); @@ -1763,11 +1720,9 @@ export function searched$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): text$u8(out, y); return rs.cmp(y, x); })); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(x, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u8): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(x, f)]), (y2: rs.u8): string => { text$u8(out, y2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(y2, f)]; - return rs.fmtFormat([args4[0]]); + return rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(y2, f)]); }, rs.cmpStr)); put(out, rs.dequePartitionPoint(q, (y3: rs.u8): boolean => { text$u8(out, y3); @@ -1786,11 +1741,9 @@ export function searched$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byt text$unit(out, y); return rs.cmpNothing(y, undefined); })); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: undefined): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]), (y2: undefined): string => { text$unit(out, y2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - return rs.fmtFormat([args4[0]]); + return rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]); }, rs.cmpStr)); put(out, rs.dequePartitionPoint(q, (y3: undefined): boolean => { text$unit(out, y3); diff --git a/ts/fixtures/lang/saturates/expected/harness.ts b/ts/fixtures/lang/saturates/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/saturates/expected/harness.ts +++ b/ts/fixtures/lang/saturates/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/saturates/expected/saturates.ts b/ts/fixtures/lang/saturates/expected/saturates.ts index d315932d5..43ecab97a 100644 --- a/ts/fixtures/lang/saturates/expected/saturates.ts +++ b/ts/fixtures/lang/saturates/expected/saturates.ts @@ -364,8 +364,8 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { const all: rs.u8[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u8SaturatingAdd, 0); @@ -389,8 +389,8 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _370[0]; const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u8(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u8(x7), hashed$num_Saturating_u8(a)) ? 1 : 0); @@ -562,8 +562,8 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { const all: rs.u16[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u16SaturatingAdd, 0); @@ -587,8 +587,8 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _370[0]; const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u16(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u16(x7), hashed$num_Saturating_u16(a)) ? 1 : 0); @@ -760,8 +760,8 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { const all: rs.u32[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u32SaturatingAdd, 0); @@ -785,8 +785,8 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _370[0]; const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u32(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u32(x7), hashed$num_Saturating_u32(a)) ? 1 : 0); @@ -958,8 +958,8 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { const all: rs.u64[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u64SaturatingAdd, 0); @@ -983,8 +983,8 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _370[0]; const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u64(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u64(x7), hashed$num_Saturating_u64(a)) ? 1 : 0); @@ -1156,8 +1156,8 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { const all: rs.u128[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u128SaturatingAdd, 0); @@ -1181,8 +1181,8 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _370[0]; const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u128(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u128(x7), hashed$num_Saturating_u128(a)) ? 1 : 0); @@ -1354,8 +1354,8 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { const all: rs.usize[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.usizeSaturatingAdd, 0); @@ -1379,8 +1379,8 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _370[0]; const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_usize(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_usize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_usize(x7), hashed$num_Saturating_usize(a)) ? 1 : 0); @@ -1559,8 +1559,8 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1572,8 +1572,8 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _344[0]; const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i8(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i8(x7), hashed$num_Saturating_i8(a)) ? 1 : 0); @@ -1753,8 +1753,8 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1766,8 +1766,8 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _344[0]; const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i16(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i16(x7), hashed$num_Saturating_i16(a)) ? 1 : 0); @@ -1947,8 +1947,8 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1960,8 +1960,8 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _344[0]; const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i32(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i32(x7), hashed$num_Saturating_i32(a)) ? 1 : 0); @@ -2141,8 +2141,8 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2154,8 +2154,8 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _344[0]; const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i64(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i64(x7), hashed$num_Saturating_i64(a)) ? 1 : 0); @@ -2335,8 +2335,8 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2348,8 +2348,8 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _344[0]; const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i128(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i128(x7), hashed$num_Saturating_i128(a)) ? 1 : 0); @@ -2529,8 +2529,8 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2542,8 +2542,8 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Gauge.Gauge = _344[0]; const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_isize(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_isize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_isize(x7), hashed$num_Saturating_isize(a)) ? 1 : 0); diff --git a/ts/fixtures/lang/searches/expected/harness.ts b/ts/fixtures/lang/searches/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/searches/expected/harness.ts +++ b/ts/fixtures/lang/searches/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/separated/expected/harness.ts b/ts/fixtures/lang/separated/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/separated/expected/harness.ts +++ b/ts/fixtures/lang/separated/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts b/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts index 77eb25d3a..7058e9bf5 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts @@ -24,8 +24,7 @@ export function fmt$fmt_Debug(self: Dropper, f: rs.Formatter): rs.Result { const arg = self.tag; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - return rs.fmtPad(f, rs.fmtFormat(["n", args2[0]])); + return rs.fmtPad(f, rs.fmtFormat(["n", (f: rs.Formatter) => rs.u8Display(arg, f)])); } export function drop$ops_Drop(self: Dropper): void { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Fails.ts b/ts/fixtures/lang/shapes/expected/fmt.Fails.ts index 607af5968..b3ea361a6 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Fails.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Fails.ts @@ -10,8 +10,7 @@ export interface Fails { export function fmt$fmt_Display(self: Fails, f: rs.Formatter): rs.Result { if (!(rs.u8Rem(self._0, 2) === 0)) { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - if (rs.fmtWriteFmt(f, ["half ", args2[0]]).ok) { + if (rs.fmtWriteFmt(f, ["half ", (f: rs.Formatter) => rs.u8Display(arg, f)]).ok) { return rs.Err(new rs.FmtError()); } return rs.Err(new rs.FmtError()); diff --git a/ts/fixtures/lang/shapes/expected/fmt.Fault.ts b/ts/fixtures/lang/shapes/expected/fmt.Fault.ts index dbc65dd04..0301c3037 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Fault.ts @@ -42,19 +42,17 @@ export function fmt$fmt_Display(self: Fault, f: rs.Formatter): rs.Result rs.u16LowerHex(arg4, f)]; - return rs.fmtWriteFmt(f, ["code=", rs.fmtSpec({ alternate: true, zero: true, width: 6 }, args2[0])]); + return rs.fmtWriteFmt(f, ["code=", rs.fmtSpec({ alternate: true, zero: true, width: 6 }, (f: rs.Formatter) => rs.u16LowerHex(arg4, f))]); } if (self.tag === "TooLarge") { const arg2 = self.size; const _20: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg2, f); const arg3 = self.max; - const args4: rs.Fmt[] = [_20, (f: rs.Formatter) => rs.usizeDisplay(arg3, f)]; - return rs.fmtWriteFmt(f, [args4[0], " bytes exceeds the ", args4[1], " byte limit"]); + const args8 = [_20, (f: rs.Formatter) => rs.usizeDisplay(arg3, f)]; + return rs.fmtWriteFmt(f, [args8[0], " bytes exceeds the ", args8[1], " byte limit"]); } const arg = self._0; - const args6: rs.Fmt[] = [(f: rs.Formatter) => Pair.fmt$fmt_Debug(arg, f)]; - return rs.fmtWriteFmt(f, ["at ", args6[0]]); + return rs.fmtWriteFmt(f, ["at ", (f: rs.Formatter) => Pair.fmt$fmt_Debug(arg, f)]); } /** The fault `data` picks. */ diff --git a/ts/fixtures/lang/shapes/expected/fmt.Hex.ts b/ts/fixtures/lang/shapes/expected/fmt.Hex.ts index 74f6d0d2d..7db5c6656 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Hex.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Hex.ts @@ -13,8 +13,7 @@ export function fmt$fmt_Binary(self: Hex, f: rs.Formatter): rs.Result { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Octal(arg, f)]; - return rs.fmtWriteFmt(f, [args2[0]]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u32Octal(arg, f)]); } export function fmt$fmt_LowerExp(self: Hex, f: rs.Formatter): rs.Result { @@ -28,12 +27,10 @@ export function fmt$fmt_UpperExp(self: Hex, f: rs.Formatter): rs.Result { if (!rs.fmtAlternate(f)) { const arg2 = self._0; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerHex(arg2, f)]; - return rs.fmtWriteFmt(f, [args4[0]]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u32LowerHex(arg2, f)]); } const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerHex(arg, f)]; - return rs.fmtWriteFmt(f, [rs.fmtSpec({ alternate: true }, args2[0])]); + return rs.fmtWriteFmt(f, [rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.u32LowerHex(arg, f))]); } export function fmt$fmt_Debug(self: Hex, f: rs.Formatter): rs.Result { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts b/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts index ae37d4ca1..1755486a6 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts @@ -13,8 +13,8 @@ export function fmt$fmt_Display(self: Lettered, f: rs.Formatter): rs.Result rs.fmtCharDisplay(arg, f); const arg2 = self._0; - const args2: rs.Fmt[] = [_16, (f: rs.Formatter) => rs.fmtCharDisplay(arg2, f)]; - return rs.fmtWriteFmt(f, [args2[0], rs.fmtSpec({ align: ">", width: 3 }, args2[1])]); + const args3 = [_16, (f: rs.Formatter) => rs.fmtCharDisplay(arg2, f)]; + return rs.fmtWriteFmt(f, [args3[0], rs.fmtSpec({ align: ">", width: 3 }, args3[1])]); } return rs.Err(new rs.FmtError()); } diff --git a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts index 415817080..47181b96b 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts @@ -7,8 +7,18 @@ import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; export function fmt$fmt_Debug(self: Nested, f: rs.Formatter): rs.Result { - const names: string[] = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; - return rs.fmtDebugStructFields(f, "Nested", names, [(f: rs.Formatter) => rs.fmtStr(self.name, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(self.point, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.shape, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.tags), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(self.pairs.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.maybe, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.none, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(self.list, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]); + const names: rs.Slice = rs.sliceFrom(["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]); + const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.name, f); + const _9: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.point, f); + const _11: rs.Fmt = (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.shape, f); + const _13: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.tags), f, rs.u8Debug); + const _15: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.pairs.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)); + const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.maybe, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)); + const _19: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.none, f, rs.u8Debug); + const _21: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, rs.fmtStr); + const _24: rs.Slice = rs.sliceFrom(self.list); + const values: rs.Slice = rs.sliceFrom([_7, _9, _11, _13, _15, _17, _19, _21, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_24), f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]); + return rs.fmtDebugStructFields(f, "Nested", rs.sliceItems(names), rs.sliceItems(values)); } export interface Nested { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Noted.ts b/ts/fixtures/lang/shapes/expected/fmt.Noted.ts index 0e0c237bf..65502a86f 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Noted.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Noted.ts @@ -12,8 +12,8 @@ export function fmt$fmt_Display(self: Noted, f: rs.Formatter): rs.Result rs.u8Display(_7, f), (f: rs.Formatter) => rs.fmtBool(_11, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(log), f, rs.u8Debug)]; - return rs.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(_7, f), (f: rs.Formatter) => rs.fmtBool(_11, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(log), f, rs.u8Debug)]; + return rs.fmtWriteFmt(f, [args3[0], " ", args3[1], " ", args3[2]]); } //# sourceMappingURL=fmt.Noted.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Wide.ts b/ts/fixtures/lang/shapes/expected/fmt.Wide.ts index bd736f9cd..e43a876ae 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Wide.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Wide.ts @@ -3,8 +3,9 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug(self: Wide, f: rs.Formatter): rs.Result { - const names: string[] = ["a", "b", "c", "d", "e", "f"]; - return rs.fmtDebugStructFields(f, "Wide", names, [(f: rs.Formatter) => rs.u8Debug(self.a, f), (f: rs.Formatter) => rs.u16Debug(self.b, f), (f: rs.Formatter) => rs.u32Debug(self.c, f), (f: rs.Formatter) => rs.u64Debug(self.d, f), (f: rs.Formatter) => rs.i8Debug(self.e, f), (f: rs.Formatter) => rs.fmtBool(self.f, f)]); + const names: rs.Slice = rs.sliceFrom(["a", "b", "c", "d", "e", "f"]); + const values: rs.Slice = rs.sliceFrom([(f: rs.Formatter) => rs.u8Debug(self.a, f), (f: rs.Formatter) => rs.u16Debug(self.b, f), (f: rs.Formatter) => rs.u32Debug(self.c, f), (f: rs.Formatter) => rs.u64Debug(self.d, f), (f: rs.Formatter) => rs.i8Debug(self.e, f), (f: rs.Formatter) => rs.fmtBool(self.f, f)]); + return rs.fmtDebugStructFields(f, "Wide", rs.sliceItems(names), rs.sliceItems(values)); } /** Past five fields, derived `Debug` takes the fields as slices. */ diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index 08f41a537..ca6999aae 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -43,144 +43,144 @@ export function ints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); const v: rs.u8 = rs.u8FromBeBytes(buf); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8Debug(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8UpperHex(v, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rs.fmtSpec({ alternate: true }, args2[1]), " ", rs.fmtSpec({ width: 3 }, args2[1])])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8Binary(v, f), (f: rs.Formatter) => rs.u8Octal(v, f), (f: rs.Formatter) => rs.u8Debug(v, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args4[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args4[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args4[1]), " ", args4[0], " ", rs.fmtSpec({ precision: 3 }, args4[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args4[0]), "|", args4[2], " ", rs.fmtSpec({ alternate: true }, args4[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args4[2]), " ", args4[3], " ", rs.fmtSpec({ alternate: true }, args4[3]), " ", rs.fmtSpec({ plus: true }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args4[4]), " ", rs.fmtSpec({ plus: true }, args4[4])])); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerExp(v, f), (f: rs.Formatter) => rs.u8UpperExp(v, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 3 }, args6[0]), " ", rs.fmtSpec({ precision: 45 }, args6[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args6[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args6[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args6[0]), "| ", rs.fmtSpec({ alternate: true }, args6[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args6[1]), "|"])); + const args106 = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8Debug(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8UpperHex(v, f)]; + put(out, rs.fmtFormat([args106[0], " ", args106[1], " ", rs.fmtSpec({ width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args106[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args106[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args106[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args106[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args106[0]), "|", args106[2], " ", args106[3], " ", rs.fmtSpec({ alternate: true }, args106[2]), " ", rs.fmtSpec({ alternate: true }, args106[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args106[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args106[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args106[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args106[3]), "|", rs.fmtSpec({ alternate: true }, args106[1]), " ", rs.fmtSpec({ width: 3 }, args106[1])])); + const args107 = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8Binary(v, f), (f: rs.Formatter) => rs.u8Octal(v, f), (f: rs.Formatter) => rs.u8Debug(v, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args107[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args107[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args107[1]), " ", args107[0], " ", rs.fmtSpec({ precision: 3 }, args107[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args107[0]), "|", args107[2], " ", rs.fmtSpec({ alternate: true }, args107[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args107[2]), " ", args107[3], " ", rs.fmtSpec({ alternate: true }, args107[3]), " ", rs.fmtSpec({ plus: true }, args107[3]), "|", rs.fmtSpec({ debugHex: "x" }, args107[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args107[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args107[4]), " ", rs.fmtSpec({ plus: true }, args107[4])])); + const args108 = [(f: rs.Formatter) => rs.u8LowerExp(v, f), (f: rs.Formatter) => rs.u8UpperExp(v, f)]; + put(out, rs.fmtFormat([args108[0], " ", args108[1], " ", rs.fmtSpec({ precision: 0 }, args108[0]), " ", rs.fmtSpec({ precision: 1 }, args108[0]), " ", rs.fmtSpec({ precision: 3 }, args108[0]), " ", rs.fmtSpec({ precision: 45 }, args108[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args108[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args108[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args108[0]), "| ", rs.fmtSpec({ alternate: true }, args108[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args108[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(v, f))); } else if (_4 === 1) { const buf2: Uint8Array = rs.bytes(2); const n2: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf2).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(data, 0, n2)); const v2: rs.u16 = rs.u16FromBeBytes(buf2); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16UpperHex(v2, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", rs.fmtSpec({ width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rs.fmtSpec({ alternate: true }, args8[2]), " ", rs.fmtSpec({ alternate: true }, args8[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rs.fmtSpec({ alternate: true }, args8[1]), " ", rs.fmtSpec({ width: 3 }, args8[1])])); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16Binary(v2, f), (f: rs.Formatter) => rs.u16Octal(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args10[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args10[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args10[1]), " ", args10[0], " ", rs.fmtSpec({ precision: 3 }, args10[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args10[0]), "|", args10[2], " ", rs.fmtSpec({ alternate: true }, args10[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args10[2]), " ", args10[3], " ", rs.fmtSpec({ alternate: true }, args10[3]), " ", rs.fmtSpec({ plus: true }, args10[3]), "|", rs.fmtSpec({ debugHex: "x" }, args10[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args10[4]), " ", rs.fmtSpec({ plus: true }, args10[4])])); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u16LowerExp(v2, f), (f: rs.Formatter) => rs.u16UpperExp(v2, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ precision: 0 }, args12[0]), " ", rs.fmtSpec({ precision: 1 }, args12[0]), " ", rs.fmtSpec({ precision: 3 }, args12[0]), " ", rs.fmtSpec({ precision: 45 }, args12[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args12[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args12[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args12[0]), "| ", rs.fmtSpec({ alternate: true }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args12[1]), "|"])); + const args103 = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16UpperHex(v2, f)]; + put(out, rs.fmtFormat([args103[0], " ", args103[1], " ", rs.fmtSpec({ width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args103[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args103[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args103[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args103[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args103[0]), "|", args103[2], " ", args103[3], " ", rs.fmtSpec({ alternate: true }, args103[2]), " ", rs.fmtSpec({ alternate: true }, args103[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args103[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args103[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args103[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args103[3]), "|", rs.fmtSpec({ alternate: true }, args103[1]), " ", rs.fmtSpec({ width: 3 }, args103[1])])); + const args104 = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16Binary(v2, f), (f: rs.Formatter) => rs.u16Octal(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args104[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args104[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args104[1]), " ", args104[0], " ", rs.fmtSpec({ precision: 3 }, args104[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args104[0]), "|", args104[2], " ", rs.fmtSpec({ alternate: true }, args104[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args104[2]), " ", args104[3], " ", rs.fmtSpec({ alternate: true }, args104[3]), " ", rs.fmtSpec({ plus: true }, args104[3]), "|", rs.fmtSpec({ debugHex: "x" }, args104[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args104[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args104[4]), " ", rs.fmtSpec({ plus: true }, args104[4])])); + const args105 = [(f: rs.Formatter) => rs.u16LowerExp(v2, f), (f: rs.Formatter) => rs.u16UpperExp(v2, f)]; + put(out, rs.fmtFormat([args105[0], " ", args105[1], " ", rs.fmtSpec({ precision: 0 }, args105[0]), " ", rs.fmtSpec({ precision: 1 }, args105[0]), " ", rs.fmtSpec({ precision: 3 }, args105[0]), " ", rs.fmtSpec({ precision: 45 }, args105[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args105[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args105[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args105[0]), "| ", rs.fmtSpec({ alternate: true }, args105[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args105[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.u16Display(v2, f))); } else if (_4 === 2) { const buf3: Uint8Array = rs.bytes(4); const n3: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf3).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(data, 0, n3)); const v3: rs.u32 = rs.u32FromBeBytes(buf3); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32UpperHex(v3, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rs.fmtSpec({ alternate: true }, args14[2]), " ", rs.fmtSpec({ alternate: true }, args14[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rs.fmtSpec({ alternate: true }, args14[1]), " ", rs.fmtSpec({ width: 3 }, args14[1])])); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32Binary(v3, f), (f: rs.Formatter) => rs.u32Octal(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args16[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args16[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args16[1]), " ", args16[0], " ", rs.fmtSpec({ precision: 3 }, args16[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args16[0]), "|", args16[2], " ", rs.fmtSpec({ alternate: true }, args16[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args16[2]), " ", args16[3], " ", rs.fmtSpec({ alternate: true }, args16[3]), " ", rs.fmtSpec({ plus: true }, args16[3]), "|", rs.fmtSpec({ debugHex: "x" }, args16[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args16[4]), " ", rs.fmtSpec({ plus: true }, args16[4])])); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerExp(v3, f), (f: rs.Formatter) => rs.u32UpperExp(v3, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", rs.fmtSpec({ precision: 0 }, args18[0]), " ", rs.fmtSpec({ precision: 1 }, args18[0]), " ", rs.fmtSpec({ precision: 3 }, args18[0]), " ", rs.fmtSpec({ precision: 45 }, args18[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args18[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args18[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args18[0]), "| ", rs.fmtSpec({ alternate: true }, args18[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args18[1]), "|"])); + const args100 = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32UpperHex(v3, f)]; + put(out, rs.fmtFormat([args100[0], " ", args100[1], " ", rs.fmtSpec({ width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args100[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args100[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args100[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args100[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args100[0]), "|", args100[2], " ", args100[3], " ", rs.fmtSpec({ alternate: true }, args100[2]), " ", rs.fmtSpec({ alternate: true }, args100[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args100[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args100[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args100[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args100[3]), "|", rs.fmtSpec({ alternate: true }, args100[1]), " ", rs.fmtSpec({ width: 3 }, args100[1])])); + const args101 = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32Binary(v3, f), (f: rs.Formatter) => rs.u32Octal(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args101[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args101[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args101[1]), " ", args101[0], " ", rs.fmtSpec({ precision: 3 }, args101[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args101[0]), "|", args101[2], " ", rs.fmtSpec({ alternate: true }, args101[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args101[2]), " ", args101[3], " ", rs.fmtSpec({ alternate: true }, args101[3]), " ", rs.fmtSpec({ plus: true }, args101[3]), "|", rs.fmtSpec({ debugHex: "x" }, args101[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args101[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args101[4]), " ", rs.fmtSpec({ plus: true }, args101[4])])); + const args102 = [(f: rs.Formatter) => rs.u32LowerExp(v3, f), (f: rs.Formatter) => rs.u32UpperExp(v3, f)]; + put(out, rs.fmtFormat([args102[0], " ", args102[1], " ", rs.fmtSpec({ precision: 0 }, args102[0]), " ", rs.fmtSpec({ precision: 1 }, args102[0]), " ", rs.fmtSpec({ precision: 3 }, args102[0]), " ", rs.fmtSpec({ precision: 45 }, args102[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args102[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args102[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args102[0]), "| ", rs.fmtSpec({ alternate: true }, args102[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args102[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.u32Display(v3, f))); } else if (_4 === 3) { const buf4: Uint8Array = rs.bytes(8); const n4: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf4).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf4), 0, n4), rs.byteSliceRange(data, 0, n4)); const v4: rs.u64 = rs.u64FromBeBytes(buf4); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64UpperHex(v4, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " ", rs.fmtSpec({ width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rs.fmtSpec({ alternate: true }, args20[2]), " ", rs.fmtSpec({ alternate: true }, args20[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rs.fmtSpec({ alternate: true }, args20[1]), " ", rs.fmtSpec({ width: 3 }, args20[1])])); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64Binary(v4, f), (f: rs.Formatter) => rs.u64Octal(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args22[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args22[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args22[1]), " ", args22[0], " ", rs.fmtSpec({ precision: 3 }, args22[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args22[0]), "|", args22[2], " ", rs.fmtSpec({ alternate: true }, args22[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args22[2]), " ", args22[3], " ", rs.fmtSpec({ alternate: true }, args22[3]), " ", rs.fmtSpec({ plus: true }, args22[3]), "|", rs.fmtSpec({ debugHex: "x" }, args22[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args22[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args22[4]), " ", rs.fmtSpec({ plus: true }, args22[4])])); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u64LowerExp(v4, f), (f: rs.Formatter) => rs.u64UpperExp(v4, f)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", rs.fmtSpec({ precision: 0 }, args24[0]), " ", rs.fmtSpec({ precision: 1 }, args24[0]), " ", rs.fmtSpec({ precision: 3 }, args24[0]), " ", rs.fmtSpec({ precision: 45 }, args24[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args24[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args24[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args24[0]), "| ", rs.fmtSpec({ alternate: true }, args24[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args24[1]), "|"])); + const args97 = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64UpperHex(v4, f)]; + put(out, rs.fmtFormat([args97[0], " ", args97[1], " ", rs.fmtSpec({ width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args97[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args97[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args97[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args97[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args97[0]), "|", args97[2], " ", args97[3], " ", rs.fmtSpec({ alternate: true }, args97[2]), " ", rs.fmtSpec({ alternate: true }, args97[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args97[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args97[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args97[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args97[3]), "|", rs.fmtSpec({ alternate: true }, args97[1]), " ", rs.fmtSpec({ width: 3 }, args97[1])])); + const args98 = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64Binary(v4, f), (f: rs.Formatter) => rs.u64Octal(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args98[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args98[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args98[1]), " ", args98[0], " ", rs.fmtSpec({ precision: 3 }, args98[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args98[0]), "|", args98[2], " ", rs.fmtSpec({ alternate: true }, args98[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args98[2]), " ", args98[3], " ", rs.fmtSpec({ alternate: true }, args98[3]), " ", rs.fmtSpec({ plus: true }, args98[3]), "|", rs.fmtSpec({ debugHex: "x" }, args98[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args98[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args98[4]), " ", rs.fmtSpec({ plus: true }, args98[4])])); + const args99 = [(f: rs.Formatter) => rs.u64LowerExp(v4, f), (f: rs.Formatter) => rs.u64UpperExp(v4, f)]; + put(out, rs.fmtFormat([args99[0], " ", args99[1], " ", rs.fmtSpec({ precision: 0 }, args99[0]), " ", rs.fmtSpec({ precision: 1 }, args99[0]), " ", rs.fmtSpec({ precision: 3 }, args99[0]), " ", rs.fmtSpec({ precision: 45 }, args99[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args99[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args99[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args99[0]), "| ", rs.fmtSpec({ alternate: true }, args99[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args99[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.u64Display(v4, f))); } else if (_4 === 4) { const buf5: Uint8Array = rs.bytes(16); const n5: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf5).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf5), 0, n5), rs.byteSliceRange(data, 0, n5)); const v5: rs.u128 = rs.u128FromBeBytes(buf5); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128UpperHex(v5, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args26[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args26[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args26[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args26[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args26[0]), "|", args26[2], " ", args26[3], " ", rs.fmtSpec({ alternate: true }, args26[2]), " ", rs.fmtSpec({ alternate: true }, args26[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args26[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args26[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args26[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args26[3]), "|", rs.fmtSpec({ alternate: true }, args26[1]), " ", rs.fmtSpec({ width: 3 }, args26[1])])); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128Binary(v5, f), (f: rs.Formatter) => rs.u128Octal(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args28[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args28[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args28[1]), " ", args28[0], " ", rs.fmtSpec({ precision: 3 }, args28[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args28[0]), "|", args28[2], " ", rs.fmtSpec({ alternate: true }, args28[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args28[2]), " ", args28[3], " ", rs.fmtSpec({ alternate: true }, args28[3]), " ", rs.fmtSpec({ plus: true }, args28[3]), "|", rs.fmtSpec({ debugHex: "x" }, args28[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args28[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args28[4]), " ", rs.fmtSpec({ plus: true }, args28[4])])); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u128LowerExp(v5, f), (f: rs.Formatter) => rs.u128UpperExp(v5, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " ", rs.fmtSpec({ precision: 0 }, args30[0]), " ", rs.fmtSpec({ precision: 1 }, args30[0]), " ", rs.fmtSpec({ precision: 3 }, args30[0]), " ", rs.fmtSpec({ precision: 45 }, args30[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args30[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args30[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args30[0]), "| ", rs.fmtSpec({ alternate: true }, args30[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args30[1]), "|"])); + const args94 = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128UpperHex(v5, f)]; + put(out, rs.fmtFormat([args94[0], " ", args94[1], " ", rs.fmtSpec({ width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args94[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args94[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args94[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args94[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args94[0]), "|", args94[2], " ", args94[3], " ", rs.fmtSpec({ alternate: true }, args94[2]), " ", rs.fmtSpec({ alternate: true }, args94[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args94[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args94[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args94[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args94[3]), "|", rs.fmtSpec({ alternate: true }, args94[1]), " ", rs.fmtSpec({ width: 3 }, args94[1])])); + const args95 = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128Binary(v5, f), (f: rs.Formatter) => rs.u128Octal(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args95[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args95[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args95[1]), " ", args95[0], " ", rs.fmtSpec({ precision: 3 }, args95[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args95[0]), "|", args95[2], " ", rs.fmtSpec({ alternate: true }, args95[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args95[2]), " ", args95[3], " ", rs.fmtSpec({ alternate: true }, args95[3]), " ", rs.fmtSpec({ plus: true }, args95[3]), "|", rs.fmtSpec({ debugHex: "x" }, args95[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args95[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args95[4]), " ", rs.fmtSpec({ plus: true }, args95[4])])); + const args96 = [(f: rs.Formatter) => rs.u128LowerExp(v5, f), (f: rs.Formatter) => rs.u128UpperExp(v5, f)]; + put(out, rs.fmtFormat([args96[0], " ", args96[1], " ", rs.fmtSpec({ precision: 0 }, args96[0]), " ", rs.fmtSpec({ precision: 1 }, args96[0]), " ", rs.fmtSpec({ precision: 3 }, args96[0]), " ", rs.fmtSpec({ precision: 45 }, args96[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args96[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args96[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args96[0]), "| ", rs.fmtSpec({ alternate: true }, args96[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args96[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.u128Display(v5, f))); } else if (_4 === 5) { const buf6: Uint8Array = rs.bytes(4); const n6: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf6).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf6), 0, n6), rs.byteSliceRange(data, 0, n6)); const v6: rs.usize = rs.usizeFromBeBytes(buf6); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeUpperHex(v6, f)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", rs.fmtSpec({ width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args32[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args32[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args32[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args32[0]), "|", args32[2], " ", args32[3], " ", rs.fmtSpec({ alternate: true }, args32[2]), " ", rs.fmtSpec({ alternate: true }, args32[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args32[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args32[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args32[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args32[3]), "|", rs.fmtSpec({ alternate: true }, args32[1]), " ", rs.fmtSpec({ width: 3 }, args32[1])])); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeBinary(v6, f), (f: rs.Formatter) => rs.usizeOctal(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args34[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args34[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args34[1]), " ", args34[0], " ", rs.fmtSpec({ precision: 3 }, args34[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", args34[2], " ", rs.fmtSpec({ alternate: true }, args34[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args34[2]), " ", args34[3], " ", rs.fmtSpec({ alternate: true }, args34[3]), " ", rs.fmtSpec({ plus: true }, args34[3]), "|", rs.fmtSpec({ debugHex: "x" }, args34[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args34[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args34[4]), " ", rs.fmtSpec({ plus: true }, args34[4])])); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeLowerExp(v6, f), (f: rs.Formatter) => rs.usizeUpperExp(v6, f)]; - put(out, rs.fmtFormat([args36[0], " ", args36[1], " ", rs.fmtSpec({ precision: 0 }, args36[0]), " ", rs.fmtSpec({ precision: 1 }, args36[0]), " ", rs.fmtSpec({ precision: 3 }, args36[0]), " ", rs.fmtSpec({ precision: 45 }, args36[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args36[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args36[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args36[0]), "| ", rs.fmtSpec({ alternate: true }, args36[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args36[1]), "|"])); + const args91 = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeUpperHex(v6, f)]; + put(out, rs.fmtFormat([args91[0], " ", args91[1], " ", rs.fmtSpec({ width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args91[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args91[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args91[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args91[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args91[0]), "|", args91[2], " ", args91[3], " ", rs.fmtSpec({ alternate: true }, args91[2]), " ", rs.fmtSpec({ alternate: true }, args91[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args91[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args91[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args91[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args91[3]), "|", rs.fmtSpec({ alternate: true }, args91[1]), " ", rs.fmtSpec({ width: 3 }, args91[1])])); + const args92 = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeBinary(v6, f), (f: rs.Formatter) => rs.usizeOctal(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args92[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args92[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args92[1]), " ", args92[0], " ", rs.fmtSpec({ precision: 3 }, args92[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args92[0]), "|", args92[2], " ", rs.fmtSpec({ alternate: true }, args92[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args92[2]), " ", args92[3], " ", rs.fmtSpec({ alternate: true }, args92[3]), " ", rs.fmtSpec({ plus: true }, args92[3]), "|", rs.fmtSpec({ debugHex: "x" }, args92[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args92[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args92[4]), " ", rs.fmtSpec({ plus: true }, args92[4])])); + const args93 = [(f: rs.Formatter) => rs.usizeLowerExp(v6, f), (f: rs.Formatter) => rs.usizeUpperExp(v6, f)]; + put(out, rs.fmtFormat([args93[0], " ", args93[1], " ", rs.fmtSpec({ precision: 0 }, args93[0]), " ", rs.fmtSpec({ precision: 1 }, args93[0]), " ", rs.fmtSpec({ precision: 3 }, args93[0]), " ", rs.fmtSpec({ precision: 45 }, args93[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args93[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args93[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args93[0]), "| ", rs.fmtSpec({ alternate: true }, args93[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args93[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v6, f))); } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); const n7: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf7).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf7), 0, n7), rs.byteSliceRange(data, 0, n7)); const v7: rs.i8 = rs.i8FromBeBytes(buf7); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8UpperHex(v7, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", rs.fmtSpec({ width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args38[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args38[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args38[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args38[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args38[0]), "|", args38[2], " ", args38[3], " ", rs.fmtSpec({ alternate: true }, args38[2]), " ", rs.fmtSpec({ alternate: true }, args38[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args38[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args38[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args38[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args38[3]), "|", rs.fmtSpec({ alternate: true }, args38[1]), " ", rs.fmtSpec({ width: 3 }, args38[1])])); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8Binary(v7, f), (f: rs.Formatter) => rs.i8Octal(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args40[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args40[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args40[1]), " ", args40[0], " ", rs.fmtSpec({ precision: 3 }, args40[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args40[0]), "|", args40[2], " ", rs.fmtSpec({ alternate: true }, args40[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args40[2]), " ", args40[3], " ", rs.fmtSpec({ alternate: true }, args40[3]), " ", rs.fmtSpec({ plus: true }, args40[3]), "|", rs.fmtSpec({ debugHex: "x" }, args40[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args40[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args40[4]), " ", rs.fmtSpec({ plus: true }, args40[4])])); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.i8LowerExp(v7, f), (f: rs.Formatter) => rs.i8UpperExp(v7, f)]; - put(out, rs.fmtFormat([args42[0], " ", args42[1], " ", rs.fmtSpec({ precision: 0 }, args42[0]), " ", rs.fmtSpec({ precision: 1 }, args42[0]), " ", rs.fmtSpec({ precision: 3 }, args42[0]), " ", rs.fmtSpec({ precision: 45 }, args42[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args42[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args42[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args42[0]), "| ", rs.fmtSpec({ alternate: true }, args42[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args42[1]), "|"])); + const args88 = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8UpperHex(v7, f)]; + put(out, rs.fmtFormat([args88[0], " ", args88[1], " ", rs.fmtSpec({ width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args88[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args88[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args88[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args88[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args88[0]), "|", args88[2], " ", args88[3], " ", rs.fmtSpec({ alternate: true }, args88[2]), " ", rs.fmtSpec({ alternate: true }, args88[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args88[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args88[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args88[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args88[3]), "|", rs.fmtSpec({ alternate: true }, args88[1]), " ", rs.fmtSpec({ width: 3 }, args88[1])])); + const args89 = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8Binary(v7, f), (f: rs.Formatter) => rs.i8Octal(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args89[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args89[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args89[1]), " ", args89[0], " ", rs.fmtSpec({ precision: 3 }, args89[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args89[0]), "|", args89[2], " ", rs.fmtSpec({ alternate: true }, args89[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args89[2]), " ", args89[3], " ", rs.fmtSpec({ alternate: true }, args89[3]), " ", rs.fmtSpec({ plus: true }, args89[3]), "|", rs.fmtSpec({ debugHex: "x" }, args89[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args89[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args89[4]), " ", rs.fmtSpec({ plus: true }, args89[4])])); + const args90 = [(f: rs.Formatter) => rs.i8LowerExp(v7, f), (f: rs.Formatter) => rs.i8UpperExp(v7, f)]; + put(out, rs.fmtFormat([args90[0], " ", args90[1], " ", rs.fmtSpec({ precision: 0 }, args90[0]), " ", rs.fmtSpec({ precision: 1 }, args90[0]), " ", rs.fmtSpec({ precision: 3 }, args90[0]), " ", rs.fmtSpec({ precision: 45 }, args90[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args90[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args90[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args90[0]), "| ", rs.fmtSpec({ alternate: true }, args90[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args90[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.i8Display(v7, f))); } else if (_4 === 7) { const buf8: Uint8Array = rs.bytes(2); const n8: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf8).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf8), 0, n8), rs.byteSliceRange(data, 0, n8)); const v8: rs.i16 = rs.i16FromBeBytes(buf8); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16UpperHex(v8, f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", rs.fmtSpec({ width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args44[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args44[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args44[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args44[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args44[0]), "|", args44[2], " ", args44[3], " ", rs.fmtSpec({ alternate: true }, args44[2]), " ", rs.fmtSpec({ alternate: true }, args44[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args44[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args44[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args44[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args44[3]), "|", rs.fmtSpec({ alternate: true }, args44[1]), " ", rs.fmtSpec({ width: 3 }, args44[1])])); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16Binary(v8, f), (f: rs.Formatter) => rs.i16Octal(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args46[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args46[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args46[1]), " ", args46[0], " ", rs.fmtSpec({ precision: 3 }, args46[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args46[0]), "|", args46[2], " ", rs.fmtSpec({ alternate: true }, args46[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args46[2]), " ", args46[3], " ", rs.fmtSpec({ alternate: true }, args46[3]), " ", rs.fmtSpec({ plus: true }, args46[3]), "|", rs.fmtSpec({ debugHex: "x" }, args46[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args46[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args46[4]), " ", rs.fmtSpec({ plus: true }, args46[4])])); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.i16LowerExp(v8, f), (f: rs.Formatter) => rs.i16UpperExp(v8, f)]; - put(out, rs.fmtFormat([args48[0], " ", args48[1], " ", rs.fmtSpec({ precision: 0 }, args48[0]), " ", rs.fmtSpec({ precision: 1 }, args48[0]), " ", rs.fmtSpec({ precision: 3 }, args48[0]), " ", rs.fmtSpec({ precision: 45 }, args48[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args48[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args48[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args48[0]), "| ", rs.fmtSpec({ alternate: true }, args48[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args48[1]), "|"])); + const args85 = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16UpperHex(v8, f)]; + put(out, rs.fmtFormat([args85[0], " ", args85[1], " ", rs.fmtSpec({ width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args85[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args85[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args85[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args85[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args85[0]), "|", args85[2], " ", args85[3], " ", rs.fmtSpec({ alternate: true }, args85[2]), " ", rs.fmtSpec({ alternate: true }, args85[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args85[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args85[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args85[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args85[3]), "|", rs.fmtSpec({ alternate: true }, args85[1]), " ", rs.fmtSpec({ width: 3 }, args85[1])])); + const args86 = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16Binary(v8, f), (f: rs.Formatter) => rs.i16Octal(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args86[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args86[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args86[1]), " ", args86[0], " ", rs.fmtSpec({ precision: 3 }, args86[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args86[0]), "|", args86[2], " ", rs.fmtSpec({ alternate: true }, args86[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args86[2]), " ", args86[3], " ", rs.fmtSpec({ alternate: true }, args86[3]), " ", rs.fmtSpec({ plus: true }, args86[3]), "|", rs.fmtSpec({ debugHex: "x" }, args86[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args86[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args86[4]), " ", rs.fmtSpec({ plus: true }, args86[4])])); + const args87 = [(f: rs.Formatter) => rs.i16LowerExp(v8, f), (f: rs.Formatter) => rs.i16UpperExp(v8, f)]; + put(out, rs.fmtFormat([args87[0], " ", args87[1], " ", rs.fmtSpec({ precision: 0 }, args87[0]), " ", rs.fmtSpec({ precision: 1 }, args87[0]), " ", rs.fmtSpec({ precision: 3 }, args87[0]), " ", rs.fmtSpec({ precision: 45 }, args87[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args87[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args87[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args87[0]), "| ", rs.fmtSpec({ alternate: true }, args87[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args87[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.i16Display(v8, f))); } else if (_4 === 8) { const buf9: Uint8Array = rs.bytes(4); const n9: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf9).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf9), 0, n9), rs.byteSliceRange(data, 0, n9)); const v9: rs.i32 = rs.i32FromBeBytes(buf9); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32UpperHex(v9, f)]; - put(out, rs.fmtFormat([args50[0], " ", args50[1], " ", rs.fmtSpec({ width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args50[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args50[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args50[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args50[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args50[0]), "|", args50[2], " ", args50[3], " ", rs.fmtSpec({ alternate: true }, args50[2]), " ", rs.fmtSpec({ alternate: true }, args50[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args50[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args50[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args50[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args50[3]), "|", rs.fmtSpec({ alternate: true }, args50[1]), " ", rs.fmtSpec({ width: 3 }, args50[1])])); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32Binary(v9, f), (f: rs.Formatter) => rs.i32Octal(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args52[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args52[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args52[1]), " ", args52[0], " ", rs.fmtSpec({ precision: 3 }, args52[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args52[0]), "|", args52[2], " ", rs.fmtSpec({ alternate: true }, args52[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args52[2]), " ", args52[3], " ", rs.fmtSpec({ alternate: true }, args52[3]), " ", rs.fmtSpec({ plus: true }, args52[3]), "|", rs.fmtSpec({ debugHex: "x" }, args52[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args52[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args52[4]), " ", rs.fmtSpec({ plus: true }, args52[4])])); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.i32LowerExp(v9, f), (f: rs.Formatter) => rs.i32UpperExp(v9, f)]; - put(out, rs.fmtFormat([args54[0], " ", args54[1], " ", rs.fmtSpec({ precision: 0 }, args54[0]), " ", rs.fmtSpec({ precision: 1 }, args54[0]), " ", rs.fmtSpec({ precision: 3 }, args54[0]), " ", rs.fmtSpec({ precision: 45 }, args54[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args54[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args54[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args54[0]), "| ", rs.fmtSpec({ alternate: true }, args54[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args54[1]), "|"])); + const args82 = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32UpperHex(v9, f)]; + put(out, rs.fmtFormat([args82[0], " ", args82[1], " ", rs.fmtSpec({ width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args82[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args82[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args82[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args82[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args82[0]), "|", args82[2], " ", args82[3], " ", rs.fmtSpec({ alternate: true }, args82[2]), " ", rs.fmtSpec({ alternate: true }, args82[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args82[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args82[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args82[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args82[3]), "|", rs.fmtSpec({ alternate: true }, args82[1]), " ", rs.fmtSpec({ width: 3 }, args82[1])])); + const args83 = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32Binary(v9, f), (f: rs.Formatter) => rs.i32Octal(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args83[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args83[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args83[1]), " ", args83[0], " ", rs.fmtSpec({ precision: 3 }, args83[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args83[0]), "|", args83[2], " ", rs.fmtSpec({ alternate: true }, args83[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args83[2]), " ", args83[3], " ", rs.fmtSpec({ alternate: true }, args83[3]), " ", rs.fmtSpec({ plus: true }, args83[3]), "|", rs.fmtSpec({ debugHex: "x" }, args83[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args83[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args83[4]), " ", rs.fmtSpec({ plus: true }, args83[4])])); + const args84 = [(f: rs.Formatter) => rs.i32LowerExp(v9, f), (f: rs.Formatter) => rs.i32UpperExp(v9, f)]; + put(out, rs.fmtFormat([args84[0], " ", args84[1], " ", rs.fmtSpec({ precision: 0 }, args84[0]), " ", rs.fmtSpec({ precision: 1 }, args84[0]), " ", rs.fmtSpec({ precision: 3 }, args84[0]), " ", rs.fmtSpec({ precision: 45 }, args84[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args84[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args84[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args84[0]), "| ", rs.fmtSpec({ alternate: true }, args84[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args84[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.i32Display(v9, f))); } else if (_4 === 9) { const buf10: Uint8Array = rs.bytes(8); const n10: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf10).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf10), 0, n10), rs.byteSliceRange(data, 0, n10)); const v10: rs.i64 = rs.i64FromBeBytes(buf10); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64UpperHex(v10, f)]; - put(out, rs.fmtFormat([args56[0], " ", args56[1], " ", rs.fmtSpec({ width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args56[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args56[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args56[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args56[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args56[0]), "|", args56[2], " ", args56[3], " ", rs.fmtSpec({ alternate: true }, args56[2]), " ", rs.fmtSpec({ alternate: true }, args56[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args56[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args56[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args56[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args56[3]), "|", rs.fmtSpec({ alternate: true }, args56[1]), " ", rs.fmtSpec({ width: 3 }, args56[1])])); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64Binary(v10, f), (f: rs.Formatter) => rs.i64Octal(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args58[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args58[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args58[1]), " ", args58[0], " ", rs.fmtSpec({ precision: 3 }, args58[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args58[0]), "|", args58[2], " ", rs.fmtSpec({ alternate: true }, args58[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args58[2]), " ", args58[3], " ", rs.fmtSpec({ alternate: true }, args58[3]), " ", rs.fmtSpec({ plus: true }, args58[3]), "|", rs.fmtSpec({ debugHex: "x" }, args58[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args58[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args58[4]), " ", rs.fmtSpec({ plus: true }, args58[4])])); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.i64LowerExp(v10, f), (f: rs.Formatter) => rs.i64UpperExp(v10, f)]; - put(out, rs.fmtFormat([args60[0], " ", args60[1], " ", rs.fmtSpec({ precision: 0 }, args60[0]), " ", rs.fmtSpec({ precision: 1 }, args60[0]), " ", rs.fmtSpec({ precision: 3 }, args60[0]), " ", rs.fmtSpec({ precision: 45 }, args60[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args60[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args60[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args60[0]), "| ", rs.fmtSpec({ alternate: true }, args60[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args60[1]), "|"])); + const args79 = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64UpperHex(v10, f)]; + put(out, rs.fmtFormat([args79[0], " ", args79[1], " ", rs.fmtSpec({ width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args79[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args79[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args79[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args79[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args79[0]), "|", args79[2], " ", args79[3], " ", rs.fmtSpec({ alternate: true }, args79[2]), " ", rs.fmtSpec({ alternate: true }, args79[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args79[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args79[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args79[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args79[3]), "|", rs.fmtSpec({ alternate: true }, args79[1]), " ", rs.fmtSpec({ width: 3 }, args79[1])])); + const args80 = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64Binary(v10, f), (f: rs.Formatter) => rs.i64Octal(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args80[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args80[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args80[1]), " ", args80[0], " ", rs.fmtSpec({ precision: 3 }, args80[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args80[0]), "|", args80[2], " ", rs.fmtSpec({ alternate: true }, args80[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args80[2]), " ", args80[3], " ", rs.fmtSpec({ alternate: true }, args80[3]), " ", rs.fmtSpec({ plus: true }, args80[3]), "|", rs.fmtSpec({ debugHex: "x" }, args80[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args80[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args80[4]), " ", rs.fmtSpec({ plus: true }, args80[4])])); + const args81 = [(f: rs.Formatter) => rs.i64LowerExp(v10, f), (f: rs.Formatter) => rs.i64UpperExp(v10, f)]; + put(out, rs.fmtFormat([args81[0], " ", args81[1], " ", rs.fmtSpec({ precision: 0 }, args81[0]), " ", rs.fmtSpec({ precision: 1 }, args81[0]), " ", rs.fmtSpec({ precision: 3 }, args81[0]), " ", rs.fmtSpec({ precision: 45 }, args81[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args81[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args81[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args81[0]), "| ", rs.fmtSpec({ alternate: true }, args81[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args81[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.i64Display(v10, f))); } else if (_4 === 10) { const buf11: Uint8Array = rs.bytes(16); const n11: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf11).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf11), 0, n11), rs.byteSliceRange(data, 0, n11)); const v11: rs.i128 = rs.i128FromBeBytes(buf11); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128UpperHex(v11, f)]; - put(out, rs.fmtFormat([args62[0], " ", args62[1], " ", rs.fmtSpec({ width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args62[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args62[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args62[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args62[0]), "|", args62[2], " ", args62[3], " ", rs.fmtSpec({ alternate: true }, args62[2]), " ", rs.fmtSpec({ alternate: true }, args62[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args62[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args62[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args62[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args62[3]), "|", rs.fmtSpec({ alternate: true }, args62[1]), " ", rs.fmtSpec({ width: 3 }, args62[1])])); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128Binary(v11, f), (f: rs.Formatter) => rs.i128Octal(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args64[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args64[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args64[1]), " ", args64[0], " ", rs.fmtSpec({ precision: 3 }, args64[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args64[0]), "|", args64[2], " ", rs.fmtSpec({ alternate: true }, args64[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args64[2]), " ", args64[3], " ", rs.fmtSpec({ alternate: true }, args64[3]), " ", rs.fmtSpec({ plus: true }, args64[3]), "|", rs.fmtSpec({ debugHex: "x" }, args64[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args64[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args64[4]), " ", rs.fmtSpec({ plus: true }, args64[4])])); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.i128LowerExp(v11, f), (f: rs.Formatter) => rs.i128UpperExp(v11, f)]; - put(out, rs.fmtFormat([args66[0], " ", args66[1], " ", rs.fmtSpec({ precision: 0 }, args66[0]), " ", rs.fmtSpec({ precision: 1 }, args66[0]), " ", rs.fmtSpec({ precision: 3 }, args66[0]), " ", rs.fmtSpec({ precision: 45 }, args66[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args66[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args66[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args66[0]), "| ", rs.fmtSpec({ alternate: true }, args66[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args66[1]), "|"])); + const args76 = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128UpperHex(v11, f)]; + put(out, rs.fmtFormat([args76[0], " ", args76[1], " ", rs.fmtSpec({ width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args76[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args76[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args76[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args76[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args76[0]), "|", args76[2], " ", args76[3], " ", rs.fmtSpec({ alternate: true }, args76[2]), " ", rs.fmtSpec({ alternate: true }, args76[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args76[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args76[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args76[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args76[3]), "|", rs.fmtSpec({ alternate: true }, args76[1]), " ", rs.fmtSpec({ width: 3 }, args76[1])])); + const args77 = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128Binary(v11, f), (f: rs.Formatter) => rs.i128Octal(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args77[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args77[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args77[1]), " ", args77[0], " ", rs.fmtSpec({ precision: 3 }, args77[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args77[0]), "|", args77[2], " ", rs.fmtSpec({ alternate: true }, args77[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args77[2]), " ", args77[3], " ", rs.fmtSpec({ alternate: true }, args77[3]), " ", rs.fmtSpec({ plus: true }, args77[3]), "|", rs.fmtSpec({ debugHex: "x" }, args77[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args77[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args77[4]), " ", rs.fmtSpec({ plus: true }, args77[4])])); + const args78 = [(f: rs.Formatter) => rs.i128LowerExp(v11, f), (f: rs.Formatter) => rs.i128UpperExp(v11, f)]; + put(out, rs.fmtFormat([args78[0], " ", args78[1], " ", rs.fmtSpec({ precision: 0 }, args78[0]), " ", rs.fmtSpec({ precision: 1 }, args78[0]), " ", rs.fmtSpec({ precision: 3 }, args78[0]), " ", rs.fmtSpec({ precision: 45 }, args78[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args78[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args78[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args78[0]), "| ", rs.fmtSpec({ alternate: true }, args78[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args78[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.i128Display(v11, f))); } else { const buf12: Uint8Array = rs.bytes(4); const n12: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf12).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf12), 0, n12), rs.byteSliceRange(data, 0, n12)); const v12: rs.isize = rs.isizeFromBeBytes(buf12); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeUpperHex(v12, f)]; - put(out, rs.fmtFormat([args68[0], " ", args68[1], " ", rs.fmtSpec({ width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args68[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args68[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args68[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args68[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args68[0]), "|", args68[2], " ", args68[3], " ", rs.fmtSpec({ alternate: true }, args68[2]), " ", rs.fmtSpec({ alternate: true }, args68[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args68[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args68[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args68[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args68[3]), "|", rs.fmtSpec({ alternate: true }, args68[1]), " ", rs.fmtSpec({ width: 3 }, args68[1])])); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeBinary(v12, f), (f: rs.Formatter) => rs.isizeOctal(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args70[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args70[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args70[1]), " ", args70[0], " ", rs.fmtSpec({ precision: 3 }, args70[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args70[0]), "|", args70[2], " ", rs.fmtSpec({ alternate: true }, args70[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args70[2]), " ", args70[3], " ", rs.fmtSpec({ alternate: true }, args70[3]), " ", rs.fmtSpec({ plus: true }, args70[3]), "|", rs.fmtSpec({ debugHex: "x" }, args70[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args70[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args70[4]), " ", rs.fmtSpec({ plus: true }, args70[4])])); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeLowerExp(v12, f), (f: rs.Formatter) => rs.isizeUpperExp(v12, f)]; - put(out, rs.fmtFormat([args72[0], " ", args72[1], " ", rs.fmtSpec({ precision: 0 }, args72[0]), " ", rs.fmtSpec({ precision: 1 }, args72[0]), " ", rs.fmtSpec({ precision: 3 }, args72[0]), " ", rs.fmtSpec({ precision: 45 }, args72[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args72[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args72[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args72[0]), "| ", rs.fmtSpec({ alternate: true }, args72[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args72[1]), "|"])); + const args73 = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeUpperHex(v12, f)]; + put(out, rs.fmtFormat([args73[0], " ", args73[1], " ", rs.fmtSpec({ width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args73[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args73[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args73[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args73[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args73[0]), "|", args73[2], " ", args73[3], " ", rs.fmtSpec({ alternate: true }, args73[2]), " ", rs.fmtSpec({ alternate: true }, args73[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args73[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args73[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args73[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args73[3]), "|", rs.fmtSpec({ alternate: true }, args73[1]), " ", rs.fmtSpec({ width: 3 }, args73[1])])); + const args74 = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeBinary(v12, f), (f: rs.Formatter) => rs.isizeOctal(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args74[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args74[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args74[1]), " ", args74[0], " ", rs.fmtSpec({ precision: 3 }, args74[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args74[0]), "|", args74[2], " ", rs.fmtSpec({ alternate: true }, args74[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args74[2]), " ", args74[3], " ", rs.fmtSpec({ alternate: true }, args74[3]), " ", rs.fmtSpec({ plus: true }, args74[3]), "|", rs.fmtSpec({ debugHex: "x" }, args74[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args74[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args74[4]), " ", rs.fmtSpec({ plus: true }, args74[4])])); + const args75 = [(f: rs.Formatter) => rs.isizeLowerExp(v12, f), (f: rs.Formatter) => rs.isizeUpperExp(v12, f)]; + put(out, rs.fmtFormat([args75[0], " ", args75[1], " ", rs.fmtSpec({ precision: 0 }, args75[0]), " ", rs.fmtSpec({ precision: 1 }, args75[0]), " ", rs.fmtSpec({ precision: 3 }, args75[0]), " ", rs.fmtSpec({ precision: 45 }, args75[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args75[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args75[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args75[0]), "| ", rs.fmtSpec({ alternate: true }, args75[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args75[1]), "|"])); put(out, rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v12, f))); } } @@ -194,23 +194,23 @@ export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _15); } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_15]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ width: 8 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ width: 12 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 2 }, args4[0]), "|", rs.fmtSpec({ width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 6, precision: 1 }, args4[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args4[0]), "|", rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 20 }, args4[0]), "|", rs.fmtSpec({ precision: 2 }, args4[1]), "|", rs.fmtSpec({ width: 10, precision: 2 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[0])])); + const args17 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([args17[0], "|", rs.fmtSpec({ width: 8 }, args17[0]), "|", rs.fmtSpec({ align: ">", width: 8 }, args17[0]), "|", rs.fmtSpec({ align: "^", width: 8 }, args17[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args17[0]), "|", args17[1], "|", rs.fmtSpec({ width: 12 }, args17[1]), "|", rs.fmtSpec({ alternate: true }, args17[1]), "|{", args17[0], "}"])); + const args18 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 2 }, args18[0]), "|", rs.fmtSpec({ width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: 6, precision: 1 }, args18[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args18[0]), "|", rs.fmtSpec({ precision: 0 }, args18[0]), "|", rs.fmtSpec({ precision: 20 }, args18[0]), "|", rs.fmtSpec({ precision: 2 }, args18[1]), "|", rs.fmtSpec({ width: 10, precision: 2 }, args18[1]), "|", rs.fmtSpec({ plus: true }, args18[0])])); } const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.u32, 257)), 63); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ precision: 0 }, args6[0]), "|", rs.fmtSpec({ width: 3, precision: 1 }, args6[0]), "|", rs.fmtSpec({ precision: 0 }, args6[1]), "|", rs.fmtSpec({ align: ">", width: 4 }, args6[1])])); + const args19 = [(f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f)]; + put(out, rs.fmtFormat([args19[0], "|", rs.fmtSpec({ precision: 0 }, args19[0]), "|", rs.fmtSpec({ width: 3, precision: 1 }, args19[0]), "|", rs.fmtSpec({ precision: 0 }, args19[1]), "|", rs.fmtSpec({ align: ">", width: 4 }, args19[1])])); const _70: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_70.ok) { const s2: string = _70.value; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(s2, f), (f: rs.Formatter) => rs.fmtPad(f, s2)]; - put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ align: ">", width: 4 }, args8[1]), " ", rs.fmtSpec({ precision: 1 }, args8[1])])); + const args21 = [(f: rs.Formatter) => rs.fmtStr(s2, f), (f: rs.Formatter) => rs.fmtPad(f, s2)]; + put(out, rs.fmtFormat([args21[0], " ", rs.fmtSpec({ align: ">", width: 4 }, args21[1]), " ", rs.fmtSpec({ precision: 1 }, args21[1])])); } else { const e: rs.FromUtf8Error = _70.error; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(e, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1]), " ", rs.fmtSpec({ align: ">", width: 80 }, args10[0]), " ", rs.fmtSpec({ precision: 4 }, args10[0]), " ", rs.fmtSpec({ debugHex: "x" }, args10[1]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[1])])); + const args20 = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(e, f)]; + put(out, rs.fmtFormat([args20[0], " ", args20[1], " ", rs.fmtSpec({ alternate: true }, args20[1]), " ", rs.fmtSpec({ align: ">", width: 80 }, args20[0]), " ", rs.fmtSpec({ precision: 4 }, args20[0]), " ", rs.fmtSpec({ debugHex: "x" }, args20[1]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args20[1])])); } const _100: rs.u8 | undefined = rs.byteSliceFirst(data); b3: { @@ -222,19 +222,18 @@ export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { } flag = false; } - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ align: ">", width: 6 }, args12[0]), " ", rs.fmtSpec({ precision: 2 }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 4, precision: 1 }, args12[1]), " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3]), " ", rs.fmtSpec({ precision: 1 }, args12[4])])); + const args22 = [(f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; + put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ align: ">", width: 6 }, args22[0]), " ", rs.fmtSpec({ precision: 2 }, args22[0]), " ", rs.fmtSpec({ align: ">", width: 4, precision: 1 }, args22[1]), " ", args22[2], " ", rs.fmtSpec({ alternate: true }, args22[3]), " ", rs.fmtSpec({ precision: 1 }, args22[4])])); const _130: boolean = flag; put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_130, f))); const _131: rs.Result = rs.u8TryFrom(rs.i32Sub(data.length | 0, 3)); if (_131.ok) { const arg = _131.value; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f)])); } else { const e2: rs.TryFromIntError = _131.error; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtTryFromIntErrorDebug(e2, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", rs.fmtSpec({ align: ">", width: 40 }, args16[0]), "| ", rs.fmtSpec({ precision: 6 }, args16[0]), "|", rs.fmtSpec({ width: 10, precision: 3 }, args16[0]), "|"])); + const args23 = [(f: rs.Formatter) => rs.fmtTryFromIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtTryFromIntErrorDebug(e2, f)]; + put(out, rs.fmtFormat([args23[0], " ", args23[1], " ", rs.fmtSpec({ align: ">", width: 40 }, args23[0]), "| ", rs.fmtSpec({ precision: 6 }, args23[0]), "|", rs.fmtSpec({ width: 10, precision: 3 }, args23[0]), "|"])); } } @@ -294,45 +293,43 @@ export function derived(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; const value: Nested.Nested = nested(data); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); - const args6: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args6[0])])); - const args8: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true, debugHex: "X" }, args8[0])])); - const args10: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true, precision: 1 }, args10[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true, debugHex: "X" }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true, precision: 1 }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); const wide: fmt_Wide.Wide = { a: at(0), b: 300, c: 70000, d: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, e: -1, f: at(1) > 10 }; const six: Six.Six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; const _87: Unit.Unit = {}; const _88: Unit.Unit = {}; - const args12: rs.Fmt[] = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_88, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3])])); - const args14: rs.Fmt[] = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ alternate: true }, args14[1])])); + const args30 = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_88, f)]; + put(out, rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " ", rs.fmtSpec({ alternate: true }, args30[3])])); + const args31 = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args31[0]), " ", rs.fmtSpec({ alternate: true }, args31[1])])); const point: Point.Point = { x: at(2) as rs.i32, y: -1 }; const _125: Pair.Pair = { _0: at(3), _1: -9 }; - const args16: rs.Fmt[] = [(f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_125, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args16[0]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[1])])); + const args32 = [(f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_125, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args32[0]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args32[1])])); const kinds: Kind.Kind[] = [{ tag: "Empty" } as Kind.Kind, { tag: "One", _0: at(4) } as Kind.Kind, { tag: "Braced" } as Kind.Kind, { tag: "Bare" } as Kind.Kind, { tag: "Many", count: 0, items: new rs.ByteVec() } as Kind.Kind]; const _154: Kind.Kind = kinds[1]; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(kinds, f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => Kind.fmt$fmt_Debug(_154, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1]])); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(kinds, f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args20[0])])); + [_154, rs.sliceFrom(kinds)] as [Kind.Kind, rs.Slice]; + const arg = rs.sliceFrom(kinds); + const args33 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => Kind.fmt$fmt_Debug(_154, f)]; + put(out, rs.fmtFormat([args33[0], " ", args33[1]])); + const arg2 = rs.sliceFrom(kinds); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)))])); const words: rs.u16[] = [at(5) as rs.u16, 65535]; const _189: rs.u8 | undefined = rs.byteSliceFirst(data); const _191: rs.u8 | undefined = rs.byteSliceGet(data, 100); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(data), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(_189, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_191, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3]])); + const _193: rs.Slice = rs.sliceFrom(words); + const args35 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(data), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_193), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(_189, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_191, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", args35[3]])); const _208: Braced.Braced = {}; const _209: Braced.Braced = {}; const _210: Bare.Bare = {}; const _211: Bare.Bare = {}; - const args24: rs.Fmt[] = [(f: rs.Formatter) => Braced.fmt$fmt_Debug(_208, f), (f: rs.Formatter) => Braced.fmt$fmt_Debug(_209, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_210, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_211, f)]; - put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[1]), " ", args24[2], " ", rs.fmtSpec({ alternate: true }, args24[3])])); + const args36 = [(f: rs.Formatter) => Braced.fmt$fmt_Debug(_208, f), (f: rs.Formatter) => Braced.fmt$fmt_Debug(_209, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_210, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_211, f)]; + put(out, rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[1]), " ", args36[2], " ", rs.fmtSpec({ alternate: true }, args36[3])])); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(Braced.eq$cmp_PartialEq({}, {}) ? 1 : 0, Bare.eq$cmp_PartialEq({}, {}) ? 1 : 0))); } @@ -355,8 +352,8 @@ export function logged(log: rs.ByteVec, dataData: Uint8Array, dataStart: number, } const _24: rs.usize = log.length; const part = dataData[dataStart + _16]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_7, f), (f: rs.Formatter) => rs.u8Display(_10, f), (f: rs.Formatter) => rs.u8Display(part, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; - return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); + const args3 = [(f: rs.Formatter) => rs.usizeDisplay(_7, f), (f: rs.Formatter) => rs.u8Display(_10, f), (f: rs.Formatter) => rs.u8Display(part, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; + return rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3]]); } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ @@ -366,22 +363,22 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; const hex: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1])])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Binary(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Octal(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_LowerExp(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_UpperExp(hex, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rs.fmtSpec({ precision: 2 }, args4[3]), "|", args4[4], "|", rs.fmtSpec({ plus: true, precision: 1 }, args4[0])])); + const args27 = [(f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f)]; + put(out, rs.fmtFormat([args27[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args27[0]), "|", rs.fmtSpec({ alternate: true }, args27[0]), "|", args27[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args27[1]), "|", rs.fmtSpec({ alternate: true }, args27[1])])); + const args28 = [(f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Binary(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Octal(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_LowerExp(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_UpperExp(hex, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args28[0]), "|", rs.fmtSpec({ alternate: true }, args28[1]), "|", rs.fmtSpec({ align: ">", width: 8 }, args28[2]), "|", rs.fmtSpec({ precision: 2 }, args28[3]), "|", args28[4], "|", rs.fmtSpec({ plus: true, precision: 1 }, args28[0])])); put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f))); const arg = { _0: "pad" }; - const args6: rs.Fmt[] = [(f: rs.Formatter) => Padded.fmt$fmt_Display(arg, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 9 }, args6[0]), "|", rs.fmtSpec({ width: 30 }, args6[0]), "|"])); + const args29 = [(f: rs.Formatter) => Padded.fmt$fmt_Display(arg, f)]; + put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args29[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 9 }, args29[0]), "|", rs.fmtSpec({ width: 30 }, args29[0]), "|"])); const manual: Manual.Manual = { id: at(1), list: rs.vecFrom([1, at(2) as rs.u16].slice()) }; const empty: Manual.Manual = { id: 0, list: new rs.Vec() }; - const args8: rs.Fmt[] = [(f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(empty, f)]; - put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", args8[1]])); + const args30 = [(f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(empty, f)]; + put(out, rs.fmtFormat([args30[0], " ", rs.fmtSpec({ alternate: true }, args30[0]), " ", args30[1]])); const seq: Seq.Seq = { _0: rs.vecFrom([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice()) }; const none: Seq.Seq = { _0: new rs.Vec() }; - const args10: rs.Fmt[] = [(f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(none, f)]; - put(out, rs.fmtFormat([args10[0], " ", rs.fmtSpec({ alternate: true }, args10[0]), " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1])])); + const args31 = [(f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(none, f)]; + put(out, rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", args31[1], " ", rs.fmtSpec({ alternate: true }, args31[1])])); const _113: rs.u8 = at(4); if (!(rs.u8Rem(at(5), 2) === 0)) { _116 = undefined; @@ -389,44 +386,43 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { _116 = at(5); } const arg2 = { _0: _113, _1: _116 }; - const args12: rs.Fmt[] = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(arg2, f)]; - put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])])); + const args32 = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(arg2, f)]; + put(out, rs.fmtFormat([args32[0], " ", rs.fmtSpec({ alternate: true }, args32[0])])); const part = { _0: at(6) & (~1 & 0xff) }; - const args14: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part, f)]; - put(out, rs.fmtFormat([args14[0], " ", rs.fmtSpec({ align: ">", width: 9 }, args14[0])])); + const args33 = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part, f)]; + put(out, rs.fmtFormat([args33[0], " ", rs.fmtSpec({ align: ">", width: 9 }, args33[0])])); const _164: rs.u8 = at(7); const _168: rs.u8 = at(8); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_168, f), (f: rs.Formatter) => rs.u8Display(_164, f), (f: rs.Formatter) => rs.u8Debug(_164, f), (f: rs.Formatter) => rs.fmtPad(f, "named")]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " named ", rs.fmtSpec({ align: ">", width: 5 }, args16[3])])); + const args34 = [(f: rs.Formatter) => rs.u8Display(_168, f), (f: rs.Formatter) => rs.u8Display(_164, f), (f: rs.Formatter) => rs.u8Debug(_164, f), (f: rs.Formatter) => rs.fmtPad(f, "named")]; + put(out, rs.fmtFormat([args34[0], " ", args34[1], " ", args34[2], " named ", rs.fmtSpec({ align: ">", width: 5 }, args34[3])])); const log: rs.ByteVec = new rs.ByteVec(); const _187: rs.u8 = at(9); const _185: rs.u8 = note(log, _187); const _194: rs.u8 = at(10); const _191: boolean = note(log, _194) === 3; const _198: rs.usize = log.length; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_191, f), (f: rs.Formatter) => rs.u8Display(_185, f), (f: rs.Formatter) => rs.u8Debug(_185, f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " ", args18[3], " ", args18[1]])); + const args35 = [(f: rs.Formatter) => rs.fmtBool(_191, f), (f: rs.Formatter) => rs.u8Display(_185, f), (f: rs.Formatter) => rs.u8Debug(_185, f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; + put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", args35[3], " ", args35[1]])); const _218: Noted.Noted = { _0: at(11) }; const _222: Noted.Noted = { _0: 2 }; - const args20: rs.Fmt[] = [(f: rs.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rs.Formatter) => Noted.fmt$fmt_Display(_222, f)]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args20[1])])); + const args36 = [(f: rs.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rs.Formatter) => Noted.fmt$fmt_Display(_222, f)]; + put(out, rs.fmtFormat([args36[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args36[1])])); if (!(data.length === 0)) { put(out, logged(log, data.data, data.start, data.length)); } const _241: rs.u8 = at(13); const part2 = note(log, _241); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(part2, f)]; - const once: string = rs.fmtFormat([args22[0]]); + const once: string = rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(part2, f)]); const _257: rs.usize = log.length; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, once), (f: rs.Formatter) => rs.usizeDisplay(_257, f)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1]])); + const args38 = [(f: rs.Formatter) => rs.fmtPad(f, once), (f: rs.Formatter) => rs.usizeDisplay(_257, f)]; + put(out, rs.fmtFormat([args38[0], " ", args38[1]])); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); if (at(12) > 250) { const _277: rs.u8 = at(12); const _275: rs.u8 = note(log, _277); const _281: rs.usize = log.length; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_275, f), (f: rs.Formatter) => rs.usizeDisplay(_281, f)]; - rs.panicFmt([args26[0], " ", args26[1]]); + const args39 = [(f: rs.Formatter) => rs.u8Display(_275, f), (f: rs.Formatter) => rs.usizeDisplay(_281, f)]; + rs.panicFmt([args39[0], " ", args39[1]]); } } @@ -451,18 +447,18 @@ export function counts(data: rs.ByteSlice, out: rs.ByteVec): void { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _39); } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_39]; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v, f), rs.fmtCount(w), (f: rs.Formatter) => rs.i64LowerExp(v, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(p), (f: rs.Formatter) => rs.usizeDisplay(w, f), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ align: "<", width: rs.fmtCountOf(args2[1]) }, args2[2]), "|", rs.fmtSpec({ plus: true, zero: true, width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[6]) }, args2[7]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args2[8]), precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[3]) }, args2[9])])); + const args7 = [(f: rs.Formatter) => rs.i64Display(v, f), rs.fmtCount(w), (f: rs.Formatter) => rs.i64LowerExp(v, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(p), (f: rs.Formatter) => rs.usizeDisplay(w, f), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: rs.fmtCountOf(args7[1]) }, args7[0]), "|", rs.fmtSpec({ align: "<", width: rs.fmtCountOf(args7[1]) }, args7[2]), "|", rs.fmtSpec({ plus: true, zero: true, width: rs.fmtCountOf(args7[1]), precision: rs.fmtCountOf(args7[3]) }, args7[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args7[3]) }, args7[4]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args7[1]), precision: rs.fmtCountOf(args7[3]) }, args7[4]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args7[6]) }, args7[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args7[6]) }, args7[7]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args7[8]), precision: rs.fmtCountOf(args7[6]) }, args7[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args7[3]) }, args7[9])])); const log: rs.ByteVec = new rs.ByteVec(); const _87: rs.u8 = at(4); const _85: rs.u8 = note(log, _87); const _91: rs.usize = note(log, 6) as rs.usize; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_85, f), rs.fmtCount(_91), (f: rs.Formatter) => rs.fmtPad(f, s)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[1]) }, args4[0]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[1]) }, args4[2])])); + const args8 = [(f: rs.Formatter) => rs.u8Display(_85, f), rs.fmtCount(_91), (f: rs.Formatter) => rs.fmtPad(f, s)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args8[1]) }, args8[0]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args8[1]) }, args8[2])])); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); const big: rs.usize = rs.usizeAdd(65535 as rs.usize, rs.u8Rem(at(5), 2) as rs.usize); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(big)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args6[1]) }, args6[0]), "|"])); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(big)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args9[1]) }, args9[0]), "|"])); } /** `{:e}` at each rounding: below, above, and ties to even, which may carry a digit. */ @@ -473,11 +469,11 @@ export function rounding(out: rs.ByteVec): void { if (_5 === rs.DONE) { break; } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerExp(_5, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args2[0]), " ", rs.fmtSpec({ precision: 1 }, args2[0]), " ", rs.fmtSpec({ precision: 2 }, args2[0]), " ", args2[0]])); + const args5 = [(f: rs.Formatter) => rs.u32LowerExp(_5, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args5[0]), " ", rs.fmtSpec({ precision: 1 }, args5[0]), " ", rs.fmtSpec({ precision: 2 }, args5[0]), " ", args5[0]])); } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u128LowerExp({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, f), (f: rs.Formatter) => rs.i128LowerExp({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, f), (f: rs.Formatter) => rs.i64UpperExp({ hi: -0x80000000, lo: 0 } as rs.i64, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), " ", args4[1], " ", rs.fmtSpec({ precision: 3 }, args4[2])])); + const args6 = [(f: rs.Formatter) => rs.u128LowerExp({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, f), (f: rs.Formatter) => rs.i128LowerExp({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, f), (f: rs.Formatter) => rs.i64UpperExp({ hi: -0x80000000, lo: 0 } as rs.i64, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args6[0]), " ", args6[1], " ", rs.fmtSpec({ precision: 3 }, args6[2])])); } /** Panics, each with the message native Rust formats. */ @@ -489,17 +485,17 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(rest), 0); const _7: rs.u8 = rs.u8Rem(kind, 20); if (_7 === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rest), f, rs.u8Debug)]; - rs.panicFmt(["bad ", args2[0], ": ", args2[1]]); + const args33 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rest), f, rs.u8Debug)]; + rs.panicFmt(["bad ", args33[0], ": ", args33[1]]); } else if (_7 === 1) { const _23: Hex.Hex = { _0: n as rs.u32 }; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => Hex.fmt$fmt_Display(_23, f)]; - rs.panicFmt(["internal error: entered unreachable code: never ", rs.fmtSpec({ alternate: true }, args4[0]), " ", args4[1]]); + const args32 = [(f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => Hex.fmt$fmt_Display(_23, f)]; + rs.panicFmt(["internal error: entered unreachable code: never ", rs.fmtSpec({ alternate: true }, args32[0]), " ", args32[1]]); } else if (_7 === 2) { if (!(n > 200)) { const _37: Pair.Pair = { _0: n, _1: 0 }; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_37, f)]; - rs.panicFmt(["small ", args6[0], " ", args6[1]]); + const args31 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_37, f)]; + rs.panicFmt(["small ", args31[0], " ", args31[1]]); } } else if (_7 === 3) { if (!(n > 200)) { @@ -513,10 +509,8 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { const _58: Pair.Pair = { _0: n, _1: 1 }; const _60: Pair.Pair = { _0: n, _1: 1 }; if (Pair.eq$cmp_PartialEq(_58, _60)) { - const kind3: string = "!="; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - const _66: rs.Arguments | undefined = ["same ", args8[0]]; - rs.assertFailed(kind3, (f: rs.Formatter) => Pair.fmt$fmt_Debug(_58, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_60, f), _66); + const args30 = [(f: rs.Formatter) => rs.u8Display(n, f)]; + rs.assertFailed("!=", (f: rs.Formatter) => Pair.fmt$fmt_Debug(_58, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_60, f), ["same ", args30[0]]); } } else if (_7 === 6) { if (!(n === 9)) { @@ -542,36 +536,32 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { const _121: rs.u8 = rs.resultUnwrapErr(rs.Ok({ x: n as rs.i32, y: 0 }), (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f)); put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_121, f))); } else if (_7 === 10) { - const missing: rs.u8 | undefined = rs.byteSliceGet(rest, 200); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; - const _129: rs.u8 = rs.optionExpect(missing, rs.fmtFormat(["missing ", args10[0]])); + const _129: rs.u8 = rs.optionExpect(rs.byteSliceGet(rest, 200), rs.fmtFormat(["missing ", (f: rs.Formatter) => rs.u8Display(n, f)])); put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_129, f))); } else if (_7 === 11) { const part3 = { _0: n }; - const args12: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part3, f)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => Fails.fmt$fmt_Display(part3, f)])); } else if (_7 === 12) { const _157: Fails.Fails = { _0: n }; put(out, rs.fmtToString((f: rs.Formatter) => Fails.fmt$fmt_Display(_157, f))); } else if (_7 === 13) { const _162: Hex.Hex = { _0: n as rs.u32 }; const _165: Fails.Fails = { _0: n }; - const args14: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(_162, f), (f: rs.Formatter) => Fails.fmt$fmt_Display(_165, f)]; - rs.panicFmt([args14[0], " then ", args14[1]]); + const args27 = [(f: rs.Formatter) => Hex.fmt$fmt_Display(_162, f), (f: rs.Formatter) => Fails.fmt$fmt_Display(_165, f)]; + rs.panicFmt([args27[0], " then ", args27[1]]); } else if (_7 === 14) { const _173: [rs.usize, rs.usize] = [rs.u8Rem(n, 8) as rs.usize, rs.u8Div(n, 32) as rs.usize]; const start: rs.usize = _173[0]; const end: rs.usize = _173[1]; const _189: rs.ByteSlice = rs.byteSliceRange(rest, start); const _193: rs.ByteSlice = rs.byteSliceRange(rest, start, end); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_189), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_193), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1]])); + const args26 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_189), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_193), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args26[0], " ", args26[1]])); } else if (_7 === 15) { const buf: Uint8Array = rs.bytes(3); rs.byteSliceCopyFromSlice(rs.byteSliceFrom(buf), rs.byteSliceRange(rest, 0, rs.min(rest.length, 4))); const arg3 = rs.byteSliceFrom(buf); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg3), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg3), f, rs.u8Debug)])); } else if (_7 === 16) { const _221: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rest)); if (_221.ok) { @@ -588,8 +578,7 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { const _246: rs.Range = new rs.Range(rs.u8Rem(n, 6) as rs.usize, rs.u8Rem(rs.u8Div(n, 6), 6) as rs.usize); rs.byteSliceCopyWithin(_244, _246.start, _246.end, dest); const arg2 = rs.byteSliceFrom(buf2); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)])); } else if (_7 === 18) { const _271: rs.usize = rs.u8Rem(n, 8) as rs.usize; rs.idx(rest, _271); @@ -602,8 +591,7 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { r5 = rs.Err(n); } const part = rs.resultUnwrapErr(r5, rs.u8Debug); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(part, f)])); } } @@ -624,8 +612,8 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _37: rs.RangeFrom = new rs.RangeFrom(a, rs.i32Step); const _39: { end: rs.i32 } = { end: b }; const _41: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_33, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_35, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_37, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_39, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_41, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]])); + const args27 = [(f: rs.Formatter) => rs.fmtRange(_33, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_35, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_37, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_39, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_41, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f)]; + put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2], " ", args27[3], " ", args27[4], " ", args27[5]])); const _60: rs.Range = new rs.Range(a, b); const _62: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); const _72: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); @@ -635,8 +623,8 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _70: rs.Range = new rs.Range(a, b); const _74: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; const _77: rs.Range = new rs.Range(a, b); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_60, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_62, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_64, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_66, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_68, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRange(_70, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_72, f, rs.i32Debug), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_74, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f), (f: rs.Formatter) => rs.fmtRange(_77, f, rs.i32Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[2]), "|", rs.fmtSpec({ zero: true, width: 5 }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[5]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args4[7]) }, args4[6]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args4[7]) }, args4[8]), "|", rs.fmtSpec({ align: ">", width: 3 }, args4[9]), "|", rs.fmtSpec({ alternate: true }, args4[10])])); + const args28 = [(f: rs.Formatter) => rs.fmtRange(_60, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_62, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_64, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_66, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_68, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRange(_70, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_72, f, rs.i32Debug), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_74, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f), (f: rs.Formatter) => rs.fmtRange(_77, f, rs.i32Debug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args28[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args28[1]), "|", rs.fmtSpec({ plus: true }, args28[2]), "|", rs.fmtSpec({ zero: true, width: 5 }, args28[3]), "|", rs.fmtSpec({ debugHex: "x" }, args28[4]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args28[5]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args28[7]) }, args28[6]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args28[7]) }, args28[8]), "|", rs.fmtSpec({ align: ">", width: 3 }, args28[9]), "|", rs.fmtSpec({ alternate: true }, args28[10])])); const _96: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_96 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _96); @@ -652,19 +640,19 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _131: { end: Clip.Clip } = { end: hi }; const _133: rs.RangeFrom = new rs.RangeFrom(lo); const _135: { end: Clip.Clip; inclusive: true } = { end: lo, inclusive: true }; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_127, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_129, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_131, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeFrom(_133, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_135, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ width: 8, precision: 2 }, args6[1]), "|", rs.fmtSpec({ alternate: true }, args6[2]), "|", rs.fmtSpec({ fill: "_", align: ">", width: rs.fmtCountOf(args6[4]), precision: 1 }, args6[3]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args6[5])])); + const args29 = [(f: rs.Formatter) => rs.fmtRange(_127, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_129, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_131, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeFrom(_133, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_135, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ width: 8, precision: 2 }, args29[1]), "|", rs.fmtSpec({ alternate: true }, args29[2]), "|", rs.fmtSpec({ fill: "_", align: ">", width: rs.fmtCountOf(args29[4]), precision: 1 }, args29[3]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args29[5])])); const _148: [rs.u32, rs.u32] = [rs.u32Mul(at(5) as rs.u32, 257), at(6) as rs.u32]; const x: rs.u32 = _148[0]; const y: rs.u32 = _148[1]; const _167: rs.Range = new rs.Range({ _0: x }, { _0: y }); const _171: rs.RangeInclusive = new rs.RangeInclusive({ _0: x }, { _0: y }); const _175: { end: Hex.Hex } = { end: { _0: y } }; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_167, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_171, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_175, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ align: ">", width: 9 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[2])])); + const args30 = [(f: rs.Formatter) => rs.fmtRange(_167, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_171, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_175, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ align: ">", width: 9 }, args30[1]), "|", rs.fmtSpec({ alternate: true }, args30[2])])); const part3 = new rs.Range({ _0: at(7), _1: -1 }, { _0: 1, _1: { hi: -0x80000000, lo: 0 } as rs.i64 }); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ plus: true }, args10[0])])); + const args31 = [(f: rs.Formatter) => rs.fmtRange(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args31[0], "|", rs.fmtSpec({ alternate: true }, args31[0]), "|", rs.fmtSpec({ debugHex: "x" }, args31[0]), "|", rs.fmtSpec({ plus: true }, args31[0])])); const drained: rs.RangeInclusive = new rs.RangeInclusive(rs.u8Rem(at(8), 4), rs.u8Rem(at(9), 4), rs.u8Step); while (rs.iterToOption(drained.next()) !== undefined) { } @@ -678,41 +666,41 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _244: rs.usize = rs.u8Rem(at(10), 8) as rs.usize; rs.iterNth(far, _244); const _257: rs.RangeInclusive = new rs.RangeInclusive(0, 0, rs.i32Step); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRangeInclusive(drained, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(top, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(back, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(far, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_257, f, rs.i32Debug)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4]])); + const args32 = [(f: rs.Formatter) => rs.fmtRangeInclusive(drained, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(top, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(back, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(far, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_257, f, rs.i32Debug)]; + put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " ", args32[3], " ", args32[4]])); const arc: rs.Arc = new rs.Arc({ _0: x }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(arc.value, f)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args14[0]), "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args14[1]), "|", rs.fmtSpec({ alternate: true }, args14[1])])); + const args33 = [(f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(arc.value, f)]; + put(out, rs.fmtFormat([args33[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args33[0]), "|", rs.fmtSpec({ alternate: true }, args33[0]), "|", args33[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args33[1]), "|", rs.fmtSpec({ alternate: true }, args33[1])])); put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f))); const nested: rs.Arc> = new rs.Arc(new rs.Arc(a)); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(nested.value.value, f), (f: rs.Formatter) => rs.i32Debug(nested.value.value, f), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ plus: true, zero: true, width: 5 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ debugHex: "x" }, args16[1]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[1]), "|", rs.fmtSpec({ align: "<", width: 6 }, args16[1]), "|", rs.fmtSpec({ align: "^", plus: true, width: rs.fmtCountOf(args16[2]) }, args16[0])])); + const args34 = [(f: rs.Formatter) => rs.i32Display(nested.value.value, f), (f: rs.Formatter) => rs.i32Debug(nested.value.value, f), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ plus: true, zero: true, width: 5 }, args34[0]), "|", args34[1], "|", rs.fmtSpec({ debugHex: "x" }, args34[1]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args34[1]), "|", rs.fmtSpec({ align: "<", width: 6 }, args34[1]), "|", rs.fmtSpec({ align: "^", plus: true, width: rs.fmtCountOf(args34[2]) }, args34[0])])); const _310: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_310 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _310); } const rc: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310]); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rc.value), (f: rs.Formatter) => rs.fmtStr(rc.value, f)]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ align: ">", width: 8, precision: 2 }, args18[0]), "|", args18[1]])); + const args35 = [(f: rs.Formatter) => rs.fmtPad(f, rc.value), (f: rs.Formatter) => rs.fmtStr(rc.value, f)]; + put(out, rs.fmtFormat([args35[0], "|", rs.fmtSpec({ align: ">", width: 8, precision: 2 }, args35[0]), "|", args35[1]])); const list: rs.Arc> = new rs.Arc(rs.vecFrom([{ _0: at(7), _1: 2 }, { _0: 3, _1: -4 }].slice())); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(list.value.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])])); + const args36 = [(f: rs.Formatter) => rs.fmtList(list.value.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0])])); const held: rs.Range> = new rs.Range(new rs.Arc(a), new rs.Arc(b)); const _366: rs.Range> = new rs.Range(new rs.Arc(lo), new rs.Arc(hi)); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(held, f, (value: rs.Arc, f: rs.Formatter) => rs.i32Debug(value.value, f)), (f: rs.Formatter) => rs.fmtRange(_366, f, (value: rs.Arc, f: rs.Formatter) => Clip.fmt$fmt_Debug(value.value, f))]; - const _362: string = rs.fmtFormat([args22[0], " ", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args22[0]), " ", args22[1]]); + const args37 = [(f: rs.Formatter) => rs.fmtRange(held, f, (value: rs.Arc, f: rs.Formatter) => rs.i32Debug(value.value, f)), (f: rs.Formatter) => rs.fmtRange(_366, f, (value: rs.Arc, f: rs.Formatter) => Clip.fmt$fmt_Debug(value.value, f))]; + const _362: string = rs.fmtFormat([args37[0], " ", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args37[0]), " ", args37[1]]); rs.dropAll([_366.start, _366.end]); put(out, _362); const shared: Shared.Shared = new Shared.Shared(new rs.Arc({ _0: at(7), _1: 5 }), new rs.Range(at(8) as rs.u16, 300), { end: at(9), inclusive: true }); - const args24: rs.Fmt[] = [(f: rs.Formatter) => Shared.fmt$fmt_Debug(shared, f)]; - put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[0])])); + const args38 = [(f: rs.Formatter) => Shared.fmt$fmt_Debug(shared, f)]; + put(out, rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0])])); const _405: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_405 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _405); } const t: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_405]); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, t.value), (f: rs.Formatter) => rs.fmtStr(t.value, f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ align: ">", width: 9, precision: 2 }, args26[0])])); + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, t.value), (f: rs.Formatter) => rs.fmtStr(t.value, f)]; + put(out, rs.fmtFormat([args39[0], " ", args39[1], " ", rs.fmtSpec({ align: ">", width: 9, precision: 2 }, args39[0])])); t[Symbol.dispose](); shared[Symbol.dispose](); rs.dropAll([held.start, held.end]); @@ -746,8 +734,8 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { rs.dequePopFront(q, rs.None); } } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(q), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0])])); + const args17 = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(q), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args17[0], "|", rs.fmtSpec({ alternate: true }, args17[0]), "|", rs.fmtSpec({ debugHex: "x" }, args17[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args17[0])])); const wrapped: rs.VecDeque = rs.dequeWithCapacity(4, 4) as rs.VecDeque; rs.dequeExtend(wrapped, rs.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, true); const _48: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; @@ -755,25 +743,24 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { const _57: Hex.Hex = { _0: at(1) as rs.u32 }; rs.dequePushFront(wrapped, _57); rs.dequePopBack(wrapped); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - const mid: string = rs.fmtFormat([args4[0]]); + const mid: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]); rs.dequePopBack(wrapped); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, mid), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1]), "|", rs.fmtSpec({ width: 6 }, args6[1])])); + const args19 = [(f: rs.Formatter) => rs.fmtPad(f, mid), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args19[0], "|", args19[1], "|", rs.fmtSpec({ alternate: true }, args19[1]), "|", rs.fmtSpec({ width: 6 }, args19[1])])); const empty: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; const units: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(2), 3)), (_2: rs.u8): undefined => {}), undefined, 0, true), 0) as rs.VecDeque; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(units), f, rs.fmtUnit)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]])); + const args20 = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(units), f, rs.fmtUnit)]; + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0]), "|", args20[1]])); const part = rs.dequeFromArray([rs.dequeNew(16) as rs.VecDeque, rs.dequeFromArray([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rs.VecDeque], 16) as rs.VecDeque>; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(part), f, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0])])); + const args21 = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(part), f, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; + put(out, rs.fmtFormat([args21[0], "|", rs.fmtSpec({ alternate: true }, args21[0])])); const _135: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.u8 | undefined => { const b5: rs.u8 = _25; return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, rs.u8Rem(b5, 8)); }); const part2 = rs.btreeExtendKeys(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, _135, true, undefined, undefined, 2, true); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(part2), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args12[0])])); + const args22 = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(part2), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args22[0])])); const map: rs.BTreeMap> = rs.btreeNew(rs.cmp) as rs.BTreeMap>; const iter2: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); while (true) { @@ -788,8 +775,8 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { } const _176: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const _178: rs.BTreeSet = rs.btreeNew(rs.cmp) as rs.BTreeSet; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(_176), f, rs.u8Debug, rs.u8Debug), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(_178), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[2])])); + const args23 = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(_176), f, rs.u8Debug, rs.u8Debug), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(_178), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args23[0], "|", rs.fmtSpec({ alternate: true }, args23[0]), "|", args23[1], "|", rs.fmtSpec({ alternate: true }, args23[2])])); const _188: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew() as rs.HashSet]; const one: rs.HashMap = _188[0]; const set: rs.HashSet = _188[1]; @@ -804,8 +791,8 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { if (_202 !== undefined) { rs.hashAdd(set, _202); } - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.hashIter(one), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtSet(rs.hashKeys(set), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1]), "|", rs.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args16[1])])); + const args24 = [(f: rs.Formatter) => rs.fmtMap(rs.hashIter(one), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtSet(rs.hashKeys(set), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args24[0]), "|", args24[1], "|", rs.fmtSpec({ alternate: true }, args24[1]), "|", rs.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args24[1])])); } /** @@ -824,25 +811,25 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { }; const w: rs.usize = rs.u8Rem(at(0), 10) as rs.usize; const n: rs.RangeBound = pick$enums_u8(at(1), at(2)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(n, f, rs.u8Debug), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args2[0])])); + const args29 = [(f: rs.Formatter) => rs.fmtBound(n, f, rs.u8Debug), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ alternate: true }, args29[0]), "|", rs.fmtSpec({ debugHex: "x" }, args29[0]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args29[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args29[1]) }, args29[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7 }, args29[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args29[0])])); const _32: rs.u8 = at(3); const _37: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_37 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _37); } const s: rs.RangeBound = pick$enums_ref_str(_32, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_37]); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(s, f, rs.fmtStr), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args4[0]), "|", rs.fmtSpec({ fill: "*", align: "<", width: rs.fmtCountOf(args4[1]), precision: 2 }, args4[0])])); + const args30 = [(f: rs.Formatter) => rs.fmtBound(s, f, rs.fmtStr), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args30[0]), "|", rs.fmtSpec({ fill: "*", align: "<", width: rs.fmtCountOf(args30[1]), precision: 2 }, args30[0])])); const part = pick$enums_char(at(5), at(6) as rs.char); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 6 }, args6[0])])); + const args31 = [(f: rs.Formatter) => rs.fmtBound(part, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args31[0], "|", rs.fmtSpec({ alternate: true }, args31[0]), "|", rs.fmtSpec({ align: "^", width: 6 }, args31[0])])); const part2 = pick$enums_Option_u8(at(7), thenSome$0quywni(rs.u8Rem(at(8), 2) === 0, at(9))); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ debugHex: "x" }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0])])); + const args32 = [(f: rs.Formatter) => rs.fmtBound(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args32[0], "|", rs.fmtSpec({ alternate: true }, args32[0]), "|", rs.fmtSpec({ debugHex: "x" }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args32[0])])); const part4 = pick$enums_ref_slice_u8(at(10), rs.byteSliceRange(data, 0, rs.min(data.length, 3))); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part4, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ width: 3 }, args10[0])])); + const args33 = [(f: rs.Formatter) => rs.fmtBound(part4, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug))]; + put(out, rs.fmtFormat([args33[0], "|", rs.fmtSpec({ alternate: true }, args33[0]), "|", rs.fmtSpec({ debugHex: "x" }, args33[0]), "|", rs.fmtSpec({ width: 3 }, args33[0])])); const _128: rs.u8 = at(11); const _134: rs.usize = rs.usizeRem(at(12) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_134 < 14)) { @@ -852,8 +839,8 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const _152: rs.RangeBound = clip; const _155: rs.RangeBound | undefined = clip; const _157: [rs.RangeBound, rs.RangeBound] = [n, s]; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_152, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(_155, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBound(_157[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_157[1], f, rs.fmtStr)], f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 8, precision: 2 }, args12[0]), "|", rs.fmtSpec({ alternate: true }, args12[1]), "|", args12[2]])); + const args34 = [(f: rs.Formatter) => rs.fmtBound(_152, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(_155, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBound(_157[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_157[1], f, rs.fmtStr)], f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", rs.fmtSpec({ alternate: true }, args34[1]), "|", args34[2]])); const r: rs.RangeInclusive = new rs.RangeInclusive(at(1), at(2), rs.u8Step); const _179: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _182: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; @@ -861,20 +848,20 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const _185: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; const _192: rs.RangeBound = { tag: "Excluded", _0: { end: at(2) }.end } as rs.RangeBound; const _199: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_179, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_182, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_185, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_192, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_199, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", rs.fmtSpec({ debugHex: "x" }, args14[3]), " ", rs.fmtSpec({ alternate: true }, args14[4])])); + const args35 = [(f: rs.Formatter) => rs.fmtBound(_179, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_182, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_185, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_192, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_199, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", rs.fmtSpec({ debugHex: "x" }, args35[3]), " ", rs.fmtSpec({ alternate: true }, args35[4])])); const ord: rs.Ordering = rs.cmp(at(1), at(2)); - const all: rs.Ordering[] = [-1, 0, 1]; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOrdering(ord, f), (f: rs.Formatter) => rs.fmtList(all, f, rs.fmtOrdering)]; - put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ align: ">", width: 8 }, args16[0]), "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1])])); + const _230: rs.Slice = rs.sliceFrom([-1, 0, 1]); + const args36 = [(f: rs.Formatter) => rs.fmtOrdering(ord, f), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_230), f, rs.fmtOrdering)]; + put(out, rs.fmtFormat([args36[0], "|", rs.fmtSpec({ align: ">", width: 8 }, args36[0]), "|", rs.fmtSpec({ alternate: true }, args36[0]), "|", args36[1], "|", rs.fmtSpec({ alternate: true }, args36[1])])); const rev: rs.u8 = at(1); const _244: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_244 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _244); } const nested: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_244]; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.u8Debug(rev, f)]), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtStr(nested, f)])])]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0]), "|", rs.fmtSpec({ debugHex: "x" }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[1]) }, args18[0]), "|", args18[2], "|", rs.fmtSpec({ alternate: true }, args18[2])])); + const args37 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.u8Debug(rev, f)]), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtStr(nested, f)])])]; + put(out, rs.fmtFormat([args37[0], "|", rs.fmtSpec({ alternate: true }, args37[0]), "|", rs.fmtSpec({ debugHex: "x" }, args37[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args37[1]) }, args37[0]), "|", args37[2], "|", rs.fmtSpec({ alternate: true }, args37[2])])); const _272: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_272 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _272); @@ -885,22 +872,22 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { } else { flow = rs.Ok(rs.u16Mul(at(2) as rs.u16, 300)); } - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(flow, f, rs.u16Debug, rs.fmtStr), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0]), "|", rs.fmtSpec({ debugHex: "x" }, args20[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args20[1]) }, args20[0])])); + const args38 = [(f: rs.Formatter) => rs.fmtControlFlow(flow, f, rs.u16Debug, rs.fmtStr), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0]), "|", rs.fmtSpec({ debugHex: "x" }, args38[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args38[1]) }, args38[0])])); if (rs.u8Rem(at(1), 2) === 0) { unit = rs.Err(at(2)); } else { unit = rs.OK; } - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(unit, f, rs.fmtUnit, rs.u8Debug)]; - put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ zero: true, width: 3 }, args22[0])])); + const args39 = [(f: rs.Formatter) => rs.fmtControlFlow(unit, f, rs.fmtUnit, rs.u8Debug)]; + put(out, rs.fmtFormat([args39[0], "|", rs.fmtSpec({ alternate: true }, args39[0]), "|", rs.fmtSpec({ zero: true, width: 3 }, args39[0])])); if (rs.u8Rem(at(1), 2) === 0) { erred = rs.Err(at(2)); } else { erred = rs.Ok(at(2) as rs.u16); } - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(erred, f, rs.u16Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value), rs.u8Debug), true)]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ align: ">", width: 5 }, args24[0])])); + const args40 = [(f: rs.Formatter) => rs.fmtControlFlow(erred, f, rs.u16Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value), rs.u8Debug), true)]; + put(out, rs.fmtFormat([args40[0], "|", rs.fmtSpec({ alternate: true }, args40[0]), "|", rs.fmtSpec({ align: ">", width: 5 }, args40[0])])); if (rs.u8Rem(at(1), 2) === 0) { none = undefined; } else { @@ -911,11 +898,11 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { } else { unitNone = undefined; } - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlowOption(none, f, rs.u8Debug, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value))), (f: rs.Formatter) => rs.fmtControlFlowOption(unitNone, f, rs.fmtUnit, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value)), rs.None)]; - put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args26[0]), "|", args26[1], "|", rs.fmtSpec({ alternate: true }, args26[1])])); + const args41 = [(f: rs.Formatter) => rs.fmtControlFlowOption(none, f, rs.u8Debug, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value))), (f: rs.Formatter) => rs.fmtControlFlowOption(unitNone, f, rs.fmtUnit, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value)), rs.None)]; + put(out, rs.fmtFormat([args41[0], "|", rs.fmtSpec({ alternate: true }, args41[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args41[0]), "|", args41[1], "|", rs.fmtSpec({ alternate: true }, args41[1])])); const part5 = rs.Ok(at(2)); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part5, f, rs.u8Debug, (value: never, _f: rs.Formatter) => rs.unreachable(value))]; - put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0])])); + const args42 = [(f: rs.Formatter) => rs.fmtResult(part5, f, rs.u8Debug, (value: never, _f: rs.Formatter) => rs.unreachable(value))]; + put(out, rs.fmtFormat([args42[0], "|", rs.fmtSpec({ alternate: true }, args42[0])])); } export function pick$enums_Option_u8(by: rs.u8, x: rs.u8 | undefined): rs.RangeBound { @@ -997,155 +984,144 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const front: rs.usize = _6[0]; const back: rs.usize = _6[1]; const part = ends$iters_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data)), front, back); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0])])); + const args81 = [(f: rs.Formatter) => rs.fmtIter(part, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args81[0], "|", rs.fmtSpec({ alternate: true }, args81[0]), "|", rs.fmtSpec({ debugHex: "x" }, args81[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args81[0])])); const part2 = ends$iters_slice_IterMut_u8(rs.iterSliceMut(rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), undefined, true))), front, back); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part2, f, rs.u8Debug, ["IterMut"])]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const args82 = [(f: rs.Formatter) => rs.fmtIter(part2, f, rs.u8Debug, ["IterMut"])]; + put(out, rs.fmtFormat([args82[0], "|", rs.fmtSpec({ alternate: true }, args82[0])])); const part3 = ends$iters_vec_IntoIter_fmt_Pair(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Pair.Pair => { const b2: rs.u8 = _2; return { _0: b2, _1: rs.i64Neg(b2 as rs.i64) }; }), undefined, 16, true)), front, back); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + const args83 = [(f: rs.Formatter) => rs.fmtIter(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; + put(out, rs.fmtFormat([args83[0], "|", rs.fmtSpec({ alternate: true }, args83[0])])); const part4 = ends$iters_vec_IntoIter_u8(rs.byteVecIntoIter(rs.byteSliceToByteVec(data)), front, back); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part4, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args8[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtIter(part4, f, rs.u8Debug, ["IntoIter"]))])); const it4: rs.Iter = ends$iters_vec_Drain_fmt_Hex(rs.vecDrain(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), (_23: rs.u8): Hex.Hex => { return { _0: rs.u32Mul(_23 as rs.u32, 257) }; }), undefined, 4, true), new rs.RangeFrom(1, rs.usizeStep)), front, back); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it4, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f), ["Drain"])]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args10[0])])); + const args85 = [(f: rs.Formatter) => rs.fmtIter(it4, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f), ["Drain"])]; + put(out, rs.fmtFormat([args85[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args85[0])])); rs.drop(it4); const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const _111: { end: rs.usize } = { end: rs.usizeDiv(data.length, 2) }; const it5: rs.Iter = ends$iters_vec_Drain_u8(rs.byteVecDrain(bytes, _111), front, back); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it5, f, rs.u8Debug, ["Drain"])]; - put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args12[0])])); + const args86 = [(f: rs.Formatter) => rs.fmtIter(it5, f, rs.u8Debug, ["Drain"])]; + put(out, rs.fmtFormat([args86[0], "|", rs.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args86[0])])); rs.drop(it5); const arrays: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); - const _32: rs.u8 = c.data[c.start]; + const _33: rs.u8 = c.data[c.start]; rs.idx(c, 1); - return Uint8Array.of(_32, c.data[c.start + 1]); + return Uint8Array.of(_33, c.data[c.start + 1]); }), undefined, 2, true); const part5 = ends$iters_slice_Iter_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), front, back); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part5, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"])]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0])])); + const args87 = [(f: rs.Formatter) => rs.fmtIter(part5, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"])]; + put(out, rs.fmtFormat([args87[0], "|", rs.fmtSpec({ alternate: true }, args87[0])])); const part6 = ends$iters_slice_IterMut_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), back, front); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part6, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["IterMut"])]; - put(out, rs.fmtFormat([args16[0]])); - const _165: Array = []; - const _174: rs.Iter = rs.iterSlice(_165); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part6, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["IterMut"])])); + const _174: rs.Iter = rs.iterSlice([]); const _176: rs.Iter = rs.byteVecIntoIter(new rs.ByteVec()); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_174, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["Iter"]), (f: rs.Formatter) => rs.fmtIter(_176, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + const args89 = [(f: rs.Formatter) => rs.fmtIter(_174, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["Iter"]), (f: rs.Formatter) => rs.fmtIter(_176, f, rs.u8Debug, ["IntoIter"])]; + put(out, rs.fmtFormat([args89[0], "|", rs.fmtSpec({ alternate: true }, args89[1])])); const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), rs.le, rs.ge, rs.lt); const part7 = ends$iters_collections_binary_heap_Iter_u8(rs.heapIter(heap), front, back); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part7, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0])])); + const args90 = [(f: rs.Formatter) => rs.fmtIter(part7, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); const part8 = ends$iters_collections_binary_heap_IntoIter_u8(rs.heapIter(rs.heapClone(heap, undefined)), front, back); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part8, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part8, f, rs.u8Debug, ["IntoIter"])])); const it8: rs.Iter = ends$iters_collections_binary_heap_Drain_u8(rs.heapDrain(rs.heapClone(heap, undefined)), front, back); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it8, f, rs.u8Debug, [["Drain", "iter"], "Drain"])]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])])); + const args92 = [(f: rs.Formatter) => rs.fmtIter(it8, f, rs.u8Debug, [["Drain", "iter"], "Drain"])]; + put(out, rs.fmtFormat([args92[0], "|", rs.fmtSpec({ alternate: true }, args92[0])])); rs.drop(it8); const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rs.dequeIntoIter(rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.u8 | undefined => { const b4: rs.u8 = _27; return thenSome$0quywni(rs.u8Rem(b4, 3) !== 0, b4); }), undefined, 2, true), 2) as rs.VecDeque), front, back); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part9, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["IntoIter"])]; - put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])])); + const args93 = [(f: rs.Formatter) => rs.fmtIter(part9, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["IntoIter"])]; + put(out, rs.fmtFormat([args93[0], "|", rs.fmtSpec({ alternate: true }, args93[0])])); const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { - const _59: rs.usize = rs.u8Rem(_28, 6) as rs.usize; - if (!(_59 < 6)) { - rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _59); + const _510: rs.usize = rs.u8Rem(_28, 6) as rs.usize; + if (!(_510 < 6)) { + rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _510); } - return [97, 233, 20013, 129408, 10, 39][_59]; + return [97, 233, 20013, 129408, 10, 39][_510]; })); const part10 = ends$iters_str_Chars(rs.strChars(text), front, back); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChars(part10, f)]; - put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args28[0])])); + const args94 = [(f: rs.Formatter) => rs.fmtChars(part10, f)]; + put(out, rs.fmtFormat([args94[0], "|", rs.fmtSpec({ alternate: true }, args94[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args94[0])])); const part11 = ends$iters_str_Bytes(rs.strBytes(text), front, back); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part11, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0]), "|", rs.fmtSpec({ debugHex: "x" }, args30[0])])); + const args95 = [(f: rs.Formatter) => rs.fmtIter(part11, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; + put(out, rs.fmtFormat([args95[0], "|", rs.fmtSpec({ alternate: true }, args95[0]), "|", rs.fmtSpec({ debugHex: "x" }, args95[0])])); const _295: rs.Iter = rs.strChars(""); const _298: rs.Iter = rs.strChars(""); const _301: rs.Iter = rs.strBytes(""); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChars(_295, f), (f: rs.Formatter) => rs.fmtChars(_298, f), (f: rs.Formatter) => rs.fmtIter(_301, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rs.fmtFormat([args32[0], "|", rs.fmtSpec({ alternate: true }, args32[1]), "|", args32[2]])); + const args96 = [(f: rs.Formatter) => rs.fmtChars(_295, f), (f: rs.Formatter) => rs.fmtChars(_298, f), (f: rs.Formatter) => rs.fmtIter(_301, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; + put(out, rs.fmtFormat([args96[0], "|", rs.fmtSpec({ alternate: true }, args96[1]), "|", args96[2]])); const _310: rs.Iter<[rs.u8, rs.u8 | undefined]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): [rs.u8, rs.u8 | undefined] => { const b6: rs.u8 = _29; return [rs.u8Rem(b6, 16), thenSome$0quywni(rs.u8Rem(b6, 3) !== 0, b6)] as [rs.u8, rs.u8 | undefined]; }); const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _310, true, undefined, undefined, undefined, 3, true); const part12 = ends$iters_collections_btree_map_Iter_u8_Option_u8(rs.btreeIter(map), front, back); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part12, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])])); + const args97 = [(f: rs.Formatter) => rs.fmtIter(part12, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + put(out, rs.fmtFormat([args97[0], "|", rs.fmtSpec({ alternate: true }, args97[0]), "|", rs.fmtSpec({ debugHex: "x" }, args97[0])])); const _335: rs.Iter = ends$iters_collections_btree_map_Keys_u8_Option_u8(rs.btreeKeys(map), front, back); const _339: rs.Iter = ends$iters_collections_btree_map_Values_u8_Option_u8(rs.btreeValues(map), front, back); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_335, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIter(_339, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args36[0], "|", args36[1]])); + const args98 = [(f: rs.Formatter) => rs.fmtIter(_335, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIter(_339, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args98[0], "|", args98[1]])); const lo: rs.u8 = rs.u8Rem(at(2), 16); const _360: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); const _365: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, { end: lo, inclusive: true }), front, back); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_360, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f)), (f: rs.Formatter) => rs.fmtIter(_365, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args38[0], "|", args38[1]])); + const args99 = [(f: rs.Formatter) => rs.fmtIter(_360, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f)), (f: rs.Formatter) => rs.fmtIter(_365, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + put(out, rs.fmtFormat([args99[0], "|", args99[1]])); const part13 = ends$iters_collections_btree_map_IterMut_u8_Option_u8(rs.btreeIterMut(map), front, back); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part13, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part13, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))])); const part14 = ends$iters_collections_btree_map_ValuesMut_u8_Option_u8(rs.btreeValuesMut(map), front, back); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part14, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part14, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); const part15 = ends$iters_collections_btree_map_RangeMut_u8_Option_u8(rs.btreeRangeMut(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part15, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part15, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))])); const part16 = ends$iters_collections_btree_map_IntoIter_u8_Option_u8(rs.btreeIter(rs.btreeClone(map, undefined, undefined)), front, back); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part16, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part16, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))])); const part17 = ends$iters_collections_btree_map_IntoKeys_u8_Option_u8(rs.btreeKeys(rs.btreeClone(map, undefined, undefined)), front, back); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part17, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args48[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part17, f, rs.u8Debug)])); const part18 = ends$iters_collections_btree_map_IntoValues_u8_Option_u8(rs.btreeValues(map), front, back); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part18, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part18, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); const _468: rs.Iter<[Uint8Array, Hex.Hex]> = rs.iterMap(rs.byteSliceChunksExact(data, 2), (c2: rs.ByteSlice): [Uint8Array, Hex.Hex] => { rs.idx(c2, 0); const _411: rs.u8 = c2.data[c2.start]; rs.idx(c2, 1); - const _33: Uint8Array = Uint8Array.of(_411, c2.data[c2.start + 1]); + const _37: Uint8Array = Uint8Array.of(_411, c2.data[c2.start + 1]); rs.idx(c2, 0); - return [_33, { _0: c2.data[c2.start] as rs.u32 }] as [Uint8Array, Hex.Hex]; + return [_37, { _0: c2.data[c2.start] as rs.u32 }] as [Uint8Array, Hex.Hex]; }); const keyed: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _468, true, undefined, undefined, undefined, 8, true); const it13: rs.Iter<[rs.ByteSlice, Hex.Hex]> = ends$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(rs.iterLend(rs.btreeIter(keyed), (held): [rs.ByteSlice, Hex.Hex] => { return [rs.byteSliceFrom(held[0]), held[1]]; }), front, back); const _481: rs.Iter = ends$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(rs.iterLend(rs.btreeKeys(keyed), rs.byteSliceFrom), back, front); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it13, f, (value: [Uint8Array, Hex.Hex], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.u8Debug), (f: rs.Formatter) => Hex.fmt$fmt_Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_481, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args52[0]), "|", args52[1]])); + const args106 = [(f: rs.Formatter) => rs.fmtIter(it13, f, (value: [Uint8Array, Hex.Hex], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.u8Debug), (f: rs.Formatter) => Hex.fmt$fmt_Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_481, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args106[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args106[0]), "|", args106[1]])); const _491: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): rs.u8 => { return rs.u8Rem(_212, 16); }); const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _491, true, undefined, undefined, 1, true); const part19 = ends$iters_collections_btree_set_Iter_u8(rs.btreeKeys(set), front, back); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part19, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0])])); + const args107 = [(f: rs.Formatter) => rs.fmtIter(part19, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args107[0], "|", rs.fmtSpec({ alternate: true }, args107[0])])); const part20 = ends$iters_collections_btree_set_Range_u8(rs.btreeRangeKeys(set, new rs.RangeFrom(lo, rs.u8Step)), front, back); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part20, f, rs.fmtSetVal(rs.u8Debug), [["Range", "iter"]])]; - put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0]), "|", rs.fmtSpec({ debugHex: "x" }, args56[0])])); + const args108 = [(f: rs.Formatter) => rs.fmtIter(part20, f, rs.fmtSetVal(rs.u8Debug), [["Range", "iter"]])]; + put(out, rs.fmtFormat([args108[0], "|", rs.fmtSpec({ alternate: true }, args108[0]), "|", rs.fmtSpec({ debugHex: "x" }, args108[0])])); const part21 = ends$iters_collections_btree_set_IntoIter_u8(rs.btreeKeys(set), front, back); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part21, f, rs.fmtSetVal(rs.u8Debug), [["IntoIter", "iter"]])]; - put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0])])); + const args109 = [(f: rs.Formatter) => rs.fmtIter(part21, f, rs.fmtSetVal(rs.u8Debug), [["IntoIter", "iter"]])]; + put(out, rs.fmtFormat([args109[0], "|", rs.fmtSpec({ alternate: true }, args109[0])])); const empty2: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const _547: rs.Iter<[rs.u8, rs.u8]> = rs.btreeIter(empty2); const _550: rs.Iter = rs.btreeKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_547, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_550, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[1])])); + const args110 = [(f: rs.Formatter) => rs.fmtIter(_547, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_550, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[1])])); const part22 = rs.btreeKeys(empty2); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part22, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args62[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part22, f, rs.u8Debug)])); const _573: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet]; const one: rs.HashMap = _573[0]; const keys: rs.HashSet = _573[1]; @@ -1160,35 +1136,31 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.usize = rs.u8Rem(at(1), 2) as rs.usize; const _608: rs.Iter<[rs.u8 | undefined, rs.u16]> = rs.hashIter(one); const _611: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Iter_Option_u8_u16(rs.hashIter(one), n); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_608, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_611, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[1])])); + const args112 = [(f: rs.Formatter) => rs.fmtIter(_608, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_611, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args112[0], "|", rs.fmtSpec({ alternate: true }, args112[1])])); const _627: rs.Iter = skip$iters_collections_hash_map_Keys_Option_u8_u16(rs.hashKeys(one), n); const _631: rs.Iter = skip$iters_collections_hash_map_Values_Option_u8_u16(rs.hashValues(one), n); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_627, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_631, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args66[0], "|", args66[1]])); + const args113 = [(f: rs.Formatter) => rs.fmtIter(_627, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_631, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args113[0], "|", args113[1]])); const part23 = skip$iters_collections_hash_map_IterMut_Option_u8_u16(rs.hashIterMut(one), n); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part23, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args68[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part23, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))])); const part24 = skip$iters_collections_hash_map_ValuesMut_Option_u8_u16(rs.hashValuesMut(one), rs.usizeSub(1, n)); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part24, f, rs.u16Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args70[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtIter(part24, f, rs.u16Debug))])); const part25 = skip$iters_collections_hash_map_IntoIter_Option_u8_u16(rs.hashIter(rs.hashClone(one, undefined, undefined)), n); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part25, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args72[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part25, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))])); const _695: rs.Iter = rs.hashKeys(rs.hashClone(one, undefined, undefined)); const _699: rs.Iter = skip$iters_collections_hash_map_IntoValues_Option_u8_u16(rs.hashValues(rs.hashClone(one, undefined, undefined)), n); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_695, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_699, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args74[0], "|", args74[1]])); + const args117 = [(f: rs.Formatter) => rs.fmtIter(_695, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_699, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args117[0], "|", args117[1]])); const it17: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Drain_Option_u8_u16(rs.hashDrain(one), n); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it17, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ alternate: true }, args76[0])])); + const args118 = [(f: rs.Formatter) => rs.fmtIter(it17, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args118[0], "|", rs.fmtSpec({ alternate: true }, args118[0])])); const _732: rs.Iter = skip$iters_collections_hash_set_Iter_array2_u8(rs.iterLend(rs.hashKeys(keys), rs.byteSliceFrom), n); const _736: rs.Iter = rs.hashKeys(rs.hashClone(keys, copy$array_u8, undefined)); - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_732, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_736, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[1])])); + const args119 = [(f: rs.Formatter) => rs.fmtIter(_732, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_736, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args119[0], "|", rs.fmtSpec({ alternate: true }, args119[1])])); const part26 = skip$iters_collections_hash_set_Drain_array2_u8(rs.hashDrainKeys(keys), rs.usizeSub(1, n)); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part26, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part26, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))])); } export function skip$iters_collections_binary_heap_Drain_u8(it: rs.Iter, n: rs.usize): rs.Iter { @@ -1868,89 +1840,80 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { const part2 = ends$adaptors_iter_Map_slice_Iter_u8_fmt_adaptors_closure1(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b: rs.u8): rs.u8 => { return rs.u8Add(b, 1); }), front, back); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part2, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + const args139 = [(f: rs.Formatter) => rs.fmtAdaptor(part2, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args139[0], "|", rs.fmtSpec({ alternate: true }, args139[0]), "|", rs.fmtSpec({ debugHex: "x" }, args139[0])])); const part3 = ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(rs.iterFilter(rs.iterSlice(rs.byteSliceView(bytes)), (_2: rs.u8): boolean => { return rs.u8Rem(_2, 2) === 0; }), front, back); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part3, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const args140 = [(f: rs.Formatter) => rs.fmtAdaptor(part3, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args140[0], "|", rs.fmtSpec({ alternate: true }, args140[0])])); const part4 = ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_23: rs.u8): rs.u8 | undefined => { return rs.u8CheckedSub(_23, 9); }), front, back); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part4, f, "FilterMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part4, f, "FilterMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); const part5 = ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(rs.iterInspect(rs.iterSlice(rs.byteSliceView(bytes)), (_26: rs.u8): undefined => {}), front, back); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part5, f, "Inspect", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part5, f, "Inspect", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); const part6 = fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_28: rs.u8): rs.u8 | undefined => { return rs.u8CheckedSub(_28, 3); }), front); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part6, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part6, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); const part7 = ends$adaptors_iter_Rev_slice_Iter_u8(rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), front, back); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part7, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0])])); + const args144 = [(f: rs.Formatter) => rs.fmtAdaptor(part7, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args144[0], "|", rs.fmtSpec({ alternate: true }, args144[0])])); const part8 = ends$adaptors_iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(bytes)), front, back); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part8, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args14[0])])); + const args145 = [(f: rs.Formatter) => rs.fmtAround(part8, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args145[0], "|", rs.fmtSpec({ alternate: true }, args145[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args145[0])])); const part9 = ends$adaptors_iter_Cloned_slice_Iter_u8(rs.iterCloned(rs.iterSlice(rs.byteSliceView(bytes))), front, back); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part9, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), "it")]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part9, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), "it")])); const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rs.iterCloned(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b5: rs.u8): string => { return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b5, f)); }), undefined, 12, true).items)), front, back); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.fmtStr, ["Iter"]), "it")]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0])])); + const args147 = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.fmtStr, ["Iter"]), "it")]; + put(out, rs.fmtFormat([args147[0], "|", rs.fmtSpec({ alternate: true }, args147[0])])); const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunksExact(data, 2), 3), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); const _32: rs.u8 = c.data[c.start]; rs.idx(c, 1); return Uint8Array.of(_32, c.data[c.start + 1]); }), undefined, 2, true).items), rs.byteSliceFrom), rs.byteSliceToArray), front, back); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part11, f, "Copied", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"]), "it")]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part11, f, "Copied", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"]), "it")])); const part12 = ends$adaptors_iter_Enumerate_slice_Iter_u8(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(bytes))), front, back); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEnumerate(part12, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ debugHex: "x" }, args22[0])])); + const args149 = [(f: rs.Formatter) => rs.fmtEnumerate(part12, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args149[0], "|", rs.fmtSpec({ alternate: true }, args149[0]), "|", rs.fmtSpec({ debugHex: "x" }, args149[0])])); const it12: rs.Iter = rs.iterSkip(rs.iterSlice(rs.byteSliceView(bytes)), at(2) as rs.usize); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])])); + const args150 = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args150[0], "|", rs.fmtSpec({ alternate: true }, args150[0])])); rs.iterToOption(it12.nextBack()); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args26[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); it12.next(); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args28[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); const part13 = ends$adaptors_iter_Take_slice_Iter_u8(rs.iterTake(rs.iterSlice(rs.byteSliceView(bytes)), rs.u8Rem(at(2), 8) as rs.usize), front, back); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])])); + const args153 = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args153[0], "|", rs.fmtSpec({ alternate: true }, args153[0])])); const it14: rs.Iter = rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_211: rs.u8): boolean => { return rs.u8Rem(_211, 3) !== 0; }); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args32[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); it14.next(); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])])); + const args155 = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args155[0], "|", rs.fmtSpec({ alternate: true }, args155[0])])); const it15: rs.Iter = rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): boolean => { return rs.u8Rem(_212, 5) !== 0; }); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args36[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); let iterStart: rs.usize = 0; const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { it15.next(); } - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0])])); + const args157 = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args157[0], "|", rs.fmtSpec({ alternate: true }, args157[0])])); const part14 = fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), 0, (sum: rs.Place, _33: rs.u8): rs.u32 | undefined => { sum.v = rs.u32Add(sum.v, _33 as rs.u32); return sum.v; }, true), front); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtScan(part14, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u32Debug)]; - put(out, rs.fmtFormat([args40[0], "|", rs.fmtSpec({ alternate: true }, args40[0]), "|", rs.fmtSpec({ debugHex: "x" }, args40[0])])); + const args158 = [(f: rs.Formatter) => rs.fmtScan(part14, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u32Debug)]; + put(out, rs.fmtFormat([args158[0], "|", rs.fmtSpec({ alternate: true }, args158[0]), "|", rs.fmtSpec({ debugHex: "x" }, args158[0])])); const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), "", (s: rs.Place, _34: rs.u8): rs.usize | undefined => { const b9: rs.u8 = _34; s.v = s.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(b9, 26)) as rs.char); @@ -1958,168 +1921,149 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.stringLen(s.v); }); }, true), front); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtScan(part15, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.fmtStr)]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtScan(part15, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.fmtStr)])); const it18: rs.Peekable = ends$adaptors_iter_Peekable_slice_Iter_u8(rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))), front, back); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)])); rs.peekablePeek(it18); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args46[0], "|", rs.fmtSpec({ alternate: true }, args46[0])])); + const args161 = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; + put(out, rs.fmtFormat([args161[0], "|", rs.fmtSpec({ alternate: true }, args161[0])])); it18.next(); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args48[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)])); const it19: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(bytes.length, 1))))); it19.next(); rs.peekablePeek(it19); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])])); + const args163 = [(f: rs.Formatter) => rs.fmtPeekable(it19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; + put(out, rs.fmtFormat([args163[0], "|", rs.fmtSpec({ alternate: true }, args163[0])])); const part19 = ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(2, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, rs.min(2, bytes.length))))), front, back); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0])])); + const args164 = [(f: rs.Formatter) => rs.fmtChain(part19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args164[0], "|", rs.fmtSpec({ alternate: true }, args164[0])])); const it21: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(1, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(7, 8))))); rs.iterToOption(it21.nextBack()); rs.iterToOption(it21.nextBack()); rs.iterToOption(it21.nextBack()); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(it21, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtChain(it21, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); const part21 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b10: rs.u8): rs.u8 => { return b10 ^ 1; }), [false, true]), front, back); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part21, f)]; - put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])])); + const args166 = [(f: rs.Formatter) => rs.fmtZip(part21, f)]; + put(out, rs.fmtFormat([args166[0], "|", rs.fmtSpec({ alternate: true }, args166[0])])); const part22 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), "len"), front, back); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part22, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args58[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtZip(part22, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))])); const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { - const _511: rs.usize = rs.u8Rem(_213, 4) as rs.usize; - if (!(_511 < 4)) { - rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _511); + const _515: rs.usize = rs.u8Rem(_213, 4) as rs.usize; + if (!(_515 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _515); } - return [97, 233, 20013, 129408][_511]; + return [97, 233, 20013, 129408][_515]; }))), rs.iterSlice(rs.byteSliceView(bytes))), front); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part23, f, rs.fmtChars, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[0])])); + const args168 = [(f: rs.Formatter) => rs.fmtZip(part23, f, rs.fmtChars, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args168[0], "|", rs.fmtSpec({ alternate: true }, args168[0])])); const part24 = fronts$adaptors_iter_Cycle_slice_Iter_u8(rs.iterCycle(rs.iterSlice(rs.byteSliceView(bytes))), rs.usizeAdd(front, rs.u8Rem(at(2), 8) as rs.usize)); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCycle(part24, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])])); + const args169 = [(f: rs.Formatter) => rs.fmtCycle(part24, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args169[0], "|", rs.fmtSpec({ alternate: true }, args169[0])])); const part25 = fronts$adaptors_iter_Fuse_slice_Iter_u8(rs.iterFuse(rs.iterSlice(rs.byteSliceView(bytes)), true), rs.usizeAdd(front, 6)); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part25, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])])); + const args170 = [(f: rs.Formatter) => rs.fmtFuse(part25, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args170[0], "|", rs.fmtSpec({ alternate: true }, args170[0])])); const part26 = fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(rs.iterFuse(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), 2), true), rs.usizeAdd(front, 2)); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part26, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtStepBy(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0])])); - const part27 = fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(rs.iterFuse(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_216: rs.u8): rs.u8 | undefined => { - const b12: rs.u8 = _216; + const args171 = [(f: rs.Formatter) => rs.fmtFuse(part26, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtStepBy(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args171[0], "|", rs.fmtSpec({ alternate: true }, args171[0])])); + const part27 = fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(rs.iterFuse(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_218: rs.u8): rs.u8 | undefined => { + const b12: rs.u8 = _218; return thenSome$0quywni(rs.u8Rem(b12, 4) !== 0, b12); })), rs.usizeMul(front, 2)); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part27, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args68[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFuse(part27, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))])); const step: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); const part28 = ends$adaptors_iter_StepBy_slice_Iter_u8(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), step), front, back); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part28, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])])); + const args173 = [(f: rs.Formatter) => rs.fmtStepBy(part28, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args173[0], "|", rs.fmtSpec({ alternate: true }, args173[0])])); const _630: [rs.u8, rs.u8] = [rs.u8Rem(at(4), 16), at(5)]; const lo: rs.u8 = _630[0]; const hi: rs.u8 = _630[1]; const part29 = ends$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(lo, hi), step, undefined, 255), front, back); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part29, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])])); + const args174 = [(f: rs.Formatter) => rs.fmtStepBy(part29, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args174[0], "|", rs.fmtSpec({ alternate: true }, args174[0])])); const part30 = fronts$adaptors_iter_StepBy_ops_Range_u32(rs.iterStepBy(new rs.Range(lo as rs.u32, hi as rs.u32), step, undefined, 4294967295), front); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part30, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u32Debug))]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part30, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u32Debug))])); const part31 = ends$adaptors_iter_StepBy_ops_Range_usize(rs.iterStepBy(new rs.Range(lo as rs.usize, hi as rs.usize), step, undefined, 4294967295), front, back); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part31, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.usizeDebug))]; - put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ debugHex: "x" }, args76[0])])); + const args176 = [(f: rs.Formatter) => rs.fmtStepBy(part31, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.usizeDebug))]; + put(out, rs.fmtFormat([args176[0], "|", rs.fmtSpec({ debugHex: "x" }, args176[0])])); const part32 = ends$adaptors_iter_StepBy_ops_Range_u16(rs.iterStepBy(new rs.Range(lo as rs.u16, hi as rs.u16), step, undefined, 65535), front, back); - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part32, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u16Debug))]; - put(out, rs.fmtFormat([args78[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part32, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u16Debug))])); const part33 = ends$adaptors_iter_StepBy_ops_Range_i32(rs.iterStepBy(new rs.Range(lo as rs.i32, hi as rs.i32), step), front, back); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part33, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.i32Debug))]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part33, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.i32Debug))])); const part34 = fronts$adaptors_iter_StepBy_ops_Range_u64(rs.iterStepBy(new rs.Range(lo as rs.u64, hi as rs.u64, rs.u64Step), step), front); - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part34, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u64Debug))]; - put(out, rs.fmtFormat([args82[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part34, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u64Debug))])); const part35 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), 300, undefined, 255), front); - const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part35, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args84[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part35, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))])); const part36 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), rs.usizeAdd(at(3) as rs.usize, 1), undefined, 255), front); - const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part36, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part36, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))])); const part37 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(hi, 255), rs.usizeAdd(step, 200), undefined, 255), front); - const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part37, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args88[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part37, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))])); const lists: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(bytes, 2), (a0: rs.ByteSlice): rs.ByteVec => { return rs.byteSliceToByteVec(a0); }), undefined, 12, true); const part38 = ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), front, back); - const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlatten(part38, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); + const args183 = [(f: rs.Formatter) => rs.fmtFlatten(part38, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args183[0], "|", rs.fmtSpec({ alternate: true }, args183[0])])); const part39 = ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(rs.iterFlatMap(rs.iterSlice(lists.items), (v: rs.ByteVec): rs.Iter => { return rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))); }, undefined, true), front, back); - const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlatten(part39, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args92[0], "|", rs.fmtSpec({ alternate: true }, args92[0])])); + const args184 = [(f: rs.Formatter) => rs.fmtFlatten(part39, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args184[0], "|", rs.fmtSpec({ alternate: true }, args184[0])])); const part40 = fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(rs.iterFuse(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), true), rs.usizeAdd(front, 6)); - const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part40, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args94[0]])); - const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_218: rs.u8): rs.u16 => { - const _517: rs.usize = rs.u8Rem(_218, 5) as rs.usize; - if (!(_517 < 5)) { - rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _517); - } - return [97, 55296, 56320, 233, 56319][_517]; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFuse(part40, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))])); + const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_219: rs.u8): rs.u16 => { + const _519: rs.usize = rs.u8Rem(_219, 5) as rs.usize; + if (!(_519 < 5)) { + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _519); + } + return [97, 55296, 56320, 233, 56319][_519]; }), undefined, 2, true); const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterSlice(units.items)), front); - const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part41, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args96[0], "|", rs.fmtSpec({ alternate: true }, args96[0]), "|", rs.fmtSpec({ debugHex: "x" }, args96[0])])); + const args186 = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part41, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args186[0], "|", rs.fmtSpec({ alternate: true }, args186[0]), "|", rs.fmtSpec({ debugHex: "x" }, args186[0])])); const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rs.charDecodeUtf16(rs.vecIntoIter(rs.vecFrom([55296, 97, 98]))), rs.u8Rem(at(2), 3) as rs.usize); - const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part42, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["IntoIter"]))]; - put(out, rs.fmtFormat([args98[0]])); - const quoted: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_219: rs.u8): rs.char => { - const _519: rs.usize = rs.u8Rem(_219, 6) as rs.usize; - if (!(_519 < 6)) { - rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _519); - } - return [97, 34, 10, 769, 233, 39][_519]; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtDecodeUtf16(part42, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["IntoIter"]))])); + const quoted: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): rs.char => { + const _523: rs.usize = rs.u8Rem(_221, 6) as rs.usize; + if (!(_523 < 6)) { + rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _523); + } + return [97, 34, 10, 769, 233, 39][_523]; })); const part43 = fronts$adaptors_str_EscapeDebug(rs.strEscapeDebug(quoted), rs.usizeMul(front, 2)); - const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part43, f, "EscapeDebug", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDebug")))]; - put(out, rs.fmtFormat([args100[0], "|", rs.fmtSpec({ alternate: true }, args100[0])])); + const args188 = [(f: rs.Formatter) => rs.fmtAround(part43, f, "EscapeDebug", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDebug")))]; + put(out, rs.fmtFormat([args188[0], "|", rs.fmtSpec({ alternate: true }, args188[0])])); const part44 = fronts$adaptors_str_EscapeDefault(rs.strEscapeDefault(quoted), rs.usizeMul(front, 3)); - const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part44, f, "EscapeDefault", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDefault")))]; - put(out, rs.fmtFormat([args102[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAround(part44, f, "EscapeDefault", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDefault")))])); const part45 = fronts$adaptors_str_EscapeUnicode(rs.strEscapeUnicode(quoted), rs.usizeMul(front, 5)); - const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part45, f, "EscapeUnicode", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeUnicode")))]; - put(out, rs.fmtFormat([args104[0], "|", rs.fmtSpec({ alternate: true }, args104[0])])); + const args190 = [(f: rs.Formatter) => rs.fmtAround(part45, f, "EscapeUnicode", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeUnicode")))]; + put(out, rs.fmtFormat([args190[0], "|", rs.fmtSpec({ alternate: true }, args190[0])])); const base: rs.Iter = rs.iterSlice(rs.byteSliceView(bytes)); base.next(); const part46 = rs.iterSkip(rs.iterMap(rs.iterBorrow(base), (b15: rs.u8): rs.u8 => { return rs.u8Add(b15, 1); }), 1); - const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part46, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args106[0], "|", rs.fmtSpec({ alternate: true }, args106[0])])); + const args191 = [(f: rs.Formatter) => rs.fmtCounted(part46, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args191[0], "|", rs.fmtSpec({ alternate: true }, args191[0])])); const part47 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterBorrow(rs.iterSlice(units.items))), front); - const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part47, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args108[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtDecodeUtf16(part47, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))])); const part48 = fronts$adaptors_iter_Copied_mut_slice_Iter_u8(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(bytes))), front); - const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part48, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[0])])); + const args193 = [(f: rs.Formatter) => rs.fmtAround(part48, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args193[0], "|", rs.fmtSpec({ alternate: true }, args193[0])])); const part49 = fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(rs.iterMap(rs.iterBox(rs.iterSlice(rs.byteSliceView(bytes))), (b16: rs.u8): rs.u8 => { return rs.u8Add(b16, 1); }), front); - const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part49, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args112[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part49, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); const boxed: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))); const _1027: Countdown.Countdown = { _0: 4 }; const part50 = fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(rs.iterZip(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed))), rs.iterBox(rs.iterFrom(_1027, Countdown.next$iter_Iterator))), front); - const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part50, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args114[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtZip(part50, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); const part51 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(rs.iterEnumerate(rs.iterMap(rs.iterFrom({ _0: rs.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rs.u8): rs.u8 => { return rs.u8Mul(n, 2); })), front); - const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEnumerate(part51, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args116[0], "|", rs.fmtSpec({ alternate: true }, args116[0])])); + const args196 = [(f: rs.Formatter) => rs.fmtEnumerate(part51, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; + put(out, rs.fmtFormat([args196[0], "|", rs.fmtSpec({ alternate: true }, args196[0])])); if (!(rs.u8Rem(at(3), 2) === 0)) { toggle = "Done" as Toggle.Toggle; } else { @@ -2128,61 +2072,54 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { const part52 = rs.iterMap(rs.iterFrom(rs.place(() => toggle, (value2) => toggle = value2), Toggle.next$iter_Iterator), (x: rs.u8): rs.u8 => { return x; }); - const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part52, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args118[0], "|", rs.fmtSpec({ alternate: true }, args118[0])])); + const args197 = [(f: rs.Formatter) => rs.fmtAdaptor(part52, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rs.fmtFormat([args197[0], "|", rs.fmtSpec({ alternate: true }, args197[0])])); const part53 = rs.iterMap(rs.iterFrom(rs.place(() => toggle, (value3) => toggle = value3), Toggle.next$iter_Iterator), (x2: rs.u8): rs.u8 => { return x2; }); - const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part53, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args120[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part53, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))])); let boxed2: Toggle.Toggle = toggle; const part54 = fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value5) => boxed2 = value5), Toggle.next$iter_Iterator))), (x3: rs.u8): rs.u8 => { return x3; }), front); - const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part54, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args122[0], "|", rs.fmtSpec({ alternate: true }, args122[0])])); + const args199 = [(f: rs.Formatter) => rs.fmtAdaptor(part54, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rs.fmtFormat([args199[0], "|", rs.fmtSpec({ alternate: true }, args199[0])])); const part55 = fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(rs.iterMap(rs.iterBox(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value6) => boxed2 = value6), Toggle.next$iter_Iterator)))), (x4: rs.u8): rs.u8 => { return x4; }), front); - const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part55, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args124[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part55, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))])); const part56 = fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(rs.iterMap(rs.iterBox(rs.iterFrom(rs.place(() => toggle, (value7) => toggle = value7), Toggle.next$iter_Iterator)), (x5: rs.u8): rs.u8 => { return x5; }), front); - const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part56, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args126[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part56, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))])); let nested: Countdown.Countdown = { _0: rs.u8Rem(at(4), 5) }; const part57 = fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(nested, Countdown.next$iter_Iterator))), (n2: rs.u8): rs.u8 => { return n2; }), front); - const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args128[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); const part58 = fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(rs.iterMap(rs.iterBox(rs.iterFrom({ _0: rs.u8Rem(at(5), 5) }, Countdown.next$iter_Iterator)), (n3: rs.u8): rs.u8 => { return n3; }), front); - const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args130[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); const own: Countdown.Countdown = { _0: rs.u8Rem(at(3), 5) }; const part59 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rs.iterPeekable(rs.iterFrom(own, Countdown.next$iter_Iterator)), front); - const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f), rs.u8Debug)]; - put(out, rs.fmtFormat([args132[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f), rs.u8Debug)])); const part60 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(rs.iterChain(rs.iterFlatMap(rs.iterSlice(lists.items), (v2: rs.ByteVec): Countdown.Countdown => { return { _0: rs.u8Rem(v2.data[rs.idx(v2, 0)], 3) }; }, (value: Countdown.Countdown) => rs.iterFrom(value, Countdown.next$iter_Iterator), true), rs.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); - const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part60, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args134[0]])); - const part61 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(rs.iterTake(rs.iterRev(rs.iterSkip(rs.iterEnumerate(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): Pair.Pair => { - return { _0: _221, _1: -1 }; + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtChain(part60, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); + const part61 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(rs.iterTake(rs.iterRev(rs.iterSkip(rs.iterEnumerate(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_225: rs.u8): Pair.Pair => { + return { _0: _225, _1: -1 }; })), 1)), 3), front, back); - const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part61, f, "Take", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtCounted(value, f, "Skip", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtEnumerate(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; - put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args136[0])])); + const args206 = [(f: rs.Formatter) => rs.fmtCounted(part61, f, "Take", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtCounted(value, f, "Skip", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtEnumerate(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; + put(out, rs.fmtFormat([args206[0], "|", rs.fmtSpec({ alternate: true }, args206[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args206[0])])); const it63: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))); rs.peekablePeek(it63); const part62 = rs.iterChain(rs.iterFilter(rs.iterZip(it63, new rs.RangeFrom(1, rs.u8Step), "len"), (p: [rs.u8, rs.u8]): boolean => { return p[0] !== 0; }), rs.vecIntoIter(rs.vecFrom(copy$array_tuple2_u8_u8([[9, 9] as [rs.u8, rs.u8]]).map(copy$tuple2_u8_u8)))); - const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part62, f, (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtZip(value, f, (value: rs.Peekable, f: rs.Formatter) => rs.fmtPeekable(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), rs.u8Debug), (value: rs.RangeFrom, f: rs.Formatter) => rs.fmtRangeFrom(value, f, rs.u8Debug))), (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtIter(value, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f), ["IntoIter"]))]; - put(out, rs.fmtFormat([args138[0], "|", rs.fmtSpec({ alternate: true }, args138[0])])); + const args207 = [(f: rs.Formatter) => rs.fmtChain(part62, f, (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtZip(value, f, (value: rs.Peekable, f: rs.Formatter) => rs.fmtPeekable(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), rs.u8Debug), (value: rs.RangeFrom, f: rs.Formatter) => rs.fmtRangeFrom(value, f, rs.u8Debug))), (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtIter(value, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f), ["IntoIter"]))]; + put(out, rs.fmtFormat([args207[0], "|", rs.fmtSpec({ alternate: true }, args207[0])])); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { @@ -3107,14 +3044,14 @@ export function placed$mut_String(w: rs.Place, n: rs.u8): rs.Result rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; - const written = rs.fmtWriteString(w.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]); + const args5 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; + const written = rs.fmtWriteString(w.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args5[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args5[1]), "|", args5[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args5[3]), "|", rs.fmtSpec({ plus: true }, args5[4])]); w.v = written.s; if (written.result.ok) { w.v = w.v + "é"; if (rs.OK.ok) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; - const written2 = rs.fmtWriteString(w.v, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); + const args6 = [(f: rs.Formatter) => rs.u8Binary(n, f)]; + const written2 = rs.fmtWriteString(w.v, [rs.fmtSpec({ alternate: true }, args6[0]), "\n"]); w.v = written2.s; return written2.result; } @@ -3128,11 +3065,11 @@ export function placed$mut_fmt_Formatter(w: rs.Formatter, n: rs.u8): rs.Result rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; - if (rs.fmtWriteFmt(w, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]).ok) { + const args5 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; + if (rs.fmtWriteFmt(w, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args5[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args5[1]), "|", args5[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args5[3]), "|", rs.fmtSpec({ plus: true }, args5[4])]).ok) { if (rs.fmtWriteChar(w, 233).ok) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; - return rs.fmtWriteFmt(w, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); + const args6 = [(f: rs.Formatter) => rs.u8Binary(n, f)]; + return rs.fmtWriteFmt(w, [rs.fmtSpec({ alternate: true }, args6[0]), "\n"]); } return rs.Err(new rs.FmtError()); } @@ -3144,14 +3081,14 @@ export function placed$mut_mut_mut_String(w: rs.Place> const _8: string = "q\"é"; const _9: rs.char = 223; const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; - const written = rs.fmtWriteString(w.v.v.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]); + const args5 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; + const written = rs.fmtWriteString(w.v.v.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args5[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args5[1]), "|", args5[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args5[3]), "|", rs.fmtSpec({ plus: true }, args5[4])]); w.v.v.v = written.s; if (written.result.ok) { w.v.v.v = w.v.v.v + "é"; if (rs.OK.ok) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; - const written2 = rs.fmtWriteString(w.v.v.v, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); + const args6 = [(f: rs.Formatter) => rs.u8Binary(n, f)]; + const written2 = rs.fmtWriteString(w.v.v.v, [rs.fmtSpec({ alternate: true }, args6[0]), "\n"]); w.v.v.v = written2.s; return written2.result; } @@ -3177,8 +3114,8 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { let s: string = ""; const _19: rs.u8 = at(1); const _25: rs.u8 = at(2); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_19, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"é", f), (f: rs.Formatter) => rs.u8LowerHex(_25, f)]; - const written = rs.fmtWriteString(s, ["a", args2[0], "b", rs.fmtSpec({ align: ">", width: 5 }, args2[1]), "|", args2[2], "|", args2[3]]); + const args9 = [(f: rs.Formatter) => rs.u8Display(_19, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"é", f), (f: rs.Formatter) => rs.u8LowerHex(_25, f)]; + const written = rs.fmtWriteString(s, ["a", args9[0], "b", rs.fmtSpec({ align: ">", width: 5 }, args9[1]), "|", args9[2], "|", args9[3]]); s = written.s; result(out, written.result); s = s + "\n"; @@ -3189,8 +3126,8 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { result(out, rs.OK); const _52: Fails.Fails = { _0: at(3) }; const _57: rs.u8 = at(4); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(_52, f), (f: rs.Formatter) => rs.u8Display(_57, f)]; - const written2 = rs.fmtWriteString(s, ["x", args4[0], "y", args4[1]]); + const args10 = [(f: rs.Formatter) => Fails.fmt$fmt_Display(_52, f), (f: rs.Formatter) => rs.u8Display(_57, f)]; + const written2 = rs.fmtWriteString(s, ["x", args10[0], "y", args10[1]]); s = written2.s; result(out, written2.result); result(out, literals$mut_String(rs.place(() => s, (value) => s = value), c)); @@ -3204,17 +3141,16 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { put(out, s); const _96: Placed.Placed = { _0: at(7) }; const _101: Placed.Placed = { _0: at(8) }; - const args6: rs.Fmt[] = [(f: rs.Formatter) => Placed.fmt$fmt_Display(_96, f), (f: rs.Formatter) => Placed.fmt$fmt_Display(_101, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 30 }, args6[1])])); + const args11 = [(f: rs.Formatter) => Placed.fmt$fmt_Display(_96, f), (f: rs.Formatter) => Placed.fmt$fmt_Display(_101, f)]; + put(out, rs.fmtFormat([args11[0], "|", rs.fmtSpec({ align: ">", width: 30 }, args11[1])])); const capped: Capped.Capped = { text: "", calls: 0, cap: rs.u8Rem(at(9), 40) as rs.usize }; result(out, literals$mut_fmt_Capped(capped, c)); result(out, Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c))); result(out, Capped.writeStr$fmt_Write(capped, "z")); const _134: rs.u8 = at(10); const _138: rs.i16 = rs.i16Neg(at(11) as rs.i16); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_134, f), (f: rs.Formatter) => rs.i16Display(_138, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"b", f)]; - const _131: rs.Arguments = [rs.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", args8[1], "|", rs.fmtSpec({ align: "^", width: 5 }, args8[2]), "|", args8[3]]; - result(out, rs.fmtWrite((s2) => Capped.writeStr$fmt_Write(capped, s2), (c2) => Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c2)), _131)); + const args12 = [(f: rs.Formatter) => rs.u8Display(_134, f), (f: rs.Formatter) => rs.i16Display(_138, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"b", f)]; + result(out, rs.fmtWrite((s2) => Capped.writeStr$fmt_Write(capped, s2), (c2) => Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c2)), [rs.fmtSpec({ align: ">", width: 4 }, args12[0]), "|", args12[1], "|", rs.fmtSpec({ align: "^", width: 5 }, args12[2]), "|", args12[3]])); let _156: Capped.Capped = capped; result(out, literals$mut_mut_fmt_Capped(rs.place(() => _156, (value7) => _156 = value7), 233)); rs.byteVecPush(out, capped.calls); @@ -3230,14 +3166,12 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { export function named(out: rs.ByteVec, first: rs.u8, second: rs.u8): void { const s: Twice.Twice = { _0: "" }; const c: Capped.Capped = { text: "", calls: 0, cap: 64 }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f), (f: rs.Formatter) => rs.fmtCharDisplay(120, f)]; - const _11: rs.Arguments = [args2[0], rs.fmtSpec({ align: ">", width: 3 }, args2[1])]; - result(out, rs.fmtWrite((s2) => Twice.writeStr$fmt_Write(s, s2), (c2) => Twice.writeChar$fmt_Write(s, c2), _11)); + const args5 = [(f: rs.Formatter) => rs.u8Display(first, f), (f: rs.Formatter) => rs.fmtCharDisplay(120, f)]; + result(out, rs.fmtWrite((s2) => Twice.writeStr$fmt_Write(s, s2), (c2) => Twice.writeChar$fmt_Write(s, c2), [args5[0], rs.fmtSpec({ align: ">", width: 3 }, args5[1])])); const _28: rs.Fmt = (f: rs.Formatter) => rs.u8Display(second, f); const arg = s._0; - const args4: rs.Fmt[] = [_28, (f: rs.Formatter) => rs.fmtPad(f, arg)]; - const _23: rs.Arguments = [rs.fmtSpec({ align: "<", width: 3 }, args4[0]), args4[1]]; - result(out, rs.fmtWrite((s3) => Capped.writeStr$fmt_Write(c, s3), (c3) => Capped.writeStr$fmt_Write(c, String.fromCodePoint(c3)), _23)); + const args6 = [_28, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + result(out, rs.fmtWrite((s3) => Capped.writeStr$fmt_Write(c, s3), (c3) => Capped.writeStr$fmt_Write(c, String.fromCodePoint(c3)), [rs.fmtSpec({ align: "<", width: 3 }, args6[0]), args6[1]])); put(out, s._0); put(out, c.text); rs.byteVecPush(out, c.calls); @@ -3255,8 +3189,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { _6.value = new rs.ByteVec(); const tags: rs.ByteVec = taken; rs.refMutRelease(_6); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(tags), f, rs.u8Debug)]; - put(out2, rs.fmtFormat([args32[0], " "])); + put(out2, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(tags), f, rs.u8Debug), " "])); }; const shown: rs.Vec = new rs.Vec(); const written: rs.Vec = new rs.Vec(); @@ -3279,22 +3212,20 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const _35: rs.Fmt = rs.fmtOwned(dropper(x), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Display(value, f), rs.drop); written.items.push(_35); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(x, f)]; - const _41: rs.Fmt = rs.fmtOwned(rs.fmtFormat(["s", args2[0]]), (value: string, f: rs.Formatter) => rs.fmtPad(f, value)); + const _41: rs.Fmt = rs.fmtOwned(rs.fmtFormat(["s", (f: rs.Formatter) => rs.u8Display(x, f)]), (value: string, f: rs.Formatter) => rs.fmtPad(f, value)); written.items.push(_41); } } for (const _55 of shown.items) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => _55(f)]; - put(out, rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " "])); + const args35 = [(f: rs.Formatter) => _55(f)]; + put(out, rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0]), " "])); } for (const _74 of written.items) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => _74(f)]; - put(out, rs.fmtFormat([args6[0], " [", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "] [", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "] "])); + const args36 = [(f: rs.Formatter) => _74(f)]; + put(out, rs.fmtFormat([args36[0], " [", rs.fmtSpec({ align: ">", width: 6 }, args36[0]), "] [", rs.fmtSpec({ align: "^", width: 7 }, args36[0]), "] "])); } const up: rs.Fmt = rs.fmtOwned(data.length, rs.usizeDebug); - const args8: rs.Fmt[] = [(f: rs.Formatter) => up(f)]; - put(out, rs.fmtFormat([args8[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => up(f), " "])); rs.dropVec(written); dropped(out); rs.vecTruncate(shown, 1, rs.drop); @@ -3309,33 +3240,31 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const shared: rs.Arc = new rs.ArcDyn(_121, rs.fmtOwned(_121.value, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))); const kept: rs.Arc = rs.arcClone(shared); const _135: rs.usize = kept.strong; - const args10: rs.Fmt[] = [(f: rs.Formatter) => shared.value(f), (f: rs.Formatter) => rs.usizeDisplay(_135, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " "])); + const args38 = [(f: rs.Formatter) => shared.value(f), (f: rs.Formatter) => rs.usizeDisplay(_135, f)]; + put(out, rs.fmtFormat([args38[0], " ", args38[1], " "])); const counted: rs.Arc = new rs.Arc(dropper(data.data[data.start])); const _149: rs.Arc = rs.arcClone(counted); const asDisplay: rs.Arc = new rs.ArcDyn(_149, rs.fmtOwned(_149.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Display(value, f), rs.drop)); _372 = true; const asDebug: rs.Arc = new rs.ArcDyn(counted, rs.fmtOwned(counted.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop)); const _160: rs.usize = asDebug.strong; - const args12: rs.Fmt[] = [(f: rs.Formatter) => asDisplay.value(f), (f: rs.Formatter) => rs.usizeDisplay(_160, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: "<", width: 5 }, args12[0]), "| ", args12[1], " "])); + const args39 = [(f: rs.Formatter) => asDisplay.value(f), (f: rs.Formatter) => rs.usizeDisplay(_160, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: "<", width: 5 }, args39[0]), "| ", args39[1], " "])); asDisplay[Symbol.dispose](); dropped(out); if (rs.u8Rem(b, 2) === 0) { _372 = false; asDebug[Symbol.dispose](); } else { - const args14: rs.Fmt[] = [(f: rs.Formatter) => asDebug.value(f)]; - put(out, rs.fmtFormat([args14[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => asDebug.value(f), " "])); } dropped(out); shared[Symbol.dispose](); const _198: rs.usize = kept.strong; - const args16: rs.Fmt[] = [(f: rs.Formatter) => kept.value(f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; - put(out, rs.fmtFormat([args16[0], " ", args16[1], " "])); + const args41 = [(f: rs.Formatter) => kept.value(f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; + put(out, rs.fmtFormat([args41[0], " ", args41[1], " "])); let n: rs.u8 = rs.u8WrappingMul(data.data[data.start], 3); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; - let text: string = rs.fmtFormat(["t", args18[0]]); + let text: string = rs.fmtFormat(["t", (f: rs.Formatter) => rs.u8Display(b, f)]); const owned: Dropper.Dropper = dropper(b); const part5 = rs.u8WrappingAdd(b, 1); let boxed: rs.Fmt = rs.fmtOwned(dropper(part5), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop); @@ -3353,29 +3282,24 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { if (_251 === rs.DONE) { break; } - const args20: rs.Fmt[] = [(f: rs.Formatter) => _251.v(f)]; - put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " "])); + const args43 = [(f: rs.Formatter) => _251.v(f)]; + put(out, rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[0]), " "])); } const _269: rs.u8 = rs.u8WrappingAdd(cell.v, 1); rs.cellSet(cell, _269); const again: rs.Fmt = objects.items[rs.idx(objects.items, 4)]; - const args22: rs.Fmt[] = [(f: rs.Formatter) => again(f)]; - put(out, rs.fmtFormat([args22[0], " "])); - const args24: rs.Fmt[] = [(f: rs.Formatter) => again(f)]; - put(out, rs.fmtFormat([args24[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => again(f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => again(f), " "])); n = rs.u8WrappingAdd(n, 1); const _304: rs.Place = rs.place(() => n, (value4) => n = value4); const part6 = (f: rs.Formatter) => rs.u8Display(_304.v, f); - const args26: rs.Fmt[] = [(f: rs.Formatter) => part6(f)]; - put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: ">", width: 5 }, args26[0]), "] "])); + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: ">", width: 5 }, (f: rs.Formatter) => part6(f)), "] "])); const part7 = (f: rs.Formatter) => Dropper.fmt$fmt_Display(owned, f); - const args28: rs.Fmt[] = [(f: rs.Formatter) => part7(f)]; - put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: "^", width: 6 }, args28[0]), "] "])); + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: "^", width: 6 }, (f: rs.Formatter) => part7(f)), "] "])); text = text + "!"; const arg3 = rs.place(() => text, (value5) => text = value5); const part8 = (f: rs.Formatter) => rs.fmtPad(f, arg3.v); - const args30: rs.Fmt[] = [(f: rs.Formatter) => part8(f)]; - put(out, rs.fmtFormat([args30[0], " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => part8(f), " "])); rs.drop(boxed); dropped(out); owned[Symbol.dispose](); @@ -3407,26 +3331,23 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = at(2); const bytes: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 7)); const part2 = fronts$sources_iter_Once_u8(rs.iterOnce(b), rs.usizeRem(front, 2)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part2, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + const args111 = [(f: rs.Formatter) => rs.fmtIterOption(part2, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args111[0], "|", rs.fmtSpec({ alternate: true }, args111[0]), "|", rs.fmtSpec({ debugHex: "x" }, args111[0])])); const part3 = rs.iterOnce(thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: -1 })); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part3, f, (value: Pair.Pair | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const args112 = [(f: rs.Formatter) => rs.fmtIterOption(part3, f, (value: Pair.Pair | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args112[0], "|", rs.fmtSpec({ alternate: true }, args112[0])])); const maybe: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b, 3) !== 0, b); const _72: rs.Iter = rs.iterOption(maybe); const _75: rs.Iter = rs.iterOption(maybe); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_72, f, rs.u8Debug, [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_75, f, rs.u8Debug, [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[1])])); + const args113 = [(f: rs.Formatter) => rs.fmtIterOption(_72, f, rs.u8Debug, [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_75, f, rs.u8Debug, [["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args113[0], "|", rs.fmtSpec({ alternate: true }, args113[1])])); const pair: Pair.Pair | undefined = thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: 2 }); const part4 = fronts$sources_option_Iter_fmt_Pair(rs.iterOption(pair), rs.usizeRem(front, 2)); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part4, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["Iter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part4, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["Iter", "inner"], ["Item", "opt"]])])); const part5 = rs.iterOption(pair); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part5, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part5, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"], ["Item", "opt"]])])); const part6 = rs.iterOption(pair); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part6, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part6, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"], ["Item", "opt"]])])); const _132: Array = [rs.None, undefined, b]; const _138: rs.usize = rs.u8Rem(b, 3) as rs.usize; if (!(_138 < 3)) { @@ -3435,12 +3356,11 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const nested: rs.u8 | undefined | rs.None = _132[_138]; const _150: rs.Iter = rs.iterOption(nested, undefined, rs.None); const _153: rs.Iter = rs.iterOption(nested, undefined, rs.None); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_150, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_153, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ debugHex: "x" }, args14[1])])); + const args117 = [(f: rs.Formatter) => rs.fmtIterOption(_150, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_153, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args117[0], "|", rs.fmtSpec({ debugHex: "x" }, args117[1])])); let mine: rs.u8 | undefined = maybe; const part7 = fronts$sources_option_IterMut_u8(rs.iterOption(mine === undefined ? undefined : rs.place(() => mine as rs.u8, (value) => mine = value)), rs.usizeRem(front, 2)); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part7, f, (value: rs.Place, f: rs.Formatter) => rs.u8Debug(value.v, f), [["IterMut", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part7, f, (value: rs.Place, f: rs.Formatter) => rs.u8Debug(value.v, f), [["IterMut", "inner"], ["Item", "opt"]])])); if (!(rs.u8Rem(b, 2) === 0)) { result = rs.Err({ _0: b, _1: 3 }); } else { @@ -3448,54 +3368,49 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { } const _190: rs.Iter = rs.iterResult(result); const _193: rs.Iter = rs.iterResult(result); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_190, f, rs.u8Debug, [["Iter", "inner"]]), (f: rs.Formatter) => rs.fmtIterOption(_193, f, rs.u8Debug, [["IntoIter", "inner"]])]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + const args119 = [(f: rs.Formatter) => rs.fmtIterOption(_190, f, rs.u8Debug, [["Iter", "inner"]]), (f: rs.Formatter) => rs.fmtIterOption(_193, f, rs.u8Debug, [["IntoIter", "inner"]])]; + put(out, rs.fmtFormat([args119[0], "|", rs.fmtSpec({ alternate: true }, args119[1])])); if (!(rs.u8Rem(b, 3) === 0)) { held = rs.Ok({ _0: b, _1: 4 }); } else { held = rs.Err(b); } const part8 = fronts$sources_result_IterMut_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"]])]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"]])])); const part9 = fronts$sources_result_IntoIter_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part9, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"]])]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part9, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"]])])); const _243: rs.u8 = at(3); const _246: rs.u8 = at(4); const _249: rs.u8 = at(5); const part10 = ends$sources_array_IntoIter_u8_4(rs.iterSlice(Uint8Array.of(b, _243, _246, _249)), front, back); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part10, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args24[0])])); + const args122 = [(f: rs.Formatter) => rs.fmtIter(part10, f, rs.u8Debug, ["IntoIter"])]; + put(out, rs.fmtFormat([args122[0], "|", rs.fmtSpec({ alternate: true }, args122[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args122[0])])); const part11 = ends$sources_array_IntoIter_fmt_Pair_2(rs.iterSlice([{ _0: b, _1: 5 }, { _0: at(3), _1: 6 }]), rs.usizeRem(front, 3), rs.usizeRem(back, 2)); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part11, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])])); + const args123 = [(f: rs.Formatter) => rs.fmtIter(part11, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; + put(out, rs.fmtFormat([args123[0], "|", rs.fmtSpec({ alternate: true }, args123[0])])); const part12 = rs.iterSlice(Uint8Array.of()); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part12, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args28[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part12, f, rs.u8Debug, ["IntoIter"])])); let n: rs.i32 = 0; const it5: rs.Iter = rs.iterFromFn((): rs.i32 | undefined => { n = rs.i32Add(n, 1); return thenSome$05ku0zn(n < 3, n); }); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn")]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])])); + const args125 = [(f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn")]; + put(out, rs.fmtFormat([args125[0], "|", rs.fmtSpec({ alternate: true }, args125[0])])); const part13 = rs.iterTake(it5, 2); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (_value: rs.Iter, f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn"))]; - put(out, rs.fmtFormat([args32[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (_value: rs.Iter, f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn"))])); const it6: rs.Iter = rs.iterRepeatWith((): rs.u8 => { return b; }); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])])); + const args127 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; + put(out, rs.fmtFormat([args127[0], "|", rs.fmtSpec({ alternate: true }, args127[0])])); const part14 = rs.iterSkip(it6, 1); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part14, f, "Skip", (_value: rs.Iter, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith")))]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args36[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtCounted(part14, f, "Skip", (_value: rs.Iter, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))))])); const part15 = fronts$sources_iter_Successors_u8_fmt_sources_closure3(rs.iterSuccessors(b, (_22: rs.u8): rs.u8 | undefined => { return rs.u8CheckedAdd(_22, 100); }), front); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSuccessors(part15, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0]), "|", rs.fmtSpec({ debugHex: "x" }, args38[0])])); + const args129 = [(f: rs.Formatter) => rs.fmtSuccessors(part15, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args129[0], "|", rs.fmtSpec({ alternate: true }, args129[0]), "|", rs.fmtSpec({ debugHex: "x" }, args129[0])])); const part16 = fronts$sources_iter_Successors_Option_u8_fmt_sources_closure4(rs.iterSuccessors(b as rs.u8 | undefined | rs.None, (_26: rs.u8 | undefined): rs.u8 | undefined | rs.None => { return option_andThen$0jc4o0i(_26, (x3: rs.u8): rs.u8 | undefined | rs.None => { return option_map$02rrcvu(rs.u8CheckedSub(x3, 100), (a0: rs.u8): rs.u8 | undefined => { @@ -3503,33 +3418,31 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { }); }); }, undefined, rs.None), front); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSuccessors(part16, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSuccessors(part16, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); const part17 = rs.iterMap(rs.iterChain(rs.iterOnce(b), rs.iterSlice(Uint8Array.of(at(3), at(4)))), (x4: rs.u8): rs.u8 => { return rs.u8Div(x4, 2); }); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part17, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtChain(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIterOption(value, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"])))]; - put(out, rs.fmtFormat([args42[0], "|", rs.fmtSpec({ alternate: true }, args42[0])])); + const args131 = [(f: rs.Formatter) => rs.fmtAdaptor(part17, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtChain(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIterOption(value, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"])))]; + put(out, rs.fmtFormat([args131[0], "|", rs.fmtSpec({ alternate: true }, args131[0])])); const part18 = rs.iterRepeat(b); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeat(part18, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args44[0], "|", rs.fmtSpec({ alternate: true }, args44[0]), "|", rs.fmtSpec({ debugHex: "x" }, args44[0])])); + const args132 = [(f: rs.Formatter) => rs.fmtRepeat(part18, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args132[0], "|", rs.fmtSpec({ alternate: true }, args132[0]), "|", rs.fmtSpec({ debugHex: "x" }, args132[0])])); const part19 = ends$sources_iter_Take_iter_Repeat_fmt_Pair(rs.iterTake(rs.iterRepeat({ _0: b, _1: 7 }), 3), front, back); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part19, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtRepeat(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(part19, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtRepeat(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))])); const n2: rs.usize = rs.u8Rem(at(3), 4) as rs.usize; const part20 = ends$sources_iter_RepeatN_u8(rs.iterRepeatN(b, n2), front, back); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeatN(part20, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args48[0], "|", rs.fmtSpec({ alternate: true }, args48[0])])); + const args134 = [(f: rs.Formatter) => rs.fmtRepeatN(part20, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args134[0], "|", rs.fmtSpec({ alternate: true }, args134[0])])); const it12: rs.Iter = rs.iterRepeatN({ _0: b, _1: 8 }, n2); const _464: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; rs.iterNth(it12, _464); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeatN(it12, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])])); + const args135 = [(f: rs.Formatter) => rs.fmtRepeatN(it12, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args135[0], "|", rs.fmtSpec({ alternate: true }, args135[0])])); const part21 = ends$sources_iter_OnceWith_fmt_sources_closure6(rs.iterOnceWith((): rs.u8 => { return b; }), rs.usizeRem(front, 2), rs.usizeRem(back, 2)); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOnceWith(part21, f)]; - put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[0])])); + const args136 = [(f: rs.Formatter) => rs.fmtOnceWith(part21, f)]; + put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args136[0])])); const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { const _54: rs.usize = rs.u8Rem(_212, 5) as rs.usize; if (!(_54 < 5)) { @@ -3538,128 +3451,110 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { return [97, 233, 20013, 129408, 10][_54]; })); const part22 = ends$sources_str_CharIndices(rs.strCharIndices(text), front, back); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharIndices(part22, f)]; - put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0]), "|", rs.fmtSpec({ debugHex: "x" }, args54[0])])); + const args137 = [(f: rs.Formatter) => rs.fmtCharIndices(part22, f)]; + put(out, rs.fmtFormat([args137[0], "|", rs.fmtSpec({ alternate: true }, args137[0]), "|", rs.fmtSpec({ debugHex: "x" }, args137[0])])); let drained: string = text; const it15: rs.Iter = ends$sources_string_Drain(rs.stringDrain(rs.place(() => drained, (value3) => drained = value3), undefined), front, back); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStringDrain(it15, f)]; - put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])])); + const args138 = [(f: rs.Formatter) => rs.fmtStringDrain(it15, f)]; + put(out, rs.fmtFormat([args138[0], "|", rs.fmtSpec({ alternate: true }, args138[0])])); rs.drop(it15); const size: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); const part23 = ends$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), front, back); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part23, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0]), "|", rs.fmtSpec({ debugHex: "x" }, args58[0])])); + const args139 = [(f: rs.Formatter) => rs.fmtParts(part23, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; + put(out, rs.fmtFormat([args139[0], "|", rs.fmtSpec({ alternate: true }, args139[0]), "|", rs.fmtSpec({ debugHex: "x" }, args139[0])])); const it17: rs.Iter = rs.byteSliceWindows(bytes, size); const _564: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; rs.iterNth(it17, _564); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it17, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args60[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it17, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); const it18: rs.Iter = fronts$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), 8); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args62[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); rs.iterToOption(it18.nextBack()); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args64[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); const it19: rs.Iter = rs.byteSliceWindows(bytes, size); const _613: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; rs.iterNthBack(it19, _613); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it19, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args66[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it19, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.u16 => { return rs.u16Mul(_213 as rs.u16, 257); }), undefined, 2, true); const part24 = ends$sources_slice_Windows_u16(rs.sliceWindows(rs.sliceFrom(wide.items), size), front, back); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part24, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Windows")]; - put(out, rs.fmtFormat([args68[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args68[0])])); + const args144 = [(f: rs.Formatter) => rs.fmtParts(part24, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Windows")]; + put(out, rs.fmtFormat([args144[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args144[0])])); const part25 = ends$sources_slice_Chunks_u8(rs.byteSliceChunks(bytes, size), front, back); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part25, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Chunks")]; - put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])])); + const args145 = [(f: rs.Formatter) => rs.fmtParts(part25, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Chunks")]; + put(out, rs.fmtFormat([args145[0], "|", rs.fmtSpec({ alternate: true }, args145[0])])); const part26 = ends$sources_slice_ChunksExact_u16(rs.sliceChunksExact(rs.sliceFrom(wide.items), size), front, back); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part26, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "ChunksExact")]; - put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])])); + const args146 = [(f: rs.Formatter) => rs.fmtParts(part26, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "ChunksExact")]; + put(out, rs.fmtFormat([args146[0], "|", rs.fmtSpec({ alternate: true }, args146[0])])); const part27 = ends$sources_slice_ChunksExact_u8(rs.byteSliceChunksExact(bytes, size), front, back); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part27, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "ChunksExact")]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part27, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "ChunksExact")])); const part28 = ends$sources_slice_RChunks_u16(rs.sliceRchunks(rs.sliceFrom(wide.items), size), front, back); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part28, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunks")]; - put(out, rs.fmtFormat([args76[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part28, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunks")])); const part29 = ends$sources_slice_RChunks_u8(rs.byteSliceRchunks(bytes, size), front, back); - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part29, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunks")]; - put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[0])])); + const args149 = [(f: rs.Formatter) => rs.fmtParts(part29, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunks")]; + put(out, rs.fmtFormat([args149[0], "|", rs.fmtSpec({ alternate: true }, args149[0])])); const part30 = ends$sources_slice_RChunksExact_u8(rs.byteSliceRchunksExact(bytes, size), front, back); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part30, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunksExact")]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part30, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunksExact")])); const it27: rs.Iter> = rs.sliceRchunksExact(rs.sliceFrom(wide.items), size); const _743: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; rs.iterNth(it27, _743); - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it27, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunksExact")]; - put(out, rs.fmtFormat([args82[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it27, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunksExact")])); const part31 = ends$sources_slice_Split_u8_fmt_sources_closure9(rs.byteSliceSplit(bytes, (x5: rs.u8): boolean => { return rs.u8Rem(x5, 3) === 0; }), front, back); - const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part31, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false)]; - put(out, rs.fmtFormat([args84[0], "|", rs.fmtSpec({ alternate: true }, args84[0]), "|", rs.fmtSpec({ debugHex: "x" }, args84[0])])); + const args152 = [(f: rs.Formatter) => rs.fmtSplit(part31, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false)]; + put(out, rs.fmtFormat([args152[0], "|", rs.fmtSpec({ alternate: true }, args152[0]), "|", rs.fmtSpec({ debugHex: "x" }, args152[0])])); const part32 = ends$sources_slice_SplitInclusive_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(bytes, (x6: rs.u8): boolean => { return rs.u8Rem(x6, 3) === 0; }), front, back); - const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part32, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusive", false)]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part32, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusive", false)])); const part33 = ends$sources_slice_RSplit_u8_fmt_sources_closure9(rs.byteSliceRsplit(bytes, (x7: rs.u8): boolean => { return rs.u8Rem(x7, 3) === 0; }), front, back); - const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part33, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false)]; - put(out, rs.fmtFormat([args88[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part33, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false)])); const part34 = fronts$sources_slice_SplitN_u8_fmt_sources_closure9(rs.byteSliceSplitn(bytes, rs.u8Rem(at(4), 4) as rs.usize, (x8: rs.u8): boolean => { return rs.u8Rem(x8, 3) === 0; }), front); - const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part34, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false, "SplitN")]; - put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); + const args155 = [(f: rs.Formatter) => rs.fmtSplit(part34, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false, "SplitN")]; + put(out, rs.fmtFormat([args155[0], "|", rs.fmtSpec({ alternate: true }, args155[0])])); const part35 = fronts$sources_slice_RSplitN_u8_fmt_sources_closure9(rs.byteSliceRsplitn(bytes, 2, (x9: rs.u8): boolean => { return rs.u8Rem(x9, 3) === 0; }), front); - const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part35, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false, "RSplitN")]; - put(out, rs.fmtFormat([args92[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part35, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false, "RSplitN")])); const part36 = ends$sources_slice_Split_u16_fmt_sources_closure10(rs.sliceSplit(rs.sliceFrom(wide.items), (x10: rs.u16): boolean => { return rs.u16Rem(x10, 3) === 0; }), front, back); - const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part36, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false)]; - put(out, rs.fmtFormat([args94[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part36, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false)])); const part37 = fronts$sources_slice_SplitN_u16_fmt_sources_closure10(rs.sliceSplitn(rs.sliceFrom(wide.items), 2, (x11: rs.u16): boolean => { return rs.u16Rem(x11, 3) === 0; }), front); - const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part37, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false, "SplitN")]; - put(out, rs.fmtFormat([args96[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part37, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false, "SplitN")])); const owned: rs.ByteVec = rs.byteSliceToByteVec(bytes); const part38 = ends$sources_slice_SplitMut_u8_fmt_sources_closure9(rs.byteSliceSplit(rs.byteVecSlice(owned), (x12: rs.u8): boolean => { return rs.u8Rem(x12, 3) === 0; }), front, back); - const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part38, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true)]; - put(out, rs.fmtFormat([args98[0], "|", rs.fmtSpec({ alternate: true }, args98[0])])); + const args159 = [(f: rs.Formatter) => rs.fmtSplit(part38, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true)]; + put(out, rs.fmtFormat([args159[0], "|", rs.fmtSpec({ alternate: true }, args159[0])])); const part39 = ends$sources_slice_SplitInclusiveMut_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(rs.byteVecSlice(owned), (x13: rs.u8): boolean => { return rs.u8Rem(x13, 3) === 0; }), front, back); - const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part39, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusiveMut", true)]; - put(out, rs.fmtFormat([args100[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part39, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusiveMut", true)])); const part40 = ends$sources_slice_RSplitMut_u8_fmt_sources_closure9(rs.byteSliceRsplit(rs.byteVecSlice(owned), (x14: rs.u8): boolean => { return rs.u8Rem(x14, 3) === 0; }), front, back); - const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part40, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true)]; - put(out, rs.fmtFormat([args102[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part40, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true)])); const part41 = fronts$sources_slice_SplitNMut_u8_fmt_sources_closure9(rs.byteSliceSplitn(rs.byteVecSlice(owned), 2, (x15: rs.u8): boolean => { return rs.u8Rem(x15, 3) === 0; }), front); - const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part41, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true, "SplitNMut")]; - put(out, rs.fmtFormat([args104[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part41, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true, "SplitNMut")])); const part42 = fronts$sources_slice_RSplitNMut_u8_fmt_sources_closure9(rs.byteSliceRsplitn(rs.byteVecSlice(owned), rs.u8Rem(at(4), 4) as rs.usize, (x16: rs.u8): boolean => { return rs.u8Rem(x16, 3) === 0; }), front); - const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part42, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true, "RSplitNMut")]; - put(out, rs.fmtFormat([args106[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part42, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true, "RSplitNMut")])); const part43 = ends$sources_slice_SplitMut_u16_fmt_sources_closure10(rs.sliceSplit(rs.sliceFrom(rs.vecFrom(wide.items.slice()).items), (x17: rs.u16): boolean => { return rs.u16Rem(x17, 3) === 0; }), front, back); - const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part43, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "SplitMut", true)]; - put(out, rs.fmtFormat([args108[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part43, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "SplitMut", true)])); const _976: [rs.HashSet, rs.HashSet] = [rs.hashNew() as rs.HashSet, rs.hashNew() as rs.HashSet]; const one: rs.HashSet = _976[0]; const other: rs.HashSet = _976[1]; @@ -3673,8 +3568,8 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const _1001: rs.Iter = rs.hashIntersection(one, other); const _1005: rs.Iter = rs.hashSymmetricDifference(one, other); const _1009: rs.Iter = rs.hashUnion(one, other); - const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterClone(_997, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1001, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1005, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1009, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[1]), "|", args110[2], "|", args110[3]])); + const args165 = [(f: rs.Formatter) => rs.fmtIterClone(_997, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1001, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1005, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1009, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args165[0], "|", rs.fmtSpec({ alternate: true }, args165[1]), "|", args165[2], "|", args165[3]])); } export function ends$sources_array_IntoIter_fmt_Pair_2(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { @@ -4219,17 +4114,17 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = fronts$sets_collections_btree_set_Difference_u8(rs.btreeDifference(_69[0], _69[1]), front); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part, f, rs.u8Debug, "Difference")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0])])); + const args19 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part, f, rs.u8Debug, "Difference")]; + put(out, rs.fmtFormat([args19[0], "|", rs.fmtSpec({ alternate: true }, args19[0])])); const part2 = fronts$sets_collections_btree_set_Intersection_u8(rs.btreeIntersection(_69[0], _69[1]), front); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part2, f, rs.u8Debug, "Intersection")]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const args20 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part2, f, rs.u8Debug, "Intersection")]; + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0])])); const part3 = fronts$sets_collections_btree_set_Union_u8(rs.btreeUnion(_69[0], _69[1]), front); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part3, f, rs.u8Debug, "Union")]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + const args21 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part3, f, rs.u8Debug, "Union")]; + put(out, rs.fmtFormat([args21[0], "|", rs.fmtSpec({ alternate: true }, args21[0])])); const part4 = fronts$sets_collections_btree_set_SymmetricDifference_u8(rs.btreeSymmetricDifference(_69[0], _69[1]), front); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part4, f, rs.u8Debug, "SymmetricDifference")]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0])])); + const args22 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part4, f, rs.u8Debug, "SymmetricDifference")]; + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0])])); } const _131: rs.Iter<[rs.u8, rs.char]> = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_23: rs.u8): [rs.u8, rs.char] => { return [rs.u8Rem(_23, 4), 112] as [rs.u8, rs.char]; @@ -4240,25 +4135,23 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { }); const more: rs.BTreeSet<[rs.u8, rs.char]> = rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.char], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.char]>, _135, true, undefined, undefined, 8, true); const part5 = fronts$sets_collections_btree_set_Union_tuple2_u8_char(rs.btreeUnion(pairs, more), front); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part5, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Union")]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ debugHex: "x" }, args10[0])])); + const args23 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part5, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Union")]; + put(out, rs.fmtFormat([args23[0], "|", rs.fmtSpec({ debugHex: "x" }, args23[0])])); const part6 = fronts$sets_collections_btree_set_Difference_tuple2_u8_char(rs.btreeDifference(pairs, more), front); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part6, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Difference")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtBTreeSetOp(part6, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Difference"))])); const _172: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); const it7: rs.Iter = fronts$sets_collections_linked_list_ExtractIf_u8_fmt_sets_closure5(rs.listExtractIfMut(rs.listExtend(rs.listNew() as rs.LinkedList, _172), (x4: rs.Place): boolean => { return rs.u8Rem(x4.v, 2) === 0; }), front); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtListExtractIf(it7, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ debugHex: "x" }, args14[0])])); + const args25 = [(f: rs.Formatter) => rs.fmtListExtractIf(it7, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args25[0], "|", rs.fmtSpec({ alternate: true }, args25[0]), "|", rs.fmtSpec({ debugHex: "x" }, args25[0])])); const _192: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_210: rs.u8): Pair.Pair => { return { _0: _210, _1: 2 }; }); const it8: rs.Iter = fronts$sets_collections_linked_list_ExtractIf_fmt_Pair_fmt_sets_closure7(rs.listExtractIf(rs.listExtend(rs.listNew() as rs.LinkedList, _192), (p: Pair.Pair): boolean => { return rs.u8Rem(p._0, 3) === 0; }), front); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtListExtractIf(it8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtListExtractIf(it8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))])); const _212: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): [rs.u8, rs.u8] => { const x6: rs.u8 = _211; return [x6, x6] as [rs.u8, rs.u8]; @@ -4272,8 +4165,8 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { rs.hashExtractKeysIf(set, (k2: rs.u8): boolean => { return k2 > 9; }); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf"))]; - put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + const args27 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf"))]; + put(out, rs.fmtFormat([args27[0], "|", rs.fmtSpec({ alternate: true }, args27[1])])); } export function fronts$sets_collections_btree_set_Difference_tuple2_u8_char(it: rs.Iter<[rs.u8, rs.char]>, front: rs.usize): rs.Iter<[rs.u8, rs.char]> { @@ -4375,9 +4268,8 @@ export function passed(out: rs.ByteVec, budget: rs.usize, args: rs.Arguments): v break; } const log: Log.Log = Log.new(_7); - const args3: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtArguments(args, f)]; - const _14: rs.Arguments = [args3[0]]; - if (!rs.fmtWrite((s) => Log.writeStr$fmt_Write(log, s), (c) => Log.writeChar$fmt_Write(log, c), _14).ok) { + const args4 = [(f: rs.Formatter) => rs.fmtArguments(args, f)]; + if (!rs.fmtWrite((s) => Log.writeStr$fmt_Write(log, s), (c) => Log.writeChar$fmt_Write(log, c), [args4[0]]).ok) { _23 = 45; } else { _23 = 43; @@ -4430,9 +4322,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log: Log.Log = Log.new(_34); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => rs.i32LowerHex(v, f), (f: rs.Formatter) => rs.i32Binary(v, f), (f: rs.Formatter) => rs.i32Octal(v, f), (f: rs.Formatter) => rs.i32Debug(v, f), (f: rs.Formatter) => rs.i32LowerExp(v, f), (f: rs.Formatter) => rs.i32UpperExp(v, f)]; - const _41: rs.Arguments = ["a", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", args2[0], "|", rs.fmtSpec({ align: "<", plus: true, width: 6 }, args2[0]), "|", rs.fmtSpec({ align: "^", alternate: true, width: 9 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), "|", rs.fmtSpec({ plus: true, alternate: true }, args2[3]), "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ alternate: true }, args2[4]), "|", rs.fmtSpec({ debugHex: "x" }, args2[4]), "|", args2[5], "|", rs.fmtSpec({ precision: 3 }, args2[5]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12, precision: 2 }, args2[6]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 12 }, args2[5]), "|", rs.fmtSpec({ precision: 0 }, args2[5]), "|", rs.fmtSpec({ precision: 12 }, args2[5]), "|", rs.fmtSpec({ alternate: true }, args2[5])]; - if (!rs.fmtWrite((s2) => Log.writeStr$fmt_Write(log, s2), (c2) => Log.writeChar$fmt_Write(log, c2), _41).ok) { + const args35 = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => rs.i32LowerHex(v, f), (f: rs.Formatter) => rs.i32Binary(v, f), (f: rs.Formatter) => rs.i32Octal(v, f), (f: rs.Formatter) => rs.i32Debug(v, f), (f: rs.Formatter) => rs.i32LowerExp(v, f), (f: rs.Formatter) => rs.i32UpperExp(v, f)]; + if (!rs.fmtWrite((s2) => Log.writeStr$fmt_Write(log, s2), (c2) => Log.writeChar$fmt_Write(log, c2), ["a", rs.fmtSpec({ align: ">", width: 4 }, args35[0]), "|", args35[0], "|", rs.fmtSpec({ align: "<", plus: true, width: 6 }, args35[0]), "|", rs.fmtSpec({ align: "^", alternate: true, width: 9 }, args35[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args35[0]), "|", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args35[2]), "|", rs.fmtSpec({ plus: true, alternate: true }, args35[3]), "|", rs.fmtSpec({ alternate: true }, args35[0]), "|", rs.fmtSpec({ alternate: true }, args35[4]), "|", rs.fmtSpec({ debugHex: "x" }, args35[4]), "|", args35[5], "|", rs.fmtSpec({ precision: 3 }, args35[5]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12, precision: 2 }, args35[6]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 12 }, args35[5]), "|", rs.fmtSpec({ precision: 0 }, args35[5]), "|", rs.fmtSpec({ precision: 12 }, args35[5]), "|", rs.fmtSpec({ alternate: true }, args35[5])]).ok) { _56 = 45; } else { _56 = 43; @@ -4451,9 +4342,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { const log2: Log.Log = Log.new(_99); const _109: rs.u8 = at(6); const _113: rs.i8 = (at(7) << 24) >> 24; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(w, f), (f: rs.Formatter) => rs.u64LowerHex(w, f), (f: rs.Formatter) => rs.i128Display(n, f), (f: rs.Formatter) => rs.i128LowerExp(n, f), (f: rs.Formatter) => rs.u8Display(_109, f), (f: rs.Formatter) => rs.i8LowerHex(_113, f), (f: rs.Formatter) => rs.i32UpperExp(v, f)]; - const _106: rs.Arguments = [rs.fmtSpec({ align: ">", width: 24 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", args4[2], "|", rs.fmtSpec({ plus: true, zero: true, width: 45 }, args4[2]), "|", args4[3], "|", rs.fmtSpec({ align: ">", width: 5 }, args4[4]), "|", rs.fmtSpec({ alternate: true, zero: true, width: 6 }, args4[5]), "|", rs.fmtSpec({ precision: 45 }, args4[6])]; - if (!rs.fmtWrite((s3) => Log.writeStr$fmt_Write(log2, s3), (c3) => Log.writeChar$fmt_Write(log2, c3), _106).ok) { + const args36 = [(f: rs.Formatter) => rs.u64Display(w, f), (f: rs.Formatter) => rs.u64LowerHex(w, f), (f: rs.Formatter) => rs.i128Display(n, f), (f: rs.Formatter) => rs.i128LowerExp(n, f), (f: rs.Formatter) => rs.u8Display(_109, f), (f: rs.Formatter) => rs.i8LowerHex(_113, f), (f: rs.Formatter) => rs.i32UpperExp(v, f)]; + if (!rs.fmtWrite((s3) => Log.writeStr$fmt_Write(log2, s3), (c3) => Log.writeChar$fmt_Write(log2, c3), [rs.fmtSpec({ align: ">", width: 24 }, args36[0]), "|", rs.fmtSpec({ alternate: true }, args36[1]), "|", args36[2], "|", rs.fmtSpec({ plus: true, zero: true, width: 45 }, args36[2]), "|", args36[3], "|", rs.fmtSpec({ align: ">", width: 5 }, args36[4]), "|", rs.fmtSpec({ alternate: true, zero: true, width: 6 }, args36[5]), "|", rs.fmtSpec({ precision: 45 }, args36[6])]).ok) { _132 = 45; } else { _132 = 43; @@ -4488,9 +4378,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log3: Log.Log = Log.new(_147); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f), (f: rs.Formatter) => rs.f64UpperExp(x, f)]; - const _154: rs.Arguments = [args6[0], "|", args6[1], "|", rs.fmtSpec({ width: 10, precision: 3 }, args6[0]), "|", rs.fmtSpec({ align: "<", plus: true, width: 12 }, args6[0]), "|", rs.fmtSpec({ align: "^", zero: true, width: 12, precision: 1 }, args6[0]), "|", args6[2], "|", rs.fmtSpec({ precision: 2 }, args6[2]), "|", rs.fmtSpec({ precision: 30 }, args6[0]), "|", rs.fmtSpec({ alternate: true }, args6[1]), "|", rs.fmtSpec({ plus: true, precision: 0 }, args6[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args6[1]), "|", args6[3], "|", rs.fmtSpec({ zero: true, width: 8 }, args6[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 9, precision: 3 }, args6[2]), "|", rs.fmtSpec({ precision: 0 }, args6[2])]; - if (!rs.fmtWrite((s4) => Log.writeStr$fmt_Write(log3, s4), (c4) => Log.writeChar$fmt_Write(log3, c4), _154).ok) { + const args37 = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f), (f: rs.Formatter) => rs.f64UpperExp(x, f)]; + if (!rs.fmtWrite((s4) => Log.writeStr$fmt_Write(log3, s4), (c4) => Log.writeChar$fmt_Write(log3, c4), [args37[0], "|", args37[1], "|", rs.fmtSpec({ width: 10, precision: 3 }, args37[0]), "|", rs.fmtSpec({ align: "<", plus: true, width: 12 }, args37[0]), "|", rs.fmtSpec({ align: "^", zero: true, width: 12, precision: 1 }, args37[0]), "|", args37[2], "|", rs.fmtSpec({ precision: 2 }, args37[2]), "|", rs.fmtSpec({ precision: 30 }, args37[0]), "|", rs.fmtSpec({ alternate: true }, args37[1]), "|", rs.fmtSpec({ plus: true, precision: 0 }, args37[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args37[1]), "|", args37[3], "|", rs.fmtSpec({ zero: true, width: 8 }, args37[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 9, precision: 3 }, args37[2]), "|", rs.fmtSpec({ precision: 0 }, args37[2])]).ok) { _166 = 45; } else { _166 = 43; @@ -4506,9 +4395,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log4: Log.Log = Log.new(_177); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f), (f: rs.Formatter) => rs.f32Display(y, f), (f: rs.Formatter) => rs.f32Debug(y, f), (f: rs.Formatter) => rs.f32LowerExp(y, f)]; - const _184: rs.Arguments = [rs.fmtSpec({ precision: 70 }, args8[0]), "|", rs.fmtSpec({ precision: 330 }, args8[0]), "|", rs.fmtSpec({ precision: 20 }, args8[1]), "|", args8[2], "|", args8[3], "|", rs.fmtSpec({ precision: 3 }, args8[2]), "|", args8[4], "|", rs.fmtSpec({ precision: 12 }, args8[4]), "|", rs.fmtSpec({ precision: 50 }, args8[2])]; - if (!rs.fmtWrite((s5) => Log.writeStr$fmt_Write(log4, s5), (c5) => Log.writeChar$fmt_Write(log4, c5), _184).ok) { + const args38 = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f), (f: rs.Formatter) => rs.f32Display(y, f), (f: rs.Formatter) => rs.f32Debug(y, f), (f: rs.Formatter) => rs.f32LowerExp(y, f)]; + if (!rs.fmtWrite((s5) => Log.writeStr$fmt_Write(log4, s5), (c5) => Log.writeChar$fmt_Write(log4, c5), [rs.fmtSpec({ precision: 70 }, args38[0]), "|", rs.fmtSpec({ precision: 330 }, args38[0]), "|", rs.fmtSpec({ precision: 20 }, args38[1]), "|", args38[2], "|", args38[3], "|", rs.fmtSpec({ precision: 3 }, args38[2]), "|", args38[4], "|", rs.fmtSpec({ precision: 12 }, args38[4]), "|", rs.fmtSpec({ precision: 50 }, args38[2])]).ok) { _198 = 45; } else { _198 = 43; @@ -4530,9 +4418,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log5: Log.Log = Log.new(_233); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f), (f: rs.Formatter) => rs.fmtCharDebug(39, f), (f: rs.Formatter) => rs.fmtCharDebug(34, f), (f: rs.Formatter) => rs.fmtCharDebug(769, f), (f: rs.Formatter) => rs.fmtCharDebug(233, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - const _240: rs.Arguments = [args10[0], "|", args10[1], "|", rs.fmtSpec({ align: ">", width: 8 }, args10[0]), "|", rs.fmtSpec({ align: "^", width: 9, precision: 2 }, args10[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args10[0]), "|", rs.fmtSpec({ alternate: true }, args10[1]), "|", args10[2], "|", args10[3], "|", rs.fmtSpec({ align: ">", width: 3 }, args10[2]), "|", rs.fmtSpec({ precision: 0 }, args10[2]), "|", rs.fmtSpec({ align: "^", width: 5 }, args10[3]), "|", args10[4], args10[5], args10[6], args10[7], "|", args10[8], "|", args10[9], "|", rs.fmtSpec({ align: ">", width: 7 }, args10[8])]; - if (!rs.fmtWrite((s6) => Log.writeStr$fmt_Write(log5, s6), (c6) => Log.writeChar$fmt_Write(log5, c6), _240).ok) { + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f), (f: rs.Formatter) => rs.fmtCharDebug(39, f), (f: rs.Formatter) => rs.fmtCharDebug(34, f), (f: rs.Formatter) => rs.fmtCharDebug(769, f), (f: rs.Formatter) => rs.fmtCharDebug(233, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; + if (!rs.fmtWrite((s6) => Log.writeStr$fmt_Write(log5, s6), (c6) => Log.writeChar$fmt_Write(log5, c6), [args39[0], "|", args39[1], "|", rs.fmtSpec({ align: ">", width: 8 }, args39[0]), "|", rs.fmtSpec({ align: "^", width: 9, precision: 2 }, args39[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args39[0]), "|", rs.fmtSpec({ alternate: true }, args39[1]), "|", args39[2], "|", args39[3], "|", rs.fmtSpec({ align: ">", width: 3 }, args39[2]), "|", rs.fmtSpec({ precision: 0 }, args39[2]), "|", rs.fmtSpec({ align: "^", width: 5 }, args39[3]), "|", args39[4], args39[5], args39[6], args39[7], "|", args39[8], "|", args39[9], "|", rs.fmtSpec({ align: ">", width: 7 }, args39[8])]).ok) { _265 = 45; } else { _265 = 43; @@ -4548,9 +4435,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log6: Log.Log = Log.new(_275); - const args12: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - const _282: rs.Arguments = [args12[0]]; - if (!rs.fmtWrite((s7) => Log.writeStr$fmt_Write(log6, s7), (c7) => Log.writeChar$fmt_Write(log6, c7), _282).ok) { + const args40 = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + if (!rs.fmtWrite((s7) => Log.writeStr$fmt_Write(log6, s7), (c7) => Log.writeChar$fmt_Write(log6, c7), [args40[0]]).ok) { _291 = 45; } else { _291 = 43; @@ -4565,9 +4451,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log7: Log.Log = Log.new(_300); - const args14: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - const _307: rs.Arguments = [rs.fmtSpec({ alternate: true }, args14[0])]; - if (!rs.fmtWrite((s8) => Log.writeStr$fmt_Write(log7, s8), (c8) => Log.writeChar$fmt_Write(log7, c8), _307).ok) { + const args41 = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + if (!rs.fmtWrite((s8) => Log.writeStr$fmt_Write(log7, s8), (c8) => Log.writeChar$fmt_Write(log7, c8), [rs.fmtSpec({ alternate: true }, args41[0])]).ok) { _316 = 45; } else { _316 = 43; @@ -4589,9 +4474,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { const _356: Tup.Tup = { _0: 1, _1: 2 }; const _362: [rs.i32, string] = [1, "t"]; const _363: Unit.Unit = {}; - const args16: rs.Fmt[] = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(_351, f), (f: rs.Formatter) => Tup.fmt$fmt_Debug(_356, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_358[0], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_362[0], f), (f: rs.Formatter) => rs.fmtStr(_362[1], f)], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_363, f)]; - const _348: rs.Arguments = [args16[0], "|", rs.fmtSpec({ alternate: true }, args16[1]), "|", args16[2], "|", rs.fmtSpec({ alternate: true }, args16[2]), "|", rs.fmtSpec({ alternate: true }, args16[3]), "|", args16[4], "|", rs.fmtSpec({ alternate: true }, args16[5]), "|", args16[6]]; - if (!rs.fmtWrite((s9) => Log.writeStr$fmt_Write(log8, s9), (c9) => Log.writeChar$fmt_Write(log8, c9), _348).ok) { + const args42 = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(_351, f), (f: rs.Formatter) => Tup.fmt$fmt_Debug(_356, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_358[0], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_362[0], f), (f: rs.Formatter) => rs.fmtStr(_362[1], f)], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_363, f)]; + if (!rs.fmtWrite((s9) => Log.writeStr$fmt_Write(log8, s9), (c9) => Log.writeChar$fmt_Write(log8, c9), [args42[0], "|", rs.fmtSpec({ alternate: true }, args42[1]), "|", args42[2], "|", rs.fmtSpec({ alternate: true }, args42[2]), "|", rs.fmtSpec({ alternate: true }, args42[3]), "|", args42[4], "|", rs.fmtSpec({ alternate: true }, args42[5]), "|", args42[6]]).ok) { _378 = 45; } else { _378 = 43; @@ -4623,9 +4507,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { const _428: { end: rs.u8 } = { end: at(20) }; const _426: rs.u8 | undefined = undefined; const _432: rs.RangeBound = { tag: "Included", _0: 3 } as rs.RangeBound; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, rs.fmtStr), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(deque), f, rs.i8Debug), (f: rs.Formatter) => rs.fmtOption(_421, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtUnit)), (f: rs.Formatter) => rs.fmtOption(_426, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(range, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_428, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_432, f, rs.i32Debug)]; - const _418: rs.Arguments = [args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0]), "|", args18[1], "|", rs.fmtSpec({ alternate: true }, args18[1]), "|", args18[2], "|", args18[3], "|", args18[4], "|", args18[5], "|", args18[6], "|", args18[7]]; - if (!rs.fmtWrite((s10) => Log.writeStr$fmt_Write(log9, s10), (c10) => Log.writeChar$fmt_Write(log9, c10), _418).ok) { + const args43 = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, rs.fmtStr), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(deque), f, rs.i8Debug), (f: rs.Formatter) => rs.fmtOption(_421, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtUnit)), (f: rs.Formatter) => rs.fmtOption(_426, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(range, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_428, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_432, f, rs.i32Debug)]; + if (!rs.fmtWrite((s10) => Log.writeStr$fmt_Write(log9, s10), (c10) => Log.writeChar$fmt_Write(log9, c10), [args43[0], "|", rs.fmtSpec({ alternate: true }, args43[0]), "|", args43[1], "|", rs.fmtSpec({ alternate: true }, args43[1]), "|", args43[2], "|", args43[3], "|", args43[4], "|", args43[5], "|", args43[6], "|", args43[7]]).ok) { _450 = 45; } else { _450 = 43; @@ -4657,9 +4540,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { const _499: rs.Iter = rs.charToUppercase(223); const _501: rs.Iter = rs.strEscapeDebug(s); const _503: rs.Iter = rs.strEscapeDefault("a\""); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(bytes, f), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EscapeAscii")), (f: rs.Formatter) => rs.fmtEscapeAscii(_489, f), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EscapeDefault")), (f: rs.Formatter) => rs.fmtCharsDisplay(_493, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_495, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_497, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_499, f), (f: rs.Formatter) => rs.fmtCharsDisplay(spent, f), (f: rs.Formatter) => rs.fmtCharsDebug(spent, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtStrEscapeDisplay(_501, f), (f: rs.Formatter) => rs.fmtStrEscapeDisplay(_503, f)]; - const _486: rs.Arguments = [args20[0], "|", args20[1], "|", args20[2], "|", args20[3], "|", args20[4], "|", args20[5], "|", args20[6], "|", args20[7], "|", args20[8], "|", args20[9], "|", args20[10], "|", args20[11]]; - if (!rs.fmtWrite((s11) => Log.writeStr$fmt_Write(log10, s11), (c11) => Log.writeChar$fmt_Write(log10, c11), _486).ok) { + const args44 = [(f: rs.Formatter) => rs.fmtEscapeAscii(bytes, f), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EscapeAscii")), (f: rs.Formatter) => rs.fmtEscapeAscii(_489, f), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EscapeDefault")), (f: rs.Formatter) => rs.fmtCharsDisplay(_493, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_495, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_497, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_499, f), (f: rs.Formatter) => rs.fmtCharsDisplay(spent, f), (f: rs.Formatter) => rs.fmtCharsDebug(spent, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtStrEscapeDisplay(_501, f), (f: rs.Formatter) => rs.fmtStrEscapeDisplay(_503, f)]; + if (!rs.fmtWrite((s11) => Log.writeStr$fmt_Write(log10, s11), (c11) => Log.writeChar$fmt_Write(log10, c11), [args44[0], "|", args44[1], "|", args44[2], "|", args44[3], "|", args44[4], "|", args44[5], "|", args44[6], "|", args44[7], "|", args44[8], "|", args44[9], "|", args44[10], "|", args44[11]]).ok) { _524 = 45; } else { _524 = 43; @@ -4675,9 +4557,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log11: Log.Log = Log.new(_559); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(d, f)]; - const _566: rs.Arguments = [args22[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args22[0]), "|", rs.fmtSpec({ precision: 2 }, args22[0]), "|", rs.fmtSpec({ plus: true }, args22[0]), "|", rs.fmtSpec({ align: "^", width: 15, precision: 11 }, args22[0]), "|", rs.fmtSpec({ align: "<", width: 4, precision: 0 }, args22[0]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 20, precision: 3 }, args22[0])]; - if (!rs.fmtWrite((s12) => Log.writeStr$fmt_Write(log11, s12), (c12) => Log.writeChar$fmt_Write(log11, c12), _566).ok) { + const args45 = [(f: rs.Formatter) => rs.durationDebug(d, f)]; + if (!rs.fmtWrite((s12) => Log.writeStr$fmt_Write(log11, s12), (c12) => Log.writeChar$fmt_Write(log11, c12), [args45[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args45[0]), "|", rs.fmtSpec({ precision: 2 }, args45[0]), "|", rs.fmtSpec({ plus: true }, args45[0]), "|", rs.fmtSpec({ align: "^", width: 15, precision: 11 }, args45[0]), "|", rs.fmtSpec({ align: "<", width: 4, precision: 0 }, args45[0]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 20, precision: 3 }, args45[0])]).ok) { _575 = 45; } else { _575 = 43; @@ -4695,9 +4576,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } const log12: Log.Log = Log.new(_586); const part8 = rs.byteSliceUtf8Chunks(data); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(part8, f)]; - const _593: rs.Arguments = [args24[0]]; - if (!rs.fmtWrite((s14) => Log.writeStr$fmt_Write(log12, s14), (c14) => Log.writeChar$fmt_Write(log12, c14), _593).ok) { + const args47 = [(f: rs.Formatter) => rs.fmtUtf8Chunks(part8, f)]; + if (!rs.fmtWrite((s14) => Log.writeStr$fmt_Write(log12, s14), (c14) => Log.writeChar$fmt_Write(log12, c14), [args47[0]]).ok) { _603 = 45; } else { _603 = 43; @@ -4715,9 +4595,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } const log13: Log.Log = Log.new(_613); const _623: rs.Iter = rs.byteSliceUtf8Chunks(data); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtUtf8Chunks(_623, f)]; - const _620: rs.Arguments = [args26[0], "|", args26[1], "|", args26[2]]; - if (!rs.fmtWrite((s13) => Log.writeStr$fmt_Write(log13, s13), (c13) => Log.writeChar$fmt_Write(log13, c13), _620).ok) { + const args46 = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtUtf8Chunks(_623, f)]; + if (!rs.fmtWrite((s13) => Log.writeStr$fmt_Write(log13, s13), (c13) => Log.writeChar$fmt_Write(log13, c13), [args46[0], "|", args46[1], "|", args46[2]]).ok) { _633 = 45; } else { _633 = 43; @@ -4736,9 +4615,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const log14: Log.Log = Log.new(_660); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e2, f)]; - const _667: rs.Arguments = [args28[0]]; - if (!rs.fmtWrite((s15) => Log.writeStr$fmt_Write(log14, s15), (c15) => Log.writeChar$fmt_Write(log14, c15), _667).ok) { + const args48 = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e2, f)]; + if (!rs.fmtWrite((s15) => Log.writeStr$fmt_Write(log14, s15), (c15) => Log.writeChar$fmt_Write(log14, c15), [args48[0]]).ok) { _676 = 45; } else { _676 = 43; @@ -4762,9 +4640,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterRepeatWith((): rs.i32 => { return 1; }); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLayoutDebug(layout, f), (f: rs.Formatter) => rs.fmtTryReserveErrorDisplay(reserve, f), (f: rs.Formatter) => rs.fmtTryReserveErrorDebug(reserve, f), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "UnsafeCell")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; - const _714: rs.Arguments = [args30[0], "|", args30[1], "|", args30[2], "|", args30[3], "|", args30[4], "|", args30[5], "|", args30[6], "|", args30[7]]; - if (!rs.fmtWrite((s16) => Log.writeStr$fmt_Write(log15, s16), (c16) => Log.writeChar$fmt_Write(log15, c16), _714).ok) { + const args49 = [(f: rs.Formatter) => rs.fmtLayoutDebug(layout, f), (f: rs.Formatter) => rs.fmtTryReserveErrorDisplay(reserve, f), (f: rs.Formatter) => rs.fmtTryReserveErrorDebug(reserve, f), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "UnsafeCell")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; + if (!rs.fmtWrite((s16) => Log.writeStr$fmt_Write(log15, s16), (c16) => Log.writeChar$fmt_Write(log15, c16), [args49[0], "|", args49[1], "|", args49[2], "|", args49[3], "|", args49[4], "|", args49[5], "|", args49[6], "|", args49[7]]).ok) { _740 = 45; } else { _740 = 43; @@ -4782,9 +4659,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { const _759: Lettered.Lettered = { _0: c }; const _762: rs.u8 = at(30); const _760: Lettered.Lettered = { _0: 233 }; - const args32: rs.Fmt[] = [(f: rs.Formatter) => Lettered.fmt$fmt_Display(_759, f), (f: rs.Formatter) => Lettered.fmt$fmt_Display(_760, f), (f: rs.Formatter) => rs.u8Display(_762, f), (f: rs.Formatter) => rs.i32Display(v, f)]; - const _756: rs.Arguments = [args32[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args32[1]), "|a", args32[2], "b", rs.fmtSpec({ align: ">", width: 3 }, args32[3])]; - if (!rs.fmtWrite((s17) => Log.writeStr$fmt_Write(log16, s17), (c17) => Log.writeChar$fmt_Write(log16, c17), _756).ok) { + const args50 = [(f: rs.Formatter) => Lettered.fmt$fmt_Display(_759, f), (f: rs.Formatter) => Lettered.fmt$fmt_Display(_760, f), (f: rs.Formatter) => rs.u8Display(_762, f), (f: rs.Formatter) => rs.i32Display(v, f)]; + if (!rs.fmtWrite((s17) => Log.writeStr$fmt_Write(log16, s17), (c17) => Log.writeChar$fmt_Write(log16, c17), [args50[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args50[1]), "|a", args50[2], "b", rs.fmtSpec({ align: ">", width: 3 }, args50[3])]).ok) { _775 = 45; } else { _775 = 43; @@ -4793,8 +4669,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { put(out, log16.text); } const _785: Pair.Pair = { _0: at(31), _1: 1 }; - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_785, f), (f: rs.Formatter) => rs.fmtStr(s, f)]; - passed(out, budget, [rs.fmtSpec({ plus: true }, args34[0]), "|", args34[1], "|", args34[2]]); + const args51 = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_785, f), (f: rs.Formatter) => rs.fmtStr(s, f)]; + passed(out, budget, [rs.fmtSpec({ plus: true }, args51[0]), "|", args51[1], "|", args51[2]]); passed(out, budget, ["lit"]); passed(out, budget, [""]); } @@ -4817,9 +4693,8 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { }); const _4: string[] = ["Cell", "OnceCell", "LazyCell", "OnceLock", "LazyLock", "(", " { "]; const setter: Setter.Setter = { log: Log.new(4294967295), trigger: _4[_5], cell, once, lazy, lock, forced }; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.cellDebug(() => cell.v, f, rs.u8Debug), (f: rs.Formatter) => rs.onceDebug(once, f, "OnceCell", rs.u8Debug), (f: rs.Formatter) => lazy.debug(f, "LazyCell", rs.u8Debug), (f: rs.Formatter) => rs.onceDebug(lock, f, "OnceLock", rs.u8Debug), (f: rs.Formatter) => forced.debug(f, "LazyLock", rs.u8Debug)]; - const _31: rs.Arguments = [args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4], "|", args2[0], "|", args2[1]]; - if (!rs.fmtWrite((s) => Setter.writeStr$fmt_Write(setter, s), (c) => Setter.writeStr$fmt_Write(setter, String.fromCodePoint(c)), _31).ok) { + const args3 = [(f: rs.Formatter) => rs.cellDebug(() => cell.v, f, rs.u8Debug), (f: rs.Formatter) => rs.onceDebug(once, f, "OnceCell", rs.u8Debug), (f: rs.Formatter) => lazy.debug(f, "LazyCell", rs.u8Debug), (f: rs.Formatter) => rs.onceDebug(lock, f, "OnceLock", rs.u8Debug), (f: rs.Formatter) => forced.debug(f, "LazyLock", rs.u8Debug)]; + if (!rs.fmtWrite((s) => Setter.writeStr$fmt_Write(setter, s), (c) => Setter.writeStr$fmt_Write(setter, String.fromCodePoint(c)), [args3[0], "|", args3[1], "|", args3[2], "|", args3[3], "|", args3[4], "|", args3[0], "|", args3[1]]).ok) { _48 = 45; } else { _48 = 43; @@ -4854,58 +4729,43 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { } const c: rs.char = [97, 233, 129408, 32][_30]; const part = ends$searches_str_Split_char(rs.strSplit(text2, String.fromCodePoint(c)), front, back); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part, f, "Split", "CharSearcher")]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + const args67 = [(f: rs.Formatter) => rs.fmtStrSearch(part, f, "Split", "CharSearcher")]; + put(out, rs.fmtFormat([args67[0], "|", rs.fmtSpec({ alternate: true }, args67[0]), "|", rs.fmtSpec({ debugHex: "x" }, args67[0])])); const part2 = ends$searches_str_RSplit_char(rs.strRsplit(text2, String.fromCodePoint(c)), front, back); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part2, f, "RSplit", "CharSearcher")]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part2, f, "RSplit", "CharSearcher")])); const part3 = ends$searches_str_SplitTerminator_char(rs.strSplitTerminator(text2, String.fromCodePoint(c)), front, back); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part3, f, "SplitTerminator", "CharSearcher")]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part3, f, "SplitTerminator", "CharSearcher")])); const part4 = ends$searches_str_RSplitTerminator_char(rs.strRsplitTerminator(text2, String.fromCodePoint(c)), front, back); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part4, f, "RSplitTerminator", "CharSearcher")]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part4, f, "RSplitTerminator", "CharSearcher")])); const part5 = fronts$searches_str_SplitN_char(rs.strSplitn(text2, rs.u8Rem(at(3), 4) as rs.usize, String.fromCodePoint(c)), front); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part5, f, "SplitN", "CharSearcher")]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part5, f, "SplitN", "CharSearcher")])); const part6 = fronts$searches_str_RSplitN_char(rs.strRsplitn(text2, 2, String.fromCodePoint(c)), front); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part6, f, "RSplitN", "CharSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part6, f, "RSplitN", "CharSearcher"))])); const part7 = ends$searches_str_SplitInclusive_char(rs.strSplitInclusive(text2, String.fromCodePoint(c)), front, back); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part7, f, "SplitInclusive", "CharSearcher")]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part7, f, "SplitInclusive", "CharSearcher")])); const part8 = ends$searches_str_Matches_char(rs.strMatches(text2, String.fromCodePoint(c)), front, back); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part8, f, "Matches", "CharSearcher")]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part8, f, "Matches", "CharSearcher")])); const part9 = ends$searches_str_RMatches_char(rs.strRmatches(text2, String.fromCodePoint(c)), front, back); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part9, f, "RMatches", "CharSearcher")]; - put(out, rs.fmtFormat([args18[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part9, f, "RMatches", "CharSearcher")])); const part10 = ends$searches_str_MatchIndices_char(rs.strMatchIndices(text2, String.fromCodePoint(c)), front, back); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part10, f, "MatchIndices", "CharSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args20[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtStrSearch(part10, f, "MatchIndices", "CharSearcher"))])); const part11 = ends$searches_str_RMatchIndices_char(rs.strRmatchIndices(text2, String.fromCodePoint(c)), front, back); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part11, f, "RMatchIndices", "CharSearcher")]; - put(out, rs.fmtFormat([args22[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part11, f, "RMatchIndices", "CharSearcher")])); const set: rs.char[] = [c, 98]; const part12 = ends$searches_str_Split_array2_char(rs.strSplit(text2, rs.patternChars(set)), front, back); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part12, f, "Split", "CharArraySearcher")]; - put(out, rs.fmtFormat([args24[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part12, f, "Split", "CharArraySearcher")])); const part13 = ends$searches_str_Matches_ref_array2_char(rs.strMatches(text2, rs.patternChars(set)), front, back); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part13, f, "Matches", "CharArrayRefSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args26[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part13, f, "Matches", "CharArrayRefSearcher"))])); const part14 = ends$searches_str_RSplit_ref_slice_char(rs.strRsplit(text2, rs.patternChars(rs.sliceItems(rs.sliceRange(rs.sliceFrom(set), 0, 1)))), front, back); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part14, f, "RSplit", "CharSliceSearcher")]; - put(out, rs.fmtFormat([args28[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part14, f, "RSplit", "CharSliceSearcher")])); const part15 = ends$searches_str_Split_fmt_searches_closure3(rs.strSplit(text2, (x: rs.char): boolean => { return x === c; }), front, back); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part15, f, "Split", "CharPredicateSearcher")]; - put(out, rs.fmtFormat([args30[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part15, f, "Split", "CharPredicateSearcher")])); const part16 = ends$searches_str_MatchIndices_char_is_whitespace(rs.strMatchIndices(text2, (a0: rs.char): boolean => { return rs.charIsWhitespace(a0); }), front, back); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args32[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher"))])); const few2: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { const _53: rs.usize = rs.u8Rem(_22, 3) as rs.usize; if (!(_53 < 3)) { @@ -4919,61 +4779,48 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { } const _281: string[] = ["", "a", "aa", "ab", "aab", "aba", "abab", "bé", "aaba", "éaé"]; const part17 = fronts$searches_str_Split_ref_str(rs.strSplit(few2, _281[_291]), front); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part17, f, "Split", "StrSearcher")]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])])); + const args83 = [(f: rs.Formatter) => rs.fmtStrSearch(part17, f, "Split", "StrSearcher")]; + put(out, rs.fmtFormat([args83[0], "|", rs.fmtSpec({ alternate: true }, args83[0]), "|", rs.fmtSpec({ debugHex: "x" }, args83[0])])); const part18 = fronts$searches_str_RSplit_ref_str(rs.strRsplit(few2, _281[_291]), front); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part18, f, "RSplit", "StrSearcher")]; - put(out, rs.fmtFormat([args36[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part18, f, "RSplit", "StrSearcher")])); const part19 = fronts$searches_str_SplitTerminator_ref_str(rs.strSplitTerminator(few2, _281[_291]), front); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part19, f, "SplitTerminator", "StrSearcher")]; - put(out, rs.fmtFormat([args38[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part19, f, "SplitTerminator", "StrSearcher")])); const part20 = fronts$searches_str_SplitN_ref_str(rs.strSplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part20, f, "SplitN", "StrSearcher")]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part20, f, "SplitN", "StrSearcher")])); const part21 = fronts$searches_str_RSplitN_ref_str(rs.strRsplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part21, f, "RSplitN", "StrSearcher")]; - put(out, rs.fmtFormat([args42[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part21, f, "RSplitN", "StrSearcher")])); const part22 = fronts$searches_str_SplitInclusive_ref_str(rs.strSplitInclusive(few2, _281[_291]), front); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part22, f, "SplitInclusive", "StrSearcher")]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part22, f, "SplitInclusive", "StrSearcher")])); const part23 = fronts$searches_str_Matches_ref_str(rs.strMatches(few2, _281[_291]), rs.usizeMul(front, 2)); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part23, f, "Matches", "StrSearcher")]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part23, f, "Matches", "StrSearcher")])); const part24 = fronts$searches_str_RMatches_ref_str(rs.strRmatches(few2, _281[_291]), rs.usizeMul(front, 2)); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part24, f, "RMatches", "StrSearcher")]; - put(out, rs.fmtFormat([args48[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part24, f, "RMatches", "StrSearcher")])); const part25 = fronts$searches_str_MatchIndices_ref_str(rs.strMatchIndices(few2, _281[_291]), front); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part25, f, "MatchIndices", "StrSearcher")]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part25, f, "MatchIndices", "StrSearcher")])); const part26 = fronts$searches_str_RMatchIndices_ref_str(rs.strRmatchIndices(few2, _281[_291]), front); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part26, f, "RMatchIndices", "StrSearcher")]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args52[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtStrSearch(part26, f, "RMatchIndices", "StrSearcher"))])); const part27 = fronts$searches_str_Split_ref_String(rs.strSplit(text2, _281[_291]), front); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part27, f, "Split", "StrSearcher")]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part27, f, "Split", "StrSearcher")])); const it3: rs.Iter = rs.strMatches(few2, _281[_291]); while (rs.iterToOption(it3.next()) !== undefined) { } - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; - put(out, rs.fmtFormat([args56[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")])); it3.next(); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; - put(out, rs.fmtFormat([args58[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")])); const it4: rs.Iter<[rs.usize, string]> = rs.strRmatchIndices(few2, _281[_291]); while (rs.iterToOption(it4.next()) !== undefined) { } - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it4, f, "RMatchIndices", "StrSearcher")]; - put(out, rs.fmtFormat([args60[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it4, f, "RMatchIndices", "StrSearcher")])); const part28 = ends$searches_str_Lines(rs.strLines(text2), front, back); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part28, f, "Lines")]; - put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])])); + const args97 = [(f: rs.Formatter) => rs.fmtStrSearch(part28, f, "Lines")]; + put(out, rs.fmtFormat([args97[0], "|", rs.fmtSpec({ alternate: true }, args97[0])])); const part29 = ends$searches_str_SplitWhitespace(rs.strSplitWhitespace(text2), front, back); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part29, f, "SplitWhitespace")]; - put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])])); + const args98 = [(f: rs.Formatter) => rs.fmtStrSearch(part29, f, "SplitWhitespace")]; + put(out, rs.fmtFormat([args98[0], "|", rs.fmtSpec({ alternate: true }, args98[0])])); const it7: rs.Iter = ends$searches_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(text2), front, back); const _556: [rs.usize, rs.usize | undefined] = it7.sizeHint(); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it7, f, "SplitAsciiWhitespace"), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_556[0], f), (f: rs.Formatter) => rs.fmtOption(_556[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0]), "|", rs.fmtSpec({ debugHex: "x" }, args66[0]), "|", args66[1]])); + const args99 = [(f: rs.Formatter) => rs.fmtStrSearch(it7, f, "SplitAsciiWhitespace"), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_556[0], f), (f: rs.Formatter) => rs.fmtOption(_556[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args99[0], "|", rs.fmtSpec({ alternate: true }, args99[0]), "|", rs.fmtSpec({ debugHex: "x" }, args99[0]), "|", args99[1]])); } export function ends$searches_str_Lines(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { diff --git a/ts/fixtures/lang/shapes/expected/generics.Fixed.ts b/ts/fixtures/lang/shapes/expected/generics.Fixed.ts index 3db54d7a0..2747c29d6 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Fixed.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Fixed.ts @@ -3,10 +3,10 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_u16(self: Fixed, f: rs.Formatter): rs.Result { - const arg = self.pair as rs.u16[]; const _3: string = "Fixed"; const _4: string = "pair"; - const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg, f, rs.u16Debug); + const _6: rs.Slice = rs.sliceFrom(self.pair as rs.u16[]); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_6), f, rs.u16Debug); const _7: string = "tag"; const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.tag, f); return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); diff --git a/ts/fixtures/lang/shapes/expected/generics.Run.ts b/ts/fixtures/lang/shapes/expected/generics.Run.ts index bcc8e9d2c..99982d68e 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Run.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Run.ts @@ -4,16 +4,16 @@ import * as rs from "./rs.ts"; export function fmt$fmt_Debug_u16(self: Run, f: rs.Formatter): rs.Result { if (self.tag === "Listed") { - const arg2 = self._0 as rs.Vec; + const arg = self._0 as rs.Vec; const _5: string = "Listed"; - const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u16Debug); + const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg.items, f, rs.u16Debug); return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); } if (self.tag === "Fixed") { - const arg = self.array as rs.u16[]; + const __self0: rs.Slice = rs.sliceFrom(self.array as rs.u16[]); const _9: string = "Fixed"; const _10: string = "array"; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg, f, rs.u16Debug); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(__self0), f, rs.u16Debug); return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); } return rs.fmtWriteStr(f, "Empty"); @@ -47,7 +47,8 @@ export function first$u16(self: Run): rs.u16 | undefined { return rs.sliceFirst(rs.sliceFrom((self._0 as rs.Vec).items)); } if (self.tag === "Fixed") { - return (self.array as rs.u16[])[0]; + const array: rs.Slice = rs.sliceFrom(self.array as rs.u16[]); + return array.data[array.start]; } return undefined; } diff --git a/ts/fixtures/lang/shapes/expected/generics.Runs.ts b/ts/fixtures/lang/shapes/expected/generics.Runs.ts index 221fb0d3c..2a6866332 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Runs.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Runs.ts @@ -6,7 +6,7 @@ import { clone$14vwxlf as option_clone$14vwxlf, clone$0e53k5z as option_clone$0e import type * as Run from "./generics.Run.ts"; export function clone$Clone_u16(self: Runs): Runs { - return new Runs(copy$array_u16(copy$array_u16(self.array as rs.u16[])), rs.vecFrom((self.list as rs.Vec).items.slice()), self.view as rs.Slice, rs.sliceFrom(rs.sliceToArray(self.boxed as rs.Slice)), rs.cowClone(self.cow as rs.Cow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u16)), option_clone$14vwxlf(self.maybe as rs.Vec | undefined)); + return new Runs(copy$array_u16((self.array as rs.u16[]).slice()), rs.vecFrom((self.list as rs.Vec).items.slice()), self.view as rs.Slice, rs.sliceFrom(rs.sliceToArray(self.boxed as rs.Slice)), rs.cowClone(self.cow as rs.Cow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u16)), option_clone$14vwxlf(self.maybe as rs.Vec | undefined)); } export function clone$Clone_u8(self: Runs): Runs { @@ -14,25 +14,25 @@ export function clone$Clone_u8(self: Runs): Runs { } export function fmt$fmt_Debug_u16(self: Runs, f: rs.Formatter): rs.Result { - const arg = self.array as rs.u16[]; - const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg, f, rs.u16Debug); - const arg2 = self.list as rs.Vec; - const _9: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u16Debug); - const arg3 = self.view as rs.Slice; - const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.u16Debug); - const arg4 = self.boxed as rs.Slice; - const _13: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg4), f, rs.u16Debug); - const arg5 = self.cow as rs.Cow; - const _15: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(arg5)), f, rs.u16Debug); - const arg6 = self.pairs as rs.Vec; - const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg6.items, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug)); - const arg7 = self.maybe as rs.Vec | undefined; - const names: string[] = ["array", "list", "view", "boxed", "cow", "pairs", "maybe"]; - return rs.fmtDebugStructFields(f, "Runs", names, [_7, _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg7, f, (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.u16Debug))]); + const names: rs.Slice = rs.sliceFrom(["array", "list", "view", "boxed", "cow", "pairs", "maybe"]); + const _8: rs.Slice = rs.sliceFrom(self.array as rs.u16[]); + const arg = self.list as rs.Vec; + const _9: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg.items, f, rs.u16Debug); + const arg2 = self.view as rs.Slice; + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, rs.u16Debug); + const arg3 = self.boxed as rs.Slice; + const _13: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.u16Debug); + const arg4 = self.cow as rs.Cow; + const _15: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(arg4)), f, rs.u16Debug); + const arg5 = self.pairs as rs.Vec; + const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg5.items, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug)); + const arg6 = self.maybe as rs.Vec | undefined; + const values: rs.Slice = rs.sliceFrom([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(_8), f, rs.u16Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.u16Debug))]); + return rs.fmtDebugStructFields(f, "Runs", rs.sliceItems(names), rs.sliceItems(values)); } export function fmt$fmt_Debug_u8(self: Runs, f: rs.Formatter): rs.Result { - const names: string[] = ["array", "list", "view", "boxed", "cow", "pairs", "maybe"]; + const names: rs.Slice = rs.sliceFrom(["array", "list", "view", "boxed", "cow", "pairs", "maybe"]); const _8: rs.ByteSlice = rs.byteSliceFrom(self.array as Uint8Array); const arg = self.list as rs.ByteVec; const _9: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(arg), f, rs.u8Debug); @@ -45,11 +45,14 @@ export function fmt$fmt_Debug_u8(self: Runs, f: rs.Formatter): rs.Result< const arg5 = self.pairs as rs.Vec; const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg5.items, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); const arg6 = self.maybe as rs.ByteVec | undefined; - return rs.fmtDebugStructFields(f, "Runs", names, [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_8), f, rs.u8Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); + const values: rs.Slice = rs.sliceFrom([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_8), f, rs.u8Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); + return rs.fmtDebugStructFields(f, "Runs", rs.sliceItems(names), rs.sliceItems(values)); } export function eq$cmp_PartialEq_u16(self: Runs, other: Runs): boolean { - if (rs.eqSlice(rs.same)(self.array as rs.u16[], other.array as rs.u16[])) { + const _4: rs.Slice = rs.sliceFrom(self.array as rs.u16[]); + const _5: rs.Slice = rs.sliceFrom(other.array as rs.u16[]); + if (rs.eqSlice(rs.same)(_4, _5)) { if (rs.eqSlice(rs.same)(self.list as rs.Vec, other.list as rs.Vec)) { if (rs.eqSlice(rs.same)(self.view as rs.Slice, other.view as rs.Slice)) { if (rs.eqSlice(rs.same)(self.boxed as rs.Slice, other.boxed as rs.Slice)) { diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index e11ee9479..e106e8026 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -33,10 +33,9 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const nested: Wrap.Wrap> = Wrap.new$generics_Wrap_fmt_Pair(Wrap.new$fmt_Pair({ _0: at(2), _1: -3 })); const meters: Wrap.Wrap = new Wrap.Wrap({ _0: at(3) as rs.u64 }, at(4)); const shape: Wrap.Wrap = Wrap.new$shapes_Shape({ tag: "Rect", corner: Wrap.intoInner$shapes_Point(point), width: at(5) as rs.u16, height: 3 } as Shape.Shape); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Point(point, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_u8(byte, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Shape(shape, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + const args13 = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Point(point, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_u8(byte, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Shape(shape, f)]; + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2], " ", args13[3]])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f))])); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(Wrap.double$u8(byte)))); rs.byteVecPush(out, Wrap.get$u8(byte)); rs.byteVecPush(out, Wrap.get$fmt_Pair(Wrap.get$generics_Wrap_fmt_Pair(nested))._0); @@ -49,8 +48,8 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { }); const _119: Wrap.Wrap = Wrap.new$fmt_Pair({ _0: at(1), _1: 0 }); const _116: boolean = Wrap.eq$cmp_PartialEq_fmt_Pair(mapped, _119); - const args6: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_fmt_Pair(mapped, f), (f: rs.Formatter) => rs.fmtBool(_116, f)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1]])); + const args15 = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_fmt_Pair(mapped, f), (f: rs.Formatter) => rs.fmtBool(_116, f)]; + put(out, rs.fmtFormat([args15[0], " ", args15[1]])); const iter: rs.Iter> = rs.iterSlice(copy$array_generics_Either_u8_shapes_Point([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either])); while (true) { const _140: Either.Either | rs.Done = iter.next(); @@ -61,8 +60,8 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const flipped: Either.Either = Either.flip$u8_shapes_Point(either); const _153: rs.u8 | undefined = Either.left$u8_shapes_Point(either); const _156: Point.Point | undefined = Either.left$shapes_Point_u8(flipped); - const args8: rs.Fmt[] = [(f: rs.Formatter) => Either.fmt$fmt_Debug_u8_shapes_Point(either, f), (f: rs.Formatter) => Either.fmt$fmt_Debug_shapes_Point_u8(flipped, f), (f: rs.Formatter) => rs.fmtOption(_153, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_156, f, (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]])); + const args16 = [(f: rs.Formatter) => Either.fmt$fmt_Debug_u8_shapes_Point(either, f), (f: rs.Formatter) => Either.fmt$fmt_Debug_shapes_Point_u8(flipped, f), (f: rs.Formatter) => rs.fmtOption(_153, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_156, f, (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args16[0], " ", rs.fmtSpec({ alternate: true }, args16[1]), " ", args16[2], " ", args16[3]])); } const list: Wrap.Wrap> = new Wrap.Wrap(new rs.Vec(), 1); const _171: rs.u16 = at(10) as rs.u16; @@ -72,12 +71,12 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const some: Wrap.Wrap = Wrap.new$Option_u8(rs.byteSliceGet(data, 11)); const err: Wrap.Wrap> = new Wrap.Wrap(rs.Err({ tag: "Dot" } as Shape.Shape), 2); const _193: rs.u8 = option_unwrapOr$1fr498u(Wrap.get$Option_u8(none), some.count); - const args10: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_Vec_u16(list, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(none, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(some, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Result_u8_shapes_Shape(err, f), (f: rs.Formatter) => rs.u8Debug(_193, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]])); + const args17 = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_Vec_u16(list, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(none, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(some, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Result_u8_shapes_Shape(err, f), (f: rs.Formatter) => rs.u8Debug(_193, f)]; + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", args17[4]])); const tagged: Tagged.Tagged, rs.i16> = new Tagged.Tagged({ tag: "Right", value: 500 } as Either.Either, Wrap.new$i16(rs.i16Sub(at(8) as rs.i16, 100)), rs.vecFrom([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rs.i16)].slice())); const _237: Wrap.Wrap | undefined = Tagged.first$generics_Either_u8_u16_i16(tagged); - const args12: rs.Fmt[] = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_generics_Either_u8_u16_i16(tagged, f), (f: rs.Formatter) => rs.fmtOption(_237, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + const args18 = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_generics_Either_u8_u16_i16(tagged, f), (f: rs.Formatter) => rs.fmtOption(_237, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]; + put(out, rs.fmtFormat([args18[0], " ", args18[1]])); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(tagged.inner.value))); rs.byteVecPush(out, option_unwrapOr$1fr498u(Either.left$u8_u16(tagged.key), 0)); } @@ -193,8 +192,8 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { const _88: rs.usize = Runs.total$u8(runs); const _91: boolean = Runs.eq$cmp_PartialEq_u8(runs, before); const _95: rs.u8 | undefined = Run.first$u8(run); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(runs, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(before, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(taken), f, rs.u8Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u8(run, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(fixed, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(copy, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(swapped, f), (f: rs.Formatter) => rs.usizeDisplay(_88, f), (f: rs.Formatter) => rs.fmtBool(_91, f), (f: rs.Formatter) => rs.fmtOption(_95, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9], " ", args2[10]])); + const args5 = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(runs, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(before, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(taken), f, rs.u8Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u8(run, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(fixed, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(copy, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(swapped, f), (f: rs.Formatter) => rs.usizeDisplay(_88, f), (f: rs.Formatter) => rs.fmtBool(_91, f), (f: rs.Formatter) => rs.fmtOption(_95, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7], " ", args5[8], " ", args5[9], " ", args5[10]])); const data3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u16 => { return _22 as rs.u16; }), undefined, 2, true); @@ -213,9 +212,9 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { } Runs.push$u16(runs2, _154); } - const _160: rs.u16[] | undefined = rs.sliceFirst(rs.sliceFrom((runs2.pairs as rs.Vec).items)); + const _160: rs.Slice | undefined = rs.optionMap(rs.sliceFirst(rs.sliceFrom((runs2.pairs as rs.Vec).items)), rs.sliceFrom); if (_160 !== undefined) { - fill$u16(rs.sliceFrom(_160), n2); + fill$u16(_160, n2); } fill$u16(rs.sliceRange(rs.sliceFrom(runs2.array as rs.u16[]), 1), 7 as rs.u16); const taken4 = runs2.list as rs.Vec; @@ -239,8 +238,8 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { const _204: rs.usize = Runs.total$u16(runs2); const _207: boolean = Runs.eq$cmp_PartialEq_u16(runs2, before2); const _211: rs.u16 | undefined = Run.first$u16(run2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(runs2, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(before2, f), (f: rs.Formatter) => rs.fmtList(taken2.items, f, rs.u16Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u16(run2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(fixed2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(copy2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(swapped2, f), (f: rs.Formatter) => rs.usizeDisplay(_204, f), (f: rs.Formatter) => rs.fmtBool(_207, f), (f: rs.Formatter) => rs.fmtOption(_211, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], " ", args4[7], " ", args4[8], " ", args4[9], " ", args4[10]])); + const args6 = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(runs2, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(before2, f), (f: rs.Formatter) => rs.fmtList(taken2.items, f, rs.u16Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u16(run2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(fixed2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(copy2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(swapped2, f), (f: rs.Formatter) => rs.usizeDisplay(_204, f), (f: rs.Formatter) => rs.fmtBool(_207, f), (f: rs.Formatter) => rs.fmtOption(_211, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", args6[6], " ", args6[7], " ", args6[8], " ", args6[9], " ", args6[10]])); const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const tick: (a0: rs.u8) => Ticked.Ticked = (id: rs.u8): Ticked.Ticked => { return new Ticked.Ticked(id, rs.arcClone(log)); diff --git a/ts/fixtures/lang/shapes/expected/harness.ts b/ts/fixtures/lang/shapes/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/shapes/expected/harness.ts +++ b/ts/fixtures/lang/shapes/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/shapes/expected/shapes.ts b/ts/fixtures/lang/shapes/expected/shapes.ts index a5d211c5c..3a096cfb2 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.ts @@ -593,8 +593,8 @@ export function order(data: rs.ByteSlice, out: rs.ByteVec): void { const _85: rs.usize = rs.min(mark(out, 14), len); const _82: rs.ByteSlice = rs.byteSliceRange(_83, rs.usizeDiv(rs.min(mark(out, 15), len), 2), _85); const _103: rs.usize = sum; - const args2: rs.Fmt[] = [(f: rs.Formatter) => Shape.fmt$fmt_Debug(rect, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(line, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(pair, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(read, f), (f: rs.Formatter) => Moved.fmt$fmt_Debug(updated, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(taken, f), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.usizeDisplay(_63, f), (f: rs.Formatter) => rs.usizeDisplay(_103, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_82), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]))); + const args3 = [(f: rs.Formatter) => Shape.fmt$fmt_Debug(rect, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(line, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(pair, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(read, f), (f: rs.Formatter) => Moved.fmt$fmt_Debug(updated, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(taken, f), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.usizeDisplay(_63, f), (f: rs.Formatter) => rs.usizeDisplay(_103, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_82), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " ", args3[5], " ", args3[6], " ", args3[7], " ", args3[8], " ", args3[9]]))); const _125: rs.usize = mark(out, 16); const _127: rs.usize = out.length; rs.byteVecPush(out, _125 & 0xff); @@ -877,8 +877,7 @@ export function diverging(data: rs.ByteSlice, out: rs.ByteVec): void { if (!(b2 === 253)) { return rs.u8Div(b2, 3); } - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b2, f)]; - rs.panicFmt(["closure ", args2[0]]); + rs.panicFmt(["closure ", (f: rs.Formatter) => rs.u8Display(b2, f)]); }; const head: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 2)); const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(head), 0); @@ -897,8 +896,7 @@ export function diverging(data: rs.ByteSlice, out: rs.ByteVec): void { */ export function closureNever(b: rs.u8): rs.u8 { const _2: (a0: rs.u8) => never = (b2: rs.u8): never => { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerHex(b2, f)]; - rs.panicFmt(["closure failed on ", rs.fmtSpec({ alternate: true }, args2[0])]); + rs.panicFmt(["closure failed on ", rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.u8LowerHex(b2, f))]); }; const _4: (a0: rs.u8) => never = madeNever(); const ptr: (a0: rs.u8) => never = bail; @@ -923,8 +921,7 @@ export function closureNever(b: rs.u8): rs.u8 { /** A closure that never returns, made by a function. */ export function madeNever(): (a0: rs.u8) => never { return (b: rs.u8): never => { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; - rs.panicFmt(["made ", args2[0]]); + rs.panicFmt(["made ", (f: rs.Formatter) => rs.u8Display(b, f)]); }; } @@ -937,15 +934,13 @@ export function genericNever(b: rs.u8, len: rs.usize): void { if (!(b === 246)) { if (b === 249) { if (!(len > 1)) { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; - rs.panicFmt(["some ", args4[0]]); + rs.panicFmt(["some ", (f: rs.Formatter) => rs.u8Display(b, f)]); } else { unwrapOrBail$generic_never_never(undefined, b); } } } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; - rs.panicFmt(["passed ", args2[0]]); + rs.panicFmt(["passed ", (f: rs.Formatter) => rs.u8Display(b, f)]); } } else { bail(b); @@ -967,21 +962,18 @@ export function unwrapOrBail$generic_never_never(o: never | undefined, b: rs.u8) /** A function that never returns. */ export function bail(b: rs.u8): never { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerHex(b, f)]; - rs.panicFmt(["failed on ", rs.fmtSpec({ alternate: true }, args2[0])]); + rs.panicFmt(["failed on ", rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.u8LowerHex(b, f))]); } /** `return`, and `break` out of the function's labeled block, with values that never exist. */ export function returnedNever(b: rs.u8, len: rs.usize): rs.u8 { if (b === 247) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; - rs.panicFmt(["returned ", args2[0]]); + rs.panicFmt(["returned ", (f: rs.Formatter) => rs.u8Display(b, f)]); } else if (b === 248) { if (!(rs.usizeRem(len, 2) === 0)) { bail(b); } else { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; - rs.panicFmt(["then ", args4[0]]); + rs.panicFmt(["then ", (f: rs.Formatter) => rs.u8Display(b, f)]); } } else { if (!(b === 254)) { @@ -1021,8 +1013,7 @@ export function brokenNever(dataData: Uint8Array, dataStart: number, dataLen: nu } const value = dataData[dataStart + _6]; if (value === 251) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f)]; - rs.panicFmt(["broken at ", args2[0]]); + rs.panicFmt(["broken at ", (f: rs.Formatter) => rs.usizeDisplay(i, f)]); } else if (value === 252) { const _19: rs.usize = i; if (_19 >= dataLen) { @@ -1052,8 +1043,7 @@ export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: num } const value = dataData[dataStart + _8]; if (value === 239) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f)]; - rs.panicFmt(["bound at ", args2[0]]); + rs.panicFmt(["bound at ", (f: rs.Formatter) => rs.usizeDisplay(i, f)]); } else if (value === 240) { const _22: rs.usize = i; if (_22 >= dataLen) { @@ -1398,8 +1388,7 @@ export function patterns(data: rs.ByteSlice, out: rs.ByteVec): void { const parsed: rs.Result = rs.Ok(data.length & 0xff); const a2: rs.u8 = (parsed as { ok: true; value: rs.u8 }).value; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rs.u8 }).value, (parsed as { ok: true; value: rs.u8 }).value, early(a2)))); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(parsed, f, rs.u8Debug, (value: Void.Void, f: rs.Formatter) => Void.fmt$fmt_Debug(value, f))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(parsed, f, rs.u8Debug, (value: Void.Void, f: rs.Formatter) => Void.fmt$fmt_Debug(value, f))]))); payloads(data.data, data.start, data.length, out); known(data.data, data.start, data.length, out); rematched(data, out); diff --git a/ts/fixtures/lang/shares/expected/core/bool.ts b/ts/fixtures/lang/shares/expected/core/bool.ts index 2174fa3cc..1ef776c7c 100644 --- a/ts/fixtures/lang/shares/expected/core/bool.ts +++ b/ts/fixtures/lang/shares/expected/core/bool.ts @@ -1,6 +1,14 @@ // Generated by rust2-ts. Do not edit. import * as rs from "../rs.ts"; +import type * as Logged from "../shares.Logged.ts"; + +export function then$0sqnsr0(self: boolean, f: () => rs.Arc): rs.Arc | undefined { + if (!self) { + return undefined; + } + return f(); +} export function then$17jt89y(self: boolean, f: () => [rs.Arc>, rs.Arc]): [rs.Arc>, rs.Arc] | undefined { if (!self) { diff --git a/ts/fixtures/lang/shares/expected/core/option.ts b/ts/fixtures/lang/shares/expected/core/option.ts index 6fb1d822f..a0c00b25a 100644 --- a/ts/fixtures/lang/shares/expected/core/option.ts +++ b/ts/fixtures/lang/shares/expected/core/option.ts @@ -10,6 +10,13 @@ export function isSomeAnd$136asov(self: rs.Arc | undefined, f: (a0 return f(self); } +export function isSomeAnd$0mo9vap(self: rs.Arc | undefined, f: (a0: rs.Arc) => boolean): boolean { + if (self === undefined) { + return false; + } + return f(self); +} + export function isSomeAnd$15uicdu(self: [rs.Weak>, rs.Weak] | undefined, f: (a0: [rs.Weak>, rs.Weak]) => boolean): boolean { if (self === undefined) { return false; @@ -31,6 +38,13 @@ export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: return f(self); } +export function mapOr$0k95fy0(self: rs.Arc> | undefined, default_: rs.u8, f: (a0: rs.Arc>) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$00xrvtw(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/shares/expected/harness.ts b/ts/fixtures/lang/shares/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/shares/expected/harness.ts +++ b/ts/fixtures/lang/shares/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/shares/expected/lib.ts b/ts/fixtures/lang/shares/expected/lib.ts index daefc8bd5..d1260614c 100644 --- a/ts/fixtures/lang/shares/expected/lib.ts +++ b/ts/fixtures/lang/shares/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { bytes, wides, copies, drops, strs, generics, keys, addresses } from "./shares.ts"; +import { bytes, wides, copies, drops, strs, generics, keys, addresses, unsizedArrays } from "./shares.ts"; import type * as Logged from "./shares.Logged.ts"; export function copy$array_u8(v: Uint8Array): Uint8Array { @@ -12,6 +12,12 @@ export function copy$tuple2_u8_u16(v: [rs.u8, rs.u16]): [rs.u8, rs.u16] { return [v[0], v[1]]; } +export function drop$Option_Rc_array2_shares_Logged(_1: rs.Arc | undefined): void { + if (_1 !== undefined) { + rs.arcDrop(_1, drop$array2_shares_Logged); + } +} + export function drop$Option_Rc_slice_shares_Logged(_1: rs.Arc> | undefined): void { if (_1 !== undefined) { rs.arcDrop(_1, drop$slice_shares_Logged); @@ -34,6 +40,10 @@ export function drop$Rc_slice_shares_Logged(value: rs.Arc): void { rs.dropAll(value); } @@ -53,7 +63,7 @@ export function drop$tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(_1: [rs.Weak undefined]> { - return rs.vecFrom([["shares::bytes", bytes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::wides", wides as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::copies", copies as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::drops", drops as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::strs", strs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::generics", generics as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::keys", keys as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::addresses", addresses as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); + return rs.vecFrom([["shares::bytes", bytes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::wides", wides as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::copies", copies as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::drops", drops as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::strs", strs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::generics", generics as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::keys", keys as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::addresses", addresses as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::unsized_arrays", unsizedArrays as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/shares/expected/shares.ts b/ts/fixtures/lang/shares/expected/shares.ts index 04f5e7bf0..d24b63954 100644 --- a/ts/fixtures/lang/shares/expected/shares.ts +++ b/ts/fixtures/lang/shares/expected/shares.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { copy$array_u8, copy$tuple2_u8_u16, drop$Option_Rc_slice_shares_Logged, drop$Option_tuple2_Rc_slice_u16_sync_Arc_slice_u8, drop$Option_tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8, drop$Rc_slice_shares_Logged, drop$slice_shares_Logged } from "./lib.ts"; -import { then$17jt89y, then$0zcjz7j } from "./core/bool.ts"; -import { isSomeAnd$136asov, isSomeAnd$15uicdu, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, mapOr$00xrvtw as option_mapOr$00xrvtw, mapOr$1tej7ml as option_mapOr$1tej7ml } from "./core/option.ts"; +import { copy$array_u8, copy$tuple2_u8_u16, drop$Option_Rc_array2_shares_Logged, drop$Option_Rc_slice_shares_Logged, drop$Option_tuple2_Rc_slice_u16_sync_Arc_slice_u8, drop$Option_tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8, drop$Rc_slice_shares_Logged, drop$slice_shares_Logged } from "./lib.ts"; +import { then$0sqnsr0, then$17jt89y, then$0zcjz7j } from "./core/bool.ts"; +import { isSomeAnd$136asov, isSomeAnd$0mo9vap, isSomeAnd$15uicdu, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, mapOr$0k95fy0 as option_mapOr$0k95fy0, mapOr$00xrvtw as option_mapOr$00xrvtw, mapOr$1tej7ml as option_mapOr$1tej7ml } from "./core/option.ts"; import { put, text } from "./harness.ts"; import * as Held from "./shares.Held.ts"; import * as Logged from "./shares.Logged.ts"; @@ -172,7 +172,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const ofStr: rs.Arc = rs.arcStrBytes(s); counts$slice_u8(ofStr, out); const ofTwin: rs.Arc = rs.arcStrBytes(twin); - rs.byteVecPush(out, ofStr === ofTwin ? 1 : 0); + rs.byteVecPush(out, rs.arcPtrEq(ofStr, ofTwin) ? 1 : 0); counts$slice_u8(ofTwin, out); ofTwin[Symbol.dispose](); counts$slice_u8(ofStr, out); @@ -241,8 +241,8 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.byteSliceEq(arc.value, a.value) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(hash$sync_Arc_slice_u8(arc), hash$Rc_slice_u8(a)) ? 1 : 0); const _285: rs.Arc = new rs.Arc(rs.byteSliceFrom(new Uint8Array(0))); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arc.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_285.value), f, rs.u8Debug)]; - const _281: string = rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]]); + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arc.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_285.value), f, rs.u8Debug)]; + const _281: string = rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3]]); _285[Symbol.dispose](); put(out, _281); arc[Symbol.dispose](); @@ -253,16 +253,16 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { counts$slice_u8(a2, out); const b3: rs.Arc = rs.arcClone(a2); counts$slice_u8(a2, out); - rs.byteVecPush(out, a2 === b3 ? 1 : 0); + rs.byteVecPush(out, rs.arcPtrEq(a2, b3) ? 1 : 0); const c: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); - rs.byteVecPush(out, a2 === c ? 1 : 0); + rs.byteVecPush(out, rs.arcPtrEq(a2, c) ? 1 : 0); rs.byteVecPush(out, rs.eqArc(rs.eqBytes, true)(a2, c) ? 1 : 0); const weak: rs.Weak = new rs.Weak(a2); counts$slice_u8(b3, out); a2[Symbol.dispose](); counts$slice_u8(b3, out); rs.byteVecPush(out, isSomeAnd$136asov(rs.weakUpgrade(weak), (up: rs.Arc): boolean => { - const _05: boolean = up === b3; + const _05: boolean = rs.arcPtrEq(up, b3); up[Symbol.dispose](); return _05; }) ? 1 : 0); @@ -275,7 +275,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const arc2: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteSliceToByteVec(data2))); const twin2: rs.Arc = rs.arcClone(arc2); arcCounts$slice_u8(arc2, out); - rs.byteVecPush(out, arc2 === twin2 ? 1 : 0); + rs.byteVecPush(out, rs.arcPtrEq(arc2, twin2) ? 1 : 0); const arcWeak: rs.Weak = new rs.Weak(twin2); arcCounts$slice_u8(arc2, out); twin2[Symbol.dispose](); @@ -298,7 +298,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { scramble(rs.arcMakeMut(rs.place(() => a3, (value) => a3 = value), (a0: rs.ByteSlice): rs.ByteSlice => { return rs.byteSliceFrom(rs.byteSliceToArray(a0)); }, rs.drop)); - rs.byteVecPush(out, a3 === b4 ? 1 : 0); + rs.byteVecPush(out, rs.arcPtrEq(a3, b4) ? 1 : 0); counts$slice_u8(a3, out); counts$slice_u8(b4, out); putBytes(a3.value, out); @@ -368,8 +368,8 @@ export function wides(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.eqArc(rs.eqSlice(rs.same), true)(fromRef, fromBox) ? 1 : 0); rs.byteVecPush(out, rs.cmpArc(rs.cmpSlice(rs.cmp))(collected, fromRef) & 0xff); rs.byteVecPush(out, rs.u64Eq(hash$Rc_slice_u16(collected), hash$slice_u16(collected.value)) ? 1 : 0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected.value), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(fromVec.value), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected.value), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(fromVec.value), f, rs.u16Debug)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1]])); let shared: rs.Arc> = rs.arcClone(fromRef); counts$slice_u16(fromRef, out); if (rs.u8Rem(kind, 2) === 0) { @@ -387,7 +387,7 @@ export function wides(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } counts$slice_u16(fromRef, out); - rs.byteVecPush(out, shared === fromRef ? 1 : 0); + rs.byteVecPush(out, rs.arcPtrEq(shared, fromRef) ? 1 : 0); putWides(shared.value, out); putWides(fromRef.value, out); const alone: rs.Arc> = collected; @@ -590,8 +590,8 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.u64Eq(hash$Rc_str(fromRef), hash$str(s)) ? 1 : 0); rs.byteVecPush(out, rs.stringLen(fromRef.value) & 0xff); rs.byteVecPush(out, rs.iterCount(rs.strChars(fromRef.value)) & 0xff); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, fromRef.value), (f: rs.Formatter) => rs.fmtStr(fromString.value, f), (f: rs.Formatter) => rs.fmtStr(empty.value, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, fromRef.value), (f: rs.Formatter) => rs.fmtStr(fromString.value, f), (f: rs.Formatter) => rs.fmtStr(empty.value, f)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2]])); const twin: rs.Arc = rs.arcClone(fromRef); counts$str(twin, out); rs.byteVecPush(out, twin === fromRef ? 1 : 0); @@ -734,7 +734,7 @@ export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const old = slot; slot = rs.arcClone(other); old[Symbol.dispose](); - rs.byteVecPush(out, slot === other ? 1 : 0); + rs.byteVecPush(out, rs.arcPtrEq(slot, other) ? 1 : 0); counts$slice_u8(other, out); other[Symbol.dispose](); slot[Symbol.dispose](); @@ -815,4 +815,103 @@ export function addresses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi wide[Symbol.dispose](); } +/** + * An `Rc` and an `Arc` of an array, and a `Weak` of one, unsized to their slice while + * clones of the array's are kept: counted, compared, read, written through `get_mut` and + * `make_mut`, and dropped by whichever owner is last, of values that log, of `u16`s, and + * of bytes. + */ +export function unsizedArrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); + }; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), i & 0xff) & 126; + }; + const part = at(0); + const _12: Logged.Logged = logged(part); + const part2 = at(1); + const array: rs.Arc = new rs.Arc([_12, logged(part2)]); + const kept: rs.Arc | undefined = then$0sqnsr0((kind & 1) !== 0, (): rs.Arc => { + return rs.arcClone(array); + }); + const weak2: rs.Weak> = rs.weakDyn(new rs.Weak(array), (arc: rs.Arc): rs.Arc> => { + return new rs.ArcDyn(arc, rs.sliceFrom(arc.value)); + }); + let shared: rs.Arc> = new rs.ArcDyn(array, rs.sliceFrom(array.value)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(shared.strong & 0xff, shared.weak & 0xff)), undefined, true); + rs.byteVecPush(out, isSomeAnd$0mo9vap(kept, (k: rs.Arc): boolean => { + const _53: rs.Arc = rs.arcClone(k); + const _45: rs.Arc> = new rs.ArcDyn(_53, rs.sliceFrom(_53.value)); + const _04: boolean = rs.arcPtrEq(_45, shared); + rs.arcDrop(_45, drop$slice_shares_Logged); + return _04; + }) ? 1 : 0); + ids(shared.value, out); + const _51: rs.Slice | undefined = rs.arcGetMut(shared); + if (_51 !== undefined) { + const _55: Logged.Logged = logged(64); + rs.idx(_51, 0); + _51.data[_51.start][Symbol.dispose](); + _51.data[_51.start] = _55; + } + flush(log.value, out); + const _65: Logged.Logged = logged(66); + const _68: rs.Slice = rs.arcMakeMut(rs.place(() => shared, (value) => shared = value), (a0: rs.Slice): rs.Slice => { + return rs.sliceFrom(rs.sliceItems(a0).map(Logged.clone$Clone)); + }, drop$Rc_slice_shares_Logged); + rs.idx(_68, 1); + _68.data[_68.start + 1][Symbol.dispose](); + _68.data[_68.start + 1] = _65; + flush(log.value, out); + ids(shared.value, out); + if (kept !== undefined) { + ids(rs.sliceFrom(kept.value), out); + } + const upgraded: rs.Arc> | undefined = rs.weakUpgrade(weak2); + rs.byteVecPush(out, option_mapOr$0k95fy0(upgraded, 255, (u: rs.Arc>): rs.u8 => { + return u.value.length & 0xff; + })); + drop$Option_Rc_slice_shares_Logged(upgraded); + if ((kind & 2) === 0) { + rs.arcDrop(shared, drop$slice_shares_Logged); + flush(log.value, out); + drop$Option_Rc_array2_shares_Logged(kept); + } else { + drop$Option_Rc_array2_shares_Logged(kept); + flush(log.value, out); + rs.arcDrop(shared, drop$slice_shares_Logged); + } + flush(log.value, out); + const _113: rs.Arc> | undefined = rs.weakUpgrade(weak2); + rs.byteVecPush(out, _113 === undefined ? 1 : 0); + drop$Option_Rc_slice_shares_Logged(_113); + const words: rs.Arc = new rs.Arc([(((at(2) as rs.u16) << 8) & 0xffff) | 1, 2, 3]); + const twin: rs.Arc = rs.arcClone(words); + let wide: rs.Arc> = new rs.ArcDyn(words, rs.sliceFrom(words.value)); + rs.byteVecPush(out, twin.strong & 0xff); + const _132: rs.Slice = rs.arcMakeMut(rs.place(() => wide, (value2) => wide = value2), (a02: rs.Slice): rs.Slice => { + return rs.sliceFrom(rs.sliceToArray(a02)); + }, rs.drop); + rs.idx(_132, 2); + _132.data[_132.start + 2] = 1792; + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.sliceItems(wide.value)), rs.iterSlice(twin.value)), (_2: rs.u16): rs.u8 => { + const w: rs.u16 = _2; + return (w ^ (w >> 8)) & 0xff; + }), undefined, true); + const bytes: rs.Arc = new rs.Arc(Uint8Array.of(at(3), at(4))); + const more: rs.Arc = rs.arcClone(bytes); + const slice: rs.Arc = new rs.ArcDyn(bytes, rs.byteSliceFrom(bytes.value)); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(slice.value)), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(more.value)))), undefined, true); + const _173: rs.Arc = new rs.ArcDyn(more, rs.byteSliceFrom(more.value)); + rs.byteVecPush(out, rs.arcPtrEq(slice, _173) ? 1 : 0); + _173[Symbol.dispose](); + slice[Symbol.dispose](); + wide[Symbol.dispose](); + twin[Symbol.dispose](); + weak2[Symbol.dispose](); + log[Symbol.dispose](); +} + //# sourceMappingURL=shares.ts.map diff --git a/ts/fixtures/lang/shares/src/lib.rs b/ts/fixtures/lang/shares/src/lib.rs index 8e8408857..8dce8908b 100644 --- a/ts/fixtures/lang/shares/src/lib.rs +++ b/ts/fixtures/lang/shares/src/lib.rs @@ -24,5 +24,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("shares::generics", shares::generics), ("shares::keys", shares::keys), ("shares::addresses", shares::addresses), + ("shares::unsized_arrays", shares::unsized_arrays), ] } diff --git a/ts/fixtures/lang/shares/src/shares.rs b/ts/fixtures/lang/shares/src/shares.rs index f524ecafc..1549a2b87 100644 --- a/ts/fixtures/lang/shares/src/shares.rs +++ b/ts/fixtures/lang/shares/src/shares.rs @@ -4,7 +4,8 @@ //! written through `get_mut` and `make_mut`, and downgraded, of bytes, of `u16`s, of //! values JS copies, and of values that log their clones and drops, empty or not, with //! what drops dropped when its last owner does; held by a generic type at each of those, -//! looked up as map keys by a borrow of their slice or text, and pointed at by `as_ptr`. +//! looked up as map keys by a borrow of their slice or text, pointed at by `as_ptr`, and +//! unsized from an `Rc` or `Arc` of an array, sharing its count. use std::borrow::{Borrow, Cow}; use std::cell::RefCell; @@ -598,3 +599,62 @@ pub fn addresses(kind: u8, data: &[u8], out: &mut Vec) { other.is_some() || weak.is_some_and(|(a, b)| a.upgrade().is_none() && b.upgrade().is_none()), )); } + +/// An `Rc` and an `Arc` of an array, and a `Weak` of one, unsized to their slice while +/// clones of the array's are kept: counted, compared, read, written through `get_mut` and +/// `make_mut`, and dropped by whichever owner is last, of values that log, of `u16`s, and +/// of bytes. +pub fn unsized_arrays(kind: u8, data: &[u8], out: &mut Vec) { + let log = Rc::new(RefCell::new(Vec::new())); + let logged = |id: u8| Logged { id, log: log.clone() }; + let at = |i: usize| data.get(i).copied().unwrap_or(i as u8) & 0x7e; + let array: Rc<[Logged; 2]> = Rc::new([logged(at(0)), logged(at(1))]); + let kept = (kind & 1 != 0).then(|| array.clone()); + let weak = Rc::downgrade(&array); + let weak: Weak<[Logged]> = weak; + let mut shared: Rc<[Logged]> = array; + out.extend([Rc::strong_count(&shared) as u8, Rc::weak_count(&shared) as u8]); + out.push(u8::from( + kept.as_ref() + .is_some_and(|k| Rc::ptr_eq(&(k.clone() as Rc<[Logged]>), &shared)), + )); + ids(&shared, out); + if let Some(items) = Rc::get_mut(&mut shared) { + items[0] = logged(0x40); + } + flush(&log, out); + Rc::make_mut(&mut shared)[1] = logged(0x42); + flush(&log, out); + ids(&shared, out); + if let Some(k) = &kept { + ids(&k[..], out); + } + let upgraded = weak.upgrade(); + out.push(upgraded.as_ref().map_or(0xff, |u| u.len() as u8)); + drop(upgraded); + match kind & 2 { + 0 => { + drop(shared); + flush(&log, out); + drop(kept); + } + _ => { + drop(kept); + flush(&log, out); + drop(shared); + } + } + flush(&log, out); + out.push(u8::from(weak.upgrade().is_none())); + let words: Arc<[u16; 3]> = Arc::new([u16::from(at(2)) << 8 | 1, 2, 3]); + let twin = words.clone(); + let mut wide: Arc<[u16]> = words; + out.push(Arc::strong_count(&twin) as u8); + Arc::make_mut(&mut wide)[2] = 0x700; + out.extend(wide.iter().chain(twin.iter()).map(|&w| (w ^ w >> 8) as u8)); + let bytes: Arc<[u8; 2]> = Arc::new([at(3), at(4)]); + let more = bytes.clone(); + let slice: Arc<[u8]> = bytes; + out.extend(slice.iter().chain(more.iter())); + out.push(u8::from(Arc::ptr_eq(&slice, &(more as Arc<[u8]>)))); +} diff --git a/ts/fixtures/lang/singles/expected/harness.ts b/ts/fixtures/lang/singles/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/singles/expected/harness.ts +++ b/ts/fixtures/lang/singles/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/singles/expected/singles.ts b/ts/fixtures/lang/singles/expected/singles.ts index c8bcdb6ad..264bfa397 100644 --- a/ts/fixtures/lang/singles/expected/singles.ts +++ b/ts/fixtures/lang/singles/expected/singles.ts @@ -53,8 +53,8 @@ export function putSecs(out: rs.ByteVec, d: rs.Result rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + const args3 = [(f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1]])); } } @@ -278,8 +278,7 @@ export function singles(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const v2: rs.f32[] = [a, b, 0.10000000149011612]; putF32(out, rs.iterSum(rs.iterSlice(v2), rs.f32Add, -0.0)); putF32(out, rs.iterProduct(rs.iterSlice(v2), rs.f32Mul, 1.0)); - const _499: rs.f32[] = []; - putF32(out, rs.iterSum(rs.iterSlice(_499), rs.f32Add, -0.0)); + putF32(out, rs.iterSum(rs.iterSlice([]), rs.f32Add, -0.0)); putF32(out, rs.iterSum(rs.iterSlice([-0.0, -0.0]), rs.f32Add, -0.0)); putF32(out, 0.0); const g: Gauge.Gauge = { level: a, peak: b }; @@ -397,14 +396,14 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const w: rs.usize = rs.usizeDiv(p, 4); const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0])])); + const args17 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(p)]; + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])])); + const args18 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0])])); put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f))); } else if (_13 === 1) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args6[0]), " ", rs.fmtSpec({ precision: 120 }, args6[1]), " ", rs.fmtSpec({ precision: 160 }, args6[2])])); + const args16 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args16[0]), " ", rs.fmtSpec({ precision: 120 }, args16[1]), " ", rs.fmtSpec({ precision: 160 }, args16[2])])); } else if (_13 === 2) { const _72: [rs.f32, rs.ByteSlice] = take(_6[1]); const b: rs.f32 = _72[0]; @@ -413,16 +412,16 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_13 === 3) { const _78: rs.Vec = rs.vecFrom([Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]); const part = { level: a, history: _78 }; - const args8: rs.Fmt[] = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); + const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])])); } else { let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rs.i32 = 0; const iterEnd: rs.i32 = 64; while (iterStart++ < iterEnd) { const x: rs.f32 = rs.f32FromBits(step(rs.place(() => state, (value) => state = value))); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(x, f), (f: rs.Formatter) => rs.f32Debug(x, f), (f: rs.Formatter) => rs.f32LowerExp(x, f)]; - put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); + const args13 = [(f: rs.Formatter) => rs.f32Display(x, f), (f: rs.Formatter) => rs.f32Debug(x, f), (f: rs.Formatter) => rs.f32LowerExp(x, f)]; + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]])); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 64; @@ -432,8 +431,8 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } const r2: rs.u32 = step(rs.place(() => state, (value2) => state = value2)); const x2: rs.f32 = Math.fround(Math.fround(r2 >>> 8) / Math.fround(rs.u32Shl(1, rs.u32Add(rs.u32Rem(r2, 16), 1)))); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Debug(x2, f), (f: rs.Formatter) => rs.f32LowerExp(x2, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + const args14 = [(f: rs.Formatter) => rs.f32Debug(x2, f), (f: rs.Formatter) => rs.f32LowerExp(x2, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1]])); } } } @@ -469,10 +468,9 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x: rs.f32 = rs.f32FromBits((step(rs.place(() => state, (value) => state = value)) & 2147483647) >>> 0); const half: rs.f64 = ((x as rs.f64) + (rs.f32NextUp(x) as rs.f64)) / 2.0; const p: rs.usize = rs.u32Add(rs.u32Rem(step(rs.place(() => state, (value2) => state = value2)), 30), 8) as rs.usize; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64LowerExp(half, f), rs.fmtCount(p)]; - one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args2[1]) }, args2[0])]), out); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f64LowerExp(half, f)]; - one(rs.fmtFormat([args4[0]]), out); + const args7 = [(f: rs.Formatter) => rs.f64LowerExp(half, f), rs.fmtCount(p)]; + one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args7[1]) }, args7[0])]), out); + one(rs.fmtFormat([(f: rs.Formatter) => rs.f64LowerExp(half, f)]), out); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 16; @@ -494,8 +492,8 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { s2 = s2 + String.fromCodePoint(_117); } const _133: rs.i64 = rs.i64Sub(rs.u32Rem(r >>> 16, 100) as rs.i64, 50); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_133, f)]; - one(rs.fmtFormat([args6[0], "e", args6[1]]), out); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_133, f)]; + one(rs.fmtFormat([args9[0], "e", args9[1]]), out); } } } @@ -507,12 +505,11 @@ export function one(s: string, out: rs.ByteVec): void { if (_4.ok) { const v: rs.f32 = _4.value; putF32(out, v); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Debug(v, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.f32Debug(v, f)])); } else { const e: rs.ParseFloatError = _4.error; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1]])); + const args5 = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; + put(out, rs.fmtFormat([args5[0], "|", args5[1]])); } rs.byteVecPush(out, rs.f32FromStr(s).ok ? 1 : 0); } diff --git a/ts/fixtures/lang/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index b5809e38e..d42d39d65 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -20,6 +20,13 @@ export function map$1sh08h7(self: rs.u16[] | undefined, f: (a0: rs.u16[]) => rs. return f(self); } +export function map$0duedp1(self: rs.Slice | undefined, f: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function map$0q6fk7x(self: rs.ByteSlice | undefined, f: (a0: rs.ByteSlice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; @@ -27,7 +34,7 @@ export function map$0q6fk7x(self: rs.ByteSlice | undefined, f: (a0: rs.ByteSlice return f(self); } -export function map$0k54dqg(self: Pair.Pair[] | undefined, f: (a0: Pair.Pair[]) => rs.u8): rs.u8 | undefined { +export function map$1uud0v7(self: rs.Slice | undefined, f: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/slices/expected/harness.ts b/ts/fixtures/lang/slices/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/slices/expected/harness.ts +++ b/ts/fixtures/lang/slices/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index 5fac50031..aa82e6676 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2,7 +2,7 @@ import * as rs from "./rs.ts"; import { copy$Option_array2_u16, copy$Option_array2_u8, copy$array_array2_array2_u8, copy$array_array2_u16, copy$array_array2_u8, copy$array_u16, copy$array_u8, copy$slices_Pair, drop$tuple2_Vec_slices_Noisy_Vec_u8 } from "./lib.ts"; -import { isSomeAnd$1ouf3e6, map$1sh08h7 as option_map$1sh08h7, map$0q6fk7x as option_map$0q6fk7x, map$0k54dqg as option_map$0k54dqg, map$1j0y4j0 as option_map$1j0y4j0, map$0vk4zok as option_map$0vk4zok, map$1aqm6sp as option_map$1aqm6sp, map$04ry0e1 as option_map$04ry0e1, mapOr$135q041 as option_mapOr$135q041, zip$0wdt346, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; +import { isSomeAnd$1ouf3e6, map$1sh08h7 as option_map$1sh08h7, map$0duedp1 as option_map$0duedp1, map$0q6fk7x as option_map$0q6fk7x, map$1uud0v7 as option_map$1uud0v7, map$1j0y4j0 as option_map$1j0y4j0, map$0vk4zok as option_map$0vk4zok, map$1aqm6sp as option_map$1aqm6sp, map$04ry0e1 as option_map$04ry0e1, mapOr$135q041 as option_mapOr$135q041, zip$0wdt346, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; import * as Counted from "./slices.Counted.ts"; import * as Item from "./slices.Item.ts"; import * as Noisy from "./slices.Noisy.ts"; @@ -977,9 +977,7 @@ export function subslices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi if (_45 === 0) { pokeWords(0, rs.sliceRange(rs.sliceFrom(words.items), a, b)); pokePairs(0, rs.sliceRange(rs.sliceFrom(pairs.items), a, b)); - const part5 = rs.min(a, 5); - const part6 = rs.min(b, 5); - pokeArray(rs.sliceRange(rs.sliceFrom(array), part5, part6)); + pokeArray(rs.sliceRange(rs.sliceFrom(array), rs.min(a, 5), rs.min(b, 5))); } else if (_45 === 1) { pokeWords(1, rs.sliceRange(rs.sliceFrom(words.items), 0, b)); pokeWords(2, rs.sliceRange(rs.sliceFrom(words.items), a)); @@ -1093,10 +1091,11 @@ export function subslices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi if (_271.length >= 1) { pokePairs(10, rs.sliceRange(_271, 0, _271.length - 1)); } - const view = rs.arrayView(array, 1, 5); - pokeArray(rs.sliceFrom(view)); - view[3] = 7; - rs.sliceSwap(rs.sliceFrom(rs.arrayView(array, 1, 4)), 0, 2); + const _278: rs.Slice = rs.sliceFrom(array); + pokeArray(rs.sliceRange(_278, 1, 5)); + const slice3 = rs.sliceRange(_278, 1, 5); + slice3.data[slice3.start + 3] = 7; + rs.sliceSwap(rs.sliceRange(rs.sliceFrom(array), 1, 4), 0, 2); } else if (_45 === 7) { const n4: rs.usize = words.items.length; const _292: [rs.usize, rs.usize] = [rs.min(rs.min(a, b), n4), rs.min(rs.max(a, b), n4)]; @@ -1379,24 +1378,23 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _47: rs.u8 = rs.u8Rem(kind, 8); if (_47 === 0) { const _53: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const slice12 = rs.byteVecSlice(bytes); - const bounds26 = rs.sliceIndexBounds(_53, slice12.length); - rs.byteVecPush(out, digest(rs.byteSliceRange(slice12, bounds26[0], bounds26[1]))); + const slice11 = rs.byteVecSlice(bytes); + const bounds26 = rs.sliceIndexBounds(_53, slice11.length); + rs.byteVecPush(out, digest(rs.byteSliceRange(slice11, bounds26[0], bounds26[1]))); const _58: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const slice13 = rs.sliceFrom(words.items); - const bounds27 = rs.sliceIndexBounds(_58, slice13.length); - rs.byteVecPush(out, digestWords(rs.sliceRange(slice13, bounds27[0], bounds27[1]))); - const slice14 = rs.sliceFrom(pairs.items); - const bounds28 = rs.sliceIndexBounds({ end: b, inclusive: true }, slice14.length); - rs.byteVecPush(out, digestPairs(rs.sliceRange(slice14, bounds28[0], bounds28[1]))); - const _70: rs.RangeInclusive = new rs.RangeInclusive(rs.min(a, 4), rs.min(b, 4), rs.usizeStep); - const slice15 = rs.sliceFrom(array); - const bounds29 = rs.sliceIndexBounds(_70, slice15.length); - const part7 = rs.sliceRange(slice15, bounds29[0], bounds29[1]); - rs.byteVecPush(out, _46(part7)); - const slice16 = rs.byteSliceRange(data, 2); - const bounds30 = rs.sliceIndexBounds({ end: b, inclusive: true }, slice16.length); - rs.byteVecPush(out, digest(rs.byteSliceRange(slice16, bounds30[0], bounds30[1]))); + const slice12 = rs.sliceFrom(words.items); + const bounds27 = rs.sliceIndexBounds(_58, slice12.length); + rs.byteVecPush(out, digestWords(rs.sliceRange(slice12, bounds27[0], bounds27[1]))); + const slice13 = rs.sliceFrom(pairs.items); + const bounds28 = rs.sliceIndexBounds({ end: b, inclusive: true }, slice13.length); + rs.byteVecPush(out, digestPairs(rs.sliceRange(slice13, bounds28[0], bounds28[1]))); + const _69: rs.Slice = rs.sliceFrom(array); + const bounds29 = rs.sliceIndexBounds(new rs.RangeInclusive(rs.min(a, 4), rs.min(b, 4), rs.usizeStep), _69.length); + const part6 = rs.sliceRange(_69, bounds29[0], bounds29[1]); + rs.byteVecPush(out, _46(part6)); + const slice14 = rs.byteSliceRange(data, 2); + const bounds30 = rs.sliceIndexBounds({ end: b, inclusive: true }, slice14.length); + rs.byteVecPush(out, digest(rs.byteSliceRange(slice14, bounds30[0], bounds30[1]))); } else if (_47 === 1) { const _79: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); const slice8 = rs.byteVecSlice(bytes); @@ -1412,10 +1410,10 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const slice10 = rs.sliceFrom(pairs.items); const bounds23 = rs.sliceIndexBounds(_92, slice10.length); pokePairs(1, rs.sliceRange(slice10, bounds23[0], bounds23[1])); + const _95: rs.Slice = rs.sliceFrom(array); const _96: { end: rs.usize; inclusive: true } = { end: rs.min(b, 4), inclusive: true }; - const slice11 = rs.sliceFrom(array); - const bounds24 = rs.sliceIndexBounds(_96, slice11.length); - pokeArray(rs.sliceRange(slice11, bounds24[0], bounds24[1])); + const bounds24 = rs.sliceIndexBounds(_96, _95.length); + pokeArray(rs.sliceRange(_95, bounds24[0], bounds24[1])); const s: rs.Slice = rs.sliceFrom(words.items); const bounds25 = rs.sliceIndexBounds(new rs.RangeInclusive(a, b, rs.usizeStep), s.length); pokeWords(2, rs.sliceRange(s, bounds25[0], bounds25[1])); @@ -1621,8 +1619,8 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const bounds11 = rs.sliceIndexBounds(_328, slice6.length); rs.byteVecPush(out, digest(rs.byteSliceRange(slice6, bounds11[0], bounds11[1]))); } else if (_47 === 5) { - const part5 = rs.byteSliceRange(data, 2).length & 0xff; - const _333: rs.RangeBound = _329(a, part5); + const part4 = rs.byteSliceRange(data, 2).length & 0xff; + const _333: rs.RangeBound = _329(a, part4); const _332: [rs.RangeBound, rs.RangeBound] = [_333, _329(b, rs.u8Div(kind, 8))]; const lo: rs.RangeBound = _333; const hi: rs.RangeBound = _332[1]; @@ -1669,14 +1667,14 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(rs.byteSliceLastChunk(rs.byteSliceRange(data, 2), 4), (c5: rs.ByteSlice): rs.u8 => { return digest(c5); })), undefined, true); - rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(rs.sliceFirstChunk(rs.sliceFrom(words.items), 4), (c6: rs.u16[]): rs.u8 => { - return digestWords(rs.sliceFrom(c6)); + rs.iterExtendBytes(out, rs.iterOption(option_map$0duedp1(rs.sliceGetRange(rs.sliceFrom(words.items), 0, 4), (c6: rs.Slice): rs.u8 => { + return digestWords(c6); })), undefined, true); - rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(rs.sliceLastChunk(rs.sliceFrom(words.items), 0), (c7: rs.u16[]): rs.u8 => { - return digestWords(rs.sliceFrom(c7)); + rs.iterExtendBytes(out, rs.iterOption(option_map$0duedp1(rs.sliceLastChunk(rs.sliceFrom(words.items), 0), (c7: rs.Slice): rs.u8 => { + return digestWords(c7); })), undefined, true); - rs.iterExtendBytes(out, rs.iterOption(option_map$0k54dqg(rs.sliceLastChunk(rs.sliceFrom(pairs.items), 3), (c8: Pair.Pair[]): rs.u8 => { - return digestPairs(rs.sliceFrom(c8)); + rs.iterExtendBytes(out, rs.iterOption(option_map$1uud0v7(rs.sliceLastChunk(rs.sliceFrom(pairs.items), 3), (c8: rs.Slice): rs.u8 => { + return digestPairs(c8); })), undefined, true); const slice: rs.ByteSlice = rs.byteVecSlice(bytes); if (slice.length >= 1) { @@ -1686,19 +1684,17 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_417 !== undefined) { rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digest(_417[0]), digest(_417[1]))), undefined, true); } - const _428: [rs.u16[], rs.Slice] | undefined = rs.sliceSplitFirstChunk(rs.sliceFrom(words.items), 0); + const _428: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitAtChecked(rs.sliceFrom(words.items), 0); if (_428 !== undefined) { - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digestWords(rs.sliceFrom(_428[0])), digestWords(_428[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digestWords(_428[0]), digestWords(_428[1]))), undefined, true); } - const _439: [rs.Slice, Pair.Pair[]] | undefined = rs.sliceSplitLastChunk(rs.sliceFrom(pairs.items), 3); + const _439: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitLastChunk(rs.sliceFrom(pairs.items), 3); if (_439 !== undefined) { - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digestPairs(_439[0]), digestPairs(rs.sliceFrom(_439[1])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digestPairs(_439[0]), digestPairs(_439[1]))), undefined, true); } - const _450: [rs.Slice, rs.u32[]] | undefined = rs.sliceSplitLastChunk(rs.sliceFrom(array), 5); + const _450: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitLastChunk(rs.sliceFrom(array), 5); if (_450 !== undefined) { - const _458: rs.u8 = _46(_450[0]); - const part4 = rs.sliceFrom(_450[1]); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_458, _46(part4))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_46(_450[0]), _46(_450[1]))), undefined, true); } } else { const _465: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, 3); @@ -1711,44 +1707,44 @@ export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_478 !== undefined) { _478.data[_478.start] = _478.data[_478.start] ^ 255; } - const _485: rs.u16[] | undefined = rs.sliceFirstChunkMut(rs.sliceFrom(words.items), 4); + const _485: rs.Slice | undefined = rs.sliceGetRange(rs.sliceFrom(words.items), 0, 4); if (_485 !== undefined) { - pokeWords(10, rs.sliceFrom(_485)); + pokeWords(10, _485); } - const _492: rs.u16[] | undefined = rs.sliceLastChunkMut(rs.sliceFrom(words.items), 0); + const _492: rs.Slice | undefined = rs.sliceLastChunk(rs.sliceFrom(words.items), 0); if (_492 !== undefined) { - pokeWords(11, rs.sliceFrom(_492)); + pokeWords(11, _492); } - const _499: Pair.Pair[] | undefined = rs.sliceLastChunkMut(rs.sliceFrom(pairs.items), 3); + const _499: rs.Slice | undefined = rs.sliceLastChunk(rs.sliceFrom(pairs.items), 3); if (_499 !== undefined) { - pokePairs(12, rs.sliceFrom(_499)); - _499[0].b = 9; + pokePairs(12, _499); + _499.data[_499.start].b = 9; } const _508: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(bytes), 1); if (_508 !== undefined) { _508[0].data[_508[0].start] = _508[1].length & 0xff; rs.byteSliceView(_508[1]).reverse(); } - const _519: [rs.Slice, rs.u16[]] | undefined = rs.sliceSplitLastChunkMut(rs.sliceFrom(words.items), 4); + const _519: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitLastChunk(rs.sliceFrom(words.items), 4); if (_519 !== undefined) { pokeWords(13, _519[0]); - rs.sliceSwap(rs.sliceFrom(_519[1]), 0, 3); - _519[1][1] = 43981; + rs.sliceSwap(_519[1], 0, 3); + _519[1].data[_519[1].start + 1] = 43981; } - const _530: [Pair.Pair[], rs.Slice] | undefined = rs.sliceSplitFirstChunkMut(rs.sliceFrom(pairs.items), 0); + const _530: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitAtChecked(rs.sliceFrom(pairs.items), 0); if (_530 !== undefined) { - pokePairs(14, rs.sliceFrom(_530[0])); + pokePairs(14, _530[0]); pokePairs(15, _530[1]); } - const _539: [Pair.Pair[], rs.Slice] | undefined = rs.sliceSplitFirstChunkMut(rs.sliceFrom(pairs.items), 2); + const _539: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitAtChecked(rs.sliceFrom(pairs.items), 2); if (_539 !== undefined) { rs.idx(_539[1], 0); - rs.sliceSwapAcross(_539[0], 0, _539[1].data, _539[1].start); - _539[0][1].a = 3; + rs.sliceSwapAcross(_539[0].data, _539[0].start, _539[1].data, _539[1].start); + _539[0].data[_539[0].start + 1].a = 3; } - const _556: [rs.Slice, rs.u32[]] | undefined = rs.sliceSplitLastChunkMut(rs.sliceFrom(array), 2); + const _556: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitLastChunk(rs.sliceFrom(array), 2); if (_556 !== undefined) { - _556[1][1] = _556[0].length as rs.u32; + _556[1].data[_556[1].start + 1] = _556[0].length as rs.u32; pokeArray(_556[0]); } } @@ -1788,11 +1784,11 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const b4: rs.u8 = _29; return { a: b4, b: rs.u16Mul(b4 as rs.u16, 3) }; }), undefined, 4, true); - const counted: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_211: rs.u8): Counted.Counted => { - return { n: _211 }; + const counted: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_212: rs.u8): Counted.Counted => { + return { n: _212 }; }), undefined, 1, true); - const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_212: rs.u8): Noisy.Noisy => { - return new Noisy.Noisy(_212); + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_214: rs.u8): Noisy.Noisy => { + return new Noisy.Noisy(_214); }), undefined, 1, true); const array: rs.u32[] = Array.from({ length: 5 }, (): rs.u32 => { return 0; @@ -1833,10 +1829,9 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { flush(out); rs.sliceFill(rs.sliceFrom(items.items), new Noisy.Noisy(c & 0xff), Noisy.clone$Clone, rs.drop); flush(out); - const part17 = rs.min(a, 5); - rs.sliceFill(rs.sliceRange(rs.sliceFrom(array), part17), c as rs.u32, undefined); - const opts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_224: rs.u8): Noisy.Noisy | undefined => { - return new Noisy.Noisy(_224); + rs.sliceFill(rs.sliceRange(rs.sliceFrom(array), rs.min(a, 5)), c as rs.u32, undefined); + const opts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_225: rs.u8): Noisy.Noisy | undefined => { + return new Noisy.Noisy(_225); }), undefined, 2, true); const part18 = a; rs.sliceFill(rs.sliceRange(rs.sliceFrom(opts.items), part18), undefined as Noisy.Noisy | undefined, option_clone$1omlcob, rs.drop); @@ -1999,10 +1994,7 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { _434.b = 48879; } const part3 = a; - const _438: rs.Slice = rs.sliceRange(rs.sliceFrom(words.items), part3); - const _442: rs.u16[] = [7, 8, 9]; - const part4 = rs.min(b, 3); - rs.sliceCopyFromSlice(_438, rs.sliceRange(rs.sliceFrom(_442), 0, part4)); + rs.sliceCopyFromSlice(rs.sliceRange(rs.sliceFrom(words.items), part3), rs.sliceRange(rs.sliceFrom([7, 8, 9]), 0, rs.min(b, 3))); const part5 = a; const _446: rs.Slice = rs.sliceRange(rs.sliceFrom(items.items), part5); const part6 = rs.min(b, c); @@ -2048,16 +2040,16 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return a & 0xffff; }); } - const _507: [Counted.Counted[], rs.Slice] | undefined = rs.sliceSplitFirstChunkMut(rs.sliceFrom(counted.items), 1); + const _507: [rs.Slice, rs.Slice] | undefined = rs.sliceSplitAtChecked(rs.sliceFrom(counted.items), 1); if (_507 !== undefined) { - rs.sliceCopyFromSlice(rs.sliceFrom(_507[0]), rs.sliceRange(_507[1], 0, rs.min(1, _507[1].length))); + rs.sliceCopyFromSlice(_507[0], rs.sliceRange(_507[1], 0, rs.min(1, _507[1].length))); } flush(out); } flush(out); rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_225: rs.u16): rs.u8 => { - const w: rs.u16 = _225; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_226: rs.u16): rs.u8 => { + const w: rs.u16 = _226; return (w ^ (w >> 8)) & 0xff; }), undefined, true); rs.byteVecPush(out, digestPairs(rs.sliceFrom(pairs.items))); @@ -2067,8 +2059,8 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(items.items), (x3: Noisy.Noisy): rs.u8 => { return x3.tag; }), undefined, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(array), (_226: rs.u32): rs.u8 => { - const x4: rs.u32 = _226; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(array), (_227: rs.u32): rs.u8 => { + const x4: rs.u32 = _227; return ((x4 ^ (x4 >>> 13)) >>> 0) & 0xff; }), undefined, true); rs.dropVec(items); @@ -2113,23 +2105,23 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_28[1].length & 0xff, digest(_28[0]))), undefined, true); const _39: [rs.Slice, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(words.items), 3); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_39[0])), (c5: rs.u16[]): rs.u8 => { - return digestWords(rs.sliceFrom(c5)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_39[0])), rs.sliceFrom), (c5: rs.Slice): rs.u8 => { + return digestWords(c5); }), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_39[0].length & 0xff, digestWords(_39[1]))), undefined, true); const _52: [rs.Slice, rs.Slice] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 1); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_52[1])), (_211: rs.u16[]): rs.u8 => { - return rs.u16Shr(_211[0], 4) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_52[1])), rs.sliceFrom), (_211: rs.Slice): rs.u8 => { + return rs.u16Shr(_211.data[_211.start], 4) & 0xff; }), undefined, true); rs.byteVecPush(out, _52[0].length & 0xff); const _63: [rs.Slice, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(items.items), 3); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_63[0])), (c6: Noisy.Noisy[]): rs.u8 => { - return _11(rs.sliceFrom(c6)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_63[0])), rs.sliceFrom), (c6: rs.Slice): rs.u8 => { + return _11(c6); }), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_63[0].length & 0xff, _11(_63[1]))), undefined, true); const _80: [rs.Slice, rs.Slice] = rs.sliceAsRchunks(rs.sliceFrom(items.items), 2); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_80[1])), (c7: Noisy.Noisy[]): rs.u8 => { - return _11(rs.sliceFrom(c7)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_80[1])), rs.sliceFrom), (c7: rs.Slice): rs.u8 => { + return _11(c7); }), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_80[1].length & 0xff, _11(_80[0]))), undefined, true); } else if (_13 === 1) { @@ -2154,8 +2146,8 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, digest(_123[1])); const _155: [rs.Slice, rs.Slice] = rs.sliceAsRchunks(rs.sliceRange(rs.sliceFrom(words.items), start), 2); - rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(rs.sliceLast(_155[1]), (c: rs.u16[]): rs.u8 => { - return digestWords(rs.sliceFrom(c)); + rs.iterExtendBytes(out, rs.iterOption(option_map$0duedp1(rs.optionMap(rs.sliceLast(_155[1]), rs.sliceFrom), (c: rs.Slice): rs.u8 => { + return digestWords(c); })), undefined, true); rs.byteVecPush(out, digestWords(_155[0])); const _165: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunks(rs.byteVecSlice(bytes), 2); @@ -2175,7 +2167,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { _195.v = _195.v ^ 255; } rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - const kept2: rs.u16[] | undefined = copy$Option_array2_u16(rs.sliceFirst(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0])); + const kept2: rs.u16[] | undefined = copy$Option_array2_u16(rs.optionMap(rs.optionMap(rs.sliceFirst(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0]), rs.sliceFrom), rs.sliceItems)); const _208: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(words.items)); if (_208 !== undefined) { _208.v = _208.v ^ 65535; @@ -2292,14 +2284,15 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } rs.byteSliceFill(_16[1], 1); const _83: [rs.Slice, rs.Slice] = rs.sliceAsRchunksMut(rs.sliceFrom(words.items), 2); - const iter4: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(_83[1]))); + const iter4: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(_83[1])), rs.sliceFrom)); while (true) { - const _90: [rs.usize, rs.u16[]] | rs.Done = iter4.next(); + const _90: [rs.usize, rs.Slice] | rs.Done = iter4.next(); if (_90 === rs.DONE) { break; } - _90[1][0] = _90[1][0] ^ (_90[0] & 0xffff); - _90[1][1] = rs.intRotateLeft(_90[1][1], 3, 16, false); + _90[1].data[_90[1].start] = _90[1].data[_90[1].start] ^ (_90[0] & 0xffff); + const _97: rs.u16 = rs.intRotateLeft(_90[1].data[_90[1].start + 1], 3, 16, false); + _90[1].data[_90[1].start + 1] = _97; } rs.sliceFill(_83[0], 1, undefined); const part7 = rs.usizeDiv(data.length, 3); @@ -2312,7 +2305,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.byteSliceSwap(_110, 0, 1); } const kept: Uint8Array | undefined = copy$Option_array2_u8(rs.optionMap(rs.optionMap(rs.sliceFirst(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0]), rs.byteSliceFrom), rs.byteSliceView)); - const keptWords: rs.u16[] | undefined = copy$Option_array2_u16(rs.sliceFirst(rs.sliceAsChunksMut(rs.sliceFrom(words.items), 2)[0])); + const keptWords: rs.u16[] | undefined = copy$Option_array2_u16(rs.optionMap(rs.optionMap(rs.sliceFirst(rs.sliceAsChunksMut(rs.sliceFrom(words.items), 2)[0]), rs.sliceFrom), rs.sliceItems)); rs.byteSliceFill(rs.byteVecSlice(bytes), 9); rs.sliceFill(rs.sliceFrom(words.items), 9, undefined); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -2345,24 +2338,24 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_142[0])), rs.byteSliceFrom), (c29: rs.ByteSlice): rs.u8 => { return digest(c29); }), undefined, true); - const f3 = (c30: rs.ByteSlice): rs.u8 => { + const f12 = (c30: rs.ByteSlice): rs.u8 => { return c30.data[c30.start + 1]; }; - rs.sliceSort(_142[0], rs.keyLt((held3) => f3(rs.byteSliceFrom(held3)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 2, true); + rs.sliceSort(_142[0], rs.keyLt((held12) => f12(rs.byteSliceFrom(held12)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 2, true); rs.sliceSortUnstable(_142[0], rs.cmpLt(rs.cmpBytes), 2, true, true); - const f4 = (c31: rs.ByteSlice): rs.u8 => { + const f13 = (c31: rs.ByteSlice): rs.u8 => { return c31.data[c31.start]; }; - rs.sliceSortByCachedKey(_142[0], (held4) => f4(rs.byteSliceFrom(held4)), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); + rs.sliceSortByCachedKey(_142[0], (held13) => f13(rs.byteSliceFrom(held13)), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); const _196: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_142[0], 1); rs.idx(_196[0], 0); const _198: rs.ByteSlice = rs.byteSliceFrom(_196[0].data[_196[0].start]); const _204: rs.usize = rs.usizeSub(n, 2); rs.idx(_196[1], _204); const _203: rs.ByteSlice = rs.byteSliceFrom(_196[1].data[_196[1].start + _204]); - const swapped3 = rs.byteSliceToArray(_198); + const swapped8 = rs.byteSliceToArray(_198); _198.data.set(rs.byteSliceToArray(_203), _198.start); - _203.data.set(swapped3, _203.start); + _203.data.set(swapped8, _203.start); rs.idx(_142[0], 0); const _210: rs.ByteSlice = rs.byteSliceFrom(_142[0].data[_142[0].start]); const old13 = rs.byteSliceToArray(_210); @@ -2391,9 +2384,11 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else if (_12 === 2) { const _253: [rs.Slice, rs.Slice] = rs.sliceAsRchunksMut(rs.sliceFrom(words.items), 2); if (_253[1].length >= 2) { - const _263: [rs.u16[], rs.u16[]] = [copy$array_u16(_253[1].data[_253[1].start]), copy$array_u16(_253[1].data[_253[1].start + (_253[1].length - 1)])]; - const first3: rs.u16[] = _263[0]; - const last3: rs.u16[] = _263[1]; + const first3: rs.Slice = rs.sliceFrom(_253[1].data[_253[1].start]); + const last3: rs.Slice = rs.sliceFrom(_253[1].data[_253[1].start + (_253[1].length - 1)]); + const _263: [rs.u16[], rs.u16[]] = [rs.sliceToArray(first3), rs.sliceToArray(last3)]; + const first4: rs.u16[] = _263[0]; + const last4: rs.u16[] = _263[1]; rs.sliceSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1)); rs.sliceReverse(_253[1]); const n2: rs.usize = _253[1].length; @@ -2405,27 +2400,31 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const kept4: rs.u16[] = copy$array_u16(_253[1].data[_253[1].start + _282]); const _288: { end: rs.usize } = { end: rs.usizeSub(n2, 1) }; rs.sliceCopyWithin(_253[1], 0, _288.end, 1, copy$array_u16); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([first3, last3, kept4]), (c3: rs.u16[]): rs.u8 => { - return digestWords(rs.sliceFrom(c3)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([first4, last4, kept4]), rs.sliceFrom), (c3: rs.Slice): rs.u8 => { + return digestWords(c3); }), undefined, true); rs.sliceSort(_253[1], rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_253[1])), (c4: rs.u16[]): rs.u8 => { - return digestWords(rs.sliceFrom(c4)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_253[1])), rs.sliceFrom), (c4: rs.Slice): rs.u8 => { + return digestWords(c4); }), undefined, true); - rs.sliceSort(_253[1], rs.keyLt((c5: rs.u16[]): rs.u16 => { - return c5[1]; - }, rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true); + const f2 = (c5: rs.Slice): rs.u16 => { + return c5.data[c5.start + 1]; + }; + rs.sliceSort(_253[1], rs.keyLt((held2) => f2(rs.sliceFrom(held2)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true); rs.sliceSortUnstable(_253[1], rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true, true); - rs.sliceSortByCachedKey(_253[1], (c6: rs.u16[]): rs.u16 => { - return c6[0]; - }, rs.cmpLt(rs.cmpTuple<[rs.u16, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); + const f3 = (c6: rs.Slice): rs.u16 => { + return c6.data[c6.start]; + }; + rs.sliceSortByCachedKey(_253[1], (held3) => f3(rs.sliceFrom(held3)), rs.cmpLt(rs.cmpTuple<[rs.u16, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); const _307: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_253[1], 1); rs.idx(_307[0], 0); + const _309: rs.Slice = rs.sliceFrom(_307[0].data[_307[0].start]); const _315: rs.usize = rs.usizeSub(n2, 2); rs.idx(_307[1], _315); - rs.sliceSwapAcross(_307[0].data, _307[0].start, _307[1].data, _307[1].start + _315); + const _314: rs.Slice = rs.sliceFrom(_307[1].data[_307[1].start + _315]); + rs.sliceSet(_314, rs.replaceIn(rs.sliceView(_309), rs.sliceToArray(_314))); rs.idx(_253[1], 0); - const old2: rs.u16[] = rs.sliceReplace(_253[1].data, _253[1].start, [7, 8]); + const old2: rs.u16[] = rs.replaceIn(rs.sliceView(rs.sliceFrom(_253[1].data[_253[1].start])), [7, 8]); const _327: rs.usize = rs.usizeSub(n2, 1); rs.idx(_253[1], _327); _253[1].data[_253[1].start + _327] = copy$array_u16(old2); @@ -2437,22 +2436,22 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi _253[1].data[_253[1].start + 1] = _337; rs.idx(_253[1], 0); _253[1].data[_253[1].start] = copy$array_u16(kept5); - const _350: rs.u16[] | undefined = rs.sliceLast(_253[1]); + const _350: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_253[1]), rs.sliceFrom); if (_350 !== undefined) { - Object.assign(_350, [9, 10]); + rs.sliceSet(_350, [9, 10]); } - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_253[1])), (c7: rs.u16[]): rs.u8 => { - return digestWords(rs.sliceFrom(c7)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_253[1])), rs.sliceFrom), (c7: rs.Slice): rs.u8 => { + return digestWords(c7); }), undefined, true); rs.sliceFill(rs.sliceRange(_253[1], rs.usizeDiv(n2, 2)), [9, 10], copy$array_u16); } const _364: [rs.ByteSlice, rs.Slice] = rs.byteSliceAsRchunksMut(rs.byteVecSlice(bytes), 4); if (_364[1].length >= 2) { - const first4: rs.ByteSlice = rs.byteSliceFrom(_364[1].data[_364[1].start]); - const last4: rs.ByteSlice = rs.byteSliceFrom(_364[1].data[_364[1].start + (_364[1].length - 1)]); - const _374: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(first4), rs.byteSliceToArray(last4)]; - const first5: Uint8Array = copy$array_u8(_374[0]); - const last5: Uint8Array = copy$array_u8(_374[1]); + const first5: rs.ByteSlice = rs.byteSliceFrom(_364[1].data[_364[1].start]); + const last5: rs.ByteSlice = rs.byteSliceFrom(_364[1].data[_364[1].start + (_364[1].length - 1)]); + const _374: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(first5), rs.byteSliceToArray(last5)]; + const first6: Uint8Array = copy$array_u8(_374[0]); + const last6: Uint8Array = copy$array_u8(_374[1]); rs.sliceSwap(_364[1], 0, rs.usizeSub(_364[1].length, 1)); rs.sliceReverse(_364[1]); const n3: rs.usize = _364[1].length; @@ -2464,31 +2463,31 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const kept6: Uint8Array = copy$array_u8(_364[1].data[_364[1].start + _393]); const _399: { end: rs.usize } = { end: rs.usizeSub(n3, 1) }; rs.sliceCopyWithin(_364[1], 0, _399.end, 1, copy$array_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([copy$array_u8(first5), copy$array_u8(last5), copy$array_u8(kept6)]), rs.byteSliceFrom), (c8: rs.ByteSlice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([copy$array_u8(first6), copy$array_u8(last6), copy$array_u8(kept6)]), rs.byteSliceFrom), (c8: rs.ByteSlice): rs.u8 => { return digest(c8); }), undefined, true); rs.sliceSort(_364[1], rs.cmpLt(rs.cmpBytes), 4, true); rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_364[1])), rs.byteSliceFrom), (c9: rs.ByteSlice): rs.u8 => { return digest(c9); }), undefined, true); - const f = (c10: rs.ByteSlice): rs.u8 => { + const f4 = (c10: rs.ByteSlice): rs.u8 => { return c10.data[c10.start + 1]; }; - rs.sliceSort(_364[1], rs.keyLt((held) => f(rs.byteSliceFrom(held)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true); + rs.sliceSort(_364[1], rs.keyLt((held4) => f4(rs.byteSliceFrom(held4)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true); rs.sliceSortUnstable(_364[1], rs.cmpLt(rs.cmpBytes), 4, true, true); - const f2 = (c11: rs.ByteSlice): rs.u8 => { + const f5 = (c11: rs.ByteSlice): rs.u8 => { return c11.data[c11.start]; }; - rs.sliceSortByCachedKey(_364[1], (held2) => f2(rs.byteSliceFrom(held2)), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); + rs.sliceSortByCachedKey(_364[1], (held5) => f5(rs.byteSliceFrom(held5)), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); const _418: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_364[1], 1); rs.idx(_418[0], 0); const _420: rs.ByteSlice = rs.byteSliceFrom(_418[0].data[_418[0].start]); const _426: rs.usize = rs.usizeSub(n3, 2); rs.idx(_418[1], _426); const _425: rs.ByteSlice = rs.byteSliceFrom(_418[1].data[_418[1].start + _426]); - const swapped2 = rs.byteSliceToArray(_420); + const swapped4 = rs.byteSliceToArray(_420); _420.data.set(rs.byteSliceToArray(_425), _420.start); - _425.data.set(swapped2, _425.start); + _425.data.set(swapped4, _425.start); rs.idx(_364[1], 0); const _432: rs.ByteSlice = rs.byteSliceFrom(_364[1].data[_364[1].start]); const old9 = rs.byteSliceToArray(_432); @@ -2516,9 +2515,11 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } const _479: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0], 2); if (_479[0].length >= 2) { - const _487: [Uint8Array[], Uint8Array[]] = [copy$array_array2_u8(_479[0].data[_479[0].start]), copy$array_array2_u8(_479[0].data[_479[0].start + (_479[0].length - 1)])]; - const first6: Uint8Array[] = copy$array_array2_u8(_487[0]); - const last6: Uint8Array[] = copy$array_array2_u8(_487[1]); + const first7: rs.Slice = rs.sliceFrom(_479[0].data[_479[0].start]); + const last7: rs.Slice = rs.sliceFrom(_479[0].data[_479[0].start + (_479[0].length - 1)]); + const _487: [Uint8Array[], Uint8Array[]] = [rs.sliceToArray(first7, copy$array_u8), rs.sliceToArray(last7, copy$array_u8)]; + const first8: Uint8Array[] = copy$array_array2_u8(_487[0]); + const last8: Uint8Array[] = copy$array_array2_u8(_487[1]); rs.sliceSwap(_479[0], 0, rs.usizeSub(_479[0].length, 1)); rs.sliceReverse(_479[0]); const n4: rs.usize = _479[0].length; @@ -2530,27 +2531,33 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const kept8: Uint8Array[] = copy$array_array2_u8(_479[0].data[_479[0].start + _506]); const _512: { end: rs.usize } = { end: rs.usizeSub(n4, 1) }; rs.sliceCopyWithin(_479[0], 0, _512.end, 1, copy$array_array2_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([copy$array_array2_u8(first6), copy$array_array2_u8(last6), copy$array_array2_u8(kept8)]), (c13: Uint8Array[]): rs.u8 => { - return c13[0][0] ^ c13[1][1]; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([copy$array_array2_u8(first8), copy$array_array2_u8(last8), copy$array_array2_u8(kept8)]), rs.sliceFrom), (c13: rs.Slice): rs.u8 => { + return c13.data[c13.start][0] ^ c13.data[c13.start + 1][1]; }), undefined, true); rs.sliceSort(_479[0], rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_479[0])), (c14: Uint8Array[]): rs.u8 => { - return c14[0][0] ^ c14[1][1]; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_479[0])), rs.sliceFrom), (c14: rs.Slice): rs.u8 => { + return c14.data[c14.start][0] ^ c14.data[c14.start + 1][1]; }), undefined, true); - rs.sliceSort(_479[0], rs.keyLt((c15: Uint8Array[]): Uint8Array => { - return copy$array_u8(c15[1]); - }, rs.cmpLt(rs.cmpReverse(rs.cmpBytes))), 4, true); + const f6 = (c15: rs.Slice): Uint8Array => { + return copy$array_u8(c15.data[c15.start + 1]); + }; + rs.sliceSort(_479[0], rs.keyLt((held6) => f6(rs.sliceFrom(held6)), rs.cmpLt(rs.cmpReverse(rs.cmpBytes))), 4, true); rs.sliceSortUnstable(_479[0], rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true, true); - rs.sliceSortByCachedKey(_479[0], (c16: Uint8Array[]): Uint8Array => { - return copy$array_u8(c16[0]); - }, rs.cmpLt(rs.cmpTuple<[Uint8Array, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpBytes), rs.cmp])), 8, true, true); + const f7 = (c16: rs.Slice): Uint8Array => { + return copy$array_u8(c16.data[c16.start]); + }; + rs.sliceSortByCachedKey(_479[0], (held7) => f7(rs.sliceFrom(held7)), rs.cmpLt(rs.cmpTuple<[Uint8Array, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpBytes), rs.cmp])), 8, true, true); const _531: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_479[0], 1); rs.idx(_531[0], 0); + const _533: rs.Slice = rs.sliceFrom(_531[0].data[_531[0].start]); const _539: rs.usize = rs.usizeSub(n4, 2); rs.idx(_531[1], _539); - rs.sliceSwapAcross(_531[0].data, _531[0].start, _531[1].data, _531[1].start + _539, 1); + const _538: rs.Slice = rs.sliceFrom(_531[1].data[_531[1].start + _539]); + rs.sliceSet(_538, rs.replaceIn(rs.sliceView(_533), rs.sliceToArray(_538, copy$array_u8), 1)); rs.idx(_479[0], 0); - const old4: Uint8Array[] = rs.sliceReplace(_479[0].data, _479[0].start, [Uint8Array.of(1, 2), Uint8Array.of(3, 4)], 1); + const _545: rs.Slice = rs.sliceFrom(_479[0].data[_479[0].start]); + const _550: Uint8Array[] = [Uint8Array.of(1, 2), Uint8Array.of(3, 4)]; + const old4: Uint8Array[] = rs.replaceIn(rs.sliceView(_545), _550, 1); const _553: rs.usize = rs.usizeSub(n4, 1); rs.idx(_479[0], _553); _479[0].data[_479[0].start + _553] = copy$array_array2_u8(old4); @@ -2562,21 +2569,23 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi _479[0].data[_479[0].start + 1] = _563; rs.idx(_479[0], 0); _479[0].data[_479[0].start] = copy$array_array2_u8(kept9); - const _576: Uint8Array[] | undefined = rs.sliceLast(_479[0]); + const _576: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_479[0]), rs.sliceFrom); if (_576 !== undefined) { - Object.assign(_576, [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]); + rs.sliceSet(_576, [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]); } - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_479[0])), (c17: Uint8Array[]): rs.u8 => { - return c17[0][0] ^ c17[1][1]; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_479[0])), rs.sliceFrom), (c17: rs.Slice): rs.u8 => { + return c17.data[c17.start][0] ^ c17.data[c17.start + 1][1]; }), undefined, true); rs.sliceFill(rs.sliceRange(_479[0], rs.usizeDiv(n4, 2)), [Uint8Array.of(5, 6), Uint8Array.of(7, 8)], copy$array_array2_u8); } const _600: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.sliceAsChunksMut(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0], 2)[0], 2); const one: Uint8Array[][] = [[Uint8Array.of(1, 2), Uint8Array.of(3, 4)], [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]]; if (_600[0].length >= 2) { - const _615: [Uint8Array[][], Uint8Array[][]] = [copy$array_array2_array2_u8(_600[0].data[_600[0].start]), copy$array_array2_array2_u8(_600[0].data[_600[0].start + (_600[0].length - 1)])]; - const first7: Uint8Array[][] = copy$array_array2_array2_u8(_615[0]); - const last7: Uint8Array[][] = copy$array_array2_array2_u8(_615[1]); + const first9: rs.Slice = rs.sliceFrom(_600[0].data[_600[0].start]); + const last9: rs.Slice = rs.sliceFrom(_600[0].data[_600[0].start + (_600[0].length - 1)]); + const _615: [Uint8Array[][], Uint8Array[][]] = [rs.sliceToArray(first9, copy$array_array2_u8), rs.sliceToArray(last9, copy$array_array2_u8)]; + const first10: Uint8Array[][] = copy$array_array2_array2_u8(_615[0]); + const last10: Uint8Array[][] = copy$array_array2_array2_u8(_615[1]); rs.sliceSwap(_600[0], 0, rs.usizeSub(_600[0].length, 1)); rs.sliceReverse(_600[0]); const n5: rs.usize = _600[0].length; @@ -2588,27 +2597,31 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const kept10: Uint8Array[][] = copy$array_array2_array2_u8(_600[0].data[_600[0].start + _634]); const _640: { end: rs.usize } = { end: rs.usizeSub(n5, 1) }; rs.sliceCopyWithin(_600[0], 0, _640.end, 1, copy$array_array2_array2_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([copy$array_array2_array2_u8(first7), copy$array_array2_array2_u8(last7), copy$array_array2_array2_u8(kept10)]), (c18: Uint8Array[][]): rs.u8 => { - return c18[0][0][0] ^ c18[1][1][1]; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([copy$array_array2_array2_u8(first10), copy$array_array2_array2_u8(last10), copy$array_array2_array2_u8(kept10)]), rs.sliceFrom), (c18: rs.Slice): rs.u8 => { + return c18.data[c18.start][0][0] ^ c18.data[c18.start + 1][1][1]; }), undefined, true); rs.sliceSort(_600[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_600[0])), (c19: Uint8Array[][]): rs.u8 => { - return c19[0][0][0] ^ c19[1][1][1]; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_600[0])), rs.sliceFrom), (c19: rs.Slice): rs.u8 => { + return c19.data[c19.start][0][0] ^ c19.data[c19.start + 1][1][1]; }), undefined, true); - rs.sliceSort(_600[0], rs.keyLt((c20: Uint8Array[][]): Uint8Array[] => { - return copy$array_array2_u8(c20[1]); - }, rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)))), 8, true); + const f8 = (c20: rs.Slice): Uint8Array[] => { + return copy$array_array2_u8(c20.data[c20.start + 1]); + }; + rs.sliceSort(_600[0], rs.keyLt((held8) => f8(rs.sliceFrom(held8)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)))), 8, true); rs.sliceSortUnstable(_600[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true, true); - rs.sliceSortByCachedKey(_600[0], (c21: Uint8Array[][]): Uint8Array[] => { - return copy$array_array2_u8(c21[0]); - }, rs.cmpLt(rs.cmpTuple<[Uint8Array[], rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)), rs.cmp])), 8, true, true); + const f9 = (c21: rs.Slice): Uint8Array[] => { + return copy$array_array2_u8(c21.data[c21.start]); + }; + rs.sliceSortByCachedKey(_600[0], (held9) => f9(rs.sliceFrom(held9)), rs.cmpLt(rs.cmpTuple<[Uint8Array[], rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)), rs.cmp])), 8, true, true); const _659: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_600[0], 1); rs.idx(_659[0], 0); + const _661: rs.Slice = rs.sliceFrom(_659[0].data[_659[0].start]); const _667: rs.usize = rs.usizeSub(n5, 2); rs.idx(_659[1], _667); - rs.sliceSwapAcross(_659[0].data, _659[0].start, _659[1].data, _659[1].start + _667, 2); + const _666: rs.Slice = rs.sliceFrom(_659[1].data[_659[1].start + _667]); + rs.sliceSet(_666, rs.replaceIn(rs.sliceView(_661), rs.sliceToArray(_666, copy$array_array2_u8), 2)); rs.idx(_600[0], 0); - const old5: Uint8Array[][] = rs.sliceReplace(_600[0].data, _600[0].start, copy$array_array2_array2_u8(one), 2); + const old5: Uint8Array[][] = rs.replaceIn(rs.sliceView(rs.sliceFrom(_600[0].data[_600[0].start])), copy$array_array2_array2_u8(one), 2); const _678: rs.usize = rs.usizeSub(n5, 1); rs.idx(_600[0], _678); _600[0].data[_600[0].start + _678] = copy$array_array2_array2_u8(old5); @@ -2620,18 +2633,18 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi _600[0].data[_600[0].start + 1] = _688; rs.idx(_600[0], 0); _600[0].data[_600[0].start] = copy$array_array2_array2_u8(kept11); - const _701: Uint8Array[][] | undefined = rs.sliceLast(_600[0]); + const _701: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_600[0]), rs.sliceFrom); if (_701 !== undefined) { const _705: Uint8Array = rs.bytes(2).fill(9); const item = copy$array_array2_u8(Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_705); })); - Object.assign(_701, Array.from({ length: 2 }, (): Uint8Array[] => { + rs.sliceSet(_701, Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array2_u8(item); })); } - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_600[0])), (c22: Uint8Array[][]): rs.u8 => { - return c22[0][0][0] ^ c22[1][1][1]; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_600[0])), rs.sliceFrom), (c22: rs.Slice): rs.u8 => { + return c22.data[c22.start][0][0] ^ c22.data[c22.start + 1][1][1]; }), undefined, true); const _711: rs.Slice = rs.sliceRange(_600[0], rs.usizeDiv(n5, 2)); const _717: Uint8Array = rs.bytes(2).fill(9); @@ -2666,9 +2679,11 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi }), undefined, true); const _760: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.sliceAsChunksMut(rs.sliceFrom(words.items), 2)[0], 2); if (_760[0].length >= 2) { - const _768: [rs.u16[][], rs.u16[][]] = [copy$array_array2_u16(_760[0].data[_760[0].start]), copy$array_array2_u16(_760[0].data[_760[0].start + (_760[0].length - 1)])]; - const first8: rs.u16[][] = _768[0]; - const last8: rs.u16[][] = _768[1]; + const first11: rs.Slice = rs.sliceFrom(_760[0].data[_760[0].start]); + const last11: rs.Slice = rs.sliceFrom(_760[0].data[_760[0].start + (_760[0].length - 1)]); + const _768: [rs.u16[][], rs.u16[][]] = [rs.sliceToArray(first11, copy$array_u16), rs.sliceToArray(last11, copy$array_u16)]; + const first12: rs.u16[][] = _768[0]; + const last12: rs.u16[][] = _768[1]; rs.sliceSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1)); rs.sliceReverse(_760[0]); const n6: rs.usize = _760[0].length; @@ -2680,27 +2695,33 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const kept12: rs.u16[][] = copy$array_array2_u16(_760[0].data[_760[0].start + _787]); const _793: { end: rs.usize } = { end: rs.usizeSub(n6, 1) }; rs.sliceCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([first8, last8, kept12]), (c23: rs.u16[][]): rs.u8 => { - return (c23[0][0] ^ c23[1][1]) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([first12, last12, kept12]), rs.sliceFrom), (c23: rs.Slice): rs.u8 => { + return (c23.data[c23.start][0] ^ c23.data[c23.start + 1][1]) & 0xff; }), undefined, true); rs.sliceSort(_760[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_760[0])), (c24: rs.u16[][]): rs.u8 => { - return (c24[0][0] ^ c24[1][1]) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_760[0])), rs.sliceFrom), (c24: rs.Slice): rs.u8 => { + return (c24.data[c24.start][0] ^ c24.data[c24.start + 1][1]) & 0xff; }), undefined, true); - rs.sliceSort(_760[0], rs.keyLt((c25: rs.u16[][]): rs.u16[] => { - return copy$array_u16(c25[1]); - }, rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmp)))), 8, true); + const f10 = (c25: rs.Slice): rs.u16[] => { + return copy$array_u16(c25.data[c25.start + 1]); + }; + rs.sliceSort(_760[0], rs.keyLt((held10) => f10(rs.sliceFrom(held10)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmp)))), 8, true); rs.sliceSortUnstable(_760[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true, true); - rs.sliceSortByCachedKey(_760[0], (c26: rs.u16[][]): rs.u16[] => { - return copy$array_u16(c26[0]); - }, rs.cmpLt(rs.cmpTuple<[rs.u16[], rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpSlice(rs.cmp)), rs.cmp])), 8, true, true); + const f11 = (c26: rs.Slice): rs.u16[] => { + return copy$array_u16(c26.data[c26.start]); + }; + rs.sliceSortByCachedKey(_760[0], (held11) => f11(rs.sliceFrom(held11)), rs.cmpLt(rs.cmpTuple<[rs.u16[], rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpSlice(rs.cmp)), rs.cmp])), 8, true, true); const _812: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_760[0], 1); rs.idx(_812[0], 0); + const _814: rs.Slice = rs.sliceFrom(_812[0].data[_812[0].start]); const _820: rs.usize = rs.usizeSub(n6, 2); rs.idx(_812[1], _820); - rs.sliceSwapAcross(_812[0].data, _812[0].start, _812[1].data, _812[1].start + _820, 1); + const _819: rs.Slice = rs.sliceFrom(_812[1].data[_812[1].start + _820]); + rs.sliceSet(_819, rs.replaceIn(rs.sliceView(_814), rs.sliceToArray(_819, copy$array_u16), 1)); rs.idx(_760[0], 0); - const old6: rs.u16[][] = rs.sliceReplace(_760[0].data, _760[0].start, [[1, 2], [3, 4]], 1); + const _826: rs.Slice = rs.sliceFrom(_760[0].data[_760[0].start]); + const _831: rs.u16[][] = [[1, 2], [3, 4]]; + const old6: rs.u16[][] = rs.replaceIn(rs.sliceView(_826), _831, 1); const _834: rs.usize = rs.usizeSub(n6, 1); rs.idx(_760[0], _834); _760[0].data[_760[0].start + _834] = copy$array_array2_u16(old6); @@ -2712,12 +2733,12 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi _760[0].data[_760[0].start + 1] = _844; rs.idx(_760[0], 0); _760[0].data[_760[0].start] = copy$array_array2_u16(kept13); - const _857: rs.u16[][] | undefined = rs.sliceLast(_760[0]); + const _857: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_760[0]), rs.sliceFrom); if (_857 !== undefined) { - Object.assign(_857, [[5, 6], [7, 8]]); + rs.sliceSet(_857, [[5, 6], [7, 8]]); } - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_760[0])), (c27: rs.u16[][]): rs.u8 => { - return (c27[0][0] ^ c27[1][1]) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_760[0])), rs.sliceFrom), (c27: rs.Slice): rs.u8 => { + return (c27.data[c27.start][0] ^ c27.data[c27.start + 1][1]) & 0xff; }), undefined, true); rs.sliceFill(rs.sliceRange(_760[0], rs.usizeDiv(n6, 2)), [[5, 6], [7, 8]], copy$array_array2_u16); } @@ -2725,16 +2746,17 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _875: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.sliceFrom(items.items), 2); if (_875[0].length >= 2) { rs.idx(_875[0], 0); - const first9: Item.Item[] = rs.sliceReplace(_875[0].data, _875[0].start, [new Item.Item(65), new Item.Item(66)], 1); + const first13: Item.Item[] = rs.replaceIn(rs.sliceView(rs.sliceFrom(_875[0].data[_875[0].start])), [new Item.Item(65), new Item.Item(66)], 1); flush(out); rs.sliceSwap(_875[0], 0, 1); rs.sliceReverse(_875[0]); - rs.sliceSort(_875[0], rs.keyLt((c: Item.Item[]): rs.u8 => { - return c[1].tag; - }, rs.lt), 2, true); + const f = (c: rs.Slice): rs.u8 => { + return c.data[c.start + 1].tag; + }; + rs.sliceSort(_875[0], rs.keyLt((held) => f(rs.sliceFrom(held)), rs.lt), 2, true); rs.idx(_875[0], 1); rs.dropAll(_875[0].data[_875[0].start + 1]); - _875[0].data[_875[0].start + 1] = first9; + _875[0].data[_875[0].start + 1] = first13; flush(out); rs.idx(_875[0], 0); _875[0].data[_875[0].start][1][Symbol.dispose](); @@ -2742,10 +2764,12 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi flush(out); const _909: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_875[0], 1); rs.idx(_909[0], 0); + const _911: rs.Slice = rs.sliceFrom(_909[0].data[_909[0].start]); rs.idx(_909[1], 0); - rs.sliceSwapAcross(_909[0].data, _909[0].start, _909[1].data, _909[1].start, 1); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.sliceItems(_875[0])), (c2: Item.Item[]): rs.u8 => { - return _11(rs.sliceFrom(c2)); + const _916: rs.Slice = rs.sliceFrom(_909[1].data[_909[1].start]); + rs.sliceSet(_916, rs.replaceIn(rs.sliceView(_911), rs.sliceToArray(_916), 1)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_875[0])), rs.sliceFrom), (c2: rs.Slice): rs.u8 => { + return _11(c2); }), undefined, true); } } else { diff --git a/ts/fixtures/lang/sorts/expected/harness.ts b/ts/fixtures/lang/sorts/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/sorts/expected/harness.ts +++ b/ts/fixtures/lang/sorts/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/splits/expected/harness.ts b/ts/fixtures/lang/splits/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/splits/expected/harness.ts +++ b/ts/fixtures/lang/splits/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/statics/expected/harness.ts b/ts/fixtures/lang/statics/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/statics/expected/harness.ts +++ b/ts/fixtures/lang/statics/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/statics/expected/statics.ts b/ts/fixtures/lang/statics/expected/statics.ts index 7af8a195b..013c99401 100644 --- a/ts/fixtures/lang/statics/expected/statics.ts +++ b/ts/fixtures/lang/statics/expected/statics.ts @@ -341,8 +341,8 @@ export function onces(data: rs.ByteSlice, out: rs.ByteVec): void { export const SHOWN: rs.LazyLock = /* @__PURE__ */ new rs.LazyLock(shown); export function shown(): string { - const args2: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; - return rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args2[0])]); + const args3 = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; + return rs.fmtFormat([args3[0], " ", rs.fmtSpec({ alternate: true }, args3[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args3[0])]); } export const FORCING: rs.LocalKey> | undefined>> = /* @__PURE__ */ new rs.LocalKey(FORCING$init, false); @@ -364,66 +364,66 @@ export function lazies(data: rs.ByteSlice, out: rs.ByteVec): void { const cell: rs.LazyCell = new rs.LazyCell((): rs.u8 => { return rs.u8Add(rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0), 10); }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; - const before: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|"]); + const args49 = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; + const before: string = rs.fmtFormat([args49[0], " ", rs.fmtSpec({ alternate: true }, args49[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args49[0]), "|"]); const forced: rs.u8 = rs.atomicLoad(FORCED, 0); cell.force(); rs.atomicSwap(FORCED, 0, 0); - const args5: rs.Fmt[] = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; - const _34: string = rs.fmtFormat([args5[0], " ", rs.fmtSpec({ alternate: true }, args5[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args5[0]), "|"]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before), (f: rs.Formatter) => rs.u8Display(forced, f), (f: rs.Formatter) => rs.fmtPad(f, _34)]; - text = rs.fmtFormat([args6[0], args6[1], args6[2]]); + const args50 = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; + const _34: string = rs.fmtFormat([args50[0], " ", rs.fmtSpec({ alternate: true }, args50[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args50[0]), "|"]); + const args51 = [(f: rs.Formatter) => rs.fmtPad(f, before), (f: rs.Formatter) => rs.u8Display(forced, f), (f: rs.Formatter) => rs.fmtPad(f, _34)]; + text = rs.fmtFormat([args51[0], args51[1], args51[2]]); } else if (_10 === 1) { const cell2: rs.LazyCell = new rs.LazyCell((): undefined => {}); - const args8: rs.Fmt[] = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; - const before2: string = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args8[0]), "|"]); + const args46 = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; + const before2: string = rs.fmtFormat([args46[0], " ", rs.fmtSpec({ alternate: true }, args46[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args46[0]), "|"]); cell2.force(); - const args11: rs.Fmt[] = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; - const _67: string = rs.fmtFormat([args11[0], " ", rs.fmtSpec({ alternate: true }, args11[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args11[0]), "|"]); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before2), (f: rs.Formatter) => rs.fmtPad(f, _67)]; - text = rs.fmtFormat([args12[0], args12[1]]); + const args47 = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; + const _67: string = rs.fmtFormat([args47[0], " ", rs.fmtSpec({ alternate: true }, args47[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args47[0]), "|"]); + const args48 = [(f: rs.Formatter) => rs.fmtPad(f, before2), (f: rs.Formatter) => rs.fmtPad(f, _67)]; + text = rs.fmtFormat([args48[0], args48[1]]); } else if (_10 === 2) { const lock: rs.LazyLock = new rs.LazyLock((): rs.u8 | undefined => { return undefined; }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - const before3: string = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args14[0]), "|"]); + const args43 = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + const before3: string = rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args43[0]), "|"]); lock.force(); - const args17: rs.Fmt[] = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - const _98: string = rs.fmtFormat([args17[0], " ", rs.fmtSpec({ alternate: true }, args17[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args17[0]), "|"]); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before3), (f: rs.Formatter) => rs.fmtPad(f, _98)]; - text = rs.fmtFormat([args18[0], args18[1]]); + const args44 = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + const _98: string = rs.fmtFormat([args44[0], " ", rs.fmtSpec({ alternate: true }, args44[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args44[0]), "|"]); + const args45 = [(f: rs.Formatter) => rs.fmtPad(f, before3), (f: rs.Formatter) => rs.fmtPad(f, _98)]; + text = rs.fmtFormat([args45[0], args45[1]]); } else if (_10 === 3) { const lock2: rs.LazyLock> = new rs.LazyLock((): rs.Vec => { return rs.vecFrom(["a", "bc"]); }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; - const before4: string = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args20[0]), "|"]); + const args40 = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; + const before4: string = rs.fmtFormat([args40[0], " ", rs.fmtSpec({ alternate: true }, args40[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args40[0]), "|"]); lock2.force().items.length; - const args23: rs.Fmt[] = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; - const _130: string = rs.fmtFormat([args23[0], " ", rs.fmtSpec({ alternate: true }, args23[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args23[0]), "|"]); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before4), (f: rs.Formatter) => rs.fmtPad(f, _130)]; - text = rs.fmtFormat([args24[0], args24[1]]); + const args41 = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; + const _130: string = rs.fmtFormat([args41[0], " ", rs.fmtSpec({ alternate: true }, args41[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args41[0]), "|"]); + const args42 = [(f: rs.Formatter) => rs.fmtPad(f, before4), (f: rs.Formatter) => rs.fmtPad(f, _130)]; + text = rs.fmtFormat([args42[0], args42[1]]); } else if (_10 === 4) { const _148: string = SHOWN.force(); - const args27: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; - const _151: string = rs.fmtFormat([args27[0], " ", rs.fmtSpec({ alternate: true }, args27[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args27[0]), "|"]); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _148), (f: rs.Formatter) => rs.fmtPad(f, _151)]; - text = rs.fmtFormat([args28[0], " ", args28[1]]); + const args38 = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; + const _151: string = rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args38[0]), "|"]); + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, _148), (f: rs.Formatter) => rs.fmtPad(f, _151)]; + text = rs.fmtFormat([args39[0], " ", args39[1]]); } else { const cell3: rs.Arc> = new rs.Arc(new rs.LazyCell((): string => { return withBorrow$03hv9ge(FORCING, (me: rs.Arc> | undefined): string => { const part = rs.optionUnwrap(me); - const args34: rs.Fmt[] = [(f: rs.Formatter) => part.value.debug(f, "LazyCell", rs.fmtStr)]; - return rs.fmtFormat([args34[0], " ", rs.fmtSpec({ alternate: true }, args34[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args34[0]), "|"]); + const args35 = [(f: rs.Formatter) => part.value.debug(f, "LazyCell", rs.fmtStr)]; + return rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args35[0]), "|"]); }); })); rs.localKeyRefCellSet(FORCING, rs.arcClone(cell3), rs.drop); const _175: string = cell3.value.force(); - const args31: rs.Fmt[] = [(f: rs.Formatter) => cell3.value.debug(f, "LazyCell", rs.fmtStr)]; - const _179: string = rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args31[0]), "|"]); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _175), (f: rs.Formatter) => rs.fmtPad(f, _179)]; - const text2: string = rs.fmtFormat([args32[0], " ", args32[1]]); + const args36 = [(f: rs.Formatter) => cell3.value.debug(f, "LazyCell", rs.fmtStr)]; + const _179: string = rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args36[0]), "|"]); + const args37 = [(f: rs.Formatter) => rs.fmtPad(f, _175), (f: rs.Formatter) => rs.fmtPad(f, _179)]; + const text2: string = rs.fmtFormat([args37[0], " ", args37[1]]); rs.drop(take$1ni7uux(FORCING)); text = text2; cell3[Symbol.dispose](); @@ -501,8 +501,7 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyCell, out: rs.ByteVec): void { const _18: (a0: rs.LazyCell) => string = (l: rs.LazyCell): string => { - const args2: rs.Fmt[] = [(f: rs.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; - return rs.fmtFormat([args2[0], "|"]); + return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); }; let _103: boolean = false; let a: rs.LazyCell = make(1); @@ -568,8 +567,7 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyLock, out: rs.ByteVec): void { const _18: (a0: rs.LazyLock) => string = (l: rs.LazyLock): string => { - const args2: rs.Fmt[] = [(f: rs.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; - return rs.fmtFormat([args2[0], "|"]); + return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); }; let _103: boolean = false; let a: rs.LazyLock = make(1); diff --git a/ts/fixtures/lang/strs/expected/core/num.ts b/ts/fixtures/lang/strs/expected/core/num.ts index da3da54fc..9d86f12bc 100644 --- a/ts/fixtures/lang/strs/expected/core/num.ts +++ b/ts/fixtures/lang/strs/expected/core/num.ts @@ -39,16 +39,15 @@ export function canNotOverflow$0bdyog2(radix: rs.u32, isSignedTy: boolean, _digi } export function fromAsciiBytesRadixPanic(radix: rs.u32): never { - doPanic$16ya8t2(radix); + doPanic$1tugyvz(radix); } -export function doPanic$16ya8t2(radix: rs.u32): never { - runtime$0o4i17s(radix); +export function doPanic$1tugyvz(radix: rs.u32): never { + runtime$09k496w(radix); } -export function runtime$0o4i17s(radix: rs.u32): never { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(radix, f)]; - rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); +export function runtime$09k496w(radix: rs.u32): never { + rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", (f: rs.Formatter) => rs.u32Display(radix, f)]); } export function fromAsciiBytesRadixImpl$1r0rye7(src: rs.ByteSlice, radix: rs.u32): rs.Result { diff --git a/ts/fixtures/lang/strs/expected/harness.ts b/ts/fixtures/lang/strs/expected/harness.ts index 78fad7cd8..4bb0dfa08 100644 --- a/ts/fixtures/lang/strs/expected/harness.ts +++ b/ts/fixtures/lang/strs/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 22f0347c0..942dbf242 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -771,12 +771,11 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed: rs.Result = _65; if (parsed.ok) { const arg26 = parsed.value; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg26, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(arg26, f)])); } else { const part13 = new rs.ParseBoolError(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseBoolErrorDisplay(part13, f), (f: rs.Formatter) => rs.fmtParseBoolErrorDebug(part13, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args4[1]), "|", rs.fmtSpec({ alternate: true }, args4[1])])); + const args191 = [(f: rs.Formatter) => rs.fmtParseBoolErrorDisplay(part13, f), (f: rs.Formatter) => rs.fmtParseBoolErrorDebug(part13, f)]; + put(out, rs.fmtFormat([args191[0], "|", args191[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args191[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args191[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args191[1]), "|", rs.fmtSpec({ alternate: true }, args191[1])])); } } parse$1yfzdza(_49); @@ -790,12 +789,11 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed2: rs.Result = _105; if (parsed2.ok) { const arg25 = parsed2.value; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(arg25, f)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCharDebug(arg25, f)])); } else { const e: rs.ParseCharError = parsed2.error; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseCharErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseCharErrorDebug(e, f)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[1])])); + const args189 = [(f: rs.Formatter) => rs.fmtParseCharErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseCharErrorDebug(e, f)]; + put(out, rs.fmtFormat([args189[0], "|", args189[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args189[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args189[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args189[1]), "|", rs.fmtSpec({ alternate: true }, args189[1])])); } } rs.charFromStr(_49); @@ -810,29 +808,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed3: rs.Result = _149; if (parsed3.ok) { const arg23 = parsed3.value; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(arg23, f)]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(arg23, f)])); } else { const e2: rs.ParseIntError = parsed3.error; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rs.fmtSpec({ alternate: true }, args12[1])])); + const args184 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f)]; + put(out, rs.fmtFormat([args184[0], "|", args184[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args184[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args184[1]), "|", rs.fmtSpec({ alternate: true }, args184[1])])); } } const _139: rs.Result = parse$1y4njjc(_49); if (!_139.ok) { const part12 = _139.error.kind; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part12)]; - put(out, rs.fmtFormat([args14[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part12)])); } const _195: rs.Result = nonzero_fromStrRadix$1i96daa(_49, radix2); if (_195.ok) { const arg24 = _195.value; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg24, f)]; - put(out, rs.fmtFormat([args16[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg24, f)])); } else { const e4: rs.ParseIntError = _195.error; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f)]; - put(out, rs.fmtFormat([args18[0], "|", args18[1]])); + const args187 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f)]; + put(out, rs.fmtFormat([args187[0], "|", args187[1]])); } } else if (_53 === 3) { const radix3: rs.u32 = radix; @@ -845,29 +840,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed4: rs.Result = _236; if (parsed4.ok) { const arg21 = parsed4.value; - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Debug(arg21, f)]; - put(out, rs.fmtFormat([args20[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Debug(arg21, f)])); } else { const e5: rs.ParseIntError = parsed4.error; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f)]; - put(out, rs.fmtFormat([args22[0], "|", args22[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rs.fmtSpec({ alternate: true }, args22[1])])); + const args179 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f)]; + put(out, rs.fmtFormat([args179[0], "|", args179[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args179[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args179[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args179[1]), "|", rs.fmtSpec({ alternate: true }, args179[1])])); } } const _226: rs.Result = parse$13tnb7e(_49); if (!_226.ok) { const part11 = _226.error.kind; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part11)]; - put(out, rs.fmtFormat([args24[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part11)])); } const _282: rs.Result = nonzero_fromStrRadix$0yk2yqd(_49, radix3); if (_282.ok) { const arg22 = _282.value; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg22, f)]; - put(out, rs.fmtFormat([args26[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg22, f)])); } else { const e7: rs.ParseIntError = _282.error; - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f)]; - put(out, rs.fmtFormat([args28[0], "|", args28[1]])); + const args182 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f)]; + put(out, rs.fmtFormat([args182[0], "|", args182[1]])); } } else if (_53 === 4) { const radix4: rs.u32 = radix; @@ -880,29 +872,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed5: rs.Result = _323; if (parsed5.ok) { const arg19 = parsed5.value; - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(arg19, f)]; - put(out, rs.fmtFormat([args30[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(arg19, f)])); } else { const e8: rs.ParseIntError = parsed5.error; - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f)]; - put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rs.fmtSpec({ alternate: true }, args32[1])])); + const args174 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f)]; + put(out, rs.fmtFormat([args174[0], "|", args174[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args174[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args174[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args174[1]), "|", rs.fmtSpec({ alternate: true }, args174[1])])); } } const _313: rs.Result = parse$04z9euf(_49); if (!_313.ok) { const part10 = _313.error.kind; - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part10)]; - put(out, rs.fmtFormat([args34[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part10)])); } const _369: rs.Result = nonzero_fromStrRadix$1y934te(_49, radix4); if (_369.ok) { const arg20 = _369.value; - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg20, f)]; - put(out, rs.fmtFormat([args36[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg20, f)])); } else { const e10: rs.ParseIntError = _369.error; - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f)]; - put(out, rs.fmtFormat([args38[0], "|", args38[1]])); + const args177 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f)]; + put(out, rs.fmtFormat([args177[0], "|", args177[1]])); } } else if (_53 === 5) { const radix5: rs.u32 = radix; @@ -915,29 +904,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed6: rs.Result = _410; if (parsed6.ok) { const arg17 = parsed6.value; - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(arg17, f)]; - put(out, rs.fmtFormat([args40[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Debug(arg17, f)])); } else { const e11: rs.ParseIntError = parsed6.error; - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f)]; - put(out, rs.fmtFormat([args42[0], "|", args42[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args42[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args42[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args42[1]), "|", rs.fmtSpec({ alternate: true }, args42[1])])); + const args169 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f)]; + put(out, rs.fmtFormat([args169[0], "|", args169[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args169[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args169[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args169[1]), "|", rs.fmtSpec({ alternate: true }, args169[1])])); } } const _400: rs.Result = parse$1fob3ck(_49); if (!_400.ok) { const part9 = _400.error.kind; - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part9)]; - put(out, rs.fmtFormat([args44[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part9)])); } const _456: rs.Result = nonzero_fromStrRadix$11u1rq7(_49, radix5); if (_456.ok) { const arg18 = _456.value; - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg18, f)]; - put(out, rs.fmtFormat([args46[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg18, f)])); } else { const e13: rs.ParseIntError = _456.error; - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f)]; - put(out, rs.fmtFormat([args48[0], "|", args48[1]])); + const args172 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f)]; + put(out, rs.fmtFormat([args172[0], "|", args172[1]])); } } else if (_53 === 6) { const radix6: rs.u32 = radix; @@ -950,29 +936,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed7: rs.Result = _497; if (parsed7.ok) { const arg15 = parsed7.value; - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(arg15, f)]; - put(out, rs.fmtFormat([args50[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Debug(arg15, f)])); } else { const e14: rs.ParseIntError = parsed7.error; - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f)]; - put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[1]), "|", rs.fmtSpec({ alternate: true }, args52[1])])); + const args164 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f)]; + put(out, rs.fmtFormat([args164[0], "|", args164[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args164[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args164[1]), "|", rs.fmtSpec({ alternate: true }, args164[1])])); } } const _487: rs.Result = parse$0j8ztlu(_49); if (!_487.ok) { const part8 = _487.error.kind; - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part8)]; - put(out, rs.fmtFormat([args54[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part8)])); } const _543: rs.Result = nonzero_fromStrRadix$1ejhcoz(_49, radix6); if (_543.ok) { const arg16 = _543.value; - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg16, f)]; - put(out, rs.fmtFormat([args56[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg16, f)])); } else { const e16: rs.ParseIntError = _543.error; - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f)]; - put(out, rs.fmtFormat([args58[0], "|", args58[1]])); + const args167 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f)]; + put(out, rs.fmtFormat([args167[0], "|", args167[1]])); } } else if (_53 === 7) { const radix7: rs.u32 = radix; @@ -985,29 +968,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed8: rs.Result = _584; if (parsed8.ok) { const arg13 = parsed8.value; - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(arg13, f)]; - put(out, rs.fmtFormat([args60[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDebug(arg13, f)])); } else { const e17: rs.ParseIntError = parsed8.error; - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f)]; - put(out, rs.fmtFormat([args62[0], "|", args62[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rs.fmtSpec({ alternate: true }, args62[1])])); + const args159 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f)]; + put(out, rs.fmtFormat([args159[0], "|", args159[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args159[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args159[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args159[1]), "|", rs.fmtSpec({ alternate: true }, args159[1])])); } } const _574: rs.Result = parse$1acldxi(_49); if (!_574.ok) { const part7 = _574.error.kind; - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part7)]; - put(out, rs.fmtFormat([args64[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part7)])); } const _630: rs.Result = nonzero_fromStrRadix$1dc88z1(_49, radix7); if (_630.ok) { const arg14 = _630.value; - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg14, f)]; - put(out, rs.fmtFormat([args66[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg14, f)])); } else { const e19: rs.ParseIntError = _630.error; - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f)]; - put(out, rs.fmtFormat([args68[0], "|", args68[1]])); + const args162 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f)]; + put(out, rs.fmtFormat([args162[0], "|", args162[1]])); } } else if (_53 === 8) { const radix8: rs.u32 = radix; @@ -1020,29 +1000,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed9: rs.Result = _671; if (parsed9.ok) { const arg11 = parsed9.value; - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Debug(arg11, f)]; - put(out, rs.fmtFormat([args70[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Debug(arg11, f)])); } else { const e20: rs.ParseIntError = parsed9.error; - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f)]; - put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rs.fmtSpec({ alternate: true }, args72[1])])); + const args154 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f)]; + put(out, rs.fmtFormat([args154[0], "|", args154[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args154[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args154[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args154[1]), "|", rs.fmtSpec({ alternate: true }, args154[1])])); } } const _661: rs.Result = parse$0jsh5gh(_49); if (!_661.ok) { const part6 = _661.error.kind; - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part6)]; - put(out, rs.fmtFormat([args74[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part6)])); } const _717: rs.Result = nonzero_fromStrRadix$011a32r(_49, radix8); if (_717.ok) { const arg12 = _717.value; - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg12, f)]; - put(out, rs.fmtFormat([args76[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg12, f)])); } else { const e22: rs.ParseIntError = _717.error; - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f)]; - put(out, rs.fmtFormat([args78[0], "|", args78[1]])); + const args157 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f)]; + put(out, rs.fmtFormat([args157[0], "|", args157[1]])); } } else if (_53 === 9) { const radix9: rs.u32 = radix; @@ -1055,29 +1032,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed10: rs.Result = _758; if (parsed10.ok) { const arg9 = parsed10.value; - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Debug(arg9, f)]; - put(out, rs.fmtFormat([args80[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Debug(arg9, f)])); } else { const e23: rs.ParseIntError = parsed10.error; - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f)]; - put(out, rs.fmtFormat([args82[0], "|", args82[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rs.fmtSpec({ alternate: true }, args82[1])])); + const args149 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f)]; + put(out, rs.fmtFormat([args149[0], "|", args149[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args149[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args149[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args149[1]), "|", rs.fmtSpec({ alternate: true }, args149[1])])); } } const _748: rs.Result = parse$0wntisu(_49); if (!_748.ok) { const part5 = _748.error.kind; - const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part5)]; - put(out, rs.fmtFormat([args84[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part5)])); } const _804: rs.Result = nonzero_fromStrRadix$1u0zwz8(_49, radix9); if (_804.ok) { const arg10 = _804.value; - const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg10, f)]; - put(out, rs.fmtFormat([args86[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg10, f)])); } else { const e25: rs.ParseIntError = _804.error; - const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f)]; - put(out, rs.fmtFormat([args88[0], "|", args88[1]])); + const args152 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f)]; + put(out, rs.fmtFormat([args152[0], "|", args152[1]])); } } else if (_53 === 10) { const radix10: rs.u32 = radix; @@ -1090,29 +1064,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed11: rs.Result = _845; if (parsed11.ok) { const arg7 = parsed11.value; - const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Debug(arg7, f)]; - put(out, rs.fmtFormat([args90[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Debug(arg7, f)])); } else { const e26: rs.ParseIntError = parsed11.error; - const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f)]; - put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rs.fmtSpec({ alternate: true }, args92[1])])); + const args144 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f)]; + put(out, rs.fmtFormat([args144[0], "|", args144[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args144[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args144[1]), "|", rs.fmtSpec({ alternate: true }, args144[1])])); } } const _835: rs.Result = parse$18h4mna(_49); if (!_835.ok) { const part4 = _835.error.kind; - const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part4)]; - put(out, rs.fmtFormat([args94[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part4)])); } const _891: rs.Result = nonzero_fromStrRadix$1m6epfo(_49, radix10); if (_891.ok) { const arg8 = _891.value; - const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg8, f)]; - put(out, rs.fmtFormat([args96[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg8, f)])); } else { const e28: rs.ParseIntError = _891.error; - const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f)]; - put(out, rs.fmtFormat([args98[0], "|", args98[1]])); + const args147 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f)]; + put(out, rs.fmtFormat([args147[0], "|", args147[1]])); } } else if (_53 === 11) { const radix11: rs.u32 = radix; @@ -1125,29 +1096,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed12: rs.Result = _932; if (parsed12.ok) { const arg5 = parsed12.value; - const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Debug(arg5, f)]; - put(out, rs.fmtFormat([args100[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Debug(arg5, f)])); } else { const e29: rs.ParseIntError = parsed12.error; - const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f)]; - put(out, rs.fmtFormat([args102[0], "|", args102[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args102[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args102[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args102[1]), "|", rs.fmtSpec({ alternate: true }, args102[1])])); + const args139 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f)]; + put(out, rs.fmtFormat([args139[0], "|", args139[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args139[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args139[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args139[1]), "|", rs.fmtSpec({ alternate: true }, args139[1])])); } } const _922: rs.Result = parse$1gh8p0t(_49); if (!_922.ok) { const part3 = _922.error.kind; - const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part3)]; - put(out, rs.fmtFormat([args104[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part3)])); } const _978: rs.Result = nonzero_fromStrRadix$15i0o2z(_49, radix11); if (_978.ok) { const arg6 = _978.value; - const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg6, f)]; - put(out, rs.fmtFormat([args106[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg6, f)])); } else { const e31: rs.ParseIntError = _978.error; - const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f)]; - put(out, rs.fmtFormat([args108[0], "|", args108[1]])); + const args142 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f)]; + put(out, rs.fmtFormat([args142[0], "|", args142[1]])); } } else if (_53 === 12) { const radix12: rs.u32 = radix; @@ -1160,29 +1128,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed13: rs.Result = _1019; if (parsed13.ok) { const arg3 = parsed13.value; - const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Debug(arg3, f)]; - put(out, rs.fmtFormat([args110[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Debug(arg3, f)])); } else { const e32: rs.ParseIntError = parsed13.error; - const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f)]; - put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args112[1]), "|", rs.fmtSpec({ alternate: true }, args112[1])])); + const args134 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f)]; + put(out, rs.fmtFormat([args134[0], "|", args134[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args134[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args134[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args134[1]), "|", rs.fmtSpec({ alternate: true }, args134[1])])); } } const _1009: rs.Result = parse$1d17hvd(_49); if (!_1009.ok) { const part2 = _1009.error.kind; - const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part2)]; - put(out, rs.fmtFormat([args114[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part2)])); } const _1065: rs.Result = nonzero_fromStrRadix$09x3avk(_49, radix12); if (_1065.ok) { const arg4 = _1065.value; - const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg4, f)]; - put(out, rs.fmtFormat([args116[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg4, f)])); } else { const e34: rs.ParseIntError = _1065.error; - const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f)]; - put(out, rs.fmtFormat([args118[0], "|", args118[1]])); + const args137 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f)]; + put(out, rs.fmtFormat([args137[0], "|", args137[1]])); } } else { const radix13: rs.u32 = radix; @@ -1195,29 +1160,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed14: rs.Result = _1106; if (parsed14.ok) { const arg = parsed14.value; - const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDebug(arg, f)]; - put(out, rs.fmtFormat([args120[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDebug(arg, f)])); } else { const e35: rs.ParseIntError = parsed14.error; - const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f)]; - put(out, rs.fmtFormat([args122[0], "|", args122[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rs.fmtSpec({ alternate: true }, args122[1])])); + const args129 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f)]; + put(out, rs.fmtFormat([args129[0], "|", args129[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args129[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args129[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args129[1]), "|", rs.fmtSpec({ alternate: true }, args129[1])])); } } const _1096: rs.Result = parse$09069e1(_49); if (!_1096.ok) { const part = _1096.error.kind; - const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part)]; - put(out, rs.fmtFormat([args124[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part)])); } const _1152: rs.Result = nonzero_fromStrRadix$1jg523s(_49, radix13); if (_1152.ok) { const arg2 = _1152.value; - const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]; - put(out, rs.fmtFormat([args126[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)])); } else { const e37: rs.ParseIntError = _1152.error; - const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f)]; - put(out, rs.fmtFormat([args128[0], "|", args128[1]])); + const args132 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f)]; + put(out, rs.fmtFormat([args132[0], "|", args132[1]])); } } } @@ -1252,8 +1214,8 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return p3; }))); put(out, rs.stringFromStrings(rs.iterFilter(rs.iterMap(rs.strSplit(s, "/"), (p4: string): string => { - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, p4)]; - return rs.fmtFormat([args4[0], args4[0]]); + const args6 = [(f: rs.Formatter) => rs.fmtPad(f, p4)]; + return rs.fmtFormat([args6[0], args6[0]]); }), (p5: string): boolean => { return !(p5.length === 0); }))); @@ -1285,8 +1247,7 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _179: rs.Iter = rs.strSplit(s, "/"); t2 = rs.stringExtend(t2, _179); const _184: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p: string): string => { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, p)]; - return rs.fmtFormat([args2[0], "é"]); + return rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, p), "é"]); }); t2 = rs.stringExtend(t2, _184); const _190: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); @@ -1847,8 +1808,8 @@ export function walk$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter, pu * after each char. */ export function escaped$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + const args3 = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; + put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])])); walk$str_EscapeDebug(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); @@ -1862,8 +1823,8 @@ export function escaped$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter): * after each char. */ export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + const args3 = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; + put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])])); walk$str_EscapeDefault(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); @@ -1877,8 +1838,8 @@ export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter) * after each char. */ export function escaped$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + const args3 = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; + put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])])); walk$str_EscapeUnicode(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); @@ -1911,8 +1872,8 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const upper: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a09: string): string => { return rs.strToUppercase(a09); }), undefined, 12, true); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(lower.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(upper.items, f, rs.fmtStr)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + const args18 = [(f: rs.Formatter) => rs.fmtList(lower.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(upper.items, f, rs.fmtStr)]; + put(out, rs.fmtFormat([args18[0], "|", args18[1]])); } else if (_11 === 1) { escaped$str_EscapeDebug(out, rs.strEscapeDebug(s)); const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a07: string): rs.Iter => { @@ -1920,8 +1881,8 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }), (e2: rs.Iter): string => { return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e2, f)); }), undefined, 12, true); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args4[0], "|", args4[1]])); + const args17 = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([args17[0], "|", args17[1]])); } else if (_11 === 2) { escaped$str_EscapeDefault(out, rs.strEscapeDefault(s)); const part2 = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a06: string): rs.Iter => { @@ -1929,8 +1890,7 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }), (e: rs.Iter): string => { return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e, f)); }), undefined, 12, true); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.fmtStr)]; - put(out, rs.fmtFormat([args6[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.fmtStr)])); } else if (_11 === 3) { escaped$str_EscapeUnicode(out, rs.strEscapeUnicode(s)); const part = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a04: string): rs.Iter => { @@ -1938,12 +1898,11 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }), (a05: rs.Iter): rs.usize => { return rs.iterCount(a05); }), undefined, 4, true); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args8[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part.items, f, rs.usizeDebug)])); } else { const it: rs.Iter = rs.strEncodeUtf16(s); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16"))]; - put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ align: ">", width: 30 }, args10[0])])); + const args13 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16"))]; + put(out, rs.fmtFormat([args13[0], "|", rs.fmtSpec({ alternate: true }, args13[0]), "|", rs.fmtSpec({ align: ">", width: 30 }, args13[0])])); walk$str_EncodeUtf16(out, it.clone(), (out2: rs.ByteVec, u: rs.u16): undefined => { rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(u))); }); @@ -1956,8 +1915,8 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _164: boolean = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { return rs.resultUnwrap(a03, rs.fmtDecodeUtf16ErrorDebug); })) === s; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(each4.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(_164, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2]])); + const args14 = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(each4.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(_164, f)]; + put(out, rs.fmtFormat([args14[0], "|", args14[1], "|", args14[2]])); } } @@ -1965,13 +1924,12 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void export function putUtf16(out: rs.ByteVec, r: rs.Result): void { if (r.ok) { const part = r.value; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(part, f)])); } else { const e: rs.FromUtf16Error = r.error; const _24: rs.usize = rs.stringLen(rs.fmtToString((f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f))); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args4[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 12 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", args4[2]])); + const args5 = [(f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args5[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 12 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", args5[2]])); } } @@ -1999,11 +1957,9 @@ export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } putUtf16(out, rs.stringFromUtf16(rs.sliceFrom(units.items))); const part3 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part3, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(part3, f)])); const part4 = rs.stringFromUtf16(rs.sliceFrom(units.items)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part4, f, rs.fmtStr, rs.fmtFromUtf16ErrorDebug)]; - put(out, rs.fmtFormat([args4[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part4, f, rs.fmtStr, rs.fmtFromUtf16ErrorDebug)])); const le: rs.ByteVec = rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(units.items), (u: rs.u16): Uint8Array => { return rs.u16ToBeBytes(u).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -2021,8 +1977,8 @@ export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putUtf16(out, rs.stringFromUtf16be(_79[1])); const _96: string = rs.stringFromUtf16leLossy(_79[0]); const _98: string = rs.stringFromUtf16beLossy(_79[1]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(_96, f), (f: rs.Formatter) => rs.fmtStr(_98, f)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1]])); + const args11 = [(f: rs.Formatter) => rs.fmtStr(_96, f), (f: rs.Formatter) => rs.fmtStr(_98, f)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1]])); } const lossy: Array<(a0: rs.ByteSlice) => string> = [(a03: rs.ByteSlice): string => { return rs.stringFromUtf16leLossy(a03); @@ -2055,8 +2011,8 @@ export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), (r: rs.Result): boolean => { return r.ok; }), undefined, 1, true); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(ok.items, f, rs.fmtBool)]; - put(out, rs.fmtFormat([args8[0], "|", args8[1]])); + const args12 = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(ok.items, f, rs.fmtBool)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]])); } //# sourceMappingURL=strs.ts.map diff --git a/ts/fixtures/lang/tuples/expected/harness.ts b/ts/fixtures/lang/tuples/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/tuples/expected/harness.ts +++ b/ts/fixtures/lang/tuples/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/tuples/expected/tuples.Tally.ts b/ts/fixtures/lang/tuples/expected/tuples.Tally.ts index 60718c48b..f84052454 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.Tally.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.Tally.ts @@ -36,8 +36,8 @@ export function extend$iter_Extend_u8_Option_u8(self: Tally, iter: rs.u8 | undef const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args3[0], " at its item ", args3[1]]); } else { self.sum = rs.u8WrappingAdd(self.sum, b); n = rs.u8Add(n, 1); @@ -63,8 +63,8 @@ export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Filter_slice_Iter_u const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args3[0], " at its item ", args3[1]]); } else { self.sum = rs.u8WrappingAdd(self.sum, b); n = rs.u8Add(n, 1); @@ -90,8 +90,8 @@ export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Inspect_slice_Iter_ const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args3[0], " at its item ", args3[1]]); } else { self.sum = rs.u8WrappingAdd(self.sum, b); n = rs.u8Add(n, 1); @@ -117,8 +117,8 @@ export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Map_iter_Enumerate_ const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args3[0], " at its item ", args3[1]]); } else { self.sum = rs.u8WrappingAdd(self.sum, b); n = rs.u8Add(n, 1); @@ -144,8 +144,8 @@ export function extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_M const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args3[0], " at its item ", args3[1]]); } else { self.sum = rs.u8WrappingAdd(self.sum, b); n = rs.u8Add(n, 1); @@ -171,8 +171,8 @@ export function extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_a const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; - rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args3[0], " at its item ", args3[1]]); } else { self.sum = rs.u8WrappingAdd(self.sum, b); n = rs.u8Add(n, 1); diff --git a/ts/fixtures/lang/tuples/expected/tuples.ts b/ts/fixtures/lang/tuples/expected/tuples.ts index 9a7e2b1ea..1d4812798 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.ts @@ -332,13 +332,15 @@ export function borrowed(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 4, true); const t: [rs.ByteVec, rs.Vec, rs.HashMap, string] = [new rs.ByteVec(), new rs.Vec(), rs.hashNew() as rs.HashMap, ""]; const marks: rs.char[] = [122, 233]; - const _10: rs.Iter<[rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char]> = rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterSlice(points.items), [false, false]), (_23: [rs.u8, Spot.Spot]): [rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char] => { + const _11: rs.Iter<[rs.u8, Spot.Spot]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterSlice(points.items), [false, false]); + const _15: rs.Slice = rs.sliceFrom(marks); + const _10: rs.Iter<[rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char]> = rs.iterMap(_11, (_23: [rs.u8, Spot.Spot]): [rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char] => { const _54: [rs.u8, rs.u8] = [_23[0], _23[0]]; const _72: rs.usize = (_23[0] & 1) as rs.usize; if (!(_72 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _72); } - return [_23[0], _23[1], _54, marks[_72]] as [rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char]; + return [_23[0], _23[1], _54, _15.data[_15.start + _72]] as [rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char]; }); rs.tupleExtend(t, _10, [rs.byteVecPart(), rs.copiedPart(rs.vecPart(4), copy$tuples_Spot), rs.hashPart(undefined, undefined, 469762048), rs.STRING_CHARS_PART]); const ones: [rs.Vec] = [new rs.Vec()]; @@ -449,8 +451,8 @@ export function panicked(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = _2[1]; if (!(i !== at)) { const _11: rs.usize = data.length; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f), (f: rs.Formatter) => rs.usizeDisplay(_11, f)]; - rs.panicFmt(["item ", args2[0], " of ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.usizeDisplay(i, f), (f: rs.Formatter) => rs.usizeDisplay(_11, f)]; + rs.panicFmt(["item ", args3[0], " of ", args3[1]]); } else { return [b, b as rs.char, b as rs.u16] as [rs.u8, rs.char, rs.u16]; } diff --git a/ts/fixtures/lang/utf8/expected/harness.ts b/ts/fixtures/lang/utf8/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/utf8/expected/harness.ts +++ b/ts/fixtures/lang/utf8/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/utf8/expected/utf8.ts b/ts/fixtures/lang/utf8/expected/utf8.ts index 8c7b601fc..546ec03fa 100644 --- a/ts/fixtures/lang/utf8/expected/utf8.ts +++ b/ts/fixtures/lang/utf8/expected/utf8.ts @@ -31,8 +31,7 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _14: rs.Result = rs.strFromUtf8(rs.byteSliceRange(rs.byteVecSlice(bytes), _10)); if (_14.ok) { const s: string = _14.value; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args2[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(s, f)])); rs.byteVecPush(out, rs.stringLen(s) & 0xff); } else { const e: rs.Utf8Error = _14.error; @@ -40,8 +39,8 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, option_mapOr$188iunt(e.errorLen, 255, (n: rs.usize): rs.u8 => { return n & 0xff; })); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 64 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1])])); + const args5 = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f)]; + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 64 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1])])); } } const _57: rs.Result = rs.strFromUtf8(rs.byteVecSlice(bytes)); @@ -69,8 +68,8 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { _20 = false; } rs.byteVecPush(out, _20 ? 1 : 0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(text)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(text), f)]; - put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + const args13 = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(text)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(text), f)]; + put(out, rs.fmtFormat([args13[0], "|", args13[1]])); rs.byteVecPush(out, rs.stringLen(rs.strCowStr(text)) & 0xff); const owned: string = rs.strCowStr(text); put(out, owned); @@ -79,8 +78,8 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(owned))); put(out, rs.strFromUtf8Unchecked(rs.byteVecSlice(rs.stringIntoBytes(owned)))); const chunks: rs.Iter = rs.byteSliceUtf8Chunks(rest); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; - put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const args14 = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0])])); let last: rs.Utf8Chunk | undefined = undefined; while (true) { const _79: rs.Utf8Chunk | rs.Done = chunks.next(); @@ -89,10 +88,9 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, chunk.valid); rs.byteVecExtendFromSlice(out, chunk.invalid); rs.byteVecPush(out, chunk.invalid.length & 0xff); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ChunkDebug(chunk, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; - put(out, rs.fmtFormat([args8[0]])); + const args15 = [(f: rs.Formatter) => rs.fmtUtf8ChunkDebug(chunk, f)]; + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)])); rs.byteVecPush(out, rs.iterCount(chunks.clone()) & 0xff); rs.byteVecPush(out, lossy_eq$1kzzmg3(chunk, chunk) ? 1 : 0); const _134: rs.Utf8Chunk | undefined = last; @@ -103,8 +101,7 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { break; } } - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; - put(out, rs.fmtFormat([args10[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)])); } const _152: rs.Result = rs.stringFromUtf8(bytes); if (_152.ok) { @@ -117,8 +114,7 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, option_mapOr$188iunt(u.errorLen, 255, (n: rs.usize): rs.u8 => { return n & 0xff; })); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(u, f)]; - put(out, rs.fmtFormat([args12[0]])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(u, f)])); put(out, rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteVecSlice(e.bytes)))); rs.byteVecPush(out, string_eq$1enuhj8(rs.fromUtf8ErrorClone(e), e) ? 1 : 0); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(e.bytes)); diff --git a/ts/fixtures/lang/wrappers/expected/harness.ts b/ts/fixtures/lang/wrappers/expected/harness.ts index 610e5cf7d..d3614fb27 100644 --- a/ts/fixtures/lang/wrappers/expected/harness.ts +++ b/ts/fixtures/lang/wrappers/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.ts b/ts/fixtures/lang/wrappers/expected/wrappers.ts index 2a08d8cd1..2a5b1f2a5 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.ts @@ -472,8 +472,8 @@ export function wrappers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putU64(out, n2); const _519: rs.u64 = option_unwrapOr$15hbiwd(rs.nonZero(b), n2); const _516: boolean = rs.u64Eq(n2, _519); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(n2, f), (f: rs.Formatter) => rs.u64Debug(n2, f), (f: rs.Formatter) => rs.fmtBool(_516, f)]; - put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])); + const args3 = [(f: rs.Formatter) => rs.u64Display(n2, f), (f: rs.Formatter) => rs.u64Debug(n2, f), (f: rs.Formatter) => rs.fmtBool(_516, f)]; + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2]])); rs.byteVecPush(out, rs.u64Gt(n2, { _0: 1 }._0) ? 1 : 0); rs.byteVecPush(out, rs.cmp(n2, { _0: 1000 }._0) & 0xff); } diff --git a/ts/fixtures/lang/wraps/expected/harness.ts b/ts/fixtures/lang/wraps/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/wraps/expected/harness.ts +++ b/ts/fixtures/lang/wraps/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/wraps/expected/wraps.ts b/ts/fixtures/lang/wraps/expected/wraps.ts index 049d40cea..383daf58e 100644 --- a/ts/fixtures/lang/wraps/expected/wraps.ts +++ b/ts/fixtures/lang/wraps/expected/wraps.ts @@ -368,8 +368,8 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.u8[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u8WrappingAdd, 0); @@ -393,8 +393,8 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u8(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u8(x7), hashed$num_Wrapping_u8(a)) ? 1 : 0); @@ -551,8 +551,8 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.u16[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u16WrappingAdd, 0); @@ -576,8 +576,8 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u16(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u16(x7), hashed$num_Wrapping_u16(a)) ? 1 : 0); @@ -734,8 +734,8 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.u32[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u32WrappingAdd, 0); @@ -759,8 +759,8 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u32(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u32(x7), hashed$num_Wrapping_u32(a)) ? 1 : 0); @@ -917,8 +917,8 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.u64[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u64WrappingAdd, 0); @@ -942,8 +942,8 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u64(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u64(x7), hashed$num_Wrapping_u64(a)) ? 1 : 0); @@ -1100,8 +1100,8 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.u128[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u128WrappingAdd, 0); @@ -1125,8 +1125,8 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u128(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u128(x7), hashed$num_Wrapping_u128(a)) ? 1 : 0); @@ -1283,8 +1283,8 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.usize[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.usizeWrappingAdd, 0); @@ -1308,8 +1308,8 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_usize(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_usize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_usize(x7), hashed$num_Wrapping_usize(a)) ? 1 : 0); @@ -1468,8 +1468,8 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.i8[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i8WrappingAdd, 0); @@ -1493,8 +1493,8 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i8(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i8(x7), hashed$num_Wrapping_i8(a)) ? 1 : 0); @@ -1653,8 +1653,8 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.i16[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i16WrappingAdd, 0); @@ -1678,8 +1678,8 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i16(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i16(x7), hashed$num_Wrapping_i16(a)) ? 1 : 0); @@ -1838,8 +1838,8 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.i32[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i32WrappingAdd, 0); @@ -1863,8 +1863,8 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i32(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i32(x7), hashed$num_Wrapping_i32(a)) ? 1 : 0); @@ -2023,8 +2023,8 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.i64[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i64WrappingAdd, 0); @@ -2048,8 +2048,8 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i64(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i64(x7), hashed$num_Wrapping_i64(a)) ? 1 : 0); @@ -2208,8 +2208,8 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.i128[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i128WrappingAdd, 0); @@ -2233,8 +2233,8 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i128(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i128(x7), hashed$num_Wrapping_i128(a)) ? 1 : 0); @@ -2393,8 +2393,8 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); + const args6 = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); } else if (_31 === 21) { const all: rs.isize[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.isizeWrappingAdd, 0); @@ -2418,8 +2418,8 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const x7: Tick.Tick = _357[0]; const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_isize(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_isize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_isize(x7), hashed$num_Wrapping_isize(a)) ? 1 : 0); diff --git a/ts/fixtures/lang/zeros/expected/harness.ts b/ts/fixtures/lang/zeros/expected/harness.ts index ecf6757a6..cd67e256f 100644 --- a/ts/fixtures/lang/zeros/expected/harness.ts +++ b/ts/fixtures/lang/zeros/expected/harness.ts @@ -29,11 +29,9 @@ export function op(name: string): rs.u16 { return _20.value; } } - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + rs.panicFmt(["case ", (f: rs.Formatter) => rs.fmtPad(f, name), " is past what two bytes pick"]); } else { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } } diff --git a/ts/fixtures/lang/zeros/expected/zeros.ts b/ts/fixtures/lang/zeros/expected/zeros.ts index 1159e0323..6585fa323 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.ts @@ -80,8 +80,8 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { phantom$u8(); rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(_11, {}) ? 1 : 0) | (((Unit.eq$cmp_PartialEq(_13._0, _16) ? 1 : 0) << 1) & 0xff)); const _40: One.One = One.clone$Clone("Only" as One.One); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_11, f), (f: rs.Formatter) => One.fmt$fmt_Debug(_40, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1]])), undefined, true); + const args6 = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_11, f), (f: rs.Formatter) => One.fmt$fmt_Debug(_40, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } else if (_8 === 1) { rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): Uint8Array => { return Uint8Array.of(); @@ -100,12 +100,12 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, One.eq$cmp_PartialEq(_72(1), one()) ? 1 : 0); } else if (_8 === 2) { const _87: Unit.Unit = unit(); - const _89: string[] = none$String(); - const _91: Unit.Unit[] = units(); + const _88: rs.Slice = rs.sliceFrom(none$String()); + const _90: rs.Slice = rs.sliceFrom(units()); const _93: One.One = one(); const _95: [undefined, Unit.Unit, Uint8Array] = tuple(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => rs.fmtList(_89, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(_91, f, (value: Unit.Unit, f: rs.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(_95[0], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rs.Formatter) => rs.fmtList(_95[2], f, rs.u8Debug)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]])), undefined, true); + const args5 = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_88), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_90), f, (value: Unit.Unit, f: rs.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(_95[0], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rs.Formatter) => rs.fmtList(_95[2], f, rs.u8Debug)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4]])), undefined, true); } else if (_8 === 3) { const _108: (a0: rs.u8) => rs.u8 = adder(); adder(); @@ -286,11 +286,11 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const copied: Tagged.Tagged = { n: _15, of: undefined, pin: undefined, unit: undefined }; const again: Tagged.Tagged = copied; const _27: Names.Names = Names.default$Default(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_String(t, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(copied, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(again, f), (f: rs.Formatter) => Names.fmt$fmt_Debug(_27, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3])])), undefined, true); + const args5 = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_String(t, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(copied, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(again, f), (f: rs.Formatter) => Names.fmt$fmt_Debug(_27, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", rs.fmtSpec({ alternate: true }, args5[2]), " ", rs.fmtSpec({ alternate: true }, args5[3])])), undefined, true); const _38: Rest.Rest = Rest.clone$Clone(Rest.default$Default()); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Rest.fmt$fmt_Debug(_38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"])]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " ", rs.fmtSpec({ align: ">", width: 9 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[2]), "|"])), undefined, true); + const args6 = [(f: rs.Formatter) => Rest.fmt$fmt_Debug(_38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"])]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[0]), " ", rs.fmtSpec({ align: ">", width: 9 }, args6[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args6[2]), "|"])), undefined, true); rs.byteVecPush(out, rs.iterCount(rs.iterEmpty() as rs.Iter) & 0xff); } else if (_7 === 1) { const sorted: rs.Vec> = rs.vecFrom(tags.items.map(Tagged.clone$Clone_String)); @@ -540,10 +540,11 @@ export function writes(kind: rs.u8, _dataData: Uint8Array, _dataStart: number, d rs.cellReplace(_113, undefined); rs.cellReplace(_113, undefined); rs.cellSet(_113, undefined); - rs.sliceSwap(rs.sliceFrom([undefined, undefined, undefined]), 0, n as rs.usize); + const units: rs.Slice = rs.sliceFrom([undefined, undefined, undefined]); + rs.sliceSwap(units, 0, n as rs.usize); const v: rs.Vec = rs.vecFromElem({}, 2, undefined); rs.sliceSwap(rs.sliceFrom(v.items), 0, 1); - rs.byteVecPush(out, (rs.sliceFrom([undefined, undefined, undefined]).length & 0xff) | (((v.items.length & 0xff) << 4) & 0xff)); + rs.byteVecPush(out, (units.length & 0xff) | (((v.items.length & 0xff) << 4) & 0xff)); const _141: rs.Cell = new rs.Cell(undefined); rs.cellReplace(_141, undefined); rs.cellReplace(_141, undefined); diff --git a/ts/fixtures/model/expected/harness.ts b/ts/fixtures/model/expected/harness.ts index abbba7835..69c6d5f2d 100644 --- a/ts/fixtures/model/expected/harness.ts +++ b/ts/fixtures/model/expected/harness.ts @@ -108,8 +108,7 @@ export function putResult$moq_net_Timescale_harness_conversions_closure0(out: rs const arg = {}; putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); const arg2 = {}; - const args2: rs.Fmt[] = [(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); } } @@ -124,8 +123,7 @@ export function putResult$moq_net_Timescale_harness_timescales_closure0(out: rs. const arg = {}; putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); const arg2 = {}; - const args2: rs.Fmt[] = [(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); } } @@ -140,8 +138,7 @@ export function putResult$moq_net_Timescale_harness_timescales_closure1(out: rs. const arg = {}; putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); const arg2 = {}; - const args2: rs.Fmt[] = [(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); } } @@ -156,8 +153,7 @@ export function putResult$moq_net_Timescale_harness_timescales_closure2(out: rs. const arg = {}; putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); const arg2 = {}; - const args2: rs.Fmt[] = [(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); } } @@ -172,8 +168,7 @@ export function putResult$moq_net_Timestamp_harness_durations_closure0(out: rs.B const arg = {}; putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); const arg2 = {}; - const args2: rs.Fmt[] = [(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); } } @@ -188,8 +183,7 @@ export function putResult$moq_net_Timestamp_harness_put_timestamp(out: rs.ByteVe const arg = {}; putText(out, rs.fmtToString((f: rs.Formatter) => TimeOverflow.fmt$fmt_Display(arg, f))); const arg2 = {}; - const args2: rs.Fmt[] = [(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => TimeOverflow.fmt$fmt_Debug(arg2, f)])); } } @@ -202,8 +196,7 @@ export function putTimestamp(out: rs.ByteVec, time: Timestamp.Timestamp): void { putU128(out, Timestamp.asMillis(time)); putU128(out, Timestamp.asMicros(time)); putU128(out, Timestamp.asNanos(time)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Timestamp.fmt$fmt_Debug(time, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => Timestamp.fmt$fmt_Debug(time, f)])); } /** A raw scale through each constructor, and what the scale reads back. */ @@ -213,10 +206,8 @@ export function timescales(data: rs.ByteSlice, out: rs.ByteVec): void { putU64(out2, Timescale.asU64(scale)); putU64(out2, time_from$convert_From_moq_net_Timescale_u64(scale)); putU64(out2, time_from$convert_From_moq_net_Timescale_num_NonZero_u64(scale)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Timescale.fmt$fmt_Debug(scale, f)]; - putText(out2, rs.fmtFormat([args2[0]])); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Timescale.fmt$fmt_Display(scale, f)]; - putText(out2, rs.fmtFormat([args4[0]])); + putText(out2, rs.fmtFormat([(f: rs.Formatter) => Timescale.fmt$fmt_Debug(scale, f)])); + putText(out2, rs.fmtFormat([(f: rs.Formatter) => Timescale.fmt$fmt_Display(scale, f)])); }); putResult$moq_net_Timescale_harness_timescales_closure1(out, Timescale.tryFrom$convert_TryFrom_u64(raw), (out3: rs.ByteVec, scale2: Timescale.Timescale): undefined => { putU64(out3, Timescale.asU64(scale2)); @@ -278,8 +269,7 @@ export function arithmetic(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, Timestamp.partialCmp$cmp_PartialOrd(a2, b2) === -1 ? 1 : 0); rs.byteVecPush(out, Timestamp.partialCmp$cmp_PartialOrd(a2, b2) === 1 ? 1 : 0); const part = rs.ordMax(a2, b2, rs.cmpLt(Timestamp.partialCmp$cmp_PartialOrd)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Timestamp.fmt$fmt_Debug(part, f)]; - putText(out, rs.fmtFormat([args2[0]])); + putText(out, rs.fmtFormat([(f: rs.Formatter) => Timestamp.fmt$fmt_Debug(part, f)])); const sorted: rs.Vec = rs.iterToVec(rs.iterChain(rs.iterSlice([a2, b2]), rs.iterResult(c)), undefined, 16, true); rs.sliceSort(rs.sliceFrom(sorted.items), rs.cmpLt(Timestamp.partialCmp$cmp_PartialOrd), 16, true); for (const _65 of sorted.items) { diff --git a/ts/fixtures/model/expected/moq_net/model/time.Timescale.ts b/ts/fixtures/model/expected/moq_net/model/time.Timescale.ts index bb2518aa1..0acbddb18 100644 --- a/ts/fixtures/model/expected/moq_net/model/time.Timescale.ts +++ b/ts/fixtures/model/expected/moq_net/model/time.Timescale.ts @@ -63,8 +63,7 @@ export function fmt$fmt_Debug(self: Timescale, f: rs.Formatter): rs.Result rs.u64Display(part, f)]; - return rs.fmtWriteFmt(f, ["Timescale(", args2[0], ")"]); + return rs.fmtWriteFmt(f, ["Timescale(", (f: rs.Formatter) => rs.u64Display(part, f), ")"]); } return rs.fmtWriteFmt(f, ["Timescale::NANO"]); } @@ -77,8 +76,7 @@ export function fmt$fmt_Debug(self: Timescale, f: rs.Formatter): rs.Result { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg, f)]; - return rs.fmtWriteFmt(f, [args2[0]]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u64Display(arg, f)]); } export { new_ as new }; diff --git a/ts/fixtures/model/expected/moq_net/model/time.Timestamp.ts b/ts/fixtures/model/expected/moq_net/model/time.Timestamp.ts index c6e036570..d44fa7666 100644 --- a/ts/fixtures/model/expected/moq_net/model/time.Timestamp.ts +++ b/ts/fixtures/model/expected/moq_net/model/time.Timestamp.ts @@ -198,20 +198,16 @@ export function fmt$fmt_Debug(self: Timestamp, f: rs.Formatter): rs.Result rs.u128Display(nanos, f)]; - return rs.fmtWriteFmt(f, [args8[0], "ns"]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u128Display(nanos, f), "ns"]); } const part3 = rs.u128Div(nanos, 1000); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(part3, f)]; - return rs.fmtWriteFmt(f, [args6[0], "µs"]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u128Display(part3, f), "µs"]); } const part2 = rs.u128Div(nanos, 1000000); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(part2, f)]; - return rs.fmtWriteFmt(f, [args4[0], "ms"]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u128Display(part2, f), "ms"]); } const part = rs.u128Div(nanos, 1000000000); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(part, f)]; - return rs.fmtWriteFmt(f, [args2[0], "s"]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u128Display(part, f), "s"]); } export function partialCmp$cmp_PartialOrd(self: Timestamp, other: Timestamp): rs.Ordering | undefined { diff --git a/ts/fixtures/names/expected/lib.ts b/ts/fixtures/names/expected/lib.ts index 9897fe3ac..a0f3e4295 100644 --- a/ts/fixtures/names/expected/lib.ts +++ b/ts/fixtures/names/expected/lib.ts @@ -24,8 +24,7 @@ export function run(data: rs.ByteSlice): rs.ByteVec { }); rs.byteVecPush(out, _15); const part = Wrap.new$wrap_Pair(pair); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Display_wrap_Pair(part, f)]; - const _22: rs.ByteSlice = rs.stringAsBytes(rs.fmtFormat([args2[0]])); + const _22: rs.ByteSlice = rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Wrap.fmt$fmt_Display_wrap_Pair(part, f)])); rs.byteVecExtendFromSlice(out, _22); if (!(first === 0)) { shape = "Line" as shapes_Shape.Shape; diff --git a/ts/fixtures/names/expected/wrap.Pair.ts b/ts/fixtures/names/expected/wrap.Pair.ts index 078c1385a..ac49024bc 100644 --- a/ts/fixtures/names/expected/wrap.Pair.ts +++ b/ts/fixtures/names/expected/wrap.Pair.ts @@ -12,8 +12,8 @@ export function fmt$fmt_Display(self: Pair, f: rs.Formatter): rs.Result rs.u8Display(arg, f); const arg2 = self._1; - const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.u8Display(arg2, f)]; - return rs.fmtWriteFmt(f, [args2[0], "-", args2[1]]); + const args3 = [_8, (f: rs.Formatter) => rs.u8Display(arg2, f)]; + return rs.fmtWriteFmt(f, [args3[0], "-", args3[1]]); } //# sourceMappingURL=wrap.Pair.ts.map diff --git a/ts/fixtures/names/expected/wrap.Wrap.ts b/ts/fixtures/names/expected/wrap.Wrap.ts index 66b2ce349..fd8ff630b 100644 --- a/ts/fixtures/names/expected/wrap.Wrap.ts +++ b/ts/fixtures/names/expected/wrap.Wrap.ts @@ -30,8 +30,7 @@ export function map$wrap_Pair_u8_run_closure1(self: Wrap, f: (a0: Pai export function fmt$fmt_Display_wrap_Pair(self: Wrap, f: rs.Formatter): rs.Result { const arg = self._0; - const args2: rs.Fmt[] = [(f: rs.Formatter) => Pair.fmt$fmt_Display(arg, f)]; - return rs.fmtWriteFmt(f, ["[", args2[0], "]"]); + return rs.fmtWriteFmt(f, ["[", (f: rs.Formatter) => Pair.fmt$fmt_Display(arg, f), "]"]); } //# sourceMappingURL=wrap.Wrap.ts.map diff --git a/ts/fixtures/reject/census.txt b/ts/fixtures/reject/census.txt index 49e780d9e..8c74743d0 100644 --- a/ts/fixtures/reject/census.txt +++ b/ts/fixtures/reject/census.txt @@ -24,7 +24,6 @@ fixtures/reject/src/buffers.rs:capacity_reads+7:4: `Bytes::truncate` in a progra fixtures/reject/src/buffers.rs:capacity_reads+8:4: `Bytes::clear` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported fixtures/reject/src/buffers.rs:capacity_reads+9:15: `Bytes::try_into_mut` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported fixtures/reject/src/buffers.rs:owned_bytes+1:2: `Bytes::from_owner` of `std::sync::Arc<[u8]>`, which would drop with the last clone of what it makes, which is not supported -fixtures/reject/src/buffers.rs:shared+1:2: a coercion to `std::sync::Arc<[u8]>` fixtures/reject/src/buffers.rs:spare+1:4: `Vec::spare_capacity_mut` of other than bytes, whose room past its length no JS array holds, which is not supported yet fixtures/reject/src/clones.rs:given_slots+6:2: a raw pointer to `(u8, u8)` in `([clones::Touched; 2], (u8, u8))`, which the crate may put another object in place of fixtures/reject/src/clones.rs:greatest_slot+6:13: a raw pointer to `(u8, u8)` in `([clones::Greatest; 2], (u8, u8))`, which the crate may put another object in place of @@ -105,6 +104,7 @@ fixtures/reject/src/keys.rs:set_keys+1:75: hashing `std::collections::BTreeSet::eq` fixtures/reject/src/objects.rs:any_type_id+1:4: `std::any::Any::type_id` of `dyn std::any::Any`, which is not supported yet fixtures/reject/src/objects.rs:any_type_id+1:17: unsupported call to `std::any::TypeId::of::` +fixtures/reject/src/objects.rs:array_object+1:2: a trait object of `[u16; 2]`, which is not supported yet fixtures/reject/src/objects.rs:dyn_compared+3:2: comparing pointers to `dyn objects::Reading`, each an object JS makes of its own as it unsizes fixtures/reject/src/objects.rs:dyn_size+1:2: unsupported call to `std::mem::size_of_val::` fixtures/reject/src/objects.rs:dynamic+2:4: unsupported call to ` as std::io::Write>::write` @@ -169,7 +169,7 @@ fixtures/reject/src/places.rs:replace_pinned_ref+1:2: an assignment through a re fixtures/reject/src/places.rs:swap_guards+1:2: replacing the value behind a reference to `std::sync::MutexGuard<'_, u8>` fixtures/reject/src/pointers.rs:arc_from_borrow+1:12: `Arc::from_raw` of a pointer to `u32` a borrow made, whose JS value is a place of its own, which no `Arc` gave fixtures/reject/src/pointers.rs:arc_raw_slice+1:2: an `Arc`'s raw pointer to `[u32]`, which JS makes anew each time -fixtures/reject/src/pointers.rs:array_pointers+1:39: comparing pointers to `[u16; 2]`, which a slice lends as a copy of its own +fixtures/reject/src/pointers.rs:array_of_one+1:2: comparing pointers to `[u32; 1]`, an array of one JS may make of its own for a value, as `array::from_ref` does fixtures/reject/src/pointers.rs:assigned_through+2:10: a raw pointer to `(u32, u32)` in a variable assigned again while it may point there fixtures/reject/src/pointers.rs:byte_option_slice+1:4: a slice of one byte's place, which a byte slice can view only in an array of bytes fixtures/reject/src/pointers.rs:byte_pointer_ops+5:3: a copy between pointers to `[u8; 4]`, which JS keeps as an object that knows no array it is in @@ -292,7 +292,6 @@ fixtures/reject/src/values.rs:manual_impls+2:34: a constant of type `std::mem::M fixtures/reject/src/values.rs:nested+0:15: `Option>>` is not supported: its `None` and `Some` would both be `rs.None` fixtures/reject/src/values.rs:nested+1:2: `Option>>` is not supported: its `None` and `Some` would both be `rs.None` fixtures/reject/src/values.rs:reclone+3:13: a reference to `std::option::Option>`, through which a raw pointer may be made, in a variable assigned again while that pointer may point there -fixtures/reject/src/values.rs:shared_values+1:2: a coercion to `std::rc::Rc<[u16]>` fixtures/reject/src/values.rs:units_compared+2:15: a raw pointer to a place of `()`, which has no address of its own fixtures/reject/src/values.rs:units_compared+2:29: a raw pointer to a place of `()`, which has no address of its own fixtures/reject/src/values.rs:units_compared+2:70: comparing pointers to `places::Bare`, which has no bytes and so no address of its own diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index 8fe260fff..b3b900074 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -28,7 +28,6 @@ fixtures/reject/src/buffers.rs:capacity_reads+7:4: `Bytes::truncate` in a progra fixtures/reject/src/buffers.rs:capacity_reads+8:4: `Bytes::clear` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported fixtures/reject/src/buffers.rs:capacity_reads+9:15: `Bytes::try_into_mut` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported fixtures/reject/src/buffers.rs:owned_bytes+1:2: `Bytes::from_owner` of `std::sync::Arc<[u8]>`, which would drop with the last clone of what it makes, which is not supported -fixtures/reject/src/buffers.rs:shared+1:2: a coercion to `std::sync::Arc<[u8]>` fixtures/reject/src/buffers.rs:spare+1:4: `Vec::spare_capacity_mut` of other than bytes, whose room past its length no JS array holds, which is not supported yet fixtures/reject/src/clones.rs:greatest_slot+6:13: a raw pointer to `(u8, u8)` in `([clones::Greatest; 2], (u8, u8))`, which the crate may put another object in place of fixtures/reject/src/clones.rs:stashed_slots+5:19: a raw pointer to `(u8, u8)` in `([u8; 2], (u8, u8))`, which the crate may put another object in place of @@ -107,6 +106,7 @@ fixtures/reject/src/keys.rs:set_keys+1:75: hashing `std::collections::BTreeSet::eq` fixtures/reject/src/objects.rs:any_type_id+1:4: `std::any::Any::type_id` of `dyn std::any::Any`, which is not supported yet fixtures/reject/src/objects.rs:any_type_id+1:17: unsupported call to `std::any::TypeId::of::` +fixtures/reject/src/objects.rs:array_object+1:2: a trait object of `[u16; 2]`, which is not supported yet fixtures/reject/src/objects.rs:dyn_compared+3:2: comparing pointers to `dyn objects::Reading`, each an object JS makes of its own as it unsizes fixtures/reject/src/objects.rs:dyn_size+1:2: unsupported call to `std::mem::size_of_val::` fixtures/reject/src/objects.rs:dynamic+2:4: unsupported call to ` as std::io::Write>::write` @@ -171,7 +171,7 @@ fixtures/reject/src/places.rs:replace_pinned_ref+1:2: an assignment through a re fixtures/reject/src/places.rs:swap_guards+1:2: replacing the value behind a reference to `std::sync::MutexGuard<'_, u8>` fixtures/reject/src/pointers.rs:arc_from_borrow+1:12: `Arc::from_raw` of a pointer to `u32` a borrow made, whose JS value is a place of its own, which no `Arc` gave fixtures/reject/src/pointers.rs:arc_raw_slice+1:2: an `Arc`'s raw pointer to `[u32]`, which JS makes anew each time -fixtures/reject/src/pointers.rs:array_pointers+1:39: comparing pointers to `[u16; 2]`, which a slice lends as a copy of its own +fixtures/reject/src/pointers.rs:array_of_one+1:2: comparing pointers to `[u32; 1]`, an array of one JS may make of its own for a value, as `array::from_ref` does fixtures/reject/src/pointers.rs:assigned_through+2:10: a raw pointer to `(u32, u32)` in a variable assigned again while it may point there fixtures/reject/src/pointers.rs:byte_option_slice+1:4: a slice of one byte's place, which a byte slice can view only in an array of bytes fixtures/reject/src/pointers.rs:byte_pointer_ops+5:3: a copy between pointers to `[u8; 4]`, which JS keeps as an object that knows no array it is in diff --git a/ts/fixtures/reject/src/buffers.rs b/ts/fixtures/reject/src/buffers.rs index fdf649e8d..135b9ce2c 100644 --- a/ts/fixtures/reject/src/buffers.rs +++ b/ts/fixtures/reject/src/buffers.rs @@ -1,10 +1,5 @@ //! `bytes`' buffers, and buffers of the crate's own, where JS's storage would tell apart what Rust's doesn't. -/// An `Arc`'s bytes would need a `ByteSlice` made inside it. -pub fn shared(b: std::sync::Arc<[u8; 2]>) -> std::sync::Arc<[u8]> { - b -} - /// An owner that drops, which would drop with the last clone of the `Bytes`. pub fn owned_bytes(owner: std::sync::Arc<[u8]>) -> usize { bytes::Bytes::from_owner(owner).len() diff --git a/ts/fixtures/reject/src/objects.rs b/ts/fixtures/reject/src/objects.rs index da5a57aa8..af0502431 100644 --- a/ts/fixtures/reject/src/objects.rs +++ b/ts/fixtures/reject/src/objects.rs @@ -179,3 +179,15 @@ pub fn dyn_compared(n: &mut u8) -> bool { let q: *mut dyn Reading = n; std::ptr::eq(p, q) } + +impl Reading for [u16; 2] { + fn read(&self) -> u8 { + self[0] as u8 + } +} + +/// An array as an object, whose class's methods would take the array a box holds and the +/// slice of it a reference is. +pub fn array_object(a: std::sync::Arc<[u16; 2]>) -> std::sync::Arc { + a +} diff --git a/ts/fixtures/reject/src/pointers.rs b/ts/fixtures/reject/src/pointers.rs index e74d8cf63..75e53e1ef 100644 --- a/ts/fixtures/reject/src/pointers.rs +++ b/ts/fixtures/reject/src/pointers.rs @@ -315,9 +315,9 @@ pub fn byte_pointer_parts(a: [u8; 4], b: [[u8; 2]; 3]) -> bool { std::ptr::eq(x, y) || std::ptr::eq(&b[0], &b[1]) } -/// Pointers to arrays of other values than bytes, which a slice lends as copies, compared. -pub fn array_pointers(a: [u16; 2], s: &[u16]) -> bool { - s.first_chunk::<2>().is_some_and(|c| std::ptr::eq(c, &a)) +/// Pointers to arrays of one, which JS makes of its own for a value, compared. +pub fn array_of_one(n: u32) -> bool { + std::ptr::eq(std::array::from_ref(&n), std::array::from_ref(&n)) } /// Pointers to an array of bytes in a variable assigned again while they point there, diff --git a/ts/fixtures/reject/src/values.rs b/ts/fixtures/reject/src/values.rs index 28adb1137..c6c5dfc0f 100644 --- a/ts/fixtures/reject/src/values.rs +++ b/ts/fixtures/reject/src/values.rs @@ -21,12 +21,6 @@ pub fn generic_unit(value: Option<()>) -> bool { Maybe { value }.value.is_some() } -/// An `Rc`'s array, as its slice, would need an `rs.Slice` made inside the `rs.Arc` its -/// other owners share. -pub fn shared_values(values: std::rc::Rc<[u16; 2]>) -> std::rc::Rc<[u16]> { - values -} - /// Parsing an address is not translated yet. pub fn addr_parsed(s: &str) -> Result { s.parse() diff --git a/ts/fixtures/reject/ts.toml b/ts/fixtures/reject/ts.toml index 651847971..c3659bf03 100644 --- a/ts/fixtures/reject/ts.toml +++ b/ts/fixtures/reject/ts.toml @@ -11,7 +11,6 @@ roots = [ "buffers::blank_bytes", "buffers::capacity_reads", "buffers::owned_bytes", - "buffers::shared", "buffers::spare", "buffers::string_bytes", "clones::cloned_slots", @@ -83,6 +82,7 @@ roots = [ "lopsided", "missing", "objects::any_type_id", + "objects::array_object", "objects::dyn_compared", "objects::dyn_size", "objects::dynamic", @@ -129,7 +129,7 @@ roots = [ "places::swap_guards", "pointers::arc_from_borrow", "pointers::arc_raw_slice", - "pointers::array_pointers", + "pointers::array_of_one", "pointers::assigned_through", "pointers::byte_option_slice", "pointers::byte_pointer_ops", diff --git a/ts/fixtures/share/expected/harness.ts b/ts/fixtures/share/expected/harness.ts index 3140334ae..4c42d9bbd 100644 --- a/ts/fixtures/share/expected/harness.ts +++ b/ts/fixtures/share/expected/harness.ts @@ -26,7 +26,7 @@ export function run(input: rs.ByteSlice): rs.ByteVec { return Uint8Array.of(_3, w.data[w.start + 1]); }), undefined, 2, true); const deque: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; - rs.dequeExtend(deque, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, true); + rs.dequeExtend(deque, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (held) => rs.byteSliceToArray(held)), undefined, true); const _47: rs.Iter = rs.iterFlatMap(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), (p: rs.ByteSlice): Uint8Array => { return Uint8Array.of(p.data[p.start], p.data[p.start + 1]); }, (value: Uint8Array) => rs.iterSlice(value), true, 2); diff --git a/ts/fixtures/stock/expected/buf.Fixed.ts b/ts/fixtures/stock/expected/buf.Fixed.ts index 21e56b059..5ecbd401f 100644 --- a/ts/fixtures/stock/expected/buf.Fixed.ts +++ b/ts/fixtures/stock/expected/buf.Fixed.ts @@ -95,8 +95,7 @@ export function remainingMut$bytes_BufMut(self: Fixed): rs.usize { export function advanceMut$bytes_BufMut(self: Fixed, cnt: rs.usize): void { const _4: rs.usize = remainingMut$bytes_BufMut_mut(self); if (!(cnt <= _4)) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(cnt, f)]; - rs.panicFmt(["advanced ", args2[0], " past the array"]); + rs.panicFmt(["advanced ", (f: rs.Formatter) => rs.usizeDisplay(cnt, f), " past the array"]); } else { self.len = rs.usizeAdd(self.len, cnt); } diff --git a/ts/fixtures/stock/expected/buf.Spare.ts b/ts/fixtures/stock/expected/buf.Spare.ts index 2e413b63f..710f56295 100644 --- a/ts/fixtures/stock/expected/buf.Spare.ts +++ b/ts/fixtures/stock/expected/buf.Spare.ts @@ -98,8 +98,7 @@ export function remainingMut$bytes_BufMut(self: Spare): rs.usize { export function advanceMut$bytes_BufMut(self: Spare, cnt: rs.usize): void { const _4: rs.usize = remainingMut$bytes_BufMut_mut(self); if (!(cnt <= _4)) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(cnt, f)]; - rs.panicFmt(["advanced ", args2[0], " past the capacity"]); + rs.panicFmt(["advanced ", (f: rs.Formatter) => rs.usizeDisplay(cnt, f), " past the capacity"]); } else { rs.byteVecSetLen(self._0, rs.usizeAdd(self._0.length, cnt)); } diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index 3a424c66d..ff71ac152 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -321,17 +321,17 @@ export function bytesMut(data: rs.ByteSlice, out: rs.ByteVec): void { _390[Symbol.dispose](); const _403: rs.usize = buf.length; const _406: rs.usize = buf.cap; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(buf), f), (f: rs.Formatter) => rs.usizeDisplay(_403, f), (f: rs.Formatter) => rs.usizeDisplay(_406, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]))); + const args7 = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(buf), f), (f: rs.Formatter) => rs.usizeDisplay(_403, f), (f: rs.Formatter) => rs.usizeDisplay(_406, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2], "\n"]))); for (const piece6 of pieces.items) { const _430: rs.usize = piece6.cap; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(piece6), f), (f: rs.Formatter) => rs.usizeDisplay(_430, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]))); + const args8 = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(piece6), f), (f: rs.Formatter) => rs.usizeDisplay(_430, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], " ", args8[1], "\n"]))); } for (const bytes3 of frozen.items) { const _452: boolean = rs.bytesIsUnique(bytes3); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(bytes3, f), (f: rs.Formatter) => rs.fmtBool(_452, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], "\n"]))); + const args9 = [(f: rs.Formatter) => rs.bytesDebug(bytes3, f), (f: rs.Formatter) => rs.fmtBool(_452, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args9[0], " ", args9[1], "\n"]))); } const vec2: rs.ByteVec = rs.bytesMutToByteVec(buf); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(vec2.data.length as rs.u32).reverse())); @@ -3216,8 +3216,7 @@ export function chunkWrite(chunk: rs.ByteSlice, op: rs.u8, n: rs.u8, out: rs.Byt break b1; } } - const args2: rs.Fmt[] = [(f: rs.Formatter) => UninitSlice.fmt$fmt_Debug(chunk, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => UninitSlice.fmt$fmt_Debug(chunk, f)]))); return 0; } return k; @@ -3946,8 +3945,8 @@ export function edits(dataData: Uint8Array, dataStart: number, dataLen: number, const _65: boolean = rs.bytesIsUnique(part); const _68: boolean = rs.bytesIsUnique(bytes); const _70: rs.ByteSlice = part; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(_70, f), (f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.fmtBool(_65, f), (f: rs.Formatter) => rs.fmtBool(_68, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]))); + const args3 = [(f: rs.Formatter) => rs.bytesDebug(_70, f), (f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.fmtBool(_65, f), (f: rs.Formatter) => rs.fmtBool(_68, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3]]))); rs.bytesDrop(part); rs.bytesDrop(bytes); } diff --git a/ts/fixtures/stock/expected/bytes.ts b/ts/fixtures/stock/expected/bytes.ts index 89771c58a..1cb458844 100644 --- a/ts/fixtures/stock/expected/bytes.ts +++ b/ts/fixtures/stock/expected/bytes.ts @@ -7,13 +7,13 @@ export function panicAdvance(errorInfo: TryGetError.TryGetError): never { const arg = errorInfo.available; const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg, f); const arg2 = errorInfo.requested; - const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; - rs.panicFmt(["advance out of bounds: the len is ", args2[0], " but advancing by ", args2[1]]); + const args3 = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; + rs.panicFmt(["advance out of bounds: the len is ", args3[0], " but advancing by ", args3[1]]); } export function panicDoesNotFit(size: rs.usize, nbytes: rs.usize): never { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(size, f), (f: rs.Formatter) => rs.usizeDisplay(nbytes, f)]; - rs.panicFmt(["size too large: the integer type can fit ", args2[0], " bytes, but nbytes is ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.usizeDisplay(size, f), (f: rs.Formatter) => rs.usizeDisplay(nbytes, f)]; + rs.panicFmt(["size too large: the integer type can fit ", args3[0], " bytes, but nbytes is ", args3[1]]); } //# sourceMappingURL=bytes.ts.map diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index a35ff3742..26c0b58f6 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -59,8 +59,7 @@ export function op(name: string): rs.u8 { return _22[0] === name; }); if (_2 === undefined) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; - rs.panicFmt(["no case ", args2[0]]); + rs.panicFmt(["no case ", (f: rs.Formatter) => rs.fmtPad(f, name)]); } else { return _2 & 0xff; } @@ -145,8 +144,7 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o const copied: rs.ByteSlice = rs.bytesCopyFromSlice(rs.byteVecSlice(source)); rs.byteVecClear(source); rs.byteVecPush(source, 0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(copied, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.bytesDebug(copied, f)]))); const iter: rs.Iter = rs.iterSlice(made, rs.bytesDrop); while (true) { const _44: rs.ByteSlice | rs.Done = iter.next(); @@ -155,8 +153,8 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o } const bytes: rs.ByteSlice = _44; const _56: rs.usize = bytes.length; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.usizeDisplay(_56, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]))); + const args6 = [(f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.usizeDisplay(_56, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], "\n"]))); rs.bytesDrop(bytes); } rs.drop(iter); diff --git a/ts/fixtures/stock/expected/maps.ts b/ts/fixtures/stock/expected/maps.ts index 122ea0fa2..cd149ec12 100644 --- a/ts/fixtures/stock/expected/maps.ts +++ b/ts/fixtures/stock/expected/maps.ts @@ -82,16 +82,13 @@ export function map(data: rs.ByteSlice, out: rs.ByteVec): void { return k5[0] !== rs.u8Rem(arg, 4); }); } else if (_35 === 6) { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(key, f)]; - const _88: string = rs.fmtFormat([args2[0]]); + const _88: string = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(key, f)]); rs.byteVecPush(out, rs.hashAdd(set, _88) ? 1 : 0); const part = rs.u16Add(key, 1); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(part, f)]; - const _102: string = rs.fmtFormat([args4[0]]); + const _102: string = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(part, f)]); rs.byteVecPush(out, rs.hashContains(set, _102) ? 1 : 0); } else if (_35 === 7) { - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(key, f)]; - const _117: string = rs.fmtFormat([args6[0]]); + const _117: string = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(key, f)]); rs.byteVecPush(out, rs.hashDelete(set, _117) ? 1 : 0); } else if (_35 === 8) { put(out, option_mapOr$0o00yzv(rs.hashRemoveEntry(own, key), 256, (_26: [rs.u16, rs.u32]): rs.usize => { diff --git a/ts/fixtures/task/expected/closures.ts b/ts/fixtures/task/expected/closures.ts index 2c968068c..965073da1 100644 --- a/ts/fixtures/task/expected/closures.ts +++ b/ts/fixtures/task/expected/closures.ts @@ -279,8 +279,8 @@ export class closuresFuture { const arg5 = this.#tallied; const _91: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(arg5[0], f), (f: rs.Formatter) => rs.u32Debug(arg5[1], f), (f: rs.Formatter) => rs.u32Debug(arg5[2], f)], f); const arg6 = this.#count; - const args2: rs.Fmt[] = [_87, _88, _89, _90, _91, (f: rs.Formatter) => rs.u32Display(arg6, f)]; - const _74: string = rs.fmtFormat(["seen ", args2[0], " first ", args2[1], " second ", args2[2], " reads ", args2[3], " tallied ", args2[4], " count ", args2[5]]); + const args9 = [_87, _88, _89, _90, _91, (f: rs.Formatter) => rs.u32Display(arg6, f)]; + const _74: string = rs.fmtFormat(["seen ", args9[0], " first ", args9[1], " second ", args9[2], " reads ", args9[3], " tallied ", args9[4], " count ", args9[5]]); Guard.note(this.#guard, _74); const captured2 = Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)); this.#awaitee$3 = new callOnceFuture$closures_closures_closure0_closure2(rs.closure(rs.byMove((rx: Consumer.Consumer): rs.Future => { @@ -300,8 +300,7 @@ export class closuresFuture { this.#third = _105; rs.drop(this.#awaitee$3); const arg7 = this.#third; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg7, f)]; - const _115: string = rs.fmtFormat(["third ", args4[0]]); + const _115: string = rs.fmtFormat(["third ", (f: rs.Formatter) => rs.u64Display(arg7, f)]); Guard.note(this.#guard, _115); this.#lent = Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)); this.#peek = (value3: rs.u64): rs.Future => { @@ -415,8 +414,8 @@ export class closuresFuture { const arg8 = this.#fourth; const _249: rs.Fmt = (f: rs.Formatter) => rs.u64Display(arg8, f); const arg9 = this.#fifth; - const args6: rs.Fmt[] = [_249, (f: rs.Formatter) => rs.u64Display(arg9, f)]; - const _240: string = rs.fmtFormat(["fourth ", args6[0], " fifth ", args6[1]]); + const args11 = [_249, (f: rs.Formatter) => rs.u64Display(arg9, f)]; + const _240: string = rs.fmtFormat(["fourth ", args11[0], " fifth ", args11[1]]); Guard.note(this.#guard, _240); const captured5 = Guard.new(rs.u32Add(this.#id, 900), Log.clone$Clone(this.#log)); this.#awaitee$3 = new callOnceFuture$boxed_Box_closures_closures_closure0_closure7(rs.closure(rs.byMove((rx2: Consumer.Consumer): rs.Future => { @@ -480,8 +479,8 @@ export class closuresFuture { captured8[Symbol.dispose](); }))()); const arg10 = this.#sixth; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg10, f), (f: rs.Formatter) => rs.u32Display(seventh, f)]; - const _319: string = rs.fmtFormat(["sixth ", args8[0], " seventh ", args8[1]]); + const args12 = [(f: rs.Formatter) => rs.u64Display(arg10, f), (f: rs.Formatter) => rs.u32Display(seventh, f)]; + const _319: string = rs.fmtFormat(["sixth ", args12[0], " seventh ", args12[1]]); Guard.note(this.#guard, _319); const _360: rs.u64 = rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(option_unwrapOr$15hbiwd(this.#first, 0), option_unwrapOr$15hbiwd(this.#second, 0)), this.#third), this.#fourth), this.#fifth), this.#sixth); this.#saved$4 = false; @@ -592,9 +591,7 @@ export class closuresFuture$closure2_closure0 { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - const _27: Guard.Guard = this.#owned; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - Guard.note(_27, rs.fmtFormat(["once ", args2[0]])); + Guard.note(this.#owned, rs.fmtFormat(["once ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)])); const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; @@ -634,8 +631,7 @@ export class closuresFuture$closure2_closure0_once { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - const _17: string = rs.fmtFormat(["once ", args2[0]]); + const _17: string = rs.fmtFormat(["once ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]); Guard.note(this.#owned, _17); const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#owned[Symbol.dispose](); @@ -663,9 +659,7 @@ export class closuresFuture$closure3_closure0 { poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const value: rs.u64 = this.#value; - const _17: Guard.Guard = this.#lent; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - Guard.note(_17, rs.fmtFormat(["peek ", args2[0]])); + Guard.note(this.#lent, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.u64Display(value, f)])); const _0: rs.Poll = rs.u64Add(value, 1); this.#state = 1; return _0; @@ -736,9 +730,7 @@ export class closuresFuture$closure6_closure0 { poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const value: rs.u64 = this.#value; - const _16: Guard.Guard = this.#last; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - Guard.note(_16, rs.fmtFormat(["last ", args2[0]])); + Guard.note(this.#last, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.u64Display(value, f)])); this.#state = 1; return value; } @@ -765,8 +757,7 @@ export class closuresFuture$closure6_closure0_once { poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const value: rs.u64 = this.#value; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - const _6: string = rs.fmtFormat(["last ", args2[0]]); + const _6: string = rs.fmtFormat(["last ", (f: rs.Formatter) => rs.u64Display(value, f)]); Guard.note(this.#last, _6); this.#last[Symbol.dispose](); this.#state = 1; @@ -803,9 +794,7 @@ export class closuresFuture$closure7_closure0 { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - const _27: Guard.Guard = this.#boxed; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - Guard.note(_27, rs.fmtFormat(["boxed ", args2[0]])); + Guard.note(this.#boxed, rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)])); const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; @@ -845,8 +834,7 @@ export class closuresFuture$closure7_closure0_once { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; - const _17: string = rs.fmtFormat(["boxed ", args2[0]]); + const _17: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]); Guard.note(this.#boxed, _17); const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#boxed[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops.Key.ts b/ts/fixtures/task/expected/drops.Key.ts index 12d9010ca..2815d6461 100644 --- a/ts/fixtures/task/expected/drops.Key.ts +++ b/ts/fixtures/task/expected/drops.Key.ts @@ -28,8 +28,7 @@ function new_(id: rs.u32, log: Log.Log): Key { export function drop$ops_Drop(self: Key): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["k", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); self.id = 4294967295; } @@ -49,8 +48,7 @@ export function cmp$cmp_Ord(self: Key, other: Key): rs.Ordering { export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void { if (self.counted) { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _6: string = rs.fmtFormat(["k", args2[0], " hashed"]); + const _6: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " hashed"]); Log.note(self.log, _6); } rs.hash32(self.id, state); @@ -58,8 +56,7 @@ export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void export function clone$Clone(self: Key): Key { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["k", args2[0], " cloned"]); + const _4: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " cloned"]); Log.note(self.log, _4); return new Key(self.id, Log.clone$Clone(self.log), self.counted); } diff --git a/ts/fixtures/task/expected/drops.Wrap.ts b/ts/fixtures/task/expected/drops.Wrap.ts index 2f78b4528..3ff9e5afd 100644 --- a/ts/fixtures/task/expected/drops.Wrap.ts +++ b/ts/fixtures/task/expected/drops.Wrap.ts @@ -22,43 +22,37 @@ export class Wrap { export function drop$ops_Drop_Vec_drops_Wrap_drops_Held(self: Wrap>>): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Held(self: Wrap): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Pair_drops_Held(self: Wrap>): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_model_Guard(self: Wrap): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_sync_Arc_drops_Held(self: Wrap>): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_u32(self: Wrap): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index d6b819aee..504a5274e 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -93,12 +93,10 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const shared: rs.Arc = rs.arcClone(arc); rs.arcDrop(arc, lib_drop$drops_Held); const part5 = shared.strong; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; - Log.note(log, rs.fmtFormat(["arc ", args2[0]])); + Log.note(log, rs.fmtFormat(["arc ", (f: rs.Formatter) => rs.usizeDisplay(part5, f)])); const part6 = shared.strong; const cloned: rs.Arc = rs.arcClone(shared); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part6, f)]; - Log.note(log, rs.fmtFormat(["counted ", args4[0]])); + Log.note(log, rs.fmtFormat(["counted ", (f: rs.Formatter) => rs.usizeDisplay(part6, f)])); rs.arcDrop(cloned, lib_drop$drops_Held); const v2: rs.Vec = new rs.Vec(); const _70 = { tag: "One", _0: guard(5) } as Held.Held; @@ -108,8 +106,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const maybe = ({ tag: "One", _0: guard(8) } as Held.Held) as Held.Held | undefined; const _94: rs.usize = held.items.length; const _97: boolean = maybe !== undefined; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_94, f), (f: rs.Formatter) => rs.fmtBool(_97, f)]; - Log.note(log, rs.fmtFormat(["held ", args6[0], " ", args6[1]])); + const args24 = [(f: rs.Formatter) => rs.usizeDisplay(_94, f), (f: rs.Formatter) => rs.fmtBool(_97, f)]; + Log.note(log, rs.fmtFormat(["held ", args24[0], " ", args24[1]])); lib_drop$drops_Held(boxed); rs.dropVec(mutex.value, lib_drop$drops_Held); lib_drop$Option_boxed_Box_drops_Held(maybe); @@ -137,8 +135,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _183: boolean = Held.isSome(wrapped.inner); const _186: rs.u32 = Guard.id(guarded.inner); const _189: rs.u32 = rs.u32Add(rs.u32Add(Guard.id(pairs.items[rs.idx(pairs.items, 1)].first), Guard.id(pairs.items[rs.idx(pairs.items, 0)].second)), nested.inner.items.length as rs.u32); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.u32Display(_186, f), (f: rs.Formatter) => rs.u32Display(_189, f)]; - Log.note(log, rs.fmtFormat(["wraps ", args8[0], " ", args8[1], " ", args8[2]])); + const args21 = [(f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.u32Display(_186, f), (f: rs.Formatter) => rs.u32Display(_189, f)]; + Log.note(log, rs.fmtFormat(["wraps ", args21[0], " ", args21[1], " ", args21[2]])); lib_drop$drops_Wrap_Vec_drops_Wrap_drops_Held(nested); _owned[Symbol.dispose](); _borrowed[Symbol.dispose](); @@ -155,16 +153,15 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const clones: rs.Vec>>> = v5; rs.arcDrop(shared2, lib_drop$drops_Wrap_drops_Pair_drops_Held); const part2 = clones.items.length; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; - Log.note(log, rs.fmtFormat(["clones ", args10[0]])); + Log.note(log, rs.fmtFormat(["clones ", (f: rs.Formatter) => rs.usizeDisplay(part2, f)])); const part3: rs.u32 | undefined = bail(log, id, true); const err: rs.u32 | undefined = part3 === undefined ? out$u32.err as rs.u32 : undefined; const part4: rs.u32 | undefined = bail(log, rs.u32Add(id, 2), false); const err2: rs.u32 | undefined = part4 === undefined ? out$u32.err as rs.u32 : undefined; const _256: boolean = !((err !== undefined ? rs.Err(err as rs.u32) : rs.Ok(part3 as rs.u32)) as rs.Result).ok; const _259: boolean = !((err2 !== undefined ? rs.Err(err2 as rs.u32) : rs.Ok(part4 as rs.u32)) as rs.Result).ok; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_256, f), (f: rs.Formatter) => rs.fmtBool(_259, f)]; - Log.note(log, rs.fmtFormat(["bailed ", args12[0], " ", args12[1]])); + const args20 = [(f: rs.Formatter) => rs.fmtBool(_256, f), (f: rs.Formatter) => rs.fmtBool(_259, f)]; + Log.note(log, rs.fmtFormat(["bailed ", args20[0], " ", args20[1]])); rs.dropVec(clones, lib_drop$sync_Arc_drops_Wrap_drops_Pair_drops_Held); } else { const arc2: rs.Arc> = new rs.Arc(new rs.Mutex({ tag: "Two", _0: guard(81), _1: guard(82) } as Held.Held)); @@ -173,16 +170,14 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _281: rs.Mutex = rs.mutexLock(other.value); const held2: boolean = Held.isSome(_281.value); rs.mutexUnlock(_281); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(held2, f)]; - Log.note(log, rs.fmtFormat(["locked ", args14[0]])); + Log.note(log, rs.fmtFormat(["locked ", (f: rs.Formatter) => rs.fmtBool(held2, f)])); const lent: Guard.Guard = guard(83); const borrowed: rs.Arc = new rs.Arc(lent); const again: rs.Arc = rs.arcClone(borrowed); rs.arcDrop(borrowed); rs.arcDrop(again); const part = Guard.id(lent); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["lent ", args16[0]])); + Log.note(log, rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.u32Display(part, f)])); lent[Symbol.dispose](); rs.arcDrop(other, lib_drop$sync_Mutex_drops_Held); } @@ -207,8 +202,8 @@ export function bail(log: Log.Log, id: rs.u32, fails: boolean): rs.u32 | undefin const n: rs.u32 = part as rs.u32; const _29: rs.usize = held.items.length; const _32: boolean = Held.isSome(wrap.inner); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_29, f), (f: rs.Formatter) => rs.fmtBool(_32, f)]; - Log.note(log, rs.fmtFormat(["not bailed ", args2[0], " ", args2[1]])); + const args3 = [(f: rs.Formatter) => rs.usizeDisplay(_29, f), (f: rs.Formatter) => rs.fmtBool(_32, f)]; + Log.note(log, rs.fmtFormat(["not bailed ", args3[0], " ", args3[1]])); _0Err = false; _02 = n; lib_drop$drops_Wrap_drops_Held(wrap); @@ -293,8 +288,8 @@ export class heldFuture { const _51: rs.usize = this.#held.items.length; const _54: boolean = Held.isSome(this.#wrap.inner.value); const arg = this.#id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_51, f), (f: rs.Formatter) => rs.fmtBool(_54, f)]; - const _46: string = rs.fmtFormat(["g", args2[0], " held ", args2[1], " ", args2[2]]); + const args3 = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_51, f), (f: rs.Formatter) => rs.fmtBool(_54, f)]; + const _46: string = rs.fmtFormat(["g", args3[0], " held ", args3[1], " ", args3[2]]); Log.note(this.#log, _46); lib_drop$drops_Wrap_sync_Arc_drops_Held(this.#wrap); rs.dropVec(this.#held, lib_drop$drops_Held); @@ -337,15 +332,13 @@ export function ordered(log: Log.Log, id: rs.u32): void { const _37: Guard.Guard = guard(4); const old: Guard.Guard | undefined = rs.btreeInsert(map, _34, _37, rs.drop); const part = old !== undefined; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - Log.note(log, rs.fmtFormat(["replaced ", args2[0]])); + Log.note(log, rs.fmtFormat(["replaced ", (f: rs.Formatter) => rs.fmtBool(part, f)])); rs.drop(old); const _56: Key.Key = key(2); const removed: Guard.Guard | undefined = rs.btreeRemove(map, _56, rs.drop); _56[Symbol.dispose](); const part2 = removed !== undefined; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; - Log.note(log, rs.fmtFormat(["removed ", args4[0]])); + Log.note(log, rs.fmtFormat(["removed ", (f: rs.Formatter) => rs.fmtBool(part2, f)])); const _74: Key.Key = key(3); const _72: rs.Entry = rs.entry(map, _74, rs.drop); if (!rs.entryOccupied(_72)) { @@ -353,8 +346,7 @@ export function ordered(log: Log.Log, id: rs.u32): void { } else { const _86: Guard.Guard = rs.entryRemove(_72, rs.drop); const part3 = Guard.id(_86); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _80: string = rs.fmtFormat(["occupied ", args6[0]]); + const _80: string = rs.fmtFormat(["occupied ", (f: rs.Formatter) => rs.u32Display(part3, f)]); _86[Symbol.dispose](); Log.note(log, _80); } @@ -366,16 +358,15 @@ export function ordered(log: Log.Log, id: rs.u32): void { if (!rs.entryOccupied(_94)) { const e2: rs.Entry = _94; const part4 = rs.entryKey(e2).id; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["left ", args8[0]])); + Log.note(log, rs.fmtFormat(["left ", (f: rs.Formatter) => rs.u32Display(part4, f)])); e2.k[Symbol.dispose](); } const _118: Key.Key = key(1); const kept: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _118, rs.drop), guard(6), rs.drop)); const _129: Key.Key = key(7); const added: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _129, rs.drop), guard(7), rs.drop)); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(kept, f), (f: rs.Formatter) => rs.u32Display(added, f)]; - Log.note(log, rs.fmtFormat(["or_insert ", args10[0], " ", args10[1]])); + const args29 = [(f: rs.Formatter) => rs.u32Display(kept, f), (f: rs.Formatter) => rs.u32Display(added, f)]; + Log.note(log, rs.fmtFormat(["or_insert ", args29[0], " ", args29[1]])); const _149: Key.Key = key(8); const _152: Guard.Guard = guard(8); rs.drop(rs.btreeInsert(map, _149, _152, rs.drop)); @@ -389,12 +380,10 @@ export function ordered(log: Log.Log, id: rs.u32): void { rs.btreeAdd(set, _165, rs.drop); const _176: Key.Key = key(10); const part5 = rs.btreeAdd(set, _176, rs.drop); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; - Log.note(log, rs.fmtFormat(["again ", args12[0]])); + Log.note(log, rs.fmtFormat(["again ", (f: rs.Formatter) => rs.fmtBool(part5, f)])); const _192: Key.Key = key(11); const part6 = rs.btreeDelete(set, _192, rs.drop); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; - const _185: string = rs.fmtFormat(["gone ", args14[0]]); + const _185: string = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part6, f)]); _192[Symbol.dispose](); Log.note(log, _185); const _201: Key.Key = key(12); @@ -413,15 +402,14 @@ export function ordered(log: Log.Log, id: rs.u32): void { }, rs.drop); rs.dequeTruncate(queue, 2, rs.drop); const part7 = queue.n; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; - Log.note(log, rs.fmtFormat(["queue ", args16[0]])); + Log.note(log, rs.fmtFormat(["queue ", (f: rs.Formatter) => rs.usizeDisplay(part7, f)])); rs.btreeClear(map, rs.drop, rs.drop); rs.btreeClear(set, rs.drop); const _248: rs.usize = rs.btreeLen(map); const _251: rs.usize = rs.btreeLen(set); const _254: rs.usize = queue.n; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_248, f), (f: rs.Formatter) => rs.usizeDisplay(_251, f), (f: rs.Formatter) => rs.usizeDisplay(_254, f)]; - Log.note(log, rs.fmtFormat(["left ", args18[0], " ", args18[1], " ", args18[2]])); + const args33 = [(f: rs.Formatter) => rs.usizeDisplay(_248, f), (f: rs.Formatter) => rs.usizeDisplay(_251, f), (f: rs.Formatter) => rs.usizeDisplay(_254, f)]; + Log.note(log, rs.fmtFormat(["left ", args33[0], " ", args33[1], " ", args33[2]])); const sink: Log.Log = Log.new(); const many: rs.BTreeSet = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeSet; let iterStart2: rs.u32 = 0; @@ -449,8 +437,8 @@ export function ordered(log: Log.Log, id: rs.u32): void { } const _298: rs.usize = found(many); const _303: rs.usize = rs.btreeLen(many); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_298, f), (f: rs.Formatter) => rs.usizeDisplay(_303, f)]; - Log.note(log, rs.fmtFormat(["replaced ", args20[0], " ", args20[1]])); + const args34 = [(f: rs.Formatter) => rs.usizeDisplay(_298, f), (f: rs.Formatter) => rs.usizeDisplay(_303, f)]; + Log.note(log, rs.fmtFormat(["replaced ", args34[0], " ", args34[1]])); const iter4: rs.Iter = rs.iterStepBy(new rs.Range(0, 400), 7, undefined, 4294967295); while (true) { const _314: rs.u32 | rs.Done = iter4.next(); @@ -463,8 +451,8 @@ export function ordered(log: Log.Log, id: rs.u32): void { } const _331: rs.usize = found(many); const _336: rs.usize = rs.btreeLen(many); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_331, f), (f: rs.Formatter) => rs.usizeDisplay(_336, f)]; - Log.note(log, rs.fmtFormat(["taken ", args22[0], " ", args22[1]])); + const args35 = [(f: rs.Formatter) => rs.usizeDisplay(_331, f), (f: rs.Formatter) => rs.usizeDisplay(_336, f)]; + Log.note(log, rs.fmtFormat(["taken ", args35[0], " ", args35[1]])); const iter5: rs.Iter = rs.iterStepBy(new rs.Range(0, 400), 5, undefined, 4294967295); while (true) { const _347: rs.u32 | rs.Done = iter5.next(); @@ -477,8 +465,8 @@ export function ordered(log: Log.Log, id: rs.u32): void { } const _363: rs.usize = found(many); const _368: rs.usize = rs.btreeLen(many); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_363, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; - Log.note(log, rs.fmtFormat(["removed ", args24[0], " ", args24[1]])); + const args36 = [(f: rs.Formatter) => rs.usizeDisplay(_363, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; + Log.note(log, rs.fmtFormat(["removed ", args36[0], " ", args36[1]])); rs.btreeDrop(many, rs.drop); sink[Symbol.dispose](); rs.dequeDrop(queue, rs.drop); @@ -505,8 +493,8 @@ export function hashed(log: Log.Log, id: rs.u32): void { return _2 as rs.u32; }), rs.u32Add, 0); const _152: rs.usize = text.length; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, what), (f: rs.Formatter) => rs.usizeDisplay(_152, f), (f: rs.Formatter) => rs.u32Display(sum, f)]; - Log.note(log, rs.fmtFormat([args10[0], ": ", args10[1], " ", args10[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtPad(f, what), (f: rs.Formatter) => rs.usizeDisplay(_152, f), (f: rs.Formatter) => rs.u32Display(sum, f)]; + Log.note(log, rs.fmtFormat([args11[0], ": ", args11[1], " ", args11[2]])); }; const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; const _15: Key.Key = key(1); @@ -543,8 +531,7 @@ export function hashed(log: Log.Log, id: rs.u32): void { if (!rs.entryOccupied(_73)) { const e2: rs.Entry = _73; const part = rs.entryKey(e2).id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["left ", args2[0]])); + Log.note(log, rs.fmtFormat(["left ", (f: rs.Formatter) => rs.u32Display(part, f)])); e2.k[Symbol.dispose](); } tally("entry"); @@ -552,8 +539,8 @@ export function hashed(log: Log.Log, id: rs.u32): void { const kept: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _101, rs.drop), guard(6), rs.drop)); const _112: Key.Key = key(7); const added: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _112, rs.drop), guard(7), rs.drop)); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(kept, f), (f: rs.Formatter) => rs.u32Display(added, f)]; - Log.note(log, rs.fmtFormat(["or_insert ", args4[0], " ", args4[1]])); + const args13 = [(f: rs.Formatter) => rs.u32Display(kept, f), (f: rs.Formatter) => rs.u32Display(added, f)]; + Log.note(log, rs.fmtFormat(["or_insert ", args13[0], " ", args13[1]])); tally("or_insert"); const _136: Key.Key = key(8); const _139: Guard.Guard = guard(8); @@ -569,12 +556,10 @@ export function hashed(log: Log.Log, id: rs.u32): void { rs.hashAdd(set, _156, rs.drop); const _167: Key.Key = key(10); const part2 = rs.hashAdd(set, _167, rs.drop); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; - Log.note(log, rs.fmtFormat(["again ", args6[0]])); + Log.note(log, rs.fmtFormat(["again ", (f: rs.Formatter) => rs.fmtBool(part2, f)])); const _183: Key.Key = key(11); const part3 = rs.hashDelete(set, _183, rs.drop); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - const _176: string = rs.fmtFormat(["gone ", args8[0]]); + const _176: string = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); _183[Symbol.dispose](); Log.note(log, _176); const _192: Key.Key = key(12); @@ -597,7 +582,7 @@ export function hashed(log: Log.Log, id: rs.u32): void { return guard(22); }); const _237: Key.Key = counted(20); - rs.entryOrInsert(rs.entryAndModify(rs.entry(counts, _237, rs.drop), (_27: Guard.Guard): undefined => {}), guard(23), rs.drop); + rs.entryOrInsert(rs.entryAndModify(rs.entry(counts, _237, rs.drop), (_211: Guard.Guard): undefined => {}), guard(23), rs.drop); const _245: Key.Key = counted(22); const _243: rs.Entry = rs.entry(counts, _245, rs.drop); if (rs.entryOccupied(_243)) { @@ -629,16 +614,16 @@ export function options(log: Log.Log, id: rs.u32): void { const none: rs.Result = option_okOr$0qyzozq(undefined as Guard.Guard | undefined, guard(3)); const _24: boolean = some.ok; const _27: boolean = none.ok; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_24, f), (f: rs.Formatter) => rs.fmtBool(_27, f)]; - Log.note(log, rs.fmtFormat(["ok_or ", args2[0], " ", args2[1]])); + const args19 = [(f: rs.Formatter) => rs.fmtBool(_24, f), (f: rs.Formatter) => rs.fmtBool(_27, f)]; + Log.note(log, rs.fmtFormat(["ok_or ", args19[0], " ", args19[1]])); const ok: Guard.Guard | undefined = ok$0p21n6j(rs.Ok(guard(4))); const err: Guard.Guard | undefined = ok$0p21n6j(rs.Err(guard(5))); const flipped: Guard.Guard | undefined = err$1guw4rh(rs.Ok(guard(6))); const _55: boolean = ok !== undefined; const _58: boolean = err !== undefined; const _61: boolean = flipped !== undefined; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_55, f), (f: rs.Formatter) => rs.fmtBool(_58, f), (f: rs.Formatter) => rs.fmtBool(_61, f)]; - Log.note(log, rs.fmtFormat(["ok ", args4[0], " ", args4[1], " ", args4[2]])); + const args20 = [(f: rs.Formatter) => rs.fmtBool(_55, f), (f: rs.Formatter) => rs.fmtBool(_58, f), (f: rs.Formatter) => rs.fmtBool(_61, f)]; + Log.note(log, rs.fmtFormat(["ok ", args20[0], " ", args20[1], " ", args20[2]])); const kept: Guard.Guard = option_unwrapOr$0v6ziq2(guard(7), guard(8)); const fallback: Guard.Guard = option_unwrapOr$0v6ziq2(undefined as Guard.Guard | undefined, guard(9)); const value: Guard.Guard = result_unwrapOr$19ff01h(rs.Ok(guard(10)), guard(11)); @@ -647,8 +632,8 @@ export function options(log: Log.Log, id: rs.u32): void { const _107: rs.u32 = Guard.id(fallback); const _110: rs.u32 = Guard.id(value); const _113: rs.u32 = Guard.id(error); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_104, f), (f: rs.Formatter) => rs.u32Display(_107, f), (f: rs.Formatter) => rs.u32Display(_110, f), (f: rs.Formatter) => rs.u32Display(_113, f)]; - Log.note(log, rs.fmtFormat(["unwrap_or ", args6[0], " ", args6[1], " ", args6[2], " ", args6[3]])); + const args21 = [(f: rs.Formatter) => rs.u32Display(_104, f), (f: rs.Formatter) => rs.u32Display(_107, f), (f: rs.Formatter) => rs.u32Display(_110, f), (f: rs.Formatter) => rs.u32Display(_113, f)]; + Log.note(log, rs.fmtFormat(["unwrap_or ", args21[0], " ", args21[1], " ", args21[2], " ", args21[3]])); const mapped: Guard.Guard = option_mapOr$19gmzl7(id, guard(14), (n2: rs.u32): Guard.Guard => { Log.note(log, rs.fmtFormat(["mapped"])); return Guard.new(rs.u32Add(n2, 15), Log.clone$Clone(log)); @@ -658,14 +643,14 @@ export function options(log: Log.Log, id: rs.u32): void { }); const _140: rs.u32 = Guard.id(mapped); const _143: rs.u32 = Guard.id(unmapped); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_140, f), (f: rs.Formatter) => rs.u32Display(_143, f)]; - Log.note(log, rs.fmtFormat(["map_or ", args8[0], " ", args8[1]])); + const args22 = [(f: rs.Formatter) => rs.u32Display(_140, f), (f: rs.Formatter) => rs.u32Display(_143, f)]; + Log.note(log, rs.fmtFormat(["map_or ", args22[0], " ", args22[1]])); const then: Guard.Guard | undefined = thenSome$0zvoczk(some.ok, guard(17)); const never: Guard.Guard | undefined = thenSome$0zvoczk(false, guard(18)); const _166: boolean = then !== undefined; const _169: boolean = never !== undefined; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_166, f), (f: rs.Formatter) => rs.fmtBool(_169, f)]; - Log.note(log, rs.fmtFormat(["then_some ", args10[0], " ", args10[1]])); + const args23 = [(f: rs.Formatter) => rs.fmtBool(_166, f), (f: rs.Formatter) => rs.fmtBool(_169, f)]; + Log.note(log, rs.fmtFormat(["then_some ", args23[0], " ", args23[1]])); const kept2: Guard.Guard | undefined = filter$1vqc90z(guard(19), (g: Guard.Guard): boolean => { return rs.u32Rem(Guard.id(g), 2) === 0; }); @@ -685,8 +670,8 @@ export function options(log: Log.Log, id: rs.u32): void { const _215: boolean = dropped !== undefined; const _218: boolean = zipped !== undefined; const _221: boolean = other !== undefined; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_212, f), (f: rs.Formatter) => rs.fmtBool(_215, f), (f: rs.Formatter) => rs.fmtBool(_218, f), (f: rs.Formatter) => rs.fmtBool(_221, f), (f: rs.Formatter) => rs.fmtBool(flag, f)]; - Log.note(log, rs.fmtFormat(["filter ", args12[0], " ", args12[1], " zip ", args12[2], " or_else ", args12[3], " is_some_and ", args12[4]])); + const args24 = [(f: rs.Formatter) => rs.fmtBool(_212, f), (f: rs.Formatter) => rs.fmtBool(_215, f), (f: rs.Formatter) => rs.fmtBool(_218, f), (f: rs.Formatter) => rs.fmtBool(_221, f), (f: rs.Formatter) => rs.fmtBool(flag, f)]; + Log.note(log, rs.fmtFormat(["filter ", args24[0], " ", args24[1], " zip ", args24[2], " or_else ", args24[3], " is_some_and ", args24[4]])); const chained: rs.Result = result_andThen$1wsai1p(rs.Ok(guard(25)), (a0: Guard.Guard): rs.Result => { return rs.Err(a0); }); @@ -704,8 +689,8 @@ export function options(log: Log.Log, id: rs.u32): void { rs.drop(_244); const _255: boolean = chained.ok; const _258: boolean = cloned !== undefined; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_255, f), (f: rs.Formatter) => rs.u32Display(error2, f), (f: rs.Formatter) => rs.fmtBool(_258, f)]; - Log.note(log, rs.fmtFormat(["and_then ", args14[0], " map_or_else ", args14[1], " clone ", args14[2]])); + const args25 = [(f: rs.Formatter) => rs.fmtBool(_255, f), (f: rs.Formatter) => rs.u32Display(error2, f), (f: rs.Formatter) => rs.fmtBool(_258, f)]; + Log.note(log, rs.fmtFormat(["and_then ", args25[0], " map_or_else ", args25[1], " clone ", args25[2]])); let slot = undefined as Guard.Guard | undefined; const _270: Guard.Guard = guard(28); if (slot === undefined) { @@ -749,8 +734,8 @@ export function options(log: Log.Log, id: rs.u32): void { slot = _297; rs.drop(old); const replaced: rs.u32 = Guard.id(slot as Guard.Guard); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(made, f), (f: rs.Formatter) => rs.u32Display(replaced, f)]; - Log.note(log, rs.fmtFormat(["get_or_insert ", args16[0], " ", args16[1]])); + const args26 = [(f: rs.Formatter) => rs.u32Display(made, f), (f: rs.Formatter) => rs.u32Display(replaced, f)]; + Log.note(log, rs.fmtFormat(["get_or_insert ", args26[0], " ", args26[1]])); let answered = undefined as rs.Result | undefined; const _315: rs.Result = rs.Ok(guard(33)); if (answered === undefined) { @@ -783,8 +768,8 @@ export function options(log: Log.Log, id: rs.u32): void { } _338 = false; } - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(kept3, f), (f: rs.Formatter) => rs.fmtBool(_338, f)]; - Log.note(log, rs.fmtFormat(["answered ", args18[0], " ", args18[1]])); + const args27 = [(f: rs.Formatter) => rs.u32Display(kept3, f), (f: rs.Formatter) => rs.fmtBool(_338, f)]; + Log.note(log, rs.fmtFormat(["answered ", args27[0], " ", args27[1]])); lib_drop$Option_Result_model_Guard_u8(answered); rs.drop(empty); rs.drop(slot); @@ -843,16 +828,16 @@ export function elements(log: Log.Log, id: rs.u32): void { const _39: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceLast(rs.sliceFrom(v.items), rs.None), (o6: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o6, Guard.id); }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_34, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_39, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["vec ", args2[0], " ", args2[1]])); + const args51 = [(f: rs.Formatter) => rs.fmtOption(_34, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_39, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["vec ", args51[0], " ", args51[1]])); const _54: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(rs.sliceFrom(v.items), 1, rs.None), (o7: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o7, Guard.id); }); const _59: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(rs.sliceFrom(v.items), 4, rs.None), (o8: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o8, Guard.id); }); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_54, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_59, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["get ", args4[0], " ", args4[1]])); + const args52 = [(f: rs.Formatter) => rs.fmtOption(_54, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_59, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["get ", args52[0], " ", args52[1]])); const _68: rs.Place | undefined = rs.sliceLastMut(rs.sliceFrom(v.items)); if (_68 !== undefined) { const _73: Guard.Guard | undefined = guard(3); @@ -879,16 +864,15 @@ export function elements(log: Log.Log, id: rs.u32): void { const _98: rs.u32 | undefined | rs.None = option_map$1x5kkz1(taken, (o11: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o11, Guard.id); }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtOption(_98, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["pop_if ", args6[0], " ", args6[1]])); + const args53 = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtOption(_98, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["pop_if ", args53[0], " ", args53[1]])); rs.drop(taken); while (true) { const _107: Guard.Guard | undefined | rs.None = rs.vecPop(v, rs.None); if (_107 !== rs.None) { const o: Guard.Guard | undefined = _107; const part2 = _7(o); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["pop ", args8[0]])); + Log.note(log, rs.fmtFormat(["pop ", (f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)])); rs.drop(o); } else { break; @@ -899,8 +883,7 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o12); return _011; }); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["popped ", args10[0]])); + Log.note(log, rs.fmtFormat(["popped ", (f: rs.Formatter) => rs.fmtOption(part4, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); const captured = guard(14); const _151: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, rs.closure((_2: rs.Place): boolean => { const _012: boolean = Guard.id(captured) > 0; @@ -910,16 +893,14 @@ export function elements(log: Log.Log, id: rs.u32): void { captured[Symbol.dispose](); }), rs.drop, rs.None); const part5 = _151 !== rs.None; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; - const _145: string = rs.fmtFormat(["uncalled ", args12[0]]); + const _145: string = rs.fmtFormat(["uncalled ", (f: rs.Formatter) => rs.fmtBool(part5, f)]); rs.drop(_151); Log.note(log, _145); v.items.push(undefined as Guard.Guard | undefined); const captured2 = guard(15); const part8 = option_map$1x5kkz1(rs.vecPopIfMut(v, rs.closure((o13: rs.Place): boolean => { const part6 = Guard.id(captured2); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Log.note(log, rs.fmtFormat(["test ", args52[0]])); + Log.note(log, rs.fmtFormat(["test ", (f: rs.Formatter) => rs.u32Display(part6, f)])); const _013: boolean = o13.v === undefined; captured2[Symbol.dispose](); return _013; @@ -930,8 +911,7 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o14); return _014; }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["called ", args14[0]])); + Log.note(log, rs.fmtFormat(["called ", (f: rs.Formatter) => rs.fmtOption(part8, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); const q: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; rs.dequePushBack(q, undefined as Guard.Guard | undefined); const _186: Guard.Guard | undefined = guard(4); @@ -948,8 +928,8 @@ export function elements(log: Log.Log, id: rs.u32): void { const _213: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeGet(q, 4, rs.None), (o17: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o17, Guard.id); }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_205, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_209, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_213, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["deque ", args16[0], " ", args16[1], " ", args16[2]])); + const args61 = [(f: rs.Formatter) => rs.fmtOption(_205, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_209, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_213, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["deque ", args61[0], " ", args61[1], " ", args61[2]])); const _222: rs.Place | undefined = rs.dequeEndMut(q); if (_222 !== undefined) { rs.drop(_222.v); @@ -964,8 +944,8 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o19); return _019; }); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_235, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_239, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["remove ", args18[0], " ", args18[1]])); + const args62 = [(f: rs.Formatter) => rs.fmtOption(_235, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_239, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["remove ", args62[0], " ", args62[1]])); rs.drop(removed); const _252: Guard.Guard | undefined = guard(6); rs.dequePushBack(q, _252); @@ -986,22 +966,20 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o22); return _022; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_273, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_277, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_283, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["swap_remove ", args20[0], " ", args20[1], " ", args20[2]])); + const args63 = [(f: rs.Formatter) => rs.fmtOption(_273, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_277, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_283, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["swap_remove ", args63[0], " ", args63[1], " ", args63[2]])); rs.drop(back); const front: Guard.Guard | undefined | rs.None = rs.dequePopFront(q, rs.None); const part12 = option_map$1x5kkz1(front, (o23: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o23, Guard.id); }); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["front ", args22[0]])); + Log.note(log, rs.fmtFormat(["front ", (f: rs.Formatter) => rs.fmtOption(part12, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); while (true) { const _310: Guard.Guard | undefined | rs.None = rs.dequePopBack(q, rs.None); if (_310 !== rs.None) { const o2: Guard.Guard | undefined = _310; const part14 = _7(o2); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part14, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["back ", args24[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part14, f, rs.u32Debug)])); rs.drop(o2); } else { break; @@ -1017,8 +995,8 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o25); return _025; }); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_334, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_340, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["emptied ", args26[0], " ", args26[1]])); + const args66 = [(f: rs.Formatter) => rs.fmtOption(_334, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_340, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["emptied ", args66[0], " ", args66[1]])); const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; const _352: Key.Key | undefined = key(7); rs.heapPush(heap, _352, rs.cmpLe(rs.cmpOption(Key.partialCmp$cmp_PartialOrd))); @@ -1030,16 +1008,14 @@ export function elements(log: Log.Log, id: rs.u32): void { return k2.id; }); }); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part17, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["heap ", args28[0]])); + Log.note(log, rs.fmtFormat(["heap ", (f: rs.Formatter) => rs.fmtOption(part17, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); const top: Key.Key | undefined | rs.None = rs.heapPop(heap, rs.cmpLe(rs.cmpOption(Key.partialCmp$cmp_PartialOrd)), rs.None); const part18 = option_map$150c7g4(top, (o27: Key.Key | undefined): rs.u32 | undefined => { return option_map$0bmexgo(o27, (k3: Key.Key): rs.u32 => { return k3.id; }); }); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part18, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["top ", args30[0]])); + Log.note(log, rs.fmtFormat(["top ", (f: rs.Formatter) => rs.fmtOption(part18, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); rs.drop(top); const sorted: rs.BTreeSet = rs.btreeNew(rs.cmpOption(Key.cmp$cmp_Ord)) as rs.BTreeSet; const _397: Key.Key | undefined = key(9); @@ -1057,8 +1033,8 @@ export function elements(log: Log.Log, id: rs.u32): void { return k5.id; }); }); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_416, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_420, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["set ", args32[0], " ", args32[1]])); + const args69 = [(f: rs.Formatter) => rs.fmtOption(_416, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_420, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["set ", args69[0], " ", args69[1]])); const _430: Key.Key | undefined = key(9); const replaced: Key.Key | undefined | rs.None = rs.btreeReplace(sorted, _430, rs.None); const _440: rs.u32 | undefined | rs.None = option_map$150c7g4(replaced, (o30: Key.Key | undefined): rs.u32 | undefined => { @@ -1071,8 +1047,8 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o31); return _036; }); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_440, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_444, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["replace ", args34[0], " ", args34[1]])); + const args70 = [(f: rs.Formatter) => rs.fmtOption(_440, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_444, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["replace ", args70[0], " ", args70[1]])); rs.drop(replaced); const _466: Key.Key | undefined = key(10); const part20 = option_map$150c7g4(rs.btreeKey(sorted, _466, false, rs.None), (o32: Key.Key | undefined): rs.u32 | undefined => { @@ -1080,8 +1056,7 @@ export function elements(log: Log.Log, id: rs.u32): void { return k7.id; }); }); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part20, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - const _458: string = rs.fmtFormat(["get ", args36[0]]); + const _458: string = rs.fmtFormat(["get ", (f: rs.Formatter) => rs.fmtOption(part20, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]); rs.drop(_466); Log.note(log, _458); const _477: Key.Key | undefined = key(10); @@ -1095,8 +1070,8 @@ export function elements(log: Log.Log, id: rs.u32): void { const _496: Key.Key | undefined = key(14); const _493: Key.Key | undefined | rs.None = rs.btreeKey(sorted, _496, true, rs.None); const _491: boolean = _493 !== rs.None; - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_487, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtBool(_491, f)]; - const _483: string = rs.fmtFormat(["take ", args38[0], " ", args38[1]]); + const args72 = [(f: rs.Formatter) => rs.fmtOption(_487, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtBool(_491, f)]; + const _483: string = rs.fmtFormat(["take ", args72[0], " ", args72[1]]); rs.drop(_493); rs.drop(_496); Log.note(log, _483); @@ -1115,8 +1090,8 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o35); return _042; }); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_522, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_526, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["popped ", args40[0], " ", args40[1]])); + const args73 = [(f: rs.Formatter) => rs.fmtOption(_522, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_526, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["popped ", args73[0], " ", args73[1]])); const hashed: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined), rs.eqOption(Key.eq$cmp_PartialEq))) as rs.HashSet; const _537: Key.Key | undefined = key(11); rs.hashAdd(hashed, _537, rs.drop); @@ -1125,8 +1100,7 @@ export function elements(log: Log.Log, id: rs.u32): void { return k9.id; }); }); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part23, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["hashed ", args42[0]])); + Log.note(log, rs.fmtFormat(["hashed ", (f: rs.Formatter) => rs.fmtOption(part23, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); rs.hashAdd(hashed, undefined as Key.Key | undefined, rs.drop); const _567: rs.u32 | undefined | rs.None = option_map$150c7g4(rs.hashKey(hashed, undefined, true, rs.None), (o37: Key.Key | undefined): rs.u32 | undefined => { const _045: rs.u32 | undefined = _348(o37); @@ -1138,8 +1112,8 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o38); return _046; }); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_567, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_571, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["taken ", args44[0], " ", args44[1]])); + const args75 = [(f: rs.Formatter) => rs.fmtOption(_567, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_571, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["taken ", args75[0], " ", args75[1]])); const _584: Key.Key | undefined = key(11); const replaced2: Key.Key | undefined | rs.None = rs.hashReplace(hashed, _584, rs.None); const part26 = option_map$150c7g4(replaced2, (o39: Key.Key | undefined): rs.u32 | undefined => { @@ -1147,8 +1121,7 @@ export function elements(log: Log.Log, id: rs.u32): void { return k10.id; }); }); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part26, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["replaced ", args46[0]])); + Log.note(log, rs.fmtFormat(["replaced ", (f: rs.Formatter) => rs.fmtOption(part26, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); rs.drop(replaced2); const _605: Key.Key | undefined = key(11); const held: Key.Key | undefined | rs.None = rs.hashKey(hashed, _605, true, rs.None); @@ -1158,13 +1131,12 @@ export function elements(log: Log.Log, id: rs.u32): void { rs.drop(o40); return _049; }); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part28, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["held ", args48[0]])); + Log.note(log, rs.fmtFormat(["held ", (f: rs.Formatter) => rs.fmtOption(part28, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); const _628: rs.usize = heap.items.length; const _631: rs.usize = rs.btreeLen(sorted); const _634: rs.usize = rs.hashLen(hashed); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_628, f), (f: rs.Formatter) => rs.usizeDisplay(_631, f), (f: rs.Formatter) => rs.usizeDisplay(_634, f)]; - Log.note(log, rs.fmtFormat(["left ", args50[0], " ", args50[1], " ", args50[2]])); + const args78 = [(f: rs.Formatter) => rs.usizeDisplay(_628, f), (f: rs.Formatter) => rs.usizeDisplay(_631, f), (f: rs.Formatter) => rs.usizeDisplay(_634, f)]; + Log.note(log, rs.fmtFormat(["left ", args78[0], " ", args78[1], " ", args78[2]])); rs.hashDrop(hashed, rs.drop); rs.btreeDrop(sorted, rs.drop); rs.heapDrop(heap, rs.drop); @@ -1180,9 +1152,9 @@ export function elements(log: Log.Log, id: rs.u32): void { */ export function arcs(log: Log.Log, id: rs.u32): void { const count: (a0: string, a1: rs.Arc) => undefined = (what: string, key: rs.Arc): undefined => { - const _92: rs.usize = key.strong; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, what), (f: rs.Formatter) => rs.usizeDisplay(_92, f)]; - Log.note(log, rs.fmtFormat([args14[0], " ", args14[1]])); + const _93: rs.usize = key.strong; + const args15 = [(f: rs.Formatter) => rs.fmtPad(f, what), (f: rs.Formatter) => rs.usizeDisplay(_93, f)]; + Log.note(log, rs.fmtFormat([args15[0], " ", args15[1]])); }; const name: rs.Arc = new rs.Arc("name"); const other: rs.Arc = new rs.Arc("other"); @@ -1212,8 +1184,8 @@ export function arcs(log: Log.Log, id: rs.u32): void { const min: rs.Arc = rs.ordMin(rs.arcClone(name), rs.arcClone(other), rs.cmpLt(rs.cmpArc(rs.cmpStr)), rs.drop); const _82: string = max.value; const _86: string = min.value; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _82), (f: rs.Formatter) => rs.fmtPad(f, _86)]; - Log.note(log, rs.fmtFormat(["max ", args2[0], " min ", args2[1]])); + const args16 = [(f: rs.Formatter) => rs.fmtPad(f, _82), (f: rs.Formatter) => rs.fmtPad(f, _86)]; + Log.note(log, rs.fmtFormat(["max ", args16[0], " min ", args16[1]])); count("name", name); count("other", other); lib_drop$tuple2_sync_Arc_str_sync_Arc_str([max, min] as [rs.Arc, rs.Arc]); @@ -1223,28 +1195,25 @@ export function arcs(log: Log.Log, id: rs.u32): void { const _113: rs.Place = rs.entryOrInsertMut(rs.entry(tags, 1), { tag: "One", _0: Guard.new(rs.u32Add(id, 2), Log.clone$Clone(log)) } as Held.Held, lib_drop$drops_Held); if (_113.v.tag === "One") { const part8 = Guard.id(_113.v._0); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; - Log.note(log, rs.fmtFormat(["tag ", args4[0]])); + Log.note(log, rs.fmtFormat(["tag ", (f: rs.Formatter) => rs.u32Display(part8, f)])); } rs.entryOrInsertMut(rs.entry(tags, 2), { tag: "Two", _0: Guard.new(rs.u32Add(id, 3), Log.clone$Clone(log)), _1: Guard.new(rs.u32Add(id, 4), Log.clone$Clone(log)) } as Held.Held, lib_drop$drops_Held); const part9 = rs.btreeLen(tags); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part9, f)]; - Log.note(log, rs.fmtFormat(["tags ", args6[0]])); + Log.note(log, rs.fmtFormat(["tags ", (f: rs.Formatter) => rs.usizeDisplay(part9, f)])); const shared: rs.Arc = new rs.Arc(Guard.new(rs.u32Add(id, 5), Log.clone$Clone(log))); const weak: rs.Weak = new rs.Weak(shared); const clone: rs.Arc = rs.arcClone(shared); const _176: Guard.Guard | undefined = rs.arcIntoInner(shared); const part10 = _176 !== undefined; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part10, f)]; - const _170: string = rs.fmtFormat(["into_inner ", args8[0]]); + const _170: string = rs.fmtFormat(["into_inner ", (f: rs.Formatter) => rs.fmtBool(part10, f)]); rs.drop(_176); Log.note(log, _170); const inner: Guard.Guard | undefined = rs.arcIntoInner(clone); const _188: rs.u32 | undefined = option_map$02u0dmi(inner, Guard.id); const _194: rs.Arc | undefined = rs.weakUpgrade(weak); const _192: boolean = _194 !== undefined; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_188, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_192, f)]; - const _184: string = rs.fmtFormat(["into_inner ", args10[0], " ", args10[1]]); + const args20 = [(f: rs.Formatter) => rs.fmtOption(_188, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_192, f)]; + const _184: string = rs.fmtFormat(["into_inner ", args20[0], " ", args20[1]]); rs.drop(_194); Log.note(log, _184); rs.drop(inner); @@ -1255,8 +1224,7 @@ export function arcs(log: Log.Log, id: rs.u32): void { const part11 = option_map$1x5kkz1(inner2, (o: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(o, Guard.id); }); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part11, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["rc ", args12[0]])); + Log.note(log, rs.fmtFormat(["rc ", (f: rs.Formatter) => rs.fmtOption(part11, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); rs.drop(inner2); rs.hashDrop(map, rs.drop); count("dropped", name); @@ -1378,15 +1346,13 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, rs.drop); const part24 = rs.sliceFrom(v.items); const part25 = ids(part24); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25)]; - Log.note(log, rs.fmtFormat(["retained ", args2[0]])); + Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, part25)])); rs.vecRetain(v, (k7: Key.Key): boolean => { return k7.id !== rs.u32Add(id, 3); }, rs.drop); const part26 = rs.sliceFrom(v.items); const part27 = ids(part26); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part27)]; - Log.note(log, rs.fmtFormat(["retained ", args4[0]])); + Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, part27)])); rs.dropVec(v); } else if (_8 === 1) { const v4: rs.Vec = new rs.Vec(); @@ -1404,22 +1370,19 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecDedupBy(v3, Key.eq$cmp_PartialEq, rs.drop); const part18 = rs.sliceFrom(v3.items); const part19 = ids(part18); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part19)]; - Log.note(log, rs.fmtFormat(["deduped ", args6[0]])); + Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part19)])); rs.vecDedupByKey(v3, (k5: Key.Key): rs.u32 => { return rs.u32Div(k5.id, 2); }, rs.same, rs.drop); const part20 = rs.sliceFrom(v3.items); const part21 = ids(part20); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21)]; - Log.note(log, rs.fmtFormat(["deduped ", args8[0]])); + Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part21)])); rs.vecDedupBy(v3, (a: Key.Key, b: Key.Key): boolean => { return a.id > b.id; }, rs.drop); const part22 = rs.sliceFrom(v3.items); const part23 = ids(part22); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23)]; - Log.note(log, rs.fmtFormat(["deduped ", args10[0]])); + Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part23)])); rs.dropVec(v3); } else if (_8 === 2) { const v6: rs.Vec = new rs.Vec(); @@ -1433,8 +1396,7 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecSwapRemove(v5, 0)[Symbol.dispose](); const part16 = rs.sliceFrom(v5.items); const part17 = ids(part16); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part17)]; - Log.note(log, rs.fmtFormat(["swapped ", args12[0]])); + Log.note(log, rs.fmtFormat(["swapped ", (f: rs.Formatter) => rs.fmtPad(f, part17)])); rs.vecSwapRemove(v5, 3)[Symbol.dispose](); rs.dropVec(v5); } else if (_8 === 3) { @@ -1447,8 +1409,7 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _209: rs.Vec = rs.vecFrom(v7.items.map(Key.clone$Clone)); const part14 = rs.sliceFrom(_209.items); const part15 = ids(part14); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15)]; - const _200: string = rs.fmtFormat(["cloned ", args14[0]]); + const _200: string = rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part15)]); rs.dropVec(_209); Log.note(log, _200); rs.dropVec(v7); @@ -1469,18 +1430,15 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecInsert(v9, 1, _244); const part8 = rs.sliceFrom(v9.items); const part9 = ids(part8); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part9)]; - Log.note(log, rs.fmtFormat(["inserted ", args16[0]])); + Log.note(log, rs.fmtFormat(["inserted ", (f: rs.Formatter) => rs.fmtPad(f, part9)])); rs.vecRemove(v9, 0)[Symbol.dispose](); const part10 = rs.sliceFrom(v9.items); const part11 = ids(part10); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11)]; - Log.note(log, rs.fmtFormat(["removed ", args18[0]])); + Log.note(log, rs.fmtFormat(["removed ", (f: rs.Formatter) => rs.fmtPad(f, part11)])); rs.vecTruncate(v9, 1, rs.drop); const part12 = rs.sliceFrom(v9.items); const part13 = ids(part12); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part13)]; - Log.note(log, rs.fmtFormat(["truncated ", args20[0]])); + Log.note(log, rs.fmtFormat(["truncated ", (f: rs.Formatter) => rs.fmtPad(f, part13)])); rs.vecTruncate(v9, 0, rs.drop); rs.dropVec(v9); } else if (_8 === 6) { @@ -1498,8 +1456,7 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { k3[Symbol.dispose](); return _05; }); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Log.note(log, rs.fmtFormat(["max ", args22[0]])); + Log.note(log, rs.fmtFormat(["max ", (f: rs.Formatter) => rs.u32Display(part6, f)])); const v12: rs.Vec = new rs.Vec(); const _339: Key.Key = key(3); v12.items.push(_339); @@ -1512,40 +1469,34 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { k4[Symbol.dispose](); return _06; }); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["min ", args24[0]])); + Log.note(log, rs.fmtFormat(["min ", (f: rs.Formatter) => rs.u32Display(part7, f)])); } else if (_8 === 7) { const boxed: Key.Key = key(1); const _377: Key.Key = Key.clone$Clone(boxed); const part5 = rs.u32Sub(_377.id, id); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - const _371: string = rs.fmtFormat(["boxed ", args26[0]]); + const _371: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.u32Display(part5, f)]); _377[Symbol.dispose](); Log.note(log, _371); boxed[Symbol.dispose](); } else { const _392: Key.Key = rs.ordMax(key(1), key(2), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part = rs.u32Sub(_392.id, id); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - const _386: string = rs.fmtFormat(["max ", args28[0]]); + const _386: string = rs.fmtFormat(["max ", (f: rs.Formatter) => rs.u32Display(part, f)]); _392[Symbol.dispose](); Log.note(log, _386); const _412: Key.Key = rs.ordMin(key(5), key(4), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part2 = rs.u32Sub(_412.id, id); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - const _406: string = rs.fmtFormat(["min ", args30[0]]); + const _406: string = rs.fmtFormat(["min ", (f: rs.Formatter) => rs.u32Display(part2, f)]); _412[Symbol.dispose](); Log.note(log, _406); const _432: Key.Key = rs.ordClamp(key(2), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part3 = rs.u32Sub(_432.id, id); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _426: string = rs.fmtFormat(["clamped ", args32[0]]); + const _426: string = rs.fmtFormat(["clamped ", (f: rs.Formatter) => rs.u32Display(part3, f)]); _432[Symbol.dispose](); Log.note(log, _426); const _455: Key.Key = rs.ordClamp(key(0), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part4 = rs.u32Sub(_455.id, id); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - const _449: string = rs.fmtFormat(["clamped ", args34[0]]); + const _449: string = rs.fmtFormat(["clamped ", (f: rs.Formatter) => rs.u32Display(part4, f)]); _455[Symbol.dispose](); Log.note(log, _449); } diff --git a/ts/fixtures/task/expected/drops/called.ts b/ts/fixtures/task/expected/drops/called.ts index a7ec4cf94..e0d57542a 100644 --- a/ts/fixtures/task/expected/drops/called.ts +++ b/ts/fixtures/task/expected/drops/called.ts @@ -37,9 +37,9 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured33 = id; const n: rs.u32 | undefined = rs.iterTryFold(it, 0, rs.closure((n17: rs.u32, g24: Guard.Guard): rs.u32 | undefined => { const _1014: rs.u32 = Guard.id(g24); - const _1317: rs.u32 = Guard.id(captured32); - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1014, f), (f: rs.Formatter) => rs.u32Display(_1317, f)]; - Log.note(log, rs.fmtFormat(["try ", args82[0], " ", args82[1]])); + const _1318: rs.u32 = Guard.id(captured32); + const args121 = [(f: rs.Formatter) => rs.u32Display(_1014, f), (f: rs.Formatter) => rs.u32Display(_1318, f)]; + Log.note(log, rs.fmtFormat(["try ", args121[0], " ", args121[1]])); const _039: rs.u32 | undefined = thenSome$1bahm2u(Guard.id(g24) !== rs.u32Add(captured33, 3), rs.u32Sub(rs.u32Add(n17, Guard.id(g24)), captured33)); g24[Symbol.dispose](); return _039; @@ -51,16 +51,16 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { g25[Symbol.dispose](); return _040; }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(n, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_32, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["broke ", args2[0], " ", args2[1]])); + const args122 = [(f: rs.Formatter) => rs.fmtOption(n, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_32, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["broke ", args122[0], " ", args122[1]])); const m: rs.u32 | undefined = rs.iterTryFold(it, 0, (n18: rs.u32, g26: Guard.Guard): rs.u32 | undefined => { const _041: rs.u32 | undefined = rs.u32Sub(rs.u32Add(n18, Guard.id(g26)), id); g26[Symbol.dispose](); return _041; }, true); const _51: rs.u32 = Guard.id(d); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(m, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_51, f)]; - Log.note(log, rs.fmtFormat(["ended ", args4[0], " ", args4[1]])); + const args123 = [(f: rs.Formatter) => rs.fmtOption(m, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_51, f)]; + Log.note(log, rs.fmtFormat(["ended ", args123[0], " ", args123[1]])); rs.drop(it); } else if (_17 === 1) { const _60: rs.Iter = rs.iterChain(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 6), rs.drop)); @@ -71,11 +71,11 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured31[Symbol.dispose](); })); - const part17 = result_mapErr$18fct1o(rs.iterTryFold(it2, 0, (n15: rs.u32, _335: [Guard.Guard, rs.u32]): rs.Result => { + const part17 = result_mapErr$18fct1o(rs.iterTryFold(it2, 0, (n15: rs.u32, _336: [Guard.Guard, rs.u32]): rs.Result => { let _036!: rs.Result; let _2112: boolean = false; _2112 = true; - const g21: Guard.Guard = _335[0]; + const g21: Guard.Guard = _336[0]; if (!(Guard.id(g21) === rs.u32Add(id, 4))) { _036 = rs.Ok(rs.u32Sub(rs.u32Add(n15, Guard.id(g21)), id)); } else { @@ -92,17 +92,16 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { g22[Symbol.dispose](); return _037; }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part17, f, rs.u32Debug, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["err ", args6[0]])); - const r2: rs.Result = rs.iterTryFold(it2, 0, (n16: rs.u32, _336: [Guard.Guard, rs.u32]): rs.Result => { - const g23: Guard.Guard = _336[0]; + Log.note(log, rs.fmtFormat(["err ", (f: rs.Formatter) => rs.fmtResult(part17, f, rs.u32Debug, rs.u32Debug)])); + const r2: rs.Result = rs.iterTryFold(it2, 0, (n16: rs.u32, _340: [Guard.Guard, rs.u32]): rs.Result => { + const g23: Guard.Guard = _340[0]; const _038: rs.Result = rs.Ok(rs.u32Sub(rs.u32Add(n16, Guard.id(g23)), id)); g23[Symbol.dispose](); return _038; }); const _94: rs.u32 = Guard.id(d); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r2, f, rs.u32Debug, rs.fmtUnit), (f: rs.Formatter) => rs.u32Display(_94, f)]; - Log.note(log, rs.fmtFormat(["ok ", args8[0], " ", args8[1]])); + const args118 = [(f: rs.Formatter) => rs.fmtResult(r2, f, rs.u32Debug, rs.fmtUnit), (f: rs.Formatter) => rs.u32Display(_94, f)]; + Log.note(log, rs.fmtFormat(["ok ", args118[0], " ", args118[1]])); rs.drop(it2); } else if (_17 === 2) { const _103: rs.Iter = rs.iterRev(rs.vecIntoIter(guards(1, 6), rs.drop)); @@ -115,15 +114,15 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }), rs.drop); const r3: rs.Result = rs.iterTryFold(it3, 0, (n13: rs.u32, g18: Guard.Guard): rs.Result => { let _033!: rs.Result; - let _2013: boolean = false; - _2013 = true; + let _2015: boolean = false; + _2015 = true; if (!(Guard.id(g18) === rs.u32Add(id, 3))) { _033 = rs.Ok(rs.u32Sub(rs.u32Add(n13, Guard.id(g18)), id)); } else { - _2013 = false; + _2015 = false; _033 = rs.Err(g18); } - if (_2013) { + if (_2015) { g18[Symbol.dispose](); return _033; } @@ -136,8 +135,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { broke = Guard.id(g); g[Symbol.dispose](); } - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(broke, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["break ", args10[0]])); + Log.note(log, rs.fmtFormat(["break ", (f: rs.Formatter) => rs.fmtOption(broke, f, rs.u32Debug)])); const _130: rs.Iter = rs.vecIntoIter(new rs.Vec(), rs.drop); _678 = false; const captured30 = d; @@ -149,8 +147,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured30[Symbol.dispose](); }), true, true); rs.drop(_130); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(none, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["none ", args12[0]])); + Log.note(log, rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtOption(none, f, rs.u32Debug)])); rs.drop(it3); } else if (_17 === 3) { const it4: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); @@ -161,8 +158,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { let _029!: rs.Result; if (!(Guard.id(g14) === rs.u32Add(captured26, 2))) { const part13 = Guard.id(g14); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; - Log.note(log, rs.fmtFormat(["each ", args80[0]])); + Log.note(log, rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part13, f)])); _029 = rs.OK; } else { _029 = rs.Err(rs.u32Sub(rs.u32Add(Guard.id(g14), Guard.id(captured27)), Guard.id(captured27))); @@ -172,8 +168,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured27[Symbol.dispose](); }), undefined, true); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part14, f, rs.fmtUnit, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["each ", args14[0]])); + Log.note(log, rs.fmtFormat(["each ", (f: rs.Formatter) => rs.fmtResult(part14, f, rs.fmtUnit, rs.u32Debug)])); const part15 = rs.iterTryForEach(it4, (g15: Guard.Guard): rs.Result => { let _030!: rs.Result; if (!(Guard.id(g15) === rs.u32Add(id, 4))) { @@ -184,8 +179,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { g15[Symbol.dispose](); return _030; }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(part15, f, rs.fmtUnit, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["flow ", args16[0]])); + Log.note(log, rs.fmtFormat(["flow ", (f: rs.Formatter) => rs.fmtControlFlow(part15, f, rs.fmtUnit, rs.u32Debug)])); _678 = false; const captured28 = d; const part16 = rs.iterTryForEach(it4, rs.closure((g16: Guard.Guard): undefined | rs.None => { @@ -195,8 +189,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured28[Symbol.dispose](); }), true, true, rs.None); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part16, f, rs.fmtUnit, rs.None)]; - Log.note(log, rs.fmtFormat(["some ", args18[0]])); + Log.note(log, rs.fmtFormat(["some ", (f: rs.Formatter) => rs.fmtOption(part16, f, rs.fmtUnit, rs.None)])); rs.drop(it4); } else if (_17 === 4) { const _190: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); @@ -205,8 +198,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _189: [rs.Vec, rs.Vec] = rs.iterPartition(_190, rs.closure((g11: Guard.Guard): boolean => { const _913: rs.u32 = Guard.id(g11); const _1115: rs.u32 = Guard.id(captured22); - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_913, f), (f: rs.Formatter) => rs.u32Display(_1115, f)]; - Log.note(log, rs.fmtFormat(["side ", args78[0], " ", args78[1]])); + const args105 = [(f: rs.Formatter) => rs.u32Display(_913, f), (f: rs.Formatter) => rs.u32Display(_1115, f)]; + Log.note(log, rs.fmtFormat(["side ", args105[0], " ", args105[1]])); return rs.u32Rem(Guard.id(g11), 2) === 1; }, (): void => { captured22[Symbol.dispose](); @@ -214,16 +207,15 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const odd: rs.Vec = _189[0]; const even: rs.Vec = _189[1]; const part12 = rs.iterToVec(rs.iterMap(rs.iterSlice(odd.items), Guard.id), undefined, 4, true); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part12.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["odd ", args20[0]])); + Log.note(log, rs.fmtFormat(["odd ", (f: rs.Formatter) => rs.fmtList(part12.items, f, rs.u32Debug)])); rs.dropVec(even); const _213: [rs.Vec, rs.Vec] = rs.iterPartition(new rs.Range(1, 4), (_220: rs.u32): boolean => { return true; }, [new rs.Vec() as rs.Vec, new rs.Vec() as rs.Vec], rs.vecPart(4)); const all: rs.Vec = _213[0]; const none2: rs.Vec = _213[1]; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(none2.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["all ", args22[0], " ", args22[1]])); + const args107 = [(f: rs.Formatter) => rs.fmtList(all.items, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(none2.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["all ", args107[0], " ", args107[1]])); const e: Guard.Guard = guard(22); const _234: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); const captured23 = e; @@ -244,8 +236,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const high: rs.Vec = _232[1]; const _246: rs.usize = low.items.length; const _249: rs.usize = high.items.length; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_246, f), (f: rs.Formatter) => rs.usizeDisplay(_249, f)]; - Log.note(log, rs.fmtFormat(["sides ", args24[0], " ", args24[1]])); + const args108 = [(f: rs.Formatter) => rs.usizeDisplay(_246, f), (f: rs.Formatter) => rs.usizeDisplay(_249, f)]; + Log.note(log, rs.fmtFormat(["sides ", args108[0], " ", args108[1]])); rs.dropVec(high); rs.dropVec(low); rs.dropVec(odd); @@ -257,15 +249,14 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const made: rs.Vec = rs.iterToVec(rs.iterTake(rs.iterRepeatWith(rs.closure((): Guard.Guard => { captured18 = rs.u32Add(captured18, 1); const _912: rs.u32 = Guard.id(captured19); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(captured18, f), (f: rs.Formatter) => rs.u32Display(_912, f)]; - Log.note(log, rs.fmtFormat(["make ", args76[0], " ", args76[1]])); + const args100 = [(f: rs.Formatter) => rs.u32Display(captured18, f), (f: rs.Formatter) => rs.u32Display(_912, f)]; + Log.note(log, rs.fmtFormat(["make ", args100[0], " ", args100[1]])); return captured20(captured18); }, (): void => { captured19[Symbol.dispose](); })), 3, rs.drop), "fold", 8, true); const part11 = made.items.length; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part11, f)]; - Log.note(log, rs.fmtFormat(["made ", args26[0]])); + Log.note(log, rs.fmtFormat(["made ", (f: rs.Formatter) => rs.usizeDisplay(part11, f)])); _678 = false; const captured21 = d; const it5: rs.Iter = rs.iterRepeatWith(rs.closure((): rs.u32 => { @@ -276,8 +267,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _280: rs.u32 | undefined = rs.iterToOption(it5.next()); const _283: [rs.usize, rs.usize | undefined] = it5.sizeHint(); const _286: [rs.usize, rs.usize | undefined] = rs.iterTake(rs.iterBorrow(it5), 2).sizeHint(); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_280, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_283[0], f), (f: rs.Formatter) => rs.fmtOption(_283[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_286[0], f), (f: rs.Formatter) => rs.fmtOption(_286[1], f, rs.usizeDebug)], f)]; - Log.note(log, rs.fmtFormat(["first ", args28[0], " ", args28[1], " ", args28[2]])); + const args102 = [(f: rs.Formatter) => rs.fmtOption(_280, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_283[0], f), (f: rs.Formatter) => rs.fmtOption(_283[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_286[0], f), (f: rs.Formatter) => rs.fmtOption(_286[1], f, rs.usizeDebug)], f)]; + Log.note(log, rs.fmtFormat(["first ", args102[0], " ", args102[1], " ", args102[2]])); rs.drop(it5); Log.note(log, "dropped"); rs.dropVec(made); @@ -287,12 +278,12 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured13 = id; const captured14 = c; const it6: rs.Iter = rs.iterScan(_303, 0, rs.closure((sum: rs.Place, g9: Guard.Guard): rs.u32 | undefined => { - const _433: rs.u32 = rs.u32Sub(Guard.id(g9), captured13); - sum.v = rs.u32Add(sum.v, _433); - const _169: rs.u32 = Guard.id(g9); + const _436: rs.u32 = rs.u32Sub(Guard.id(g9), captured13); + sum.v = rs.u32Add(sum.v, _436); + const _1610: rs.u32 = Guard.id(g9); const _1910: rs.u32 = Guard.id(captured14); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_169, f), (f: rs.Formatter) => rs.u32Display(sum.v, f), (f: rs.Formatter) => rs.u32Display(_1910, f)]; - Log.note(log, rs.fmtFormat(["scan ", args72[0], " ", args72[1], " ", args72[2]])); + const args91 = [(f: rs.Formatter) => rs.u32Display(_1610, f), (f: rs.Formatter) => rs.u32Display(sum.v, f), (f: rs.Formatter) => rs.u32Display(_1910, f)]; + Log.note(log, rs.fmtFormat(["scan ", args91[0], " ", args91[1], " ", args91[2]])); const _020: rs.u32 | undefined = thenSome$1bahm2u(sum.v < 10, sum.v); g9[Symbol.dispose](); return _020; @@ -301,15 +292,14 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }), true); const sums: rs.Vec = rs.iterToVec(rs.iterBorrow(it6), "next", 4); const _317: rs.u32 | undefined = rs.iterToOption(it6.next()); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(sums.items, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_317, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["sums ", args30[0], " ", args30[1]])); + const args92 = [(f: rs.Formatter) => rs.fmtList(sums.items, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_317, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["sums ", args92[0], " ", args92[1]])); rs.drop(it6); const part9 = rs.iterSum(rs.iterScan(new rs.Range(1, 4), 1, (n11: rs.Place, k2: rs.u32): rs.u32 | undefined => { n11.v = rs.u32Mul(n11.v, k2); return n11.v; }, true), rs.u32Add, 0); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; - Log.note(log, rs.fmtFormat(["total ", args32[0]])); + Log.note(log, rs.fmtFormat(["total ", (f: rs.Formatter) => rs.u32Display(part9, f)])); const e2: Guard.Guard = guard(22); const v: rs.Vec> = new rs.Vec(); const _351: rs.Vec = guards(1, 3); @@ -324,10 +314,10 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured17 = e2; const part10 = rs.iterFold(rs.iterScan(_345, _359, rs.closure((held: Guard.Guard, g10: Guard.Guard): rs.u32 | undefined => { const _109: rs.u32 = Guard.id(held); - const _1311: rs.u32 = Guard.id(g10); - const _1610: rs.u32 = Guard.id(captured15); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_109, f), (f: rs.Formatter) => rs.u32Display(_1311, f), (f: rs.Formatter) => rs.u32Display(_1610, f)]; - Log.note(log, rs.fmtFormat(["held ", args74[0], " ", args74[1], " ", args74[2]])); + const _1312: rs.u32 = Guard.id(g10); + const _1611: rs.u32 = Guard.id(captured15); + const args96 = [(f: rs.Formatter) => rs.u32Display(_109, f), (f: rs.Formatter) => rs.u32Display(_1312, f), (f: rs.Formatter) => rs.u32Display(_1611, f)]; + Log.note(log, rs.fmtFormat(["held ", args96[0], " ", args96[1], " ", args96[2]])); const _022: rs.u32 | undefined = thenSome$1bahm2u(Guard.id(g10) !== rs.u32Add(captured16, 4), rs.u32Sub(rs.u32Add(Guard.id(g10), Guard.id(captured17)), Guard.id(captured17))); g10[Symbol.dispose](); return _022; @@ -337,8 +327,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }), undefined, rs.drop), 0, (n12: rs.u32, k3: rs.u32): rs.u32 => { return rs.u32Sub(rs.u32Add(n12, k3), id); }, true); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; - Log.note(log, rs.fmtFormat(["flat ", args34[0]])); + Log.note(log, rs.fmtFormat(["flat ", (f: rs.Formatter) => rs.u32Display(part10, f)])); } else if (_17 === 7) { const v2: rs.Vec = rs.iterToVec(rs.iterSlice(rs.arrayMap([3, 1, 4, 5, 2], guard), rs.drop), "fold", 8, true); const _380: rs.Slice = rs.sliceFrom(v2.items); @@ -347,29 +336,26 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.sliceSortByCachedKey(_380, rs.closure((g8: Guard.Guard): Key.Key => { const _910: rs.u32 = Guard.id(g8); const _1113: rs.u32 = Guard.id(captured12); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1113, f)]; - Log.note(log, rs.fmtFormat(["key ", args70[0], " ", args70[1]])); + const args86 = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1113, f)]; + Log.note(log, rs.fmtFormat(["key ", args86[0], " ", args86[1]])); return Key.new(rs.u32Rem(rs.u32Mul(Guard.id(g8), 7), 5), Log.clone$Clone(log)); }, (): void => { captured12[Symbol.dispose](); }), rs.cmpLt(rs.cmpTuple<[Key.Key, rs.usize], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 16, true, false, true, rs.drop); const part8 = rs.iterToVec(rs.iterMap(rs.iterSlice(v2.items), Guard.id), undefined, 4, true); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part8.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["sorted ", args36[0]])); + Log.note(log, rs.fmtFormat(["sorted ", (f: rs.Formatter) => rs.fmtList(part8.items, f, rs.u32Debug)])); const w: rs.Vec = rs.vecFrom([3, 1, 2]); rs.sliceSortByCachedKey(rs.sliceFrom(w.items), (_210: rs.u32): rs.u32 => { return rs.u32Add(_210, Guard.id(d)); }, rs.cmpLt(rs.cmpTuple<[rs.u32, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(w.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["rev ", args38[0]])); + Log.note(log, rs.fmtFormat(["rev ", (f: rs.Formatter) => rs.fmtList(w.items, f, rs.u32Debug)])); rs.dropVec(v2); } else if (_17 === 8) { _679 = false; const captured9 = c; const lazy: rs.LazyCell = new rs.LazyCell(rs.closure((): rs.u32 => { const part6 = Guard.id(captured9); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Log.note(log, rs.fmtFormat(["force ", args68[0]])); + Log.note(log, rs.fmtFormat(["force ", (f: rs.Formatter) => rs.u32Display(part6, f)])); const _015: rs.u32 = rs.u32Add(Guard.id(captured9), 1); captured9[Symbol.dispose](); return _015; @@ -379,8 +365,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, "made"); const _425: rs.u32 = lazy.force(); const _427: rs.u32 = lazy.force(); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_425, f), (f: rs.Formatter) => rs.u32Display(_427, f)]; - Log.note(log, rs.fmtFormat(["forced ", args40[0], " ", args40[1]])); + const args82 = [(f: rs.Formatter) => rs.u32Display(_425, f), (f: rs.Formatter) => rs.u32Display(_427, f)]; + Log.note(log, rs.fmtFormat(["forced ", args82[0], " ", args82[1]])); _678 = false; const captured10 = d; rs.lazyDrop(new rs.LazyCell(rs.closure((): rs.u32 => { @@ -398,8 +384,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured11[Symbol.dispose](); }))); const part7 = lazy2.force(); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["by Fn ", args42[0]])); + Log.note(log, rs.fmtFormat(["by Fn ", (f: rs.Formatter) => rs.u32Display(part7, f)])); rs.lazyDrop(lazy2, undefined, rs.drop); rs.lazyDrop(lazy, undefined, rs.drop); } else if (_17 === 9) { @@ -408,8 +393,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured6 = c; rs.cellUpdate(cell, rs.closure((n7: rs.u32): rs.u32 => { const _93: rs.u32 = Guard.id(captured6); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n7, f), (f: rs.Formatter) => rs.u32Display(_93, f)]; - Log.note(log, rs.fmtFormat(["update ", args62[0], " ", args62[1]])); + const args68 = [(f: rs.Formatter) => rs.u32Display(n7, f), (f: rs.Formatter) => rs.u32Display(_93, f)]; + Log.note(log, rs.fmtFormat(["update ", args68[0], " ", args68[1]])); const _010: rs.u32 = rs.u32Add(n7, 1); captured6[Symbol.dispose](); return _010; @@ -417,23 +402,22 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured6[Symbol.dispose](); })); const part = cell.v; - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["updated ", args44[0]])); + Log.note(log, rs.fmtFormat(["updated ", (f: rs.Formatter) => rs.u32Display(part, f)])); const cell2: rs.RefCell = new rs.RefCell(5); const old: rs.u32 = rs.refCellReplaceWith(cell2, (n8: rs.Place): rs.u32 => { const _95: rs.u32 = Guard.id(d); const _137: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell2); const _1110: boolean = !_137.ok; - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8.v, f), (f: rs.Formatter) => rs.u32Display(_95, f), (f: rs.Formatter) => rs.fmtBool(_1110, f)]; - const _511: string = rs.fmtFormat(["replace ", args64[0], " ", args64[1], " ", args64[2]]); + const args72 = [(f: rs.Formatter) => rs.u32Display(n8.v, f), (f: rs.Formatter) => rs.u32Display(_95, f), (f: rs.Formatter) => rs.fmtBool(_1110, f)]; + const _512: string = rs.fmtFormat(["replace ", args72[0], " ", args72[1], " ", args72[2]]); lib_drop$Result_cell_Ref_u32_cell_BorrowError(_137); - Log.note(log, _511); + Log.note(log, _512); n8.v = rs.u32Add(n8.v, 1); return rs.u32Mul(n8.v, 2); }, true); const _484: rs.RefCell = rs.refCellBorrow(cell2); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(old, f), (f: rs.Formatter) => rs.u32Display(_484.value, f)]; - const _480: string = rs.fmtFormat(["replaced ", args46[0], " ", args46[1]]); + const args73 = [(f: rs.Formatter) => rs.u32Display(old, f), (f: rs.Formatter) => rs.u32Display(_484.value, f)]; + const _480: string = rs.fmtFormat(["replaced ", args73[0], " ", args73[1]]); rs.refRelease(_484); Log.note(log, _480); const _494: [Guard.Guard, Guard.Guard] = [guard(22), guard(23)]; @@ -459,16 +443,14 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _155: rs.u32[] = copy$array_u32(pair.v); const part2 = p[0]; const part3 = _155[0]; - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f), (f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["pair ", args66[0], " ", args66[1]])); + const args76 = [(f: rs.Formatter) => rs.u32Display(part2, f), (f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["pair ", args76[0], " ", args76[1]])); return copy$array_u32(p); }); - const part4 = copy$array_u32(pair.v); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["paired ", args48[0]])); + const part4 = rs.sliceFrom(copy$array_u32(pair.v)); + Log.note(log, rs.fmtFormat(["paired ", (f: rs.Formatter) => rs.fmtList(rs.sliceItems(part4), f, rs.u32Debug)])); const part5 = rs.refCellReplaceWith(cell2, rs.once(doubled), true); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - Log.note(log, rs.fmtFormat(["by Fn ", args50[0]])); + Log.note(log, rs.fmtFormat(["by Fn ", (f: rs.Formatter) => rs.u32Display(part5, f)])); } else if (_17 === 10) { const _539: rs.Iter = _536(); _679 = false; @@ -481,8 +463,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured3[Symbol.dispose](); }), undefined, true); rs.drop(_539); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r7, f, rs.u32Debug, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["fold ", args52[0]])); + Log.note(log, rs.fmtFormat(["fold ", (f: rs.Formatter) => rs.fmtResult(r7, f, rs.u32Debug, rs.u32Debug)])); const _554: rs.Iter = _536(); _678 = false; const captured4 = d; @@ -494,8 +475,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured4[Symbol.dispose](); }), true, true, rs.None); rs.drop(_554); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(r8, f, rs.fmtUnit, rs.None)]; - Log.note(log, rs.fmtFormat(["each ", args54[0]])); + Log.note(log, rs.fmtFormat(["each ", (f: rs.Formatter) => rs.fmtOption(r8, f, rs.fmtUnit, rs.None)])); const _569: [rs.Vec, rs.Vec] = rs.iterPartition(_536(), (g5: Guard.Guard): boolean => { return Guard.id(g5) > 0; }, [new rs.Vec() as rs.Vec, new rs.Vec() as rs.Vec], rs.vecPart(8), true); @@ -503,8 +483,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const b: rs.Vec = _569[1]; const _578: rs.usize = a.items.length; const _581: rs.usize = b.items.length; - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_578, f), (f: rs.Formatter) => rs.usizeDisplay(_581, f)]; - Log.note(log, rs.fmtFormat(["sides ", args56[0], " ", args56[1]])); + const args64 = [(f: rs.Formatter) => rs.usizeDisplay(_578, f), (f: rs.Formatter) => rs.usizeDisplay(_581, f)]; + Log.note(log, rs.fmtFormat(["sides ", args64[0], " ", args64[1]])); const scanned: rs.Vec = rs.iterToVec(rs.iterScan(_536(), 0, (n6: rs.Place, g6: Guard.Guard): rs.u32 | undefined => { const _08: rs.u32 | undefined = rs.u32Add(n6.v, Guard.id(g6)); g6[Symbol.dispose](); @@ -524,8 +504,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _612: rs.usize = scanned.items.length; const _615: rs.usize = empty.items.length; const _618: rs.usize = one.items.length; - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_612, f), (f: rs.Formatter) => rs.usizeDisplay(_615, f), (f: rs.Formatter) => rs.usizeDisplay(_618, f)]; - Log.note(log, rs.fmtFormat(["scanned ", args58[0], " ", args58[1], " ", args58[2]])); + const args65 = [(f: rs.Formatter) => rs.usizeDisplay(_612, f), (f: rs.Formatter) => rs.usizeDisplay(_615, f), (f: rs.Formatter) => rs.usizeDisplay(_618, f)]; + Log.note(log, rs.fmtFormat(["scanned ", args65[0], " ", args65[1], " ", args65[2]])); rs.dropVec(one); rs.dropVec(empty); rs.dropVec(b); @@ -537,11 +517,11 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured2 = a2; rs.iterTryFold(_631, 0, rs.closure((n4: rs.u32, g2: Guard.Guard): rs.u32 | undefined => { if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { - const _142: rs.u32 = Guard.id(g2); - const _173: rs.u32 = Guard.id(captured2); + const _143: rs.u32 = Guard.id(g2); + const _174: rs.u32 = Guard.id(captured2); const _205: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_142, f), (f: rs.Formatter) => rs.u32Display(_173, f), (f: rs.Formatter) => rs.fmtPad(f, _205)]; - rs.panicFmt(["try_fold of g", args60[0], " with g", args60[1], " after\n", args60[2]]); + const args61 = [(f: rs.Formatter) => rs.u32Display(_143, f), (f: rs.Formatter) => rs.u32Display(_174, f), (f: rs.Formatter) => rs.fmtPad(f, _205)]; + rs.panicFmt(["try_fold of g", args61[0], " with g", args61[1], " after\n", args61[2]]); } else { const _04: rs.u32 | undefined = rs.u32Add(n4, Guard.id(g2)); g2[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/closures.ts b/ts/fixtures/task/expected/drops/closures.ts index 0d9ac7ec7..d4fc29c1e 100644 --- a/ts/fixtures/task/expected/drops/closures.ts +++ b/ts/fixtures/task/expected/drops/closures.ts @@ -58,21 +58,18 @@ export function scoped(log: Log.Log, id: rs.u32): void { captured2[Symbol.dispose](); }); const part = rs.u32Add(read(1), read(2)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["read ", args2[0]])); + Log.note(log, rs.fmtFormat(["read ", (f: rs.Formatter) => rs.u32Display(part, f)])); rs.drop(unused); const captured4 = guard(4); const part2 = once$u32_drops_closures_scoped_closure3(rs.closure((): rs.u32 => { const n3: rs.u32 = Guard.id(captured4); captured4[Symbol.dispose](); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n3, f)]; - Log.note(log, rs.fmtFormat(["moved ", args16[0]])); + Log.note(log, rs.fmtFormat(["moved ", (f: rs.Formatter) => rs.u32Display(n3, f)])); return n3; }, (): void => { captured4[Symbol.dispose](); })); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["moved ", args4[0]])); + Log.note(log, rs.fmtFormat(["moved ", (f: rs.Formatter) => rs.u32Display(part2, f)])); const captured5 = guard(5); const part3 = once$u32_drops_closures_scoped_closure4(rs.closure((): rs.u32 => { const _04: rs.u32 = Guard.id(captured5); @@ -81,24 +78,21 @@ export function scoped(log: Log.Log, id: rs.u32): void { }, (): void => { captured5[Symbol.dispose](); })); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["kept ", args6[0]])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.u32Display(part3, f)])); const captured6 = guard(6); const part4 = once$u32_drops_closures_scoped_closure5(rs.closure((): rs.u32 => { return Guard.id(captured6); }, (): void => { captured6[Symbol.dispose](); })); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["by ref ", args8[0]])); + Log.note(log, rs.fmtFormat(["by ref ", (f: rs.Formatter) => rs.u32Display(part4, f)])); const captured7 = guard(7); const part5 = twice$drops_closures_scoped_closure10(1, rs.closure((n4: rs.u32): rs.u32 => { return rs.u32Add(n4, Guard.id(captured7)); }, (): void => { captured7[Symbol.dispose](); })); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - Log.note(log, rs.fmtFormat(["twice ", args10[0]])); + Log.note(log, rs.fmtFormat(["twice ", (f: rs.Formatter) => rs.u32Display(part5, f)])); const captured8 = guard(8); const holder: Holder.Holder<(a0: rs.u32) => rs.u32> = new Holder.Holder(rs.closure((n5: rs.u32): rs.u32 => { return rs.u32Add(n5, Guard.id(captured8)); @@ -106,8 +100,7 @@ export function scoped(log: Log.Log, id: rs.u32): void { captured8[Symbol.dispose](); }), guard(9)); const part6 = rs.u32Add(holder.f(1), Guard.id(holder.guard)); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Log.note(log, rs.fmtFormat(["holder ", args12[0]])); + Log.note(log, rs.fmtFormat(["holder ", (f: rs.Formatter) => rs.u32Display(part6, f)])); const captured9 = guard(10); const captured10 = rs.closure((n6: rs.u32): rs.u32 => { return rs.u32Add(n6, Guard.id(captured9)); @@ -119,8 +112,7 @@ export function scoped(log: Log.Log, id: rs.u32): void { }, (): void => { rs.drop(captured10); })); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["outer ", args14[0]])); + Log.note(log, rs.fmtFormat(["outer ", (f: rs.Formatter) => rs.u32Display(part7, f)])); holder[Symbol.dispose](); let captured11 = new rs.Vec(); const push: (a0: Guard.Guard) => rs.usize = rs.closure((g2: Guard.Guard): rs.usize => { @@ -167,8 +159,8 @@ export function discarded(log: Log.Log, id: rs.u32): void { }, (): void => { captured2[Symbol.dispose](); })); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(mapped, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(unmapped, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["map ", args2[0], " ", args2[1]])); + const args17 = [(f: rs.Formatter) => rs.fmtOption(mapped, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(unmapped, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["map ", args17[0], " ", args17[1]])); const ok: rs.Result = rs.Ok(id); const err: rs.Result = rs.Err(id); const _38: [Guard.Guard, Guard.Guard, Guard.Guard, Guard.Guard] = [guard(3), guard(4), guard(5), guard(6)]; @@ -208,8 +200,8 @@ export function discarded(log: Log.Log, id: rs.u32): void { }, (): void => { captured6[Symbol.dispose](); }))]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(values[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(values[1], f, rs.u32Debug, rs.u32Debug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(errors[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(errors[1], f, rs.u32Debug, rs.u32Debug)], f)]; - Log.note(log, rs.fmtFormat(["result ", args4[0], " ", args4[1]])); + const args18 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(values[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(values[1], f, rs.u32Debug, rs.u32Debug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(errors[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(errors[1], f, rs.u32Debug, rs.u32Debug)], f)]; + Log.note(log, rs.fmtFormat(["result ", args18[0], " ", args18[1]])); const _75: [Guard.Guard, Guard.Guard] = [guard(7), guard(8)]; const g: Guard.Guard = _75[0]; const h: Guard.Guard = _75[1]; @@ -235,8 +227,7 @@ export function discarded(log: Log.Log, id: rs.u32): void { const captured9 = i; const _97: rs.Result = inspectErr$1vjhjw3(ok, rs.closure((_2: rs.u32): undefined => { const part = Guard.id(captured9); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args18[0]])); + Log.note(log, rs.fmtFormat(["inspect ", (f: rs.Formatter) => rs.u32Display(part, f)])); captured9[Symbol.dispose](); }, (): void => { captured9[Symbol.dispose](); @@ -244,14 +235,13 @@ export function discarded(log: Log.Log, id: rs.u32): void { const captured10 = j; const inspected: [rs.Result, rs.Result] = [_97, inspectErr$1vjhjw3(err, rs.closure((_24: rs.u32): undefined => { const part2 = Guard.id(captured10); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args20[0]])); + Log.note(log, rs.fmtFormat(["inspect ", (f: rs.Formatter) => rs.u32Display(part2, f)])); captured10[Symbol.dispose](); }, (): void => { captured10[Symbol.dispose](); }))]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(chained[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(chained[1], f, rs.u32Debug, rs.u32Debug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(inspected[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(inspected[1], f, rs.u32Debug, rs.u32Debug)], f)]; - Log.note(log, rs.fmtFormat(["chained ", args6[0], " ", args6[1]])); + const args25 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(chained[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(chained[1], f, rs.u32Debug, rs.u32Debug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(inspected[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(inspected[1], f, rs.u32Debug, rs.u32Debug)], f)]; + Log.note(log, rs.fmtFormat(["chained ", args25[0], " ", args25[1]])); const _115: [Guard.Guard, Guard.Guard] = [guard(11), guard(12)]; const k: Guard.Guard = _115[0]; const l: Guard.Guard = _115[1]; @@ -271,8 +261,7 @@ export function discarded(log: Log.Log, id: rs.u32): void { }, (): void => { captured12[Symbol.dispose](); }))] as [rs.u32, rs.u32]; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(part3[0], f), (f: rs.Formatter) => rs.u32Debug(part3[1], f)], f)]; - Log.note(log, rs.fmtFormat(["map_or ", args8[0]])); + Log.note(log, rs.fmtFormat(["map_or ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(part3[0], f), (f: rs.Formatter) => rs.u32Debug(part3[1], f)], f)])); const _139: [Guard.Guard, Guard.Guard] = [guard(13), guard(14)]; const m: Guard.Guard = _139[0]; const n: Guard.Guard = _139[1]; @@ -293,8 +282,7 @@ export function discarded(log: Log.Log, id: rs.u32): void { }, (): void => { captured14[Symbol.dispose](); }))] as [rs.u32 | undefined, rs.u32 | undefined]; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u32Debug)], f)]; - Log.note(log, rs.fmtFormat(["then ", args10[0]])); + Log.note(log, rs.fmtFormat(["then ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u32Debug)], f)])); const _166: [Guard.Guard, Guard.Guard] = [guard(15), guard(16)]; const o: Guard.Guard = _166[0]; const p: Guard.Guard = _166[1]; @@ -311,8 +299,8 @@ export function discarded(log: Log.Log, id: rs.u32): void { captured15[Symbol.dispose](); })); const _183: rs.u32 | undefined = option_map$0cxn9jm(none, other); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_181, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_183, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["by ref ", args12[0], " ", args12[1]])); + const args28 = [(f: rs.Formatter) => rs.fmtOption(_181, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_183, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["by ref ", args28[0], " ", args28[1]])); const _191: [Guard.Guard, Guard.Guard] = [guard(18), guard(19)]; const r: Guard.Guard = _191[0]; const s: Guard.Guard = _191[1]; @@ -329,8 +317,8 @@ export function discarded(log: Log.Log, id: rs.u32): void { captured17[Symbol.dispose](); })); const _208: rs.u32 | undefined = then$04r7us0(!yes, skipped); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_206, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_208, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["then by ref ", args14[0], " ", args14[1]])); + const args29 = [(f: rs.Formatter) => rs.fmtOption(_206, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_208, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["then by ref ", args29[0], " ", args29[1]])); const captured19 = guard(17); const captured20 = rs.closure((n15: rs.u32): rs.u32 => { return rs.u32Add(n15, Guard.id(captured19)); @@ -344,8 +332,7 @@ export function discarded(log: Log.Log, id: rs.u32): void { }, (): void => { rs.drop(captured20); })); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["nested ", args16[0]])); + Log.note(log, rs.fmtFormat(["nested ", (f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)])); } /** @@ -377,8 +364,8 @@ export function iterated(log: Log.Log, id: rs.u32): void { })); const _34: rs.u32 | undefined = rs.iterToOption(mapped.next()); const _37: rs.u32 | undefined = rs.iterToOption(mapped.next()); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_34, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["map ", args2[0], " ", args2[1]])); + const args29 = [(f: rs.Formatter) => rs.fmtOption(_34, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["map ", args29[0], " ", args29[1]])); rs.drop(mapped); const b: Guard.Guard = guard(5); const v2: rs.Vec = new rs.Vec(); @@ -402,8 +389,7 @@ export function iterated(log: Log.Log, id: rs.u32): void { } const g: Guard.Guard = _71; const part = Guard.id(g); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["filter ", args4[0]])); + Log.note(log, rs.fmtFormat(["filter ", (f: rs.Formatter) => rs.u32Display(part, f)])); if (!(Guard.id(g) === rs.u32Add(id, 7))) { g[Symbol.dispose](); } else { @@ -442,8 +428,8 @@ export function iterated(log: Log.Log, id: rs.u32): void { const chained: rs.Iter = rs.iterInspect(_106, rs.closure((g7: Guard.Guard): undefined => { const _92: rs.u32 = Guard.id(g7); const _11: rs.u32 = Guard.id(captured5); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_11, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args30[0], " ", args30[1]])); + const args33 = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_11, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args33[0], " ", args33[1]])); }, (): void => { captured5[Symbol.dispose](); })); @@ -452,15 +438,13 @@ export function iterated(log: Log.Log, id: rs.u32): void { g8[Symbol.dispose](); return _06; }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["chained ", args6[0]])); + Log.note(log, rs.fmtFormat(["chained ", (f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)])); const part3 = option_map$06w9waf(rs.iterToOption(chained.next()), (g9: Guard.Guard): rs.u32 => { const _07: rs.u32 = Guard.id(g9); g9[Symbol.dispose](); return _07; }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["chained ", args8[0]])); + Log.note(log, rs.fmtFormat(["chained ", (f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)])); rs.drop(chained); const _164: [Guard.Guard, Guard.Guard] = [guard(16), guard(17)]; f = _164[0]; @@ -487,8 +471,7 @@ export function iterated(log: Log.Log, id: rs.u32): void { captured7[Symbol.dispose](); }), (value: rs.Vec) => rs.vecIntoIter(value), true); const part4 = rs.iterToOption(flat.next()); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["flat ", args10[0]])); + Log.note(log, rs.fmtFormat(["flat ", (f: rs.Formatter) => rs.fmtOption(part4, f, rs.u32Debug)])); rs.drop(flat); const w: Guard.Guard = guard(47); const _202: rs.Iter = rs.iterSlice([1]); @@ -511,8 +494,7 @@ export function iterated(log: Log.Log, id: rs.u32): void { }, (): void => { captured9[Symbol.dispose](); })), "next", 4); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part5.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["map_while ", args12[0]])); + Log.note(log, rs.fmtFormat(["map_while ", (f: rs.Formatter) => rs.fmtList(part5.items, f, rs.u32Debug)])); const _237: [Guard.Guard, Guard.Guard] = [guard(19), guard(20)]; const i: Guard.Guard = _237[0]; const j: Guard.Guard = _237[1]; @@ -544,15 +526,14 @@ export function iterated(log: Log.Log, id: rs.u32): void { g11[Symbol.dispose](); return _016; }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(made, f), (f: rs.Formatter) => rs.u32Display(walked, f), (f: rs.Formatter) => rs.fmtOption(_267, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["lazy ", args14[0], " ", args14[1], " ", args14[2]])); + const args38 = [(f: rs.Formatter) => rs.usizeDisplay(made, f), (f: rs.Formatter) => rs.u32Display(walked, f), (f: rs.Formatter) => rs.fmtOption(_267, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["lazy ", args38[0], " ", args38[1], " ", args38[2]])); const part6 = option_map$06w9waf(rs.iterToOption(chain.next()), (g12: Guard.Guard): rs.u32 => { const _017: rs.u32 = Guard.id(g12); g12[Symbol.dispose](); return _017; }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["successor ", args16[0]])); + Log.note(log, rs.fmtFormat(["successor ", (f: rs.Formatter) => rs.fmtOption(part6, f, rs.u32Debug)])); rs.drop(chain); const v5: rs.Vec = new rs.Vec(); const _297: Guard.Guard = guard(21); @@ -592,8 +573,8 @@ export function iterated(log: Log.Log, id: rs.u32): void { captured15[Symbol.dispose](); }); const atPos: rs.usize | undefined = rs.dropAfter(_341, () => rs.iterPosition(_338, _341)); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(any, f), (f: rs.Formatter) => rs.fmtOption(found, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(atPos, f, rs.usizeDebug)]; - Log.note(log, rs.fmtFormat(["found ", args18[0], " ", args18[1], " ", args18[2]])); + const args40 = [(f: rs.Formatter) => rs.fmtBool(any, f), (f: rs.Formatter) => rs.fmtOption(found, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(atPos, f, rs.usizeDebug)]; + Log.note(log, rs.fmtFormat(["found ", args40[0], " ", args40[1], " ", args40[2]])); const n: Guard.Guard = guard(27); const _361: rs.Iter = rs.iterSlice([1, 2, 3]); const captured16 = n; @@ -607,13 +588,11 @@ export function iterated(log: Log.Log, id: rs.u32): void { const captured17 = o; rs.iterForEach(_369, rs.closure((_214: rs.u32): undefined => { const part7 = rs.u32Add(_214, Guard.id(captured17)); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["each ", args32[0]])); + Log.note(log, rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part7, f)])); }, (): void => { captured17[Symbol.dispose](); }), undefined, true); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; - Log.note(log, rs.fmtFormat(["sum ", args20[0]])); + Log.note(log, rs.fmtFormat(["sum ", (f: rs.Formatter) => rs.u32Display(sum, f)])); const _386: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(44), guard(45), guard(46)]; const t: Guard.Guard = _386[0]; const u: Guard.Guard = _386[1]; @@ -639,8 +618,8 @@ export function iterated(log: Log.Log, id: rs.u32): void { }, (): void => { captured20[Symbol.dispose](); })), 1)); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(peeked, f), (f: rs.Formatter) => rs.usizeDisplay(skipped, f), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["counted ", args22[0], " ", args22[1], " ", args22[2]])); + const args45 = [(f: rs.Formatter) => rs.usizeDisplay(peeked, f), (f: rs.Formatter) => rs.usizeDisplay(skipped, f), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["counted ", args45[0], " ", args45[1], " ", args45[2]])); const r: Guard.Guard = guard(36); const _435: rs.Iter = rs.iterMap(rs.iterSlice([1, 2, 3]), (_225: rs.u32): Guard.Guard => { return guard(rs.u32Add(36, _225)); @@ -655,8 +634,7 @@ export function iterated(log: Log.Log, id: rs.u32): void { g18[Symbol.dispose](); return _028; }); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["best ", args24[0]])); + Log.note(log, rs.fmtFormat(["best ", (f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)])); const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const iter2: rs.Iter<[rs.u32, rs.u32]> = rs.iterSlice([[1, 29] as [rs.u32, rs.u32], [2, 30] as [rs.u32, rs.u32], [3, 31] as [rs.u32, rs.u32]]); while (true) { @@ -690,25 +668,23 @@ export function iterated(log: Log.Log, id: rs.u32): void { rs.dropAfter(_492, () => rs.dequeRetain(queue, _492, rs.drop)); const _499: rs.usize = rs.btreeLen(map); const _502: rs.usize = queue.n; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_499, f), (f: rs.Formatter) => rs.usizeDisplay(_502, f)]; - Log.note(log, rs.fmtFormat(["retained ", args26[0], " ", args26[1]])); + const args47 = [(f: rs.Formatter) => rs.usizeDisplay(_499, f), (f: rs.Formatter) => rs.usizeDisplay(_502, f)]; + Log.note(log, rs.fmtFormat(["retained ", args47[0], " ", args47[1]])); const x: Guard.Guard = guard(48); const _513: Guard.Guard[] = [guard(49), guard(50), guard(51)]; const captured25 = x; const _523: (a0: Guard.Guard) => Guard.Guard | undefined = rs.closure((g20: Guard.Guard): Guard.Guard | undefined => { const part10 = Guard.id(g20); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; - Log.note(log, rs.fmtFormat(["array map ", args34[0]])); + Log.note(log, rs.fmtFormat(["array map ", (f: rs.Formatter) => rs.u32Display(part10, f)])); return thenSome$0zvoczk(Guard.id(g20) !== rs.u32Add(Guard.id(captured25), 2), g20); }, (): void => { captured25[Symbol.dispose](); }); const kept: Array = rs.dropAfter(_523, () => rs.arrayMap(_513, _523)); - const part11 = rs.arrayMap(rs.arrayFrom(kept), (g21: Guard.Guard | undefined): rs.u32 | undefined => { + const part11 = rs.sliceFrom(rs.arrayMap(rs.arrayFrom(kept), (g21: Guard.Guard | undefined): rs.u32 | undefined => { return option_map$02u0dmi(g21, Guard.id); - }); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part11, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug))]; - Log.note(log, rs.fmtFormat(["array mapped ", args28[0]])); + })); + Log.note(log, rs.fmtFormat(["array mapped ", (f: rs.Formatter) => rs.fmtList(rs.sliceItems(part11), f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug))])); rs.dropAll(kept); rs.dequeDrop(queue, rs.drop); rs.btreeDrop(map, undefined, rs.drop); diff --git a/ts/fixtures/task/expected/drops/flattened.ts b/ts/fixtures/task/expected/drops/flattened.ts index e0c3ecb1c..49c18e8ff 100644 --- a/ts/fixtures/task/expected/drops/flattened.ts +++ b/ts/fixtures/task/expected/drops/flattened.ts @@ -30,8 +30,7 @@ export function firsts(log: Log.Log, id: rs.u32, n: rs.u32): rs.Iter): rs.Iter => { const part = rs.u32Sub(Guard.id(v.items[rs.idx(v.items, 0)]), captured); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["inner ", args2[0]])); + Log.note(log, rs.fmtFormat(["inner ", (f: rs.Formatter) => rs.u32Display(part, f)])); return rs.iterTake(rs.vecIntoIter(v, rs.drop), 1, rs.drop); }), undefined, true); } @@ -50,12 +49,10 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { const it: rs.Iter = firsts(log, id, 1); const part62 = rs.iterToOption(it.next()); const part63 = idOf(part62); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part63, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["next ", args2[0]])); + Log.note(log, rs.fmtFormat(["next ", (f: rs.Formatter) => rs.fmtOption(part63, f, rs.u32Debug)])); const part64 = rs.iterToOption(it.next()); const part65 = idOf(part64); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part65, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["next ", args4[0]])); + Log.note(log, rs.fmtFormat(["next ", (f: rs.Formatter) => rs.fmtOption(part65, f, rs.u32Debug)])); rs.drop(it); const iter: rs.Iter = firsts(log, id, 20); while (true) { @@ -65,37 +62,31 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { } const g: Guard.Guard = _44; const part66 = rs.u32Sub(Guard.id(g), id); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part66, f)]; - Log.note(log, rs.fmtFormat(["for ", args6[0]])); + Log.note(log, rs.fmtFormat(["for ", (f: rs.Formatter) => rs.u32Display(part66, f)])); g[Symbol.dispose](); } rs.drop(iter); } else if (_6 === 1) { rs.iterForEach(firsts(log, id, 1), (g26: Guard.Guard): undefined => { const part58 = rs.u32Sub(Guard.id(g26), id); - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part58, f)]; - Log.note(log, rs.fmtFormat(["each ", args82[0]])); + Log.note(log, rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part58, f)])); g26[Symbol.dispose](); }, true); const part59 = rs.ownedCount(firsts(log, id, 20), rs.drop); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part59, f)]; - Log.note(log, rs.fmtFormat(["count ", args8[0]])); + Log.note(log, rs.fmtFormat(["count ", (f: rs.Formatter) => rs.usizeDisplay(part59, f)])); const part60 = rs.ownedLast(firsts(log, id, 40), rs.drop); const part61 = idOf(part60); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part61, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["last ", args10[0]])); + Log.note(log, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.fmtOption(part61, f, rs.u32Debug)])); } else if (_6 === 2) { const it2: rs.Iter = firsts(log, id, 1); const part51 = rs.iterFind(it2, (g22: Guard.Guard): boolean => { return Guard.id(g22) === rs.u32Add(id, 4); }, rs.drop); const part52 = idOf(part51); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part52, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["find ", args12[0]])); + Log.note(log, rs.fmtFormat(["find ", (f: rs.Formatter) => rs.fmtOption(part52, f, rs.u32Debug)])); const part53 = rs.iterToOption(it2.next()); const part54 = idOf(part53); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part54, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["then ", args14[0]])); + Log.note(log, rs.fmtFormat(["then ", (f: rs.Formatter) => rs.fmtOption(part54, f, rs.u32Debug)])); rs.drop(it2); const it3: rs.Iter = firsts(log, id, 20); const part55 = rs.iterAny(it3, (g23: Guard.Guard): boolean => { @@ -103,8 +94,7 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { g23[Symbol.dispose](); return _025; }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part55, f)]; - Log.note(log, rs.fmtFormat(["any ", args16[0]])); + Log.note(log, rs.fmtFormat(["any ", (f: rs.Formatter) => rs.fmtBool(part55, f)])); rs.drop(it3); const _153: rs.Iter = firsts(log, id, 40); const part56 = rs.iterAll(_153, (g24: Guard.Guard): boolean => { @@ -112,8 +102,7 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { g24[Symbol.dispose](); return _026; }); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part56, f)]; - const _147: string = rs.fmtFormat(["all ", args18[0]]); + const _147: string = rs.fmtFormat(["all ", (f: rs.Formatter) => rs.fmtBool(part56, f)]); rs.drop(_153); Log.note(log, _147); const _168: rs.Iter = firsts(log, id, 60); @@ -122,8 +111,7 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { g25[Symbol.dispose](); return _027; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part57, f, rs.usizeDebug)]; - const _162: string = rs.fmtFormat(["position ", args20[0]]); + const _162: string = rs.fmtFormat(["position ", (f: rs.Formatter) => rs.fmtOption(part57, f, rs.usizeDebug)]); rs.drop(_168); Log.note(log, _162); } else if (_6 === 3) { @@ -132,100 +120,85 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, rs.drop); const part43 = rs.iterToOption(it4.next()); const part44 = idOf(part43); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part44, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["filter ", args22[0]])); + Log.note(log, rs.fmtFormat(["filter ", (f: rs.Formatter) => rs.fmtOption(part44, f, rs.u32Debug)])); const part45 = rs.iterToOption(it4.next()); const part46 = idOf(part45); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part46, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["filter ", args24[0]])); + Log.note(log, rs.fmtFormat(["filter ", (f: rs.Formatter) => rs.fmtOption(part46, f, rs.u32Debug)])); rs.drop(it4); const it5: rs.Iter = rs.iterFilterMap(firsts(log, id, 20), (g20: Guard.Guard): Guard.Guard | undefined => { return thenSome$0zvoczk(Guard.id(g20) !== rs.u32Add(id, 20), g20); }); const part47 = rs.iterToOption(it5.next()); const part48 = idOf(part47); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part48, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["filter_map ", args26[0]])); + Log.note(log, rs.fmtFormat(["filter_map ", (f: rs.Formatter) => rs.fmtOption(part48, f, rs.u32Debug)])); rs.drop(it5); const it6: rs.Iter = rs.iterSkipWhile(firsts(log, id, 40), (g21: Guard.Guard): boolean => { return Guard.id(g21) < rs.u32Add(id, 44); }, rs.drop); const part49 = rs.iterToOption(it6.next()); const part50 = idOf(part49); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part50, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["skip_while ", args28[0]])); + Log.note(log, rs.fmtFormat(["skip_while ", (f: rs.Formatter) => rs.fmtOption(part50, f, rs.u32Debug)])); rs.drop(it6); } else if (_6 === 4) { const it7: rs.Iter = firsts(log, id, 1); const part35 = rs.iterNth(it7, 1, rs.drop); const part36 = idOf(part35); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part36, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["nth ", args30[0]])); + Log.note(log, rs.fmtFormat(["nth ", (f: rs.Formatter) => rs.fmtOption(part36, f, rs.u32Debug)])); rs.drop(it7); const it8: rs.Iter = rs.iterSkip(firsts(log, id, 20), 1, rs.drop); const part37 = rs.iterToOption(it8.next()); const part38 = idOf(part37); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part38, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["skip ", args32[0]])); + Log.note(log, rs.fmtFormat(["skip ", (f: rs.Formatter) => rs.fmtOption(part38, f, rs.u32Debug)])); rs.drop(it8); const it9: rs.Iter = rs.iterStepBy(firsts(log, id, 40), 2, rs.drop); const part39 = rs.iterToOption(it9.next()); const part40 = idOf(part39); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part40, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["step ", args34[0]])); + Log.note(log, rs.fmtFormat(["step ", (f: rs.Formatter) => rs.fmtOption(part40, f, rs.u32Debug)])); const part41 = rs.iterToOption(it9.next()); const part42 = idOf(part41); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part42, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["step ", args36[0]])); + Log.note(log, rs.fmtFormat(["step ", (f: rs.Formatter) => rs.fmtOption(part42, f, rs.u32Debug)])); rs.drop(it9); } else if (_6 === 5) { const it10: rs.Iter = firsts(log, id, 1); const part21 = rs.iterToOption(it10.nextBack()); const part22 = idOf(part21); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part22, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["back ", args38[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part22, f, rs.u32Debug)])); const part23 = rs.iterToOption(it10.next()); const part24 = idOf(part23); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part24, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["front ", args40[0]])); + Log.note(log, rs.fmtFormat(["front ", (f: rs.Formatter) => rs.fmtOption(part24, f, rs.u32Debug)])); rs.drop(it10); const it11: rs.Iter = firsts(log, id, 20); const part25 = rs.iterRfind(it11, (g16: Guard.Guard): boolean => { return Guard.id(g16) === rs.u32Add(id, 20); }, rs.drop); const part26 = idOf(part25); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part26, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["rfind ", args42[0]])); + Log.note(log, rs.fmtFormat(["rfind ", (f: rs.Formatter) => rs.fmtOption(part26, f, rs.u32Debug)])); rs.drop(it11); const it12: rs.Iter = rs.iterRev(firsts(log, id, 40)); const part27 = rs.iterFind(it12, (g17: Guard.Guard): boolean => { return Guard.id(g17) === rs.u32Add(id, 43); }, rs.drop); const part28 = idOf(part27); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part28, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["rev find ", args44[0]])); + Log.note(log, rs.fmtFormat(["rev find ", (f: rs.Formatter) => rs.fmtOption(part28, f, rs.u32Debug)])); const part29 = rs.iterToOption(it12.next()); const part30 = idOf(part29); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part30, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["rev next ", args46[0]])); + Log.note(log, rs.fmtFormat(["rev next ", (f: rs.Formatter) => rs.fmtOption(part30, f, rs.u32Debug)])); rs.drop(it12); const it13: rs.Iter = rs.iterFilter(rs.iterRev(firsts(log, id, 60)), (g18: Guard.Guard): boolean => { return Guard.id(g18) !== rs.u32Add(id, 65); }, rs.drop); const part31 = rs.iterToOption(it13.next()); const part32 = idOf(part31); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part32, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["rev filter ", args48[0]])); + Log.note(log, rs.fmtFormat(["rev filter ", (f: rs.Formatter) => rs.fmtOption(part32, f, rs.u32Debug)])); rs.drop(it13); const _439: rs.Vec> = nested(log, id, 80); const it14: rs.Iter = rs.iterTake(rs.vecIntoIter(rs.vecSwapRemove(_439, 0), rs.drop), 1, rs.drop); rs.dropVec(_439, lib_drop$Vec_model_Guard); - const part33 = rs.iterRfind(it14, (_28: Guard.Guard): boolean => { + const part33 = rs.iterRfind(it14, (_29: Guard.Guard): boolean => { return true; }, rs.drop); const part34 = idOf(part33); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part34, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["take rfind ", args50[0]])); + Log.note(log, rs.fmtFormat(["take rfind ", (f: rs.Formatter) => rs.fmtOption(part34, f, rs.u32Debug)])); rs.drop(it14); } else if (_6 === 6) { const it15: rs.Iter = rs.iterMap(firsts(log, id, 1), (g12: Guard.Guard): rs.u32 => { @@ -236,36 +209,32 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part16 = rs.iterFind(it15, (_2: rs.u32): boolean => { return _2 === 4; }); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part16, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["map find ", args52[0]])); + Log.note(log, rs.fmtFormat(["map find ", (f: rs.Formatter) => rs.fmtOption(part16, f, rs.u32Debug)])); rs.drop(it15); const it16: rs.Iter<[rs.usize, Guard.Guard]> = rs.iterEnumerate(firsts(log, id, 20)); - const part17 = option_map$1389p4b(rs.iterFind(it16, (_23: [rs.usize, Guard.Guard]): boolean => { - return _23[0] === 1; - }, lib_drop$tuple2_usize_model_Guard), (_24: [rs.usize, Guard.Guard]): [rs.usize, rs.u32] => { - const i: rs.usize = _24[0]; - const g13: Guard.Guard = _24[1]; + const part17 = option_map$1389p4b(rs.iterFind(it16, (_24: [rs.usize, Guard.Guard]): boolean => { + return _24[0] === 1; + }, lib_drop$tuple2_usize_model_Guard), (_28: [rs.usize, Guard.Guard]): [rs.usize, rs.u32] => { + const i: rs.usize = _28[0]; + const g13: Guard.Guard = _28[1]; const _015: [rs.usize, rs.u32] = [i, rs.u32Sub(Guard.id(g13), id)]; g13[Symbol.dispose](); return _015; }); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part17, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["enumerate ", args54[0]])); + Log.note(log, rs.fmtFormat(["enumerate ", (f: rs.Formatter) => rs.fmtOption(part17, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); rs.drop(it16); const part18 = rs.iterFold(rs.iterTake(firsts(log, id, 40), 2, rs.drop), 0, (n3: rs.u32, g14: Guard.Guard): rs.u32 => { const _016: rs.u32 = rs.u32Sub(rs.u32Add(n3, Guard.id(g14)), id); g14[Symbol.dispose](); return _016; }, true); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part18, f)]; - Log.note(log, rs.fmtFormat(["take ", args56[0]])); + Log.note(log, rs.fmtFormat(["take ", (f: rs.Formatter) => rs.u32Display(part18, f)])); const it17: rs.Iter = rs.iterChain(firsts(log, id, 60), firsts(log, id, 80)); const part19 = rs.iterFind(it17, (g15: Guard.Guard): boolean => { return Guard.id(g15) === rs.u32Add(id, 81); }, rs.drop); const part20 = idOf(part19); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part20, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["chain ", args58[0]])); + Log.note(log, rs.fmtFormat(["chain ", (f: rs.Formatter) => rs.fmtOption(part20, f, rs.u32Debug)])); rs.drop(it17); } else if (_6 === 7) { const it18: rs.Iter = rs.iterFlatMap(rs.vecIntoIter(nested(log, id, 1), lib_drop$Vec_model_Guard), (v: rs.Vec): rs.Iter => { @@ -275,45 +244,38 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { return Guard.id(g9) === rs.u32Add(id, 4); }, rs.drop); const part10 = idOf(part9); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["flat_map ", args60[0]])); + Log.note(log, rs.fmtFormat(["flat_map ", (f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)])); const part11 = rs.iterToOption(it18.next()); const part12 = idOf(part11); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["flat_map ", args62[0]])); + Log.note(log, rs.fmtFormat(["flat_map ", (f: rs.Formatter) => rs.fmtOption(part12, f, rs.u32Debug)])); rs.drop(it18); const it19: rs.Peekable = rs.iterPeekable(firsts(log, id, 20), rs.drop); const part13 = option_map$06w9waf(rs.peekablePeek(it19), (g10: Guard.Guard): rs.u32 => { return rs.u32Sub(Guard.id(g10), id); }); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part13, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["peek ", args64[0]])); + Log.note(log, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.fmtOption(part13, f, rs.u32Debug)])); const part14 = rs.iterFind(it19, (g11: Guard.Guard): boolean => { return Guard.id(g11) === rs.u32Add(id, 23); }, rs.drop); const part15 = idOf(part14); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part15, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["peek find ", args66[0]])); + Log.note(log, rs.fmtFormat(["peek find ", (f: rs.Formatter) => rs.fmtOption(part15, f, rs.u32Debug)])); rs.drop(it19); } else if (_6 === 8) { const all: rs.Vec = rs.iterToVec(firsts(log, id, 1), "next", 8); const part5 = all.items.length; - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; - Log.note(log, rs.fmtFormat(["collect ", args68[0]])); + Log.note(log, rs.fmtFormat(["collect ", (f: rs.Formatter) => rs.usizeDisplay(part5, f)])); rs.dropVec(all); const part6 = rs.iterMaxByKey(firsts(log, id, 20), (g7: Guard.Guard): rs.u32 => { return rs.u32Rem(Guard.id(g7), 3); }, rs.lt, true, rs.drop); const part7 = idOf(part6); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["max ", args70[0]])); + Log.note(log, rs.fmtFormat(["max ", (f: rs.Formatter) => rs.fmtOption(part7, f, rs.u32Debug)])); const part8 = rs.iterSum(rs.iterMap(firsts(log, id, 40), (g8: Guard.Guard): rs.u32 => { const _07: rs.u32 = rs.u32Sub(Guard.id(g8), id); g8[Symbol.dispose](); return _07; }), rs.u32Add, 0, true); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; - Log.note(log, rs.fmtFormat(["sum ", args72[0]])); + Log.note(log, rs.fmtFormat(["sum ", (f: rs.Formatter) => rs.u32Display(part8, f)])); } else { const it20: rs.Iter = firsts(log, id, 1); const part = rs.iterAny(it20, (g4: Guard.Guard): boolean => { @@ -321,26 +283,22 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { g4[Symbol.dispose](); return _03; }); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - Log.note(log, rs.fmtFormat(["any ", args74[0]])); + Log.note(log, rs.fmtFormat(["any ", (f: rs.Formatter) => rs.fmtBool(part, f)])); const part2 = rs.iterFold(it20, 0, (n: rs.u32, g5: Guard.Guard): rs.u32 => { const _04: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n, 100), Guard.id(g5)), id); g5[Symbol.dispose](); return _04; }, true); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["rest ", args76[0]])); + Log.note(log, rs.fmtFormat(["rest ", (f: rs.Formatter) => rs.u32Display(part2, f)])); const it21: rs.Iter = firsts(log, id, 20); const part3 = rs.iterAny(it21, (g6: Guard.Guard): boolean => { const _05: boolean = Guard.id(g6) === rs.u32Add(id, 23); g6[Symbol.dispose](); return _05; }); - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - Log.note(log, rs.fmtFormat(["any ", args78[0]])); + Log.note(log, rs.fmtFormat(["any ", (f: rs.Formatter) => rs.fmtBool(part3, f)])); const part4 = rs.ownedCount(it21, rs.drop); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part4, f)]; - Log.note(log, rs.fmtFormat(["count ", args80[0]])); + Log.note(log, rs.fmtFormat(["count ", (f: rs.Formatter) => rs.usizeDisplay(part4, f)])); } } diff --git a/ts/fixtures/task/expected/drops/folds.Pile.ts b/ts/fixtures/task/expected/drops/folds.Pile.ts index ef293336e..8eb37427e 100644 --- a/ts/fixtures/task/expected/drops/folds.Pile.ts +++ b/ts/fixtures/task/expected/drops/folds.Pile.ts @@ -34,8 +34,7 @@ export function sizeHint$iter_Iterator(self: Pile): [rs.usize, rs.usize | undefi } export function nth$iter_Iterator(self: Pile, n: rs.usize): Guard.Guard | undefined { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f)]; - const _5: string = rs.fmtFormat(["pile nth ", args2[0]]); + const _5: string = rs.fmtFormat(["pile nth ", (f: rs.Formatter) => rs.usizeDisplay(n, f)]); Log.note(self.log, _5); let iterStart: rs.usize = 0; const iterEnd: rs.usize = n; @@ -65,8 +64,7 @@ export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Opt export function count$iter_Iterator(self: Pile): rs.usize { const part = self.held.items.length; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; - const _4: string = rs.fmtFormat(["pile count ", args2[0]]); + const _4: string = rs.fmtFormat(["pile count ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); Log.note(self.log, _4); const _0: rs.usize = self.held.items.length; self[Symbol.dispose](); @@ -89,8 +87,7 @@ export function nextBack$iter_DoubleEndedIterator(self: Pile): Guard.Guard | und } export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rs.usize): Guard.Guard | undefined { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f)]; - const _5: string = rs.fmtFormat(["pile nth_back ", args2[0]]); + const _5: string = rs.fmtFormat(["pile nth_back ", (f: rs.Formatter) => rs.usizeDisplay(n, f)]); Log.note(self.log, _5); let iterStart: rs.usize = 0; const iterEnd: rs.usize = n; diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index c73aa0931..571ebbcad 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -49,8 +49,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured67[Symbol.dispose](); })), rs.u32Add, 0, true); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.u32Display(sum, f)]; - Log.note(log, rs.fmtFormat(["count ", args2[0], " ", args2[1]])); + const args165 = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.u32Display(sum, f)]; + Log.note(log, rs.fmtFormat(["count ", args165[0], " ", args165[1]])); } else if (_17 === 1) { const _49: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _1090 = false; @@ -61,27 +61,27 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured64[Symbol.dispose](); }), rs.drop), undefined as Guard.Guard | undefined, (kept4: Guard.Guard | undefined, g82: Guard.Guard): Guard.Guard | undefined => { let _087!: Guard.Guard | undefined; - let _3110: boolean = false; + let _3111: boolean = false; let _304: boolean = false; - _3110 = true; + _3111 = true; _304 = true; - const _1020: rs.u32 = Guard.id(g82); - const _1317: rs.u32 | undefined = option_map$06w9waf(kept4, (k2: Guard.Guard): rs.u32 => { + const _1021: rs.u32 = Guard.id(g82); + const _1318: rs.u32 | undefined = option_map$06w9waf(kept4, (k2: Guard.Guard): rs.u32 => { return Guard.id(k2); }); - const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1020, f), (f: rs.Formatter) => rs.fmtOption(_1317, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["fold ", args110[0], " ", args110[1]])); + const args163 = [(f: rs.Formatter) => rs.u32Display(_1021, f), (f: rs.Formatter) => rs.fmtOption(_1318, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["fold ", args163[0], " ", args163[1]])); if (!(rs.u32Rem(Guard.id(g82), 4) === 0)) { _304 = false; _087 = g82; } else { - _3110 = false; + _3111 = false; _087 = kept4; } if (_304) { g82[Symbol.dispose](); } - if (_3110) { + if (_3111) { rs.drop(kept4); return _087; } @@ -92,8 +92,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _089; }); const _64: rs.u32 = Guard.id(d); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_62, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_64, f)]; - Log.note(log, rs.fmtFormat(["fold ", args4[0], " ", args4[1]])); + const args164 = [(f: rs.Formatter) => rs.fmtOption(_62, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_64, f)]; + Log.note(log, rs.fmtFormat(["fold ", args164[0], " ", args164[1]])); } else if (_17 === 2) { const _73: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _1090 = false; @@ -104,22 +104,20 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured63[Symbol.dispose](); })), (g80: Guard.Guard): undefined => { const part13 = Guard.id(g80); - const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; - Log.note(log, rs.fmtFormat(["each ", args108[0]])); + Log.note(log, rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part13, f)])); g80[Symbol.dispose](); }, true); const part14 = Guard.id(d); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part14, f)]; - Log.note(log, rs.fmtFormat(["each ", args6[0]])); + Log.note(log, rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part14, f)])); } else if (_17 === 3) { const _93: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured62 = c; const _104: rs.u32 | undefined = option_map$06w9waf(rs.ownedLast(rs.iterInspect(_93, rs.closure((g77: Guard.Guard): undefined => { - const _982: rs.u32 = Guard.id(g77); - const _1175: rs.u32 = Guard.id(captured62); - const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_982, f), (f: rs.Formatter) => rs.u32Display(_1175, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args106[0], " ", args106[1]])); + const _996: rs.u32 = Guard.id(g77); + const _1179: rs.u32 = Guard.id(captured62); + const args155 = [(f: rs.Formatter) => rs.u32Display(_996, f), (f: rs.Formatter) => rs.u32Display(_1179, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args155[0], " ", args155[1]])); }, (): void => { captured62[Symbol.dispose](); })), rs.drop), (g78: Guard.Guard): rs.u32 => { @@ -128,17 +126,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _084; }); const _106: rs.u32 = Guard.id(d); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_104, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_106, f)]; - Log.note(log, rs.fmtFormat(["last ", args8[0], " ", args8[1]])); + const args156 = [(f: rs.Formatter) => rs.fmtOption(_104, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_106, f)]; + Log.note(log, rs.fmtFormat(["last ", args156[0], " ", args156[1]])); } else if (_17 === 4) { const _115: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _1090 = false; const captured61 = c; const best: Guard.Guard | undefined = rs.iterMaxByKey(rs.iterMap(_115, rs.closure((g72: Guard.Guard): Guard.Guard => { - const _978: rs.u32 = Guard.id(g72); + const _992: rs.u32 = Guard.id(g72); const _1226: rs.u32 = Guard.id(captured61); - const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_978, f), (f: rs.Formatter) => rs.u32Display(_1226, f)]; - Log.note(log, rs.fmtFormat(["map ", args104[0], " ", args104[1]])); + const args151 = [(f: rs.Formatter) => rs.u32Display(_992, f), (f: rs.Formatter) => rs.u32Display(_1226, f)]; + Log.note(log, rs.fmtFormat(["map ", args151[0], " ", args151[1]])); return g72; }, (): void => { captured61[Symbol.dispose](); @@ -158,8 +156,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g76[Symbol.dispose](); return _083; }); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_133, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_135, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["best ", args10[0], " ", args10[1]])); + const args152 = [(f: rs.Formatter) => rs.fmtOption(_133, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_135, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["best ", args152[0], " ", args152[1]])); } else if (_17 === 5) { const _143: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; @@ -182,17 +180,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured60[Symbol.dispose](); })), rs.u32Mul, 1, true); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(max, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(product, f)]; - Log.note(log, rs.fmtFormat(["max ", args12[0], " ", args12[1]])); + const args148 = [(f: rs.Formatter) => rs.fmtOption(max, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(product, f)]; + Log.note(log, rs.fmtFormat(["max ", args148[0], " ", args148[1]])); } else if (_17 === 6) { const _169: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; const captured56 = c; const same: rs.Vec = rs.iterToVec(rs.iterMap(_169, rs.closure((g68: Guard.Guard): Guard.Guard => { - const _976: rs.u32 = Guard.id(g68); + const _978: rs.u32 = Guard.id(g68); const _1224: rs.u32 = Guard.id(captured56); - const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_976, f), (f: rs.Formatter) => rs.u32Display(_1224, f)]; - Log.note(log, rs.fmtFormat(["map ", args102[0], " ", args102[1]])); + const args146 = [(f: rs.Formatter) => rs.u32Display(_978, f), (f: rs.Formatter) => rs.u32Display(_1224, f)]; + Log.note(log, rs.fmtFormat(["map ", args146[0], " ", args146[1]])); return g68; }, (): void => { captured56[Symbol.dispose](); @@ -207,8 +205,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { })), "fold", 16, true); const _187: rs.usize = same.items.length; const _190: rs.usize = wider.items.length; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_187, f), (f: rs.Formatter) => rs.usizeDisplay(_190, f)]; - Log.note(log, rs.fmtFormat(["collected ", args14[0], " ", args14[1]])); + const args147 = [(f: rs.Formatter) => rs.usizeDisplay(_187, f), (f: rs.Formatter) => rs.usizeDisplay(_190, f)]; + Log.note(log, rs.fmtFormat(["collected ", args147[0], " ", args147[1]])); rs.dropVec(wider, lib_drop$tuple2_model_Guard_u64); rs.dropVec(same); } else if (_17 === 7) { @@ -216,10 +214,10 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { _1090 = false; const captured54 = c; const queue: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(_199, rs.closure((g66: Guard.Guard): Guard.Guard => { - const _974: rs.u32 = Guard.id(g66); + const _977: rs.u32 = Guard.id(g66); const _1223: rs.u32 = Guard.id(captured54); - const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_974, f), (f: rs.Formatter) => rs.u32Display(_1223, f)]; - Log.note(log, rs.fmtFormat(["map ", args100[0], " ", args100[1]])); + const args142 = [(f: rs.Formatter) => rs.u32Display(_977, f), (f: rs.Formatter) => rs.u32Display(_1223, f)]; + Log.note(log, rs.fmtFormat(["map ", args142[0], " ", args142[1]])); return g66; }, (): void => { captured54[Symbol.dispose](); @@ -235,8 +233,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const tree: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterToVec(_205, "fold", 12, true).items, 12, true, undefined, undefined, rs.drop); const _217: rs.usize = queue.n; const _220: rs.usize = rs.btreeLen(tree); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_217, f), (f: rs.Formatter) => rs.usizeDisplay(_220, f)]; - Log.note(log, rs.fmtFormat(["collected ", args16[0], " ", args16[1]])); + const args143 = [(f: rs.Formatter) => rs.usizeDisplay(_217, f), (f: rs.Formatter) => rs.usizeDisplay(_220, f)]; + Log.note(log, rs.fmtFormat(["collected ", args143[0], " ", args143[1]])); rs.btreeDrop(tree, undefined, rs.drop); rs.dequeDrop(queue, rs.drop); } else if (_17 === 8) { @@ -245,10 +243,10 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { _1090 = false; const captured52 = c; const _232: rs.Iter = rs.iterMap(_233, rs.closure((g64: Guard.Guard): Guard.Guard => { - const _973: rs.u32 = Guard.id(g64); + const _976: rs.u32 = Guard.id(g64); const _1222: rs.u32 = Guard.id(captured52); - const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_973, f), (f: rs.Formatter) => rs.u32Display(_1222, f)]; - Log.note(log, rs.fmtFormat(["map ", args98[0], " ", args98[1]])); + const args138 = [(f: rs.Formatter) => rs.u32Display(_976, f), (f: rs.Formatter) => rs.u32Display(_1222, f)]; + Log.note(log, rs.fmtFormat(["map ", args138[0], " ", args138[1]])); return g64; }, (): void => { captured52[Symbol.dispose](); @@ -266,8 +264,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.btreeExtend(tree2, _241, false, undefined, rs.drop, "fold"); const _253: rs.usize = v.items.length; const _256: rs.usize = rs.btreeLen(tree2); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_253, f), (f: rs.Formatter) => rs.usizeDisplay(_256, f)]; - Log.note(log, rs.fmtFormat(["extended ", args18[0], " ", args18[1]])); + const args139 = [(f: rs.Formatter) => rs.usizeDisplay(_253, f), (f: rs.Formatter) => rs.usizeDisplay(_256, f)]; + Log.note(log, rs.fmtFormat(["extended ", args139[0], " ", args139[1]])); rs.btreeDrop(tree2, undefined, rs.drop); rs.dropVec(v); } else if (_17 === 9) { @@ -286,8 +284,7 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured51[Symbol.dispose](); }))); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part12, f)]; - Log.note(log, rs.fmtFormat(["count ", args20[0]])); + Log.note(log, rs.fmtFormat(["count ", (f: rs.Formatter) => rs.usizeDisplay(part12, f)])); } else if (_17 === 10) { const _284: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; @@ -319,15 +316,15 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { })); const captured49 = f; const m: rs.usize = rs.ownedCount(rs.iterInspect(_301, rs.closure((g63: Guard.Guard): undefined => { - const _835: rs.u32 = Guard.id(g63); - const _1019: rs.u32 = Guard.id(captured49); - const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_835, f), (f: rs.Formatter) => rs.u32Display(_1019, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args96[0], " ", args96[1]])); + const _841: rs.u32 = Guard.id(g63); + const _1020: rs.u32 = Guard.id(captured49); + const args133 = [(f: rs.Formatter) => rs.u32Display(_841, f), (f: rs.Formatter) => rs.u32Display(_1020, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args133[0], " ", args133[1]])); }, (): void => { captured49[Symbol.dispose](); })), rs.drop); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n3, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; - Log.note(log, rs.fmtFormat(["two ", args22[0], " ", args22[1]])); + const args134 = [(f: rs.Formatter) => rs.u32Display(n3, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; + Log.note(log, rs.fmtFormat(["two ", args134[0], " ", args134[1]])); } else if (_17 === 11) { const _322: rs.Iter = rs.iterChain(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 5), rs.drop)); _1090 = false; @@ -350,8 +347,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured44[Symbol.dispose](); })), rs.iterSlice([1, 2]))); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n4, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f)]; - Log.note(log, rs.fmtFormat(["chain ", args24[0], " ", args24[1]])); + const args130 = [(f: rs.Formatter) => rs.u32Display(n4, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f)]; + Log.note(log, rs.fmtFormat(["chain ", args130[0], " ", args130[1]])); } else if (_17 === 12) { const _354: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); const _359: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); @@ -372,17 +369,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _063; }); const _381: rs.u32 = Guard.id(d); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n5, f), (f: rs.Formatter) => rs.fmtOption(_379, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_381, f)]; - Log.note(log, rs.fmtFormat(["chain ", args26[0], " ", args26[1], " ", args26[2]])); + const args129 = [(f: rs.Formatter) => rs.u32Display(n5, f), (f: rs.Formatter) => rs.fmtOption(_379, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_381, f)]; + Log.note(log, rs.fmtFormat(["chain ", args129[0], " ", args129[1], " ", args129[2]])); } else if (_17 === 13) { const _396: rs.Iter = rs.vecIntoIter(guards(1, 8), rs.drop); _1090 = false; const captured40 = c; const n6: rs.u32 = rs.iterFold(rs.iterTake(rs.iterStepBy(rs.iterSkip(rs.iterRev(rs.iterMap(_396, rs.closure((g53: Guard.Guard): Guard.Guard => { - const _954: rs.u32 = Guard.id(g53); + const _964: rs.u32 = Guard.id(g53); const _1219: rs.u32 = Guard.id(captured40); - const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_954, f), (f: rs.Formatter) => rs.u32Display(_1219, f)]; - Log.note(log, rs.fmtFormat(["map ", args94[0], " ", args94[1]])); + const args127 = [(f: rs.Formatter) => rs.u32Display(_964, f), (f: rs.Formatter) => rs.u32Display(_1219, f)]; + Log.note(log, rs.fmtFormat(["map ", args127[0], " ", args127[1]])); return g53; }, (): void => { captured40[Symbol.dispose](); @@ -392,8 +389,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _060; }, true); const _409: rs.u32 = Guard.id(d); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n6, f), (f: rs.Formatter) => rs.u32Display(_409, f)]; - Log.note(log, rs.fmtFormat(["read ", args28[0], " ", args28[1]])); + const args128 = [(f: rs.Formatter) => rs.u32Display(n6, f), (f: rs.Formatter) => rs.u32Display(_409, f)]; + Log.note(log, rs.fmtFormat(["read ", args128[0], " ", args128[1]])); } else if (_17 === 14) { const _419: rs.Iter<[rs.usize, Guard.Guard]> = rs.iterEnumerate(rs.vecIntoIter(guards(1, 4), rs.drop)); _1090 = false; @@ -409,10 +406,10 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { _1089 = false; const captured39 = d; const _439: [rs.usize, rs.u32] | undefined = option_map$1389p4b(rs.ownedLast(rs.iterEnumerate(rs.iterMap(_428, rs.closure((g51: Guard.Guard): Guard.Guard => { - const _953: rs.u32 = Guard.id(g51); + const _959: rs.u32 = Guard.id(g51); const _1218: rs.u32 = Guard.id(captured39); - const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_953, f), (f: rs.Formatter) => rs.u32Display(_1218, f)]; - Log.note(log, rs.fmtFormat(["map ", args92[0], " ", args92[1]])); + const args123 = [(f: rs.Formatter) => rs.u32Display(_959, f), (f: rs.Formatter) => rs.u32Display(_1218, f)]; + Log.note(log, rs.fmtFormat(["map ", args123[0], " ", args123[1]])); return g51; }, (): void => { captured39[Symbol.dispose](); @@ -423,17 +420,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g52[Symbol.dispose](); return _058; }); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n7, f), (f: rs.Formatter) => rs.fmtOption(_439, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["enumerate ", args30[0], " ", args30[1]])); + const args124 = [(f: rs.Formatter) => rs.usizeDisplay(n7, f), (f: rs.Formatter) => rs.fmtOption(_439, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["enumerate ", args124[0], " ", args124[1]])); } else if (_17 === 15) { const _448: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured36 = c; const peek: rs.Peekable = rs.iterPeekable(rs.iterMap(_448, rs.closure((g46: Guard.Guard): Guard.Guard => { - const _948: rs.u32 = Guard.id(g46); + const _949: rs.u32 = Guard.id(g46); const _1217: rs.u32 = Guard.id(captured36); - const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_948, f), (f: rs.Formatter) => rs.u32Display(_1217, f)]; - Log.note(log, rs.fmtFormat(["map ", args90[0], " ", args90[1]])); + const args118 = [(f: rs.Formatter) => rs.u32Display(_949, f), (f: rs.Formatter) => rs.u32Display(_1217, f)]; + Log.note(log, rs.fmtFormat(["map ", args118[0], " ", args118[1]])); return g46; }, (): void => { captured36[Symbol.dispose](); @@ -441,8 +438,7 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part11 = option_map$06w9waf(rs.peekablePeek(peek), (g47: Guard.Guard): rs.u32 => { return Guard.id(g47); }); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part11, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["peek ", args32[0]])); + Log.note(log, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.fmtOption(part11, f, rs.u32Debug)])); const n8: rs.u32 = rs.iterFold(peek, 0, (n34: rs.u32, g48: Guard.Guard): rs.u32 => { const _053: rs.u32 = rs.u32Sub(rs.u32Add(n34, Guard.id(g48)), id); g48[Symbol.dispose](); @@ -460,8 +456,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g50[Symbol.dispose](); return _055; }, true); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8, f), (f: rs.Formatter) => rs.u32Display(m4, f)]; - Log.note(log, rs.fmtFormat(["peek ", args34[0], " ", args34[1]])); + const args120 = [(f: rs.Formatter) => rs.u32Display(n8, f), (f: rs.Formatter) => rs.u32Display(m4, f)]; + Log.note(log, rs.fmtFormat(["peek ", args120[0], " ", args120[1]])); } else if (_17 === 16) { const _493: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; @@ -489,8 +485,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g45[Symbol.dispose](); return _050; }), rs.u32Add, 0, true); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n9, f), (f: rs.Formatter) => rs.u32Display(m5, f)]; - Log.note(log, rs.fmtFormat(["skip ", args36[0], " ", args36[1]])); + const args115 = [(f: rs.Formatter) => rs.u32Display(n9, f), (f: rs.Formatter) => rs.u32Display(m5, f)]; + Log.note(log, rs.fmtFormat(["skip ", args115[0], " ", args115[1]])); } else if (_17 === 17) { const _527: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; @@ -513,8 +509,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured33[Symbol.dispose](); }), rs.drop), rs.drop); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n10, f), (f: rs.Formatter) => rs.usizeDisplay(m6, f)]; - Log.note(log, rs.fmtFormat(["while ", args38[0], " ", args38[1]])); + const args114 = [(f: rs.Formatter) => rs.u32Display(n10, f), (f: rs.Formatter) => rs.usizeDisplay(m6, f)]; + Log.note(log, rs.fmtFormat(["while ", args114[0], " ", args114[1]])); } else if (_17 === 18) { const _553: rs.Iter = rs.iterSlice([1, 3, 5]); _1090 = false; @@ -522,20 +518,21 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured30 = c; const n11: rs.usize = rs.ownedCount(rs.iterFlatMap(_553, rs.closure((n33: rs.u32): rs.Vec => { const v6: rs.Vec = new rs.Vec(); - const _659: Guard.Guard = captured29(n33); - v6.items.push(_659); - const _1128: Guard.Guard = captured29(rs.u32Add(n33, 1)); - v6.items.push(_1128); - const _226: rs.u32 = Guard.id(captured30); - const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n33, f), (f: rs.Formatter) => rs.u32Display(_226, f)]; - Log.note(log, rs.fmtFormat(["flat ", args88[0], " ", args88[1]])); - return v6; + const _661: Guard.Guard = captured29(n33); + v6.items.push(_661); + const _1132: Guard.Guard = captured29(rs.u32Add(n33, 1)); + v6.items.push(_1132); + const v5: rs.Vec = v6; + const _227: rs.u32 = Guard.id(captured30); + const args112 = [(f: rs.Formatter) => rs.u32Display(n33, f), (f: rs.Formatter) => rs.u32Display(_227, f)]; + Log.note(log, rs.fmtFormat(["flat ", args112[0], " ", args112[1]])); + return v5; }, (): void => { captured30[Symbol.dispose](); }), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true), rs.drop); const _562: rs.u32 = Guard.id(d); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n11, f), (f: rs.Formatter) => rs.u32Display(_562, f)]; - Log.note(log, rs.fmtFormat(["flat ", args40[0], " ", args40[1]])); + const args113 = [(f: rs.Formatter) => rs.usizeDisplay(n11, f), (f: rs.Formatter) => rs.u32Display(_562, f)]; + Log.note(log, rs.fmtFormat(["flat ", args113[0], " ", args113[1]])); } else if (_17 === 19) { const _572: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; @@ -556,8 +553,7 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g36[Symbol.dispose](); return _039; }); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["front ", args42[0]])); + Log.note(log, rs.fmtFormat(["front ", (f: rs.Formatter) => rs.fmtOption(part7, f, rs.u32Debug)])); const n12: rs.u32 = rs.iterSum(rs.iterMap(flat, (g37: Guard.Guard): rs.u32 => { const _040: rs.u32 = rs.u32Sub(Guard.id(g37), id); g37[Symbol.dispose](); @@ -570,10 +566,10 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured28 = id; const _606: rs.u32 | undefined = option_map$06w9waf(rs.ownedLast(rs.iterFlatMap(_597, rs.closure((n32: rs.u32): rs.Vec => { const v4: rs.Vec = new rs.Vec(); - const _658: Guard.Guard = captured26(n32); - v4.items.push(_658); - const _1125: Guard.Guard = captured26(rs.u32Add(rs.u32Sub(Guard.id(captured27), captured28), n32)); - v4.items.push(_1125); + const _660: Guard.Guard = captured26(n32); + v4.items.push(_660); + const _1129: Guard.Guard = captured26(rs.u32Add(rs.u32Sub(Guard.id(captured27), captured28), n32)); + v4.items.push(_1129); return v4; }, (): void => { captured27[Symbol.dispose](); @@ -582,17 +578,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g38[Symbol.dispose](); return _042; }); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n12, f), (f: rs.Formatter) => rs.fmtOption(_606, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["flat ", args44[0], " ", args44[1]])); + const args109 = [(f: rs.Formatter) => rs.u32Display(n12, f), (f: rs.Formatter) => rs.fmtOption(_606, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["flat ", args109[0], " ", args109[1]])); } else if (_17 === 20) { const held: rs.Vec = guards(1, 5); _1090 = false; let captured19 = held; const captured20 = c; const n13: rs.usize = rs.ownedCount(rs.iterFromFn(rs.closure((): rs.u32 | undefined => { - const _336: Guard.Guard | undefined = rs.vecPop(captured19); - if (_336 !== undefined) { - const g32: Guard.Guard = _336; + const _340: Guard.Guard | undefined = rs.vecPop(captured19); + if (_340 !== undefined) { + const g32: Guard.Guard = _340; const _034: rs.u32 | undefined = rs.u32Add(Guard.id(g32), Guard.id(captured20)); g32[Symbol.dispose](); return _034; @@ -617,8 +613,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g34[Symbol.dispose](); return _037; }, true); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n13, f), (f: rs.Formatter) => rs.u32Display(m8, f)]; - Log.note(log, rs.fmtFormat(["lazy ", args46[0], " ", args46[1]])); + const args107 = [(f: rs.Formatter) => rs.usizeDisplay(n13, f), (f: rs.Formatter) => rs.u32Display(m8, f)]; + Log.note(log, rs.fmtFormat(["lazy ", args107[0], " ", args107[1]])); } else if (_17 === 21) { const _643: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; @@ -631,18 +627,18 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured18[Symbol.dispose](); })), 1)); const m9: rs.usize = rs.ownedCount(rs.iterTake(rs.vecIntoIter(guards(5, 8), rs.drop), 2, rs.drop), rs.drop); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n14, f), (f: rs.Formatter) => rs.usizeDisplay(m9, f)]; - Log.note(log, rs.fmtFormat(["over ", args48[0], " ", args48[1]])); + const args106 = [(f: rs.Formatter) => rs.usizeDisplay(n14, f), (f: rs.Formatter) => rs.usizeDisplay(m9, f)]; + Log.note(log, rs.fmtFormat(["over ", args106[0], " ", args106[1]])); } else if (_17 === 22) { const _669: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured15 = c; const captured16 = id; const n15: rs.u32 = rs.iterFold(rs.iterRev(rs.iterMap(_669, rs.closure((g29: Guard.Guard): rs.u32 => { - const _940: rs.u32 = Guard.id(g29); + const _941: rs.u32 = Guard.id(g29); const _1215: rs.u32 = Guard.id(captured15); - const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_940, f), (f: rs.Formatter) => rs.u32Display(_1215, f)]; - Log.note(log, rs.fmtFormat(["map ", args86[0], " ", args86[1]])); + const args104 = [(f: rs.Formatter) => rs.u32Display(_941, f), (f: rs.Formatter) => rs.u32Display(_1215, f)]; + Log.note(log, rs.fmtFormat(["map ", args104[0], " ", args104[1]])); const _030: rs.u32 = rs.u32Sub(Guard.id(g29), captured16); g29[Symbol.dispose](); return _030; @@ -659,17 +655,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured17[Symbol.dispose](); }), rs.drop)), rs.drop); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n15, f), (f: rs.Formatter) => rs.usizeDisplay(m10, f)]; - Log.note(log, rs.fmtFormat(["rev ", args50[0], " ", args50[1]])); + const args105 = [(f: rs.Formatter) => rs.u32Display(n15, f), (f: rs.Formatter) => rs.usizeDisplay(m10, f)]; + Log.note(log, rs.fmtFormat(["rev ", args105[0], " ", args105[1]])); } else if (_17 === 23) { const _702: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _1090 = false; const captured13 = c; const n16: rs.u32 = rs.iterFold(rs.iterRev(rs.iterTake(rs.iterMap(_702, rs.closure((g26: Guard.Guard): Guard.Guard => { - const _931: rs.u32 = Guard.id(g26); + const _937: rs.u32 = Guard.id(g26); const _1214: rs.u32 = Guard.id(captured13); - const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_931, f), (f: rs.Formatter) => rs.u32Display(_1214, f)]; - Log.note(log, rs.fmtFormat(["map ", args84[0], " ", args84[1]])); + const args100 = [(f: rs.Formatter) => rs.u32Display(_937, f), (f: rs.Formatter) => rs.u32Display(_1214, f)]; + Log.note(log, rs.fmtFormat(["map ", args100[0], " ", args100[1]])); return g26; }, (): void => { captured13[Symbol.dispose](); @@ -686,17 +682,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _029; }), 0)), rs.u32Add, 0, true); const _724: rs.u32 = Guard.id(d); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n16, f), (f: rs.Formatter) => rs.u32Display(m11, f), (f: rs.Formatter) => rs.u32Display(_724, f)]; - Log.note(log, rs.fmtFormat(["take ", args52[0], " ", args52[1], " ", args52[2]])); + const args101 = [(f: rs.Formatter) => rs.u32Display(n16, f), (f: rs.Formatter) => rs.u32Display(m11, f), (f: rs.Formatter) => rs.u32Display(_724, f)]; + Log.note(log, rs.fmtFormat(["take ", args101[0], " ", args101[1], " ", args101[2]])); } else if (_17 === 24) { const _739: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _1090 = false; const captured11 = c; const n17: rs.u32 = rs.iterSum(rs.iterMap(rs.iterRev(rs.iterStepBy(rs.iterMap(_739, rs.closure((g23: Guard.Guard): Guard.Guard => { - const _928: rs.u32 = Guard.id(g23); + const _931: rs.u32 = Guard.id(g23); const _1213: rs.u32 = Guard.id(captured11); - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_928, f), (f: rs.Formatter) => rs.u32Display(_1213, f)]; - Log.note(log, rs.fmtFormat(["map ", args82[0], " ", args82[1]])); + const args96 = [(f: rs.Formatter) => rs.u32Display(_931, f), (f: rs.Formatter) => rs.u32Display(_1213, f)]; + Log.note(log, rs.fmtFormat(["map ", args96[0], " ", args96[1]])); return g23; }, (): void => { captured11[Symbol.dispose](); @@ -713,17 +709,17 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured12[Symbol.dispose](); }), rs.drop), 3, rs.drop), rs.drop); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n17, f), (f: rs.Formatter) => rs.usizeDisplay(m12, f)]; - Log.note(log, rs.fmtFormat(["step ", args54[0], " ", args54[1]])); + const args97 = [(f: rs.Formatter) => rs.u32Display(n17, f), (f: rs.Formatter) => rs.usizeDisplay(m12, f)]; + Log.note(log, rs.fmtFormat(["step ", args97[0], " ", args97[1]])); } else if (_17 === 25) { const _768: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured10 = c; const peek2: rs.Peekable = rs.iterPeekable(rs.iterMap(_768, rs.closure((g18: Guard.Guard): Guard.Guard => { - const _922: rs.u32 = Guard.id(g18); + const _923: rs.u32 = Guard.id(g18); const _1212: rs.u32 = Guard.id(captured10); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_922, f), (f: rs.Formatter) => rs.u32Display(_1212, f)]; - Log.note(log, rs.fmtFormat(["map ", args80[0], " ", args80[1]])); + const args89 = [(f: rs.Formatter) => rs.u32Display(_923, f), (f: rs.Formatter) => rs.u32Display(_1212, f)]; + Log.note(log, rs.fmtFormat(["map ", args89[0], " ", args89[1]])); return g18; }, (): void => { captured10[Symbol.dispose](); @@ -731,8 +727,7 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part3 = option_map$06w9waf(rs.peekablePeek(peek2), (g19: Guard.Guard): rs.u32 => { return Guard.id(g19); }); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["peek ", args56[0]])); + Log.note(log, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)])); const n18: rs.u32 = rs.iterFold(rs.iterRev(peek2), 0, (n28: rs.u32, g20: Guard.Guard): rs.u32 => { const _021: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n28, 10), Guard.id(g20)), id); g20[Symbol.dispose](); @@ -744,17 +739,15 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g21[Symbol.dispose](); return _022; }); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["peek ", args58[0]])); + Log.note(log, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.fmtOption(part4, f, rs.u32Debug)])); const part5 = option_map$06w9waf(rs.peekablePeek(ended), (g22: Guard.Guard): rs.u32 => { return Guard.id(g22); }); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["peek ", args60[0]])); + Log.note(log, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)])); const _828: rs.usize = rs.ownedCount(rs.iterRev(ended), rs.drop); const _832: rs.u32 = Guard.id(d); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n18, f), (f: rs.Formatter) => rs.usizeDisplay(_828, f), (f: rs.Formatter) => rs.u32Display(_832, f)]; - Log.note(log, rs.fmtFormat(["peek ", args62[0], " ", args62[1], " ", args62[2]])); + const args93 = [(f: rs.Formatter) => rs.u32Display(n18, f), (f: rs.Formatter) => rs.usizeDisplay(_828, f), (f: rs.Formatter) => rs.u32Display(_832, f)]; + Log.note(log, rs.fmtFormat(["peek ", args93[0], " ", args93[1], " ", args93[2]])); } else if (_17 === 26) { const _843: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; @@ -775,8 +768,7 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g15[Symbol.dispose](); return _016; }); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["back ", args64[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)])); const n19: rs.u32 = rs.iterFold(rs.iterRev(flat2), 0, (n27: rs.u32, g16: Guard.Guard): rs.u32 => { const _017: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n27, 100), Guard.id(g16)), id); g16[Symbol.dispose](); @@ -790,8 +782,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _018; }); const _881: rs.u32 = Guard.id(d); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n19, f), (f: rs.Formatter) => rs.fmtOption(_879, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(_881, f)]; - Log.note(log, rs.fmtFormat(["flat ", args66[0], " ", args66[1], " ", args66[2]])); + const args86 = [(f: rs.Formatter) => rs.u32Display(n19, f), (f: rs.Formatter) => rs.fmtOption(_879, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(_881, f)]; + Log.note(log, rs.fmtFormat(["flat ", args86[0], " ", args86[1], " ", args86[2]])); } else if (_17 === 27) { const _893: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; @@ -839,8 +831,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g13[Symbol.dispose](); return _014; }); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_916, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(n20, f)]; - Log.note(log, rs.fmtFormat(["rev ", args68[0], " ", args68[1]])); + const args84 = [(f: rs.Formatter) => rs.fmtOption(_916, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(n20, f)]; + Log.note(log, rs.fmtFormat(["rev ", args84[0], " ", args84[1]])); } else if (_17 === 28) { const _926: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; @@ -848,8 +840,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const n21: rs.usize = rs.ownedCount(rs.iterRev(rs.iterInspect(_926, rs.closure((g7: Guard.Guard): undefined => { const _910: rs.u32 = Guard.id(g7); const _1111: rs.u32 = Guard.id(captured4); - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args78[0], " ", args78[1]])); + const args82 = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args82[0], " ", args82[1]])); }, (): void => { captured4[Symbol.dispose](); }))), rs.drop); @@ -858,8 +850,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g8[Symbol.dispose](); return _09; }), rs.u32Add, 0, true); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n21, f), (f: rs.Formatter) => rs.u32Display(m14, f)]; - Log.note(log, rs.fmtFormat(["rev ", args70[0], " ", args70[1]])); + const args83 = [(f: rs.Formatter) => rs.usizeDisplay(n21, f), (f: rs.Formatter) => rs.u32Display(m14, f)]; + Log.note(log, rs.fmtFormat(["rev ", args83[0], " ", args83[1]])); } else if (_17 === 29) { const _957: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); const _962: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); @@ -875,8 +867,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _08; }, true); const _975: rs.u32 = Guard.id(c); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n22, f), (f: rs.Formatter) => rs.u32Display(_975, f)]; - Log.note(log, rs.fmtFormat(["rev ", args72[0], " ", args72[1]])); + const args79 = [(f: rs.Formatter) => rs.u32Display(n22, f), (f: rs.Formatter) => rs.u32Display(_975, f)]; + Log.note(log, rs.fmtFormat(["rev ", args79[0], " ", args79[1]])); } else if (_17 === 31) { options(log, id); } else if (_17 === 32) { @@ -896,8 +888,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const n23: rs.u32 = rs.iterSum(rs.iterMap(rs.iterRev(rs.iterSkip(rs.iterMap(_990, rs.closure((g: Guard.Guard): Guard.Guard => { const _9: rs.u32 = Guard.id(g); const _123: rs.u32 = Guard.id(captured); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_9, f), (f: rs.Formatter) => rs.u32Display(_123, f)]; - Log.note(log, rs.fmtFormat(["map ", args76[0], " ", args76[1]])); + const args77 = [(f: rs.Formatter) => rs.u32Display(_9, f), (f: rs.Formatter) => rs.u32Display(_123, f)]; + Log.note(log, rs.fmtFormat(["map ", args77[0], " ", args77[1]])); return g; }, (): void => { captured[Symbol.dispose](); @@ -918,8 +910,8 @@ export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g4[Symbol.dispose](); return _06; }, true); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n23, f), (f: rs.Formatter) => rs.u32Display(m15, f)]; - Log.note(log, rs.fmtFormat(["skip ", args74[0], " ", args74[1]])); + const args78 = [(f: rs.Formatter) => rs.u32Display(n23, f), (f: rs.Formatter) => rs.u32Display(m15, f)]; + Log.note(log, rs.fmtFormat(["skip ", args78[0], " ", args78[1]])); } } if (_1089) { @@ -969,8 +961,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _27: rs.Iter = rs.iterRev(rs.iterMap(_29, rs.closure((g53: Guard.Guard): Guard.Guard => { const _928: rs.u32 = Guard.id(g53); const _1226: rs.u32 = Guard.id(captured48); - const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_928, f), (f: rs.Formatter) => rs.u32Display(_1226, f)]; - Log.note(log, rs.fmtFormat(["map ", args86[0], " ", args86[1]])); + const args128 = [(f: rs.Formatter) => rs.u32Display(_928, f), (f: rs.Formatter) => rs.u32Display(_1226, f)]; + Log.note(log, rs.fmtFormat(["map ", args128[0], " ", args128[1]])); return g53; }, (): void => { captured48[Symbol.dispose](); @@ -986,8 +978,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured50[Symbol.dispose](); })), rs.u32Add, 0, true); const _41: rs.u32 = Guard.id(e); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.u32Display(_41, f)]; - Log.note(log, rs.fmtFormat(["map ", args2[0], " ", args2[1]])); + const args129 = [(f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.u32Display(_41, f)]; + Log.note(log, rs.fmtFormat(["map ", args129[0], " ", args129[1]])); } else if (_23 === 1) { const _53: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; @@ -1024,17 +1016,17 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured47[Symbol.dispose](); }))); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n2, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; - Log.note(log, rs.fmtFormat(["filter ", args4[0], " ", args4[1]])); + const args125 = [(f: rs.Formatter) => rs.u32Display(n2, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; + Log.note(log, rs.fmtFormat(["filter ", args125[0], " ", args125[1]])); } else if (_23 === 2) { const _87: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _775 = false; const captured39 = c; const _86: rs.Iter = rs.iterInspect(_87, rs.closure((g45: Guard.Guard): undefined => { const _925: rs.u32 = Guard.id(g45); - const _1136: rs.u32 = Guard.id(captured39); - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_925, f), (f: rs.Formatter) => rs.u32Display(_1136, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args82[0], " ", args82[1]])); + const _1139: rs.u32 = Guard.id(captured39); + const args120 = [(f: rs.Formatter) => rs.u32Display(_925, f), (f: rs.Formatter) => rs.u32Display(_1139, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args120[0], " ", args120[1]])); }, (): void => { captured39[Symbol.dispose](); })); @@ -1053,9 +1045,9 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured41 = e; const _98: rs.Iter = rs.iterRev(rs.iterInspect(_100, rs.closure((g47: Guard.Guard): undefined => { const _926: rs.u32 = Guard.id(g47); - const _1139: rs.u32 = Guard.id(captured41); - const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_926, f), (f: rs.Formatter) => rs.u32Display(_1139, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args84[0], " ", args84[1]])); + const _1142: rs.u32 = Guard.id(captured41); + const args123 = [(f: rs.Formatter) => rs.u32Display(_926, f), (f: rs.Formatter) => rs.u32Display(_1142, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args123[0], " ", args123[1]])); }, (): void => { captured41[Symbol.dispose](); }))); @@ -1067,8 +1059,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured42[Symbol.dispose](); }))); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f)]; - Log.note(log, rs.fmtFormat(["inspect ", args6[0], " ", args6[1]])); + const args124 = [(f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args124[0], " ", args124[1]])); } else if (_23 === 3) { const _122: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; @@ -1076,8 +1068,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _133: [rs.usize, rs.u32] | undefined = option_map$1389p4b(rs.ownedLast(rs.iterRev(rs.iterEnumerate(rs.iterMap(_122, rs.closure((g43: Guard.Guard): Guard.Guard => { const _924: rs.u32 = Guard.id(g43); const _1224: rs.u32 = Guard.id(captured38); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_924, f), (f: rs.Formatter) => rs.u32Display(_1224, f)]; - Log.note(log, rs.fmtFormat(["map ", args80[0], " ", args80[1]])); + const args116 = [(f: rs.Formatter) => rs.u32Display(_924, f), (f: rs.Formatter) => rs.u32Display(_1224, f)]; + Log.note(log, rs.fmtFormat(["map ", args116[0], " ", args116[1]])); return g43; }, (): void => { captured38[Symbol.dispose](); @@ -1090,8 +1082,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const _135: rs.u32 = Guard.id(d); const _138: rs.u32 = Guard.id(e); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_133, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(_135, f), (f: rs.Formatter) => rs.u32Display(_138, f)]; - Log.note(log, rs.fmtFormat(["enumerate ", args8[0], " ", args8[1], " ", args8[2]])); + const args117 = [(f: rs.Formatter) => rs.fmtOption(_133, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(_135, f), (f: rs.Formatter) => rs.u32Display(_138, f)]; + Log.note(log, rs.fmtFormat(["enumerate ", args117[0], " ", args117[1], " ", args117[2]])); } else if (_23 === 4) { const _150: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; @@ -1116,8 +1108,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return rs.u32Add(n25, k6); }, true); const _169: rs.u32 = Guard.id(e); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n4, f), (f: rs.Formatter) => rs.u32Display(m3, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; - Log.note(log, rs.fmtFormat(["twice ", args10[0], " ", args10[1], " ", args10[2]])); + const args113 = [(f: rs.Formatter) => rs.usizeDisplay(n4, f), (f: rs.Formatter) => rs.u32Display(m3, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; + Log.note(log, rs.fmtFormat(["twice ", args113[0], " ", args113[1], " ", args113[2]])); } else if (_23 === 5) { const _183: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; @@ -1125,8 +1117,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _181: rs.Iter = rs.iterStepBy(rs.iterMap(_183, rs.closure((g37: Guard.Guard): Guard.Guard => { const _922: rs.u32 = Guard.id(g37); const _1222: rs.u32 = Guard.id(captured34); - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_922, f), (f: rs.Formatter) => rs.u32Display(_1222, f)]; - Log.note(log, rs.fmtFormat(["map ", args78[0], " ", args78[1]])); + const args111 = [(f: rs.Formatter) => rs.u32Display(_922, f), (f: rs.Formatter) => rs.u32Display(_1222, f)]; + Log.note(log, rs.fmtFormat(["map ", args111[0], " ", args111[1]])); return g37; }, (): void => { captured34[Symbol.dispose](); @@ -1137,24 +1129,24 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return [g38, Guard.id(captured35)] as [Guard.Guard, rs.u32]; }, (): void => { captured35[Symbol.dispose](); - })), guard(20), (kept7: Guard.Guard | undefined, _347: [Guard.Guard, rs.u32]): Guard.Guard | undefined => { + })), guard(20), (kept7: Guard.Guard | undefined, _352: [Guard.Guard, rs.u32]): Guard.Guard | undefined => { let _046!: Guard.Guard | undefined; let _1223: boolean = false; - let _1128: boolean = false; + let _1131: boolean = false; _1223 = true; - _1128 = true; - const g39: Guard.Guard = _347[0]; + _1131 = true; + const g39: Guard.Guard = _352[0]; if (!(rs.u32Rem(Guard.id(g39), 2) === 1)) { _1223 = false; _046 = kept7; } else { - _1128 = false; + _1131 = false; _046 = g39; } - if (_1128) { + if (_1131) { g39[Symbol.dispose](); } - _1128 = false; + _1131 = false; if (_1223) { rs.drop(kept7); return _046; @@ -1166,8 +1158,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _047; }); const _201: rs.u32 = Guard.id(e); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_199, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_201, f)]; - Log.note(log, rs.fmtFormat(["step ", args12[0], " ", args12[1]])); + const args112 = [(f: rs.Formatter) => rs.fmtOption(_199, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_201, f)]; + Log.note(log, rs.fmtFormat(["step ", args112[0], " ", args112[1]])); } else if (_23 === 6) { const _213: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _775 = false; @@ -1175,8 +1167,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _210: rs.Iter = rs.iterRev(rs.iterStepBy(rs.iterMap(_213, rs.closure((g33: Guard.Guard): Guard.Guard => { const _920: rs.u32 = Guard.id(g33); const _1220: rs.u32 = Guard.id(captured32); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_920, f), (f: rs.Formatter) => rs.u32Display(_1220, f)]; - Log.note(log, rs.fmtFormat(["map ", args76[0], " ", args76[1]])); + const args107 = [(f: rs.Formatter) => rs.u32Display(_920, f), (f: rs.Formatter) => rs.u32Display(_1220, f)]; + Log.note(log, rs.fmtFormat(["map ", args107[0], " ", args107[1]])); return g33; }, (): void => { captured32[Symbol.dispose](); @@ -1187,24 +1179,24 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return [g34, Guard.id(captured33)] as [Guard.Guard, rs.u32]; }, (): void => { captured33[Symbol.dispose](); - })), guard(20), (kept6: Guard.Guard | undefined, _344: [Guard.Guard, rs.u32]): Guard.Guard | undefined => { + })), guard(20), (kept6: Guard.Guard | undefined, _346: [Guard.Guard, rs.u32]): Guard.Guard | undefined => { let _042!: Guard.Guard | undefined; let _1221: boolean = false; - let _1123: boolean = false; + let _1126: boolean = false; _1221 = true; - _1123 = true; - const g35: Guard.Guard = _344[0]; + _1126 = true; + const g35: Guard.Guard = _346[0]; if (!(rs.u32Rem(Guard.id(g35), 2) === 1)) { _1221 = false; _042 = kept6; } else { - _1123 = false; + _1126 = false; _042 = g35; } - if (_1123) { + if (_1126) { g35[Symbol.dispose](); } - _1123 = false; + _1126 = false; if (_1221) { rs.drop(kept6); return _042; @@ -1216,8 +1208,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _043; }); const _231: rs.u32 = Guard.id(e); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_229, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_231, f)]; - Log.note(log, rs.fmtFormat(["step ", args14[0], " ", args14[1]])); + const args108 = [(f: rs.Formatter) => rs.fmtOption(_229, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_231, f)]; + Log.note(log, rs.fmtFormat(["step ", args108[0], " ", args108[1]])); } else if (_23 === 7) { const _241: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; @@ -1241,8 +1233,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured31[Symbol.dispose](); })), true))); const _261: rs.u32 = Guard.id(e); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n5, f), (f: rs.Formatter) => rs.usizeDisplay(m4, f), (f: rs.Formatter) => rs.u32Display(_261, f)]; - Log.note(log, rs.fmtFormat(["fuse ", args16[0], " ", args16[1], " ", args16[2]])); + const args104 = [(f: rs.Formatter) => rs.u32Display(n5, f), (f: rs.Formatter) => rs.usizeDisplay(m4, f), (f: rs.Formatter) => rs.u32Display(_261, f)]; + Log.note(log, rs.fmtFormat(["fuse ", args104[0], " ", args104[1], " ", args104[2]])); } else if (_23 === 8) { const _273: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _775 = false; @@ -1252,8 +1244,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const flat: rs.Iter = rs.iterFlatten(rs.iterMap(_273, rs.closure((g27: Guard.Guard): rs.Vec => { const _918: rs.u32 = Guard.id(g27); const _1218: rs.u32 = Guard.id(captured25); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_918, f), (f: rs.Formatter) => rs.u32Display(_1218, f)]; - Log.note(log, rs.fmtFormat(["map ", args74[0], " ", args74[1]])); + const args100 = [(f: rs.Formatter) => rs.u32Display(_918, f), (f: rs.Formatter) => rs.u32Display(_1218, f)]; + Log.note(log, rs.fmtFormat(["map ", args100[0], " ", args100[1]])); const v: rs.Vec = new rs.Vec(); const _2211: Guard.Guard = captured26(rs.u32Add(rs.u32Sub(Guard.id(g27), captured27), 3)); v.items.push(_2211); @@ -1267,15 +1259,13 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g28[Symbol.dispose](); return _035; }); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["ends ", args18[0]])); + Log.note(log, rs.fmtFormat(["ends ", (f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)])); const part9 = option_map$06w9waf(rs.iterToOption(flat.nextBack()), (g29: Guard.Guard): rs.u32 => { const _036: rs.u32 = Guard.id(g29); g29[Symbol.dispose](); return _036; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["ends ", args20[0]])); + Log.note(log, rs.fmtFormat(["ends ", (f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)])); const _306: rs.Iter = flat; _774 = false; const captured28 = d; @@ -1287,8 +1277,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured28[Symbol.dispose](); }))); const _314: rs.u32 = Guard.id(e); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.u32Display(_314, f)]; - Log.note(log, rs.fmtFormat(["flat ", args22[0], " ", args22[1]])); + const args103 = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.u32Display(_314, f)]; + Log.note(log, rs.fmtFormat(["flat ", args103[0], " ", args103[1]])); } else if (_23 === 9) { const _324: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _775 = false; @@ -1296,8 +1286,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _323: rs.Iter = rs.iterMap(_324, rs.closure((g24: Guard.Guard): Guard.Guard => { const _916: rs.u32 = Guard.id(g24); const _1216: rs.u32 = Guard.id(captured22); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_916, f), (f: rs.Formatter) => rs.u32Display(_1216, f)]; - Log.note(log, rs.fmtFormat(["map ", args70[0], " ", args70[1]])); + const args93 = [(f: rs.Formatter) => rs.u32Display(_916, f), (f: rs.Formatter) => rs.u32Display(_1216, f)]; + Log.note(log, rs.fmtFormat(["map ", args93[0], " ", args93[1]])); return g24; }, (): void => { captured22[Symbol.dispose](); @@ -1307,16 +1297,16 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured23 = d; const kept3: Guard.Guard | undefined = rs.iterRfold(_323, _329, rs.closure((kept5: Guard.Guard | undefined, g25: Guard.Guard): Guard.Guard | undefined => { let _031!: Guard.Guard | undefined; - let _304: boolean = false; + let _308: boolean = false; let _296: boolean = false; - _304 = true; + _308 = true; _296 = true; const _1014: rs.u32 = Guard.id(g25); const _1316: rs.u32 = Guard.id(captured23); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1014, f), (f: rs.Formatter) => rs.u32Display(_1316, f)]; - Log.note(log, rs.fmtFormat(["rfold ", args72[0], " ", args72[1]])); + const args96 = [(f: rs.Formatter) => rs.u32Display(_1014, f), (f: rs.Formatter) => rs.u32Display(_1316, f)]; + Log.note(log, rs.fmtFormat(["rfold ", args96[0], " ", args96[1]])); if (!(rs.u32Rem(Guard.id(g25), 2) === 1)) { - _304 = false; + _308 = false; _031 = kept5; } else { _296 = false; @@ -1325,7 +1315,7 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { if (_296) { g25[Symbol.dispose](); } - if (_304) { + if (_308) { rs.drop(kept5); return _031; } @@ -1336,8 +1326,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _335: rs.Iter = rs.iterSlice([1, 2, 3]); _773 = false; const captured24 = e; - const n7: rs.u32 = rs.iterRfold(_335, 0, rs.closure((n24: rs.u32, _326: rs.u32): rs.u32 => { - return rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(n24, 10), _326), Guard.id(captured24)), Guard.id(captured24)); + const n7: rs.u32 = rs.iterRfold(_335, 0, rs.closure((n24: rs.u32, _331: rs.u32): rs.u32 => { + return rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(n24, 10), _331), Guard.id(captured24)), Guard.id(captured24)); }, (): void => { captured24[Symbol.dispose](); }), undefined, true); @@ -1346,8 +1336,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g26[Symbol.dispose](); return _033; }); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_345, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(n7, f)]; - Log.note(log, rs.fmtFormat(["rfold ", args24[0], " ", args24[1]])); + const args97 = [(f: rs.Formatter) => rs.fmtOption(_345, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(n7, f)]; + Log.note(log, rs.fmtFormat(["rfold ", args97[0], " ", args97[1]])); } else if (_23 === 10) { const held: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _775 = false; @@ -1356,8 +1346,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const sum: rs.u32 | undefined = rs.iterTryRfold(held, 0, rs.closure((n22: rs.u32, g22: Guard.Guard): rs.u32 | undefined => { const _1012: rs.u32 = Guard.id(g22); const _1314: rs.u32 = Guard.id(captured19); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1012, f), (f: rs.Formatter) => rs.u32Display(_1314, f)]; - Log.note(log, rs.fmtFormat(["try ", args68[0], " ", args68[1]])); + const args88 = [(f: rs.Formatter) => rs.u32Display(_1012, f), (f: rs.Formatter) => rs.u32Display(_1314, f)]; + Log.note(log, rs.fmtFormat(["try ", args88[0], " ", args88[1]])); const _027: rs.u32 | undefined = then$0apfzgv(Guard.id(g22) !== rs.u32Add(captured20, 3), (): rs.u32 => { return rs.u32Sub(rs.u32Add(n22, Guard.id(g22)), captured20); }); @@ -1367,8 +1357,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured19[Symbol.dispose](); }), true, true); const _365: rs.usize = held.len(); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(sum, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_365, f)]; - Log.note(log, rs.fmtFormat(["tried ", args26[0], " ", args26[1]])); + const args89 = [(f: rs.Formatter) => rs.fmtOption(sum, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_365, f)]; + Log.note(log, rs.fmtFormat(["tried ", args89[0], " ", args89[1]])); _774 = false; const captured21 = d; const rest: rs.u32 | undefined = rs.iterTryRfold(held, 0, rs.closure((n23: rs.u32, g23: Guard.Guard): rs.u32 | undefined => { @@ -1379,8 +1369,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured21[Symbol.dispose](); }), true, true); const _382: rs.u32 = Guard.id(e); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(rest, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_382, f)]; - Log.note(log, rs.fmtFormat(["rest ", args28[0], " ", args28[1]])); + const args90 = [(f: rs.Formatter) => rs.fmtOption(rest, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_382, f)]; + Log.note(log, rs.fmtFormat(["rest ", args90[0], " ", args90[1]])); rs.drop(held); } else if (_23 === 11) { const _391: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); @@ -1389,8 +1379,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const mapped: rs.Iter = rs.iterMap(_391, rs.closure((g19: Guard.Guard): Guard.Guard => { const _913: rs.u32 = Guard.id(g19); const _1213: rs.u32 = Guard.id(captured16); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_913, f), (f: rs.Formatter) => rs.u32Display(_1213, f)]; - Log.note(log, rs.fmtFormat(["map ", args66[0], " ", args66[1]])); + const args83 = [(f: rs.Formatter) => rs.u32Display(_913, f), (f: rs.Formatter) => rs.u32Display(_1213, f)]; + Log.note(log, rs.fmtFormat(["map ", args83[0], " ", args83[1]])); return g19; }, (): void => { captured16[Symbol.dispose](); @@ -1420,12 +1410,10 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g21[Symbol.dispose](); return _026; }); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part5, f, rs.u32Debug, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["tried ", args30[0]])); + Log.note(log, rs.fmtFormat(["tried ", (f: rs.Formatter) => rs.fmtResult(part5, f, rs.u32Debug, rs.u32Debug)])); rs.drop(mapped); const part6 = Guard.id(e); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Log.note(log, rs.fmtFormat(["dropped ", args32[0]])); + Log.note(log, rs.fmtFormat(["dropped ", (f: rs.Formatter) => rs.u32Display(part6, f)])); } else if (_23 === 12) { const chained: rs.Iter = rs.iterRev(rs.iterChain(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 6), rs.drop))); _775 = false; @@ -1456,8 +1444,7 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { broke = Guard.id(g); g[Symbol.dispose](); } - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(broke, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["broke ", args34[0]])); + Log.note(log, rs.fmtFormat(["broke ", (f: rs.Formatter) => rs.fmtOption(broke, f, rs.u32Debug)])); const n8: rs.Result = rs.iterTryRfold(chained, 0, (n20: rs.u32, g18: Guard.Guard): rs.Result => { const _023: rs.Result = rs.Ok(rs.u32Sub(rs.u32Add(n20, Guard.id(g18)), id)); g18[Symbol.dispose](); @@ -1465,8 +1452,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const _461: rs.u32 = Guard.id(d); const _464: rs.u32 = Guard.id(e); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(n8, f, rs.u32Debug, rs.fmtUnit), (f: rs.Formatter) => rs.u32Display(_461, f), (f: rs.Formatter) => rs.u32Display(_464, f)]; - Log.note(log, rs.fmtFormat(["rest ", args36[0], " ", args36[1], " ", args36[2]])); + const args80 = [(f: rs.Formatter) => rs.fmtControlFlow(n8, f, rs.u32Debug, rs.fmtUnit), (f: rs.Formatter) => rs.u32Display(_461, f), (f: rs.Formatter) => rs.u32Display(_464, f)]; + Log.note(log, rs.fmtFormat(["rest ", args80[0], " ", args80[1], " ", args80[2]])); rs.drop(chained); } else if (_23 === 13) { const _474: rs.Iter = rs.vecIntoIter(guards(1, 1), rs.drop); @@ -1475,8 +1462,7 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured11 = c; const none: Guard.Guard = rs.iterRfold(_474, _478, rs.closure((acc: Guard.Guard, _316: Guard.Guard): Guard.Guard => { const part3 = Guard.id(captured11); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["never ", args62[0]])); + Log.note(log, rs.fmtFormat(["never ", (f: rs.Formatter) => rs.u32Display(part3, f)])); _316[Symbol.dispose](); return acc; }, (): void => { @@ -1496,15 +1482,14 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured13 = e; const tried: rs.u32 | undefined = rs.iterTryRfold(empty, 0, rs.closure((n18: rs.u32, k4: rs.u32): rs.u32 | undefined => { const part4 = Guard.id(captured13); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["never ", args64[0]])); + Log.note(log, rs.fmtFormat(["never ", (f: rs.Formatter) => rs.u32Display(part4, f)])); return rs.u32CheckedAdd(n18, k4); }, (): void => { captured13[Symbol.dispose](); }), true, true); const _497: rs.u32 = Guard.id(none); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_497, f), (f: rs.Formatter) => rs.fmtOption(tried, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["empty ", args38[0], " ", args38[1]])); + const args78 = [(f: rs.Formatter) => rs.u32Display(_497, f), (f: rs.Formatter) => rs.fmtOption(tried, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["empty ", args78[0], " ", args78[1]])); rs.drop(empty); none[Symbol.dispose](); } else if (_23 === 14) { @@ -1515,8 +1500,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _510: (a0: Guard.Guard) => rs.u32 = rs.closure((g13: Guard.Guard): rs.u32 => { const _910: rs.u32 = Guard.id(g13); const _1211: rs.u32 = Guard.id(captured7); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1211, f)]; - Log.note(log, rs.fmtFormat(["map ", args58[0], " ", args58[1]])); + const args66 = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1211, f)]; + Log.note(log, rs.fmtFormat(["map ", args66[0], " ", args66[1]])); const _016: rs.u32 = rs.u32Sub(Guard.id(g13), captured8); g13[Symbol.dispose](); return _016; @@ -1526,16 +1511,15 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part2 = rs.iterFold(rs.iterMap(rs.iterFrom(_507, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _510), 0, (n17: rs.u32, k3: rs.u32): rs.u32 => { return rs.u32Add(rs.u32Mul(n17, 10), k3); }, true); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["fold ", args40[0]])); + Log.note(log, rs.fmtFormat(["fold ", (f: rs.Formatter) => rs.u32Display(part2, f)])); const _522: Pile.Pile = pile(5, 8); _774 = false; const captured9 = d; const _525: (a0: Guard.Guard) => undefined = rs.closure((g14: Guard.Guard): undefined => { - const _810: rs.u32 = Guard.id(g14); + const _811: rs.u32 = Guard.id(g14); const _1112: rs.u32 = Guard.id(captured9); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_810, f), (f: rs.Formatter) => rs.u32Display(_1112, f)]; - Log.note(log, rs.fmtFormat(["each ", args60[0], " ", args60[1]])); + const args70 = [(f: rs.Formatter) => rs.u32Display(_811, f), (f: rs.Formatter) => rs.u32Display(_1112, f)]; + Log.note(log, rs.fmtFormat(["each ", args70[0], " ", args70[1]])); g14[Symbol.dispose](); }, (): void => { captured9[Symbol.dispose](); @@ -1553,8 +1537,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const m5: rs.usize = rs.ownedCount(rs.iterMap(rs.iterFrom(_528, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _531)); const _538: rs.usize = Pile.count$iter_Iterator(pile(4, 6)); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(m5, f), (f: rs.Formatter) => rs.usizeDisplay(_538, f)]; - Log.note(log, rs.fmtFormat(["count ", args42[0], " ", args42[1]])); + const args71 = [(f: rs.Formatter) => rs.usizeDisplay(m5, f), (f: rs.Formatter) => rs.usizeDisplay(_538, f)]; + Log.note(log, rs.fmtFormat(["count ", args71[0], " ", args71[1]])); } else if (_23 === 15) { const last2: Guard.Guard | undefined = Pile.last$iter_Iterator(pile(1, 4)); const back: Guard.Guard | undefined = rs.ownedLast(rs.iterRev(rs.iterFrom(pile(4, 7), Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })), rs.drop); @@ -1574,8 +1558,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g9[Symbol.dispose](); return _012; }); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_568, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_570, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_572, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["last ", args44[0], " ", args44[1], " ", args44[2]])); + const args62 = [(f: rs.Formatter) => rs.fmtOption(_568, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_570, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_572, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["last ", args62[0], " ", args62[1], " ", args62[2]])); const _581: rs.Iter = rs.iterRev(rs.iterFrom(pile(1, 6), Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })); _775 = false; const captured6 = c; @@ -1594,8 +1578,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const _595: rs.u32 = Guard.id(d); const _598: rs.u32 = Guard.id(e); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_593, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_595, f), (f: rs.Formatter) => rs.u32Display(_598, f)]; - Log.note(log, rs.fmtFormat(["rev ", args46[0], " ", args46[1], " ", args46[2]])); + const args63 = [(f: rs.Formatter) => rs.fmtOption(_593, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_595, f), (f: rs.Formatter) => rs.u32Display(_598, f)]; + Log.note(log, rs.fmtFormat(["rev ", args63[0], " ", args63[1], " ", args63[2]])); } else if (_23 === 16) { const held2: Pile.Pile = pile(1, 6); const part = option_map$06w9waf(rs.iterNth(rs.iterRev(rs.iterFrom(held2, Pile.next$iter_Iterator, undefined, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)) })), 1, rs.drop), (g3: Guard.Guard): rs.u32 => { @@ -1603,8 +1587,7 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { g3[Symbol.dispose](); return _05; }); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["nth ", args48[0]])); + Log.note(log, rs.fmtFormat(["nth ", (f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)])); _775 = false; const captured3 = c; const n10: rs.u32 = rs.iterFold(rs.iterMap(rs.iterFrom(held2, Pile.next$iter_Iterator, undefined, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.closure((g4: Guard.Guard): rs.u32 => { @@ -1617,15 +1600,15 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { return rs.u32Add(n14, k2); }, true); const _635: rs.usize = held2.held.items.length; - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n10, f), (f: rs.Formatter) => rs.usizeDisplay(_635, f)]; - Log.note(log, rs.fmtFormat(["borrowed ", args50[0], " ", args50[1]])); + const args59 = [(f: rs.Formatter) => rs.u32Display(n10, f), (f: rs.Formatter) => rs.usizeDisplay(_635, f)]; + Log.note(log, rs.fmtFormat(["borrowed ", args59[0], " ", args59[1]])); const _645: Pile.Pile = pile(6, 8); const _648: rs.Vec = guards(8, 10); const m6: rs.usize = rs.ownedCount(rs.iterChain(rs.iterFrom(_645, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), rs.vecIntoIter(_648, rs.drop)), rs.drop); const _657: rs.u32 = Guard.id(d); const _660: rs.u32 = Guard.id(e); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(m6, f), (f: rs.Formatter) => rs.u32Display(_657, f), (f: rs.Formatter) => rs.u32Display(_660, f)]; - Log.note(log, rs.fmtFormat(["chain ", args52[0], " ", args52[1], " ", args52[2]])); + const args60 = [(f: rs.Formatter) => rs.usizeDisplay(m6, f), (f: rs.Formatter) => rs.u32Display(_657, f), (f: rs.Formatter) => rs.u32Display(_660, f)]; + Log.note(log, rs.fmtFormat(["chain ", args60[0], " ", args60[1], " ", args60[2]])); const _671: [Guard.Guard, Guard.Guard] = [guard(30), guard(31)]; const k: Guard.Guard = _671[0]; const l: Guard.Guard = _671[1]; @@ -1649,8 +1632,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured5[Symbol.dispose](); }), true, true); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n11, f), (f: rs.Formatter) => rs.u32Display(r3, f)]; - Log.note(log, rs.fmtFormat(["lent ", args54[0], " ", args54[1]])); + const args61 = [(f: rs.Formatter) => rs.u32Display(n11, f), (f: rs.Formatter) => rs.u32Display(r3, f)]; + Log.note(log, rs.fmtFormat(["lent ", args61[0], " ", args61[1]])); held2[Symbol.dispose](); } else { const a: Guard.Guard = guard(20); @@ -1659,11 +1642,11 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured2 = a; rs.iterTryRfold(_714, 0, rs.closure((n13: rs.u32, g2: Guard.Guard): rs.u32 | undefined => { if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { - const _145: rs.u32 = Guard.id(g2); + const _146: rs.u32 = Guard.id(g2); const _172: rs.u32 = Guard.id(captured2); const _202: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_145, f), (f: rs.Formatter) => rs.u32Display(_172, f), (f: rs.Formatter) => rs.fmtPad(f, _202)]; - rs.panicFmt(["try_rfold of g", args56[0], " with g", args56[1], " after\n", args56[2]]); + const args57 = [(f: rs.Formatter) => rs.u32Display(_146, f), (f: rs.Formatter) => rs.u32Display(_172, f), (f: rs.Formatter) => rs.fmtPad(f, _202)]; + rs.panicFmt(["try_rfold of g", args57[0], " with g", args57[1], " after\n", args57[2]]); } else { const _04: rs.u32 | undefined = rs.u32Add(n13, Guard.id(g2)); g2[Symbol.dispose](); @@ -1727,8 +1710,8 @@ export function options(log: Log.Log, id: rs.u32): void { }, (): void => { captured3[Symbol.dispose](); })), rs.cmpLt(rs.cmpOption(rs.cmp)), true, undefined, rs.None); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(odd, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(least, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["options ", args2[0], " ", args2[1], " ", args2[2]])); + const args3 = [(f: rs.Formatter) => rs.fmtOption(odd, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(least, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["options ", args3[0], " ", args3[1], " ", args3[2]])); } /** @@ -1757,8 +1740,8 @@ export function reducers(log: Log.Log, id: rs.u32): void { const most: Guard.Guard | undefined = rs.iterMaxBy(rs.iterMap(_18, rs.closure((g3: Guard.Guard): Guard.Guard => { const _92: rs.u32 = Guard.id(g3); const _122: rs.u32 = Guard.id(captured); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_122, f)]; - Log.note(log, rs.fmtFormat(["map ", args6[0], " ", args6[1]])); + const args7 = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_122, f)]; + Log.note(log, rs.fmtFormat(["map ", args7[0], " ", args7[1]])); return g3; }, (): void => { captured[Symbol.dispose](); @@ -1776,8 +1759,8 @@ export function reducers(log: Log.Log, id: rs.u32): void { _28 = true; const _104: rs.u32 = Guard.id(a3); const _132: rs.u32 = Guard.id(b3); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_104, f), (f: rs.Formatter) => rs.u32Display(_132, f)]; - Log.note(log, rs.fmtFormat(["reduce ", args8[0], " ", args8[1]])); + const args10 = [(f: rs.Formatter) => rs.u32Display(_104, f), (f: rs.Formatter) => rs.u32Display(_132, f)]; + Log.note(log, rs.fmtFormat(["reduce ", args10[0], " ", args10[1]])); if (!(rs.u32Rem(Guard.id(b3), 2) === 0)) { _292 = false; _08 = a3; @@ -1808,8 +1791,8 @@ export function reducers(log: Log.Log, id: rs.u32): void { const _48: rs.u32 | undefined = _41(most); const _52: rs.u32 | undefined = _41(least); const _56: rs.u32 | undefined = _41(kept); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_48, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_52, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_56, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["reducers ", args2[0], " ", args2[1], " ", args2[2], " ", args2[3]])); + const args11 = [(f: rs.Formatter) => rs.fmtOption(_48, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_52, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_56, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["reducers ", args11[0], " ", args11[1], " ", args11[2], " ", args11[3]])); const _69: [rs.Vec, Guard.Guard] = [guards(1, 3), guard(12)]; const held: rs.Vec = _69[0]; const e: Guard.Guard = _69[1]; @@ -1820,8 +1803,7 @@ export function reducers(log: Log.Log, id: rs.u32): void { }, (): void => { captured3[Symbol.dispose](); }), undefined, undefined, true), Guard.id); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["first ", args4[0]])); + Log.note(log, rs.fmtFormat(["first ", (f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)])); rs.dropVec(held); } @@ -1868,8 +1850,8 @@ export function closures(log: Log.Log, id: rs.u32): void { const part2 = rs.iterToVec(rs.iterMap(rs.iterFilterMap(_33, rs.closure((g2: Guard.Guard): Guard.Guard | undefined | rs.None => { const _92: rs.u32 = Guard.id(g2); const _127: rs.u32 = Guard.id(captured); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_127, f)]; - Log.note(log, rs.fmtFormat(["filter_map ", args16[0], " ", args16[1]])); + const args17 = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_127, f)]; + Log.note(log, rs.fmtFormat(["filter_map ", args17[0], " ", args17[1]])); return captured2(g2); }, (): void => { captured[Symbol.dispose](); @@ -1880,8 +1862,7 @@ export function closures(log: Log.Log, id: rs.u32): void { return _06; }); }), "next", 8, false, 8); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug))]; - Log.note(log, rs.fmtFormat(["kept ", args2[0]])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.fmtList(part2.items, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug))])); const part3 = rs.iterFold(rs.iterFilterMap(rs.vecIntoIter(guards(1, 7), rs.drop), pick, rs.None), 0, (n3: rs.u32, o2: Guard.Guard | undefined): rs.u32 => { return rs.u32Add(rs.u32Mul(n3, 10), option_mapOr$1re20rq(o2, 9, (g4: Guard.Guard): rs.u32 => { const _08: rs.u32 = rs.u32Sub(Guard.id(g4), id); @@ -1889,16 +1870,15 @@ export function closures(log: Log.Log, id: rs.u32): void { return _08; })); }, true); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["folded ", args4[0]])); + Log.note(log, rs.fmtFormat(["folded ", (f: rs.Formatter) => rs.u32Display(part3, f)])); const _67: rs.Iter = rs.vecIntoIter(guards(4, 8), rs.drop); const captured3 = d; const captured4 = pick; const whiles: rs.Iter = rs.iterMapWhile(_67, rs.closure((g5: Guard.Guard): Guard.Guard | undefined | rs.None => { const _93: rs.u32 = Guard.id(g5); const _128: rs.u32 = Guard.id(captured3); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_93, f), (f: rs.Formatter) => rs.u32Display(_128, f)]; - Log.note(log, rs.fmtFormat(["map_while ", args18[0], " ", args18[1]])); + const args22 = [(f: rs.Formatter) => rs.u32Display(_93, f), (f: rs.Formatter) => rs.u32Display(_128, f)]; + Log.note(log, rs.fmtFormat(["map_while ", args22[0], " ", args22[1]])); return captured4(g5); }, (): void => { captured3[Symbol.dispose](); @@ -1918,16 +1898,16 @@ export function closures(log: Log.Log, id: rs.u32): void { }); }); rs.drop(whiles); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["whiles ", args6[0], " ", args6[1]])); + const args23 = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["whiles ", args23[0], " ", args23[1]])); const _94: rs.Iter = rs.vecIntoIter(guards(3, 7), rs.drop); const captured5 = e; const captured6 = pick; const _98: (a0: Guard.Guard) => Guard.Guard | undefined | rs.None = rs.closure((g8: Guard.Guard): Guard.Guard | undefined | rs.None => { const _96: rs.u32 = Guard.id(g8); const _1210: rs.u32 = Guard.id(captured5); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_96, f), (f: rs.Formatter) => rs.u32Display(_1210, f)]; - Log.note(log, rs.fmtFormat(["find_map ", args20[0], " ", args20[1]])); + const args26 = [(f: rs.Formatter) => rs.u32Display(_96, f), (f: rs.Formatter) => rs.u32Display(_1210, f)]; + Log.note(log, rs.fmtFormat(["find_map ", args26[0], " ", args26[1]])); return captured6(g8); }, (): void => { captured5[Symbol.dispose](); @@ -1941,18 +1921,17 @@ export function closures(log: Log.Log, id: rs.u32): void { return _016; }); }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["found ", args8[0]])); + Log.note(log, rs.fmtFormat(["found ", (f: rs.Formatter) => rs.fmtOption(part6, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)])); let captured7 = guards(1, 6); const captured8 = f; const made: rs.Iter = rs.iterFromFn(rs.closure((): Guard.Guard | undefined | rs.None => { const _310: Guard.Guard | undefined = rs.vecPop(captured7); if (_310 !== undefined) { const g10: Guard.Guard = _310; - const _144: rs.u32 = Guard.id(g10); - const _177: rs.u32 = Guard.id(captured8); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_144, f), (f: rs.Formatter) => rs.u32Display(_177, f)]; - Log.note(log, rs.fmtFormat(["from_fn ", args22[0], " ", args22[1]])); + const _145: rs.u32 = Guard.id(g10); + const _178: rs.u32 = Guard.id(captured8); + const args30 = [(f: rs.Formatter) => rs.u32Display(_145, f), (f: rs.Formatter) => rs.u32Display(_178, f)]; + Log.note(log, rs.fmtFormat(["from_fn ", args30[0], " ", args30[1]])); return thenSome$0zvoczk(rs.u32Rem(Guard.id(g10), 2) === 0, g10); } return rs.None; @@ -1975,8 +1954,8 @@ export function closures(log: Log.Log, id: rs.u32): void { }); }); rs.drop(made); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first2, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second2, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["made ", args10[0], " ", args10[1]])); + const args31 = [(f: rs.Formatter) => rs.fmtOption(first2, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second2, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["made ", args31[0], " ", args31[1]])); const captured9 = id; const captured10 = h; const walked: rs.Iter = rs.iterSuccessors(undefined as Guard.Guard | undefined | rs.None, rs.closure((prev: Guard.Guard | undefined): Guard.Guard | undefined | rs.None => { @@ -1984,8 +1963,8 @@ export function closures(log: Log.Log, id: rs.u32): void { return rs.u32Add(rs.u32Sub(Guard.id(g13), captured9), 1); }); const _1310: rs.u32 = Guard.id(captured10); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(next, f), (f: rs.Formatter) => rs.u32Display(_1310, f)]; - Log.note(log, rs.fmtFormat(["successors ", args24[0], " ", args24[1]])); + const args34 = [(f: rs.Formatter) => rs.u32Display(next, f), (f: rs.Formatter) => rs.u32Display(_1310, f)]; + Log.note(log, rs.fmtFormat(["successors ", args34[0], " ", args34[1]])); return then$0frk932(next < 8, (): Guard.Guard | undefined => { return Guard.new(rs.u32Add(captured9, next), Log.clone$Clone(log)); }); @@ -2007,8 +1986,8 @@ export function closures(log: Log.Log, id: rs.u32): void { }); }); rs.drop(walked); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second3, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; - Log.note(log, rs.fmtFormat(["walked ", args12[0], " ", args12[1]])); + const args35 = [(f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second3, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["walked ", args35[0], " ", args35[1]])); const part7 = rs.ownedCount(rs.iterSuccessors(undefined as Guard.Guard | undefined | rs.None, (prev2: Guard.Guard | undefined): Guard.Guard | undefined | rs.None => { const next2: rs.u32 = option_mapOr$1re20rq(prev2, 5, (g16: Guard.Guard): rs.u32 => { return rs.u32Add(rs.u32Sub(Guard.id(g16), id), 1); @@ -2017,8 +1996,7 @@ export function closures(log: Log.Log, id: rs.u32): void { return Guard.new(rs.u32Add(id, next2), Log.clone$Clone(log)); }); }, rs.drop, rs.None), rs.drop); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; - Log.note(log, rs.fmtFormat(["walked ", args14[0]])); + Log.note(log, rs.fmtFormat(["walked ", (f: rs.Formatter) => rs.usizeDisplay(part7, f)])); } /** @@ -2036,8 +2014,7 @@ export function zips(log: Log.Log, id: rs.u32, arg: rs.u8): void { return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; const made: (a0: rs.u32) => Guard.Guard = (n8: rs.u32): Guard.Guard => { - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8, f)]; - Log.note(log, rs.fmtFormat(["make ", args20[0]])); + Log.note(log, rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u32Display(n8, f)])); return guard(n8); }; const ids: (a0: [Guard.Guard, Guard.Guard] | undefined) => [rs.u32, rs.u32] | undefined = (p: [Guard.Guard, Guard.Guard] | undefined): [rs.u32, rs.u32] | undefined => { @@ -2056,8 +2033,8 @@ export function zips(log: Log.Log, id: rs.u32, arg: rs.u8): void { const nth: [rs.u32, rs.u32] | undefined = ids(part8); const part9 = rs.iterNth(rs.iterZip(rs.iterMap(new rs.Range(1, 3), made), rs.iterMap(new rs.Range(3, 6), made), [true, true], rs.drop, rs.drop), 3, lib_drop$tuple2_model_Guard_model_Guard); const past: [rs.u32, rs.u32] | undefined = ids(part9); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(past, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["index ", args2[0], " ", args2[1], " ", args2[2]])); + const args33 = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(past, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["index ", args33[0], " ", args33[1], " ", args33[2]])); } else if (arg === 1) { const longer: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.iterMap(new rs.Range(1, 5), made), rs.iterMap(new rs.Range(5, 7), made), [true, true], rs.drop, rs.drop); const part5 = rs.iterToOption(longer.nextBack()); @@ -2067,50 +2044,50 @@ export function zips(log: Log.Log, id: rs.u32, arg: rs.u8): void { const shorter: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.iterMap(new rs.Range(1, 3), made), rs.iterMap(new rs.Range(3, 7), made), [true, true], rs.drop, rs.drop); const part7 = rs.iterToOption(shorter.next()); const next: [rs.u32, rs.u32] | undefined = ids(part7); - const rest: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(shorter), (_235: [Guard.Guard, Guard.Guard]): rs.u32 => { - const a4: Guard.Guard = _235[0]; - const b4: Guard.Guard = _235[1]; + const rest: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(shorter), (_239: [Guard.Guard, Guard.Guard]): rs.u32 => { + const a4: Guard.Guard = _239[0]; + const b4: Guard.Guard = _239[1]; const _019: rs.u32 = rs.u32Sub(rs.u32Add(Guard.id(a4), Guard.id(b4)), rs.u32Mul(2, id)); b4[Symbol.dispose](); a4[Symbol.dispose](); return _019; }), undefined, 4, true); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(back, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(front, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(next, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rest.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["back ", args4[0], " ", args4[1], " ", args4[2], " ", args4[3]])); + const args32 = [(f: rs.Formatter) => rs.fmtOption(back, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(front, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(next, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rest.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["back ", args32[0], " ", args32[1], " ", args32[2], " ", args32[3]])); } else if (arg === 2) { const n2: rs.usize = rs.ownedCount(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); const _110: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop); - const any: boolean = rs.iterAny(_110, (_230: [Guard.Guard, Guard.Guard]): boolean => { - lib_drop$tuple2_model_Guard_model_Guard(_230); + const any: boolean = rs.iterAny(_110, (_234: [Guard.Guard, Guard.Guard]): boolean => { + lib_drop$tuple2_model_Guard_model_Guard(_234); return false; }); rs.drop(_110); const part4 = rs.ownedLast(rs.iterZip(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 6), rs.drop), "len", rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); const last: [rs.u32, rs.u32] | undefined = ids(part4); - rs.iterForEach(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop), (_233: [Guard.Guard, Guard.Guard]): undefined => { - const a3: Guard.Guard = _233[0]; - const b3: Guard.Guard = _233[1]; + rs.iterForEach(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop), (_235: [Guard.Guard, Guard.Guard]): undefined => { + const a3: Guard.Guard = _235[0]; + const b3: Guard.Guard = _235[1]; const _1010: rs.u32 = rs.u32Sub(Guard.id(a3), id); - const _163: rs.u32 = rs.u32Sub(Guard.id(b3), id); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1010, f), (f: rs.Formatter) => rs.u32Display(_163, f)]; - Log.note(log, rs.fmtFormat(["each ", args22[0], " ", args22[1]])); + const _164: rs.u32 = rs.u32Sub(Guard.id(b3), id); + const args30 = [(f: rs.Formatter) => rs.u32Display(_1010, f), (f: rs.Formatter) => rs.u32Display(_164, f)]; + Log.note(log, rs.fmtFormat(["each ", args30[0], " ", args30[1]])); b3[Symbol.dispose](); a3[Symbol.dispose](); }, true); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtBool(any, f), (f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["len ", args6[0], " ", args6[1], " ", args6[2]])); + const args31 = [(f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtBool(any, f), (f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["len ", args31[0], " ", args31[1], " ", args31[2]])); } else if (arg === 3) { const zip: () => rs.Iter<[Guard.Guard, Guard.Guard]> = (): rs.Iter<[Guard.Guard, Guard.Guard]> => { return rs.iterZip(rs.iterMap(rs.vecIntoIter(rs.vecFrom([1, 2, 3])), made), rs.iterMap(rs.vecIntoIter(rs.vecFrom([4, 5])), made), "index", rs.drop, rs.drop); }; const n3: rs.usize = rs.ownedCount(zip(), lib_drop$tuple2_model_Guard_model_Guard); - const at: rs.usize | undefined = rs.iterPosition(zip(), (_227: [Guard.Guard, Guard.Guard]): boolean => { - lib_drop$tuple2_model_Guard_model_Guard(_227); + const at: rs.usize | undefined = rs.iterPosition(zip(), (_229: [Guard.Guard, Guard.Guard]): boolean => { + lib_drop$tuple2_model_Guard_model_Guard(_229); return false; }); - const sum: rs.u32 = rs.iterSum(rs.iterMap(zip(), (_229: [Guard.Guard, Guard.Guard]): rs.u32 => { - const a2: Guard.Guard = _229[0]; - const b2: Guard.Guard = _229[1]; + const sum: rs.u32 = rs.iterSum(rs.iterMap(zip(), (_230: [Guard.Guard, Guard.Guard]): rs.u32 => { + const a2: Guard.Guard = _230[0]; + const b2: Guard.Guard = _230[1]; const _016: rs.u32 = rs.u32Sub(rs.u32Add(Guard.id(a2), Guard.id(b2)), rs.u32Mul(2, id)); b2[Symbol.dispose](); a2[Symbol.dispose](); @@ -2135,36 +2112,34 @@ export function zips(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured3[Symbol.dispose](); })), "next", 4, true, 4); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.usizeDisplay(skipped, f), (f: rs.Formatter) => rs.fmtList(kept.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["no coerce ", args8[0], " ", args8[1], " ", args8[2], " ", args8[3], " ", args8[4]])); + const args27 = [(f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.usizeDisplay(skipped, f), (f: rs.Formatter) => rs.fmtList(kept.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["no coerce ", args27[0], " ", args27[1], " ", args27[2], " ", args27[3], " ", args27[4]])); } else if (arg === 4) { const v: rs.Vec<[Guard.Guard, Guard.Guard]> = rs.iterToVec(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.iterMap(new rs.Range(4, 6), guard), "len", rs.drop, rs.drop), "fold", 16, true); const part2 = v.items.length; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; - Log.note(log, rs.fmtFormat(["collect ", args10[0]])); + Log.note(log, rs.fmtFormat(["collect ", (f: rs.Formatter) => rs.usizeDisplay(part2, f)])); rs.dropVec(v, lib_drop$tuple2_model_Guard_model_Guard); const _240: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.vecIntoIter(guards(1, 3), rs.drop), rs.iterMap(new rs.Range(3, 6), guard), "len", rs.drop, rs.drop); - const part3 = rs.iterFind(_240, (_222: [Guard.Guard, Guard.Guard]): boolean => { - return Guard.id(_222[0]) === rs.u32Add(id, 9); + const part3 = rs.iterFind(_240, (_226: [Guard.Guard, Guard.Guard]): boolean => { + return Guard.id(_226[0]) === rs.u32Add(id, 9); }, lib_drop$tuple2_model_Guard_model_Guard); const found: [rs.u32, rs.u32] | undefined = ids(part3); rs.drop(_240); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["find ", args12[0]])); + Log.note(log, rs.fmtFormat(["find ", (f: rs.Formatter) => rs.fmtOption(found, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); } else if (arg === 5) { const nested: () => rs.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> = (): rs.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> => { return rs.iterZip(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop), rs.iterMap(new rs.Range(6, 9), guard), "len", lib_drop$tuple2_model_Guard_model_Guard, rs.drop); }; const n4: rs.usize = rs.ownedCount(nested(), lib_drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard); const _269: rs.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> = nested(); - const _267: [[Guard.Guard, Guard.Guard], Guard.Guard] | undefined = rs.iterFind(_269, (_218: [[Guard.Guard, Guard.Guard], Guard.Guard]): boolean => { - return Guard.id(_218[0][0]) === rs.u32Add(id, 9); + const _267: [[Guard.Guard, Guard.Guard], Guard.Guard] | undefined = rs.iterFind(_269, (_222: [[Guard.Guard, Guard.Guard], Guard.Guard]): boolean => { + return Guard.id(_222[0][0]) === rs.u32Add(id, 9); }, lib_drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard); const found2: boolean = _267 !== undefined; lib_drop$Option_tuple2_tuple2_model_Guard_model_Guard_model_Guard(_267); rs.drop(_269); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n4, f), (f: rs.Formatter) => rs.fmtBool(found2, f)]; - Log.note(log, rs.fmtFormat(["nested ", args14[0], " ", args14[1]])); + const args24 = [(f: rs.Formatter) => rs.usizeDisplay(n4, f), (f: rs.Formatter) => rs.fmtBool(found2, f)]; + Log.note(log, rs.fmtFormat(["nested ", args24[0], " ", args24[1]])); } else if (arg === 6) { const n5: rs.usize = rs.ownedCount(rs.iterZip(rs.iterFilter(rs.vecIntoIter(guards(1, 4), rs.drop), (g: Guard.Guard): boolean => { return Guard.id(g) !== id; @@ -2172,8 +2147,8 @@ export function zips(log: Log.Log, id: rs.u32, arg: rs.u8): void { const m: rs.usize = rs.ownedCount(rs.iterZip(rs.vecIntoIter(guards(1, 3), rs.drop), rs.iterFilter(rs.vecIntoIter(guards(3, 6), rs.drop), (g2: Guard.Guard): boolean => { return Guard.id(g2) !== id; }, rs.drop), undefined, rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n5, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; - Log.note(log, rs.fmtFormat(["neither ", args16[0], " ", args16[1]])); + const args23 = [(f: rs.Formatter) => rs.usizeDisplay(n5, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; + Log.note(log, rs.fmtFormat(["neither ", args23[0], " ", args23[1]])); } else { const v2: rs.u32[] = [1, 2, 3]; const n6: rs.usize = rs.ownedCount(rs.iterZip(rs.iterMap(rs.iterSlice(v2), (_22: rs.u32): Guard.Guard => { @@ -2184,11 +2159,11 @@ export function zips(log: Log.Log, id: rs.u32, arg: rs.u8): void { }), new rs.Range(0, 2), [true, false], rs.drop)), lib_drop$tuple2_model_Guard_i32); const empty: rs.usize = rs.usizeAdd(rs.ownedCount(rs.iterZip(rs.iterMap(rs.iterSlice(v2), (_29: rs.u32): Guard.Guard => { return made(_29); - }), new rs.Range(0, 0), [true, false], rs.drop), lib_drop$tuple2_model_Guard_i32), rs.ownedCount(rs.iterZip(new rs.Range(0, 0), rs.iterMap(rs.iterSlice(v2), (_213: rs.u32): Guard.Guard => { - return made(_213); + }), new rs.Range(0, 0), [true, false], rs.drop), lib_drop$tuple2_model_Guard_i32), rs.ownedCount(rs.iterZip(new rs.Range(0, 0), rs.iterMap(rs.iterSlice(v2), (_214: rs.u32): Guard.Guard => { + return made(_214); }), [false, true], undefined, rs.drop), lib_drop$tuple2_i32_model_Guard)); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.usizeDisplay(back2, f), (f: rs.Formatter) => rs.usizeDisplay(empty, f)]; - Log.note(log, rs.fmtFormat(["trimmed ", args18[0], " ", args18[1], " ", args18[2]])); + const args22 = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.usizeDisplay(back2, f), (f: rs.Formatter) => rs.usizeDisplay(empty, f)]; + Log.note(log, rs.fmtFormat(["trimmed ", args22[0], " ", args22[1], " ", args22[2]])); } } diff --git a/ts/fixtures/task/expected/drops/indexed.ts b/ts/fixtures/task/expected/drops/indexed.ts index 80e1d98fa..0db75f805 100644 --- a/ts/fixtures/task/expected/drops/indexed.ts +++ b/ts/fixtures/task/expected/drops/indexed.ts @@ -13,19 +13,20 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { return Guard.new(rs.u32Add(id, n9), Log.clone$Clone(log)); }; const made: (a0: rs.u32) => Guard.Guard = (n10: rs.u32): Guard.Guard => { - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n10, f)]; - Log.note(log, rs.fmtFormat(["make ", args76[0]])); + Log.note(log, rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u32Display(n10, f)])); return guard(n10); }; const v: rs.u32[] = [1, 2, 3, 4]; const w: rs.u32[] = [11, 12, 13, 14]; + const _11: rs.Slice = rs.sliceFrom(v); + const _13: rs.Slice = rs.sliceFrom(w); const pairs: () => rs.Iter<[Guard.Guard, Guard.Guard]> = (): rs.Iter<[Guard.Guard, Guard.Guard]> => { - const _33: rs.Iter = rs.iterSlice(v); + const _33: rs.Iter = rs.iterSlice(rs.sliceItems(_11)); const captured = made; const _2: rs.Iter = rs.iterMap(_33, (_22: rs.u32): Guard.Guard => { return captured(_22); }); - const _7: rs.Iter = rs.iterSlice(w); + const _7: rs.Iter = rs.iterSlice(rs.sliceItems(_13)); const captured2 = made; return rs.iterZip(_2, rs.iterMap(_7, (_24: rs.u32): Guard.Guard => { return captured2(_24); @@ -48,146 +49,134 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { const it: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard); const part51 = rs.iterToOption(it.next()); const _35: [rs.u32, rs.u32, rs.u32] | undefined = ids(part51); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.fmtOption(_35, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["count ", args2[0], " ", args2[1]])); + const args118 = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.fmtOption(_35, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["count ", args118[0], " ", args118[1]])); const part52 = rs.iterToOption(it.next()); const part53 = ids(part52); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part53, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["next ", args4[0]])); + Log.note(log, rs.fmtFormat(["next ", (f: rs.Formatter) => rs.fmtOption(part53, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const part54 = rs.iterToOption(it.next()); const part55 = ids(part54); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part55, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["past ", args6[0]])); + Log.note(log, rs.fmtFormat(["past ", (f: rs.Formatter) => rs.fmtOption(part55, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); } else if (_16 === 1) { const it2: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard); const part39 = rs.iterToOption(it2.nextBack()); const part40 = ids(part39); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part40, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["back ", args8[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part40, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const part41 = rs.iterToOption(it2.nextBack()); const part42 = ids(part41); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part42, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["back ", args10[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part42, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const part43 = rs.iterToOption(it2.nextBack()); const part44 = ids(part43); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part44, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["back ", args12[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part44, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const part45 = rs.iterNth(rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); const part46 = ids(part45); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part46, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["nth ", args14[0]])); + Log.note(log, rs.fmtFormat(["nth ", (f: rs.Formatter) => rs.fmtOption(part46, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const it4: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard); const part47 = rs.iterToOption(it4.next()); const part48 = ids(part47); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part48, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["front ", args16[0]])); + Log.note(log, rs.fmtFormat(["front ", (f: rs.Formatter) => rs.fmtOption(part48, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const part49 = rs.iterToOption(it4.nextBack()); const part50 = ids(part49); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part50, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["back ", args18[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part50, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); } else if (_16 === 2) { - const part38 = option_map$0j32j8c(rs.iterToOption(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard).next()), (_258: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { - const a15: Guard.Guard = _258[0]; - const b12: Guard.Guard = _258[1]; + const part38 = option_map$0j32j8c(rs.iterToOption(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard).next()), (_264: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { + const a15: Guard.Guard = _264[0]; + const b12: Guard.Guard = _264[1]; const _040: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a15), id), rs.u32Sub(Guard.id(b12), id)]; b12[Symbol.dispose](); a15[Symbol.dispose](); return _040; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part38, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["skip next ", args20[0]])); + Log.note(log, rs.fmtFormat(["skip next ", (f: rs.Formatter) => rs.fmtOption(part38, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const n2: rs.usize = rs.ownedCount(rs.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_model_Guard_model_Guard); - const last: [rs.u32, rs.u32] | undefined = option_map$0j32j8c(rs.ownedLast(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_model_Guard_model_Guard), (_259: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { - const a16: Guard.Guard = _259[0]; - const b13: Guard.Guard = _259[1]; + const last: [rs.u32, rs.u32] | undefined = option_map$0j32j8c(rs.ownedLast(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_model_Guard_model_Guard), (_265: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { + const a16: Guard.Guard = _265[0]; + const b13: Guard.Guard = _265[1]; const _041: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a16), id), rs.u32Sub(Guard.id(b13), id)]; b13[Symbol.dispose](); a16[Symbol.dispose](); return _041; }); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["skip count ", args22[0], " ", args22[1]])); + const args111 = [(f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["skip count ", args111[0], " ", args111[1]])); } else if (_16 === 3) { - const part35 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n35: rs.u32, _320: [Guard.Guard, Guard.Guard]): rs.u32 => { - const a10: Guard.Guard = _320[0]; - const b8: Guard.Guard = _320[1]; + const part35 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n35: rs.u32, _326: [Guard.Guard, Guard.Guard]): rs.u32 => { + const a10: Guard.Guard = _326[0]; + const b8: Guard.Guard = _326[1]; const _035: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(n35, 100), Guard.id(a10)), Guard.id(b8)), rs.u32Mul(2, id)); b8[Symbol.dispose](); a10[Symbol.dispose](); return _035; }); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part35, f)]; - Log.note(log, rs.fmtFormat(["take fold ", args24[0]])); - rs.iterForEach(rs.iterTake(rs.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), 5, lib_drop$tuple2_model_Guard_model_Guard, true), (_250: [Guard.Guard, Guard.Guard]): undefined => { - const a11: Guard.Guard = _250[0]; - const b9: Guard.Guard = _250[1]; + Log.note(log, rs.fmtFormat(["take fold ", (f: rs.Formatter) => rs.u32Display(part35, f)])); + rs.iterForEach(rs.iterTake(rs.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), 5, lib_drop$tuple2_model_Guard_model_Guard, true), (_256: [Guard.Guard, Guard.Guard]): undefined => { + const a11: Guard.Guard = _256[0]; + const b9: Guard.Guard = _256[1]; const _1019: rs.u32 = rs.u32Sub(Guard.id(a11), id); - const _1613: rs.u32 = rs.u32Sub(Guard.id(b9), id); - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1019, f), (f: rs.Formatter) => rs.u32Display(_1613, f)]; - Log.note(log, rs.fmtFormat(["each ", args80[0], " ", args80[1]])); + const _1614: rs.u32 = rs.u32Sub(Guard.id(b9), id); + const args106 = [(f: rs.Formatter) => rs.u32Display(_1019, f), (f: rs.Formatter) => rs.u32Display(_1614, f)]; + Log.note(log, rs.fmtFormat(["each ", args106[0], " ", args106[1]])); b9[Symbol.dispose](); a11[Symbol.dispose](); }); - const part36 = option_map$0j94wbv(rs.iterFind(rs.iterTake(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 3, lib_drop$tuple2_model_Guard_model_Guard, true), (_254: [Guard.Guard, Guard.Guard]): boolean => { - return Guard.id(_254[0]) === rs.u32Add(id, 3); - }, lib_drop$tuple2_model_Guard_model_Guard), (_256: [Guard.Guard, Guard.Guard]): rs.u32 => { - const a12: Guard.Guard = _256[0]; + const part36 = option_map$0j94wbv(rs.iterFind(rs.iterTake(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 3, lib_drop$tuple2_model_Guard_model_Guard, true), (_259: [Guard.Guard, Guard.Guard]): boolean => { + return Guard.id(_259[0]) === rs.u32Add(id, 3); + }, lib_drop$tuple2_model_Guard_model_Guard), (_263: [Guard.Guard, Guard.Guard]): rs.u32 => { + const a12: Guard.Guard = _263[0]; const _037: rs.u32 = rs.u32Sub(Guard.id(a12), id); a12[Symbol.dispose](); - _256[1][Symbol.dispose](); + _263[1][Symbol.dispose](); return _037; }); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part36, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["take find ", args26[0]])); - const n4: rs.u32 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 4, lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n36: rs.u32, _326: [Guard.Guard, Guard.Guard]): rs.u32 => { - const a13: Guard.Guard = _326[0]; - const b10: Guard.Guard = _326[1]; + Log.note(log, rs.fmtFormat(["take find ", (f: rs.Formatter) => rs.fmtOption(part36, f, rs.u32Debug)])); + const n4: rs.u32 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 4, lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n36: rs.u32, _329: [Guard.Guard, Guard.Guard]): rs.u32 => { + const a13: Guard.Guard = _329[0]; + const b10: Guard.Guard = _329[1]; const _038: rs.u32 = rs.u32Add(rs.u32Add(n36, Guard.id(a13)), Guard.id(b10)); b10[Symbol.dispose](); a13[Symbol.dispose](); return _038; }); - const m: rs.u32 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 3, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n37: rs.u32, _329: [Guard.Guard, Guard.Guard]): rs.u32 => { - const a14: Guard.Guard = _329[0]; - const b11: Guard.Guard = _329[1]; + const m: rs.u32 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 3, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n37: rs.u32, _330: [Guard.Guard, Guard.Guard]): rs.u32 => { + const a14: Guard.Guard = _330[0]; + const b11: Guard.Guard = _330[1]; const _039: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(n37, 100), Guard.id(a14)), Guard.id(b11)), rs.u32Mul(2, id)); b11[Symbol.dispose](); a14[Symbol.dispose](); return _039; }); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n4, f), (f: rs.Formatter) => rs.u32Display(m, f)]; - Log.note(log, rs.fmtFormat(["take past ", args28[0], " ", args28[1]])); + const args108 = [(f: rs.Formatter) => rs.u32Display(n4, f), (f: rs.Formatter) => rs.u32Display(m, f)]; + Log.note(log, rs.fmtFormat(["take past ", args108[0], " ", args108[1]])); const part37 = rs.ownedCount(rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), rs.vecIntoIter(rs.vecFrom([0, 1])), "index", lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part37, f)]; - Log.note(log, rs.fmtFormat(["vec count ", args30[0]])); + Log.note(log, rs.fmtFormat(["vec count ", (f: rs.Formatter) => rs.usizeDisplay(part37, f)])); } else if (_16 === 4) { - const n6: rs.usize = rs.iterCount(rs.iterZip(rs.iterMap(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), (_247: [Guard.Guard, Guard.Guard]): rs.u32 => { - const a8: Guard.Guard = _247[0]; - const b7: Guard.Guard = _247[1]; + const n6: rs.usize = rs.iterCount(rs.iterZip(rs.iterMap(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), (_250: [Guard.Guard, Guard.Guard]): rs.u32 => { + const a8: Guard.Guard = _250[0]; + const b7: Guard.Guard = _250[1]; const _033: rs.u32 = rs.u32Sub(rs.u32Add(Guard.id(a8), Guard.id(b7)), rs.u32Mul(2, id)); b7[Symbol.dispose](); a8[Symbol.dispose](); return _033; }), new rs.Range(0, 2), [true, false])); - const e: [rs.usize, rs.u32, rs.i32] | undefined = option_map$0nncxiz(rs.ownedLast(rs.iterZip(rs.iterEnumerate(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard)), new rs.Range(0, 2), [true, false], lib_drop$tuple2_usize_tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32), (_248: [[rs.usize, [Guard.Guard, Guard.Guard]], rs.i32]): [rs.usize, rs.u32, rs.i32] => { - const i2: rs.usize = _248[0][0]; - const a9: Guard.Guard = _248[0][1][0]; - const n34: rs.i32 = _248[1]; + const e: [rs.usize, rs.u32, rs.i32] | undefined = option_map$0nncxiz(rs.ownedLast(rs.iterZip(rs.iterEnumerate(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard)), new rs.Range(0, 2), [true, false], lib_drop$tuple2_usize_tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32), (_254: [[rs.usize, [Guard.Guard, Guard.Guard]], rs.i32]): [rs.usize, rs.u32, rs.i32] => { + const i2: rs.usize = _254[0][0]; + const a9: Guard.Guard = _254[0][1][0]; + const n34: rs.i32 = _254[1]; const _034: [rs.usize, rs.u32, rs.i32] = [i2, rs.u32Sub(Guard.id(a9), id), n34]; a9[Symbol.dispose](); - _248[0][1][1][Symbol.dispose](); + _254[0][1][1][Symbol.dispose](); return _034; }); f = rs.ownedCount(rs.iterZip(rs.iterFuse(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), true), new rs.Range(0, 1), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.fmtOption(e, f, (value: [rs.usize, rs.u32, rs.i32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.i32Debug(value[2], f)], f)), (f2: rs.Formatter) => rs.usizeDisplay(f, f2)]; - Log.note(log, rs.fmtFormat(["adapted ", args32[0], " ", args32[1], " ", args32[2]])); + const args102 = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.fmtOption(e, f, (value: [rs.usize, rs.u32, rs.i32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.i32Debug(value[2], f)], f)), (f2: rs.Formatter) => rs.usizeDisplay(f, f2)]; + Log.note(log, rs.fmtFormat(["adapted ", args102[0], " ", args102[1], " ", args102[2]])); } else if (_16 === 5) { const n7: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(pairs(), 9, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); const m2: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(pairs(), 0, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); const o: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); const p: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32), new rs.Range(0, 1), [true, false], lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32), lib_drop$tuple2_tuple2_tuple2_model_Guard_model_Guard_i32_i32); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n7, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f), (f: rs.Formatter) => rs.usizeDisplay(o, f), (f: rs.Formatter) => rs.usizeDisplay(p, f)]; - Log.note(log, rs.fmtFormat(["edges ", args34[0], " ", args34[1], " ", args34[2], " ", args34[3]])); + const args101 = [(f: rs.Formatter) => rs.usizeDisplay(n7, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f), (f: rs.Formatter) => rs.usizeDisplay(o, f), (f: rs.Formatter) => rs.usizeDisplay(p, f)]; + Log.note(log, rs.fmtFormat(["edges ", args101[0], " ", args101[1], " ", args101[2], " ", args101[3]])); } else if (_16 === 6) { const _398: rs.Iter = rs.iterSlice(v); const captured14 = made; @@ -205,60 +194,54 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { }; const part7 = rs.iterToOption(it6.nextBack()); const part8 = id1(part7); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["back ", args36[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const part9 = rs.iterToOption(it6.nextBack()); const part10 = id1(part9); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["back ", args38[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part10, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const part11 = rs.iterToOption(it6.nextBack()); const part12 = id1(part11); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["back ", args40[0]])); + Log.note(log, rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(part12, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const _453: rs.Iter = rs.iterSlice(v); const captured15 = made; - const _452: rs.Iter = rs.iterMap(_453, (_223: rs.u32): Guard.Guard => { - return captured15(_223); + const _452: rs.Iter = rs.iterMap(_453, (_224: rs.u32): Guard.Guard => { + return captured15(_224); }); const _458: rs.Iter = rs.iterSlice(rs.sliceItems(rs.sliceRange(rs.sliceFrom(w), 0, 3))); const captured16 = made; - const it7: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterZip(_452, rs.iterMap(_458, (_224: rs.u32): Guard.Guard => { - return captured16(_224); + const it7: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterZip(_452, rs.iterMap(_458, (_228: rs.u32): Guard.Guard => { + return captured16(_228); }), [true, true], rs.drop, rs.drop), new rs.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard); const part13 = rs.iterToOption(it7.nextBack()); const part14 = ids(part13); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part14, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["uneven ", args42[0]])); + Log.note(log, rs.fmtFormat(["uneven ", (f: rs.Formatter) => rs.fmtOption(part14, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const part15 = rs.iterToOption(it7.next()); const part16 = ids(part15); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part16, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; - Log.note(log, rs.fmtFormat(["uneven ", args44[0]])); + Log.note(log, rs.fmtFormat(["uneven ", (f: rs.Formatter) => rs.fmtOption(part16, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))])); const _499: rs.Iter = rs.iterSlice(v); const captured17 = made; - const _498: rs.Iter = rs.iterMap(_499, (_228: rs.u32): Guard.Guard => { - return captured17(_228); + const _498: rs.Iter = rs.iterMap(_499, (_230: rs.u32): Guard.Guard => { + return captured17(_230); }); const _504: rs.Iter = rs.iterSlice(rs.sliceItems(rs.sliceRange(rs.sliceFrom(w), 0, 2))); const captured18 = made; - const part17 = rs.ownedCount(rs.iterRev(rs.iterZip(rs.iterZip(_498, rs.iterMap(_504, (_230: rs.u32): Guard.Guard => { - return captured18(_230); + const part17 = rs.ownedCount(rs.iterRev(rs.iterZip(rs.iterZip(_498, rs.iterMap(_504, (_231: rs.u32): Guard.Guard => { + return captured18(_231); }), [true, true], rs.drop, rs.drop), new rs.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard)), lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part17, f)]; - Log.note(log, rs.fmtFormat(["uneven rev ", args46[0]])); + Log.note(log, rs.fmtFormat(["uneven rev ", (f: rs.Formatter) => rs.usizeDisplay(part17, f)])); const _522: rs.Iter = rs.iterSlice(v); const captured19 = made; - const _521: rs.Iter = rs.iterMap(_522, (_231: rs.u32): Guard.Guard => { - return captured19(_231); + const _521: rs.Iter = rs.iterMap(_522, (_235: rs.u32): Guard.Guard => { + return captured19(_235); }); const _527: rs.Iter = rs.iterSlice(rs.sliceItems(rs.sliceRange(rs.sliceFrom(w), 0, 3))); const captured20 = made; - const it8: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(_521, rs.iterMap(_527, (_235: rs.u32): Guard.Guard => { - return captured20(_235); + const it8: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(_521, rs.iterMap(_527, (_236: rs.u32): Guard.Guard => { + return captured20(_236); }), [true, true], rs.drop, rs.drop); const id2: (a0: [Guard.Guard, Guard.Guard] | undefined) => [rs.u32, rs.u32] | undefined = (p4: [Guard.Guard, Guard.Guard] | undefined): [rs.u32, rs.u32] | undefined => { - return option_map$0j32j8c(p4, (_236: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { - const a5: Guard.Guard = _236[0]; - const b4: Guard.Guard = _236[1]; + return option_map$0j32j8c(p4, (_237: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { + const a5: Guard.Guard = _237[0]; + const b4: Guard.Guard = _237[1]; const _027: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a5), id), rs.u32Sub(Guard.id(b4), id)]; b4[Symbol.dispose](); a5[Symbol.dispose](); @@ -267,32 +250,27 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { }; const part18 = rs.iterToOption(it8.next()); const part19 = id2(part18); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part19, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["ends ", args48[0]])); + Log.note(log, rs.fmtFormat(["ends ", (f: rs.Formatter) => rs.fmtOption(part19, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const part20 = rs.iterToOption(it8.nextBack()); const part21 = id2(part20); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part21, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["ends ", args50[0]])); + Log.note(log, rs.fmtFormat(["ends ", (f: rs.Formatter) => rs.fmtOption(part21, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const part22 = rs.iterToOption(it8.next()); const part23 = id2(part22); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part23, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["ends ", args52[0]])); + Log.note(log, rs.fmtFormat(["ends ", (f: rs.Formatter) => rs.fmtOption(part23, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const part24 = rs.iterToOption(it8.nextBack()); const part25 = id2(part24); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part25, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["ends ", args54[0]])); + Log.note(log, rs.fmtFormat(["ends ", (f: rs.Formatter) => rs.fmtOption(part25, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const inner: rs.Iter<[Guard.Guard, Guard.Guard]> = pairs(); const part26 = rs.iterToOption(inner.nextBack()); const part27 = id2(part26); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part27, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["inner ", args56[0]])); + Log.note(log, rs.fmtFormat(["inner ", (f: rs.Formatter) => rs.fmtOption(part27, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))])); const it9: rs.Iter<[[[Guard.Guard, Guard.Guard], rs.u32], rs.u32]> = rs.iterZip(rs.iterZip(inner, new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); const id3: (a0: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32] | undefined) => [rs.u32, rs.u32, rs.u32, rs.u32] | undefined = (p5: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32] | undefined): [rs.u32, rs.u32, rs.u32, rs.u32] | undefined => { - return option_map$0ss4ft9(p5, (_237: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32]): [rs.u32, rs.u32, rs.u32, rs.u32] => { - const a6: Guard.Guard = _237[0][0][0]; - const b5: Guard.Guard = _237[0][0][1]; - const m3: rs.u32 = _237[0][1]; - const n30: rs.u32 = _237[1]; + return option_map$0ss4ft9(p5, (_241: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32]): [rs.u32, rs.u32, rs.u32, rs.u32] => { + const a6: Guard.Guard = _241[0][0][0]; + const b5: Guard.Guard = _241[0][0][1]; + const m3: rs.u32 = _241[0][1]; + const n30: rs.u32 = _241[1]; const _029: [rs.u32, rs.u32, rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a6), id), rs.u32Sub(Guard.id(b5), id), m3, n30]; b5[Symbol.dispose](); a6[Symbol.dispose](); @@ -301,37 +279,33 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { }; const part28 = rs.iterToOption(it9.nextBack()); const part29 = id3(part28); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part29, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; - Log.note(log, rs.fmtFormat(["nested ", args58[0]])); + Log.note(log, rs.fmtFormat(["nested ", (f: rs.Formatter) => rs.fmtOption(part29, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))])); const part30 = rs.iterToOption(it9.nextBack()); const part31 = id3(part30); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part31, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; - Log.note(log, rs.fmtFormat(["nested ", args60[0]])); + Log.note(log, rs.fmtFormat(["nested ", (f: rs.Formatter) => rs.fmtOption(part31, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))])); const part32 = rs.iterToOption(it9.nextBack()); const part33 = id3(part32); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part33, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; - Log.note(log, rs.fmtFormat(["nested ", args62[0]])); + Log.note(log, rs.fmtFormat(["nested ", (f: rs.Formatter) => rs.fmtOption(part33, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))])); const _667: rs.Iter = rs.iterSlice(v); const captured21 = made; - const _665: rs.Iter<[rs.usize, Guard.Guard]> = rs.iterEnumerate(rs.iterMap(_667, (_240: rs.u32): Guard.Guard => { - return captured21(_240); + const _665: rs.Iter<[rs.usize, Guard.Guard]> = rs.iterEnumerate(rs.iterMap(_667, (_245: rs.u32): Guard.Guard => { + return captured21(_245); })); const _672: rs.Iter = rs.iterSlice(rs.sliceItems(rs.sliceRange(rs.sliceFrom(w), 0, 3))); const captured22 = made; - const part34 = option_map$1pp5yot(rs.iterToOption(rs.iterZip(rs.iterZip(_665, rs.iterMap(_672, (_241: rs.u32): Guard.Guard => { - return captured22(_241); - }), [true, true], lib_drop$tuple2_usize_model_Guard, rs.drop), new rs.Range(0, 5), [true, false], lib_drop$tuple2_tuple2_usize_model_Guard_model_Guard).nextBack()), (_245: [[[rs.usize, Guard.Guard], Guard.Guard], rs.u32]): [rs.usize, rs.u32, rs.u32, rs.u32] => { - const i: rs.usize = _245[0][0][0]; - const a7: Guard.Guard = _245[0][0][1]; - const b6: Guard.Guard = _245[0][1]; - const n33: rs.u32 = _245[1]; + const part34 = option_map$1pp5yot(rs.iterToOption(rs.iterZip(rs.iterZip(_665, rs.iterMap(_672, (_247: rs.u32): Guard.Guard => { + return captured22(_247); + }), [true, true], lib_drop$tuple2_usize_model_Guard, rs.drop), new rs.Range(0, 5), [true, false], lib_drop$tuple2_tuple2_usize_model_Guard_model_Guard).nextBack()), (_248: [[[rs.usize, Guard.Guard], Guard.Guard], rs.u32]): [rs.usize, rs.u32, rs.u32, rs.u32] => { + const i: rs.usize = _248[0][0][0]; + const a7: Guard.Guard = _248[0][0][1]; + const b6: Guard.Guard = _248[0][1]; + const n33: rs.u32 = _248[1]; const _032: [rs.usize, rs.u32, rs.u32, rs.u32] = [i, rs.u32Sub(Guard.id(a7), id), rs.u32Sub(Guard.id(b6), id), n33]; b6[Symbol.dispose](); a7[Symbol.dispose](); return _032; }); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part34, f, (value: [rs.usize, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; - Log.note(log, rs.fmtFormat(["enumerated ", args64[0]])); + Log.note(log, rs.fmtFormat(["enumerated ", (f: rs.Formatter) => rs.fmtOption(part34, f, (value: [rs.usize, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))])); } else if (_16 === 7) { const _695: [Guard.Guard, Guard.Guard] = [guard(20), guard(21)]; const a: Guard.Guard = _695[0]; @@ -354,8 +328,7 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured9[Symbol.dispose](); })), "index", 4, true, 4); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part5.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["in place ", args66[0]])); + Log.note(log, rs.fmtFormat(["in place ", (f: rs.Formatter) => rs.fmtList(part5.items, f, rs.u32Debug)])); const c: Guard.Guard = guard(22); const _732: rs.Iter = rs.vecIntoIter(rs.vecFrom([5, 6, 7])); const _736: rs.Range = new rs.Range(0, 9); @@ -368,16 +341,14 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { })), "index"), (_217: [rs.u32, rs.u32]): rs.u32 => { return rs.u32Add(_217[0], _217[1]); }), "index", 4, true, 4); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part6.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["in place ", args68[0]])); + Log.note(log, rs.fmtFormat(["in place ", (f: rs.Formatter) => rs.fmtList(part6.items, f, rs.u32Debug)])); } else { const d: Guard.Guard = guard(23); const _756: rs.Iter = rs.vecIntoIter(rs.vecFrom([1, 2, 3, 4])); const captured3 = d; const captured4 = id; const part2 = rs.iterToVec(rs.iterMap(rs.iterSkip(rs.iterZip(rs.iterMap(_756, rs.closure((n14: rs.u32): rs.u32 => { - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n14, f)]; - Log.note(log, rs.fmtFormat(["map ", args78[0]])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.u32Display(n14, f)])); const _156: rs.u32 = Guard.id(captured3); return rs.u32Sub(rs.u32Sub(rs.u32Add(n14, _156), captured4), 23); }, (): void => { @@ -385,8 +356,7 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { })), new rs.Range(0, 3), "index"), 1), (_29: [rs.u32, rs.u32]): rs.u32 => { return rs.u32Add(_29[0], _29[1]); }), "index", 4, true, 4); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["skipped ", args70[0]])); + Log.note(log, rs.fmtFormat(["skipped ", (f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug)])); const part3 = rs.iterToVec(rs.iterMap(rs.iterZip(rs.vecIntoIter(rs.vecFrom([1, 2, 3])), rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), "index", undefined, lib_drop$tuple2_model_Guard_model_Guard), (_211: [rs.u32, [Guard.Guard, Guard.Guard]]): rs.u32 => { const n16: rs.u32 = _211[0]; const a3: Guard.Guard = _211[1][0]; @@ -396,8 +366,7 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { a3[Symbol.dispose](); return _010; }), "index", 4, true, 4); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part3.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["beside ", args72[0]])); + Log.note(log, rs.fmtFormat(["beside ", (f: rs.Formatter) => rs.fmtList(part3.items, f, rs.u32Debug)])); const e2: Guard.Guard = guard(24); const _799: rs.Iter = rs.vecIntoIter(new rs.Vec()); const captured5 = e2; @@ -408,8 +377,7 @@ export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { })), new rs.Range(0, 3), "index"), (_212: [rs.u32, rs.u32]): rs.u32 => { return rs.u32Add(_212[0], _212[1]); }), "index", 4, true, 4); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["empty ", args74[0]])); + Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtList(part4.items, f, rs.u32Debug)])); } } diff --git a/ts/fixtures/task/expected/drops/inside.Bomb.ts b/ts/fixtures/task/expected/drops/inside.Bomb.ts index 41b678b9f..22bdb8fd8 100644 --- a/ts/fixtures/task/expected/drops/inside.Bomb.ts +++ b/ts/fixtures/task/expected/drops/inside.Bomb.ts @@ -21,8 +21,8 @@ export function drop$ops_Drop(self: Bomb): void { const arg = self._0; const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg, f); const arg2 = self._1; - const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; - rs.panicFmt(["range ", args2[0], "..", args2[1], " dropped"]); + const args3 = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; + rs.panicFmt(["range ", args3[0], "..", args3[1], " dropped"]); } export function startBound$ops_RangeBounds_usize(self: Bomb): rs.RangeBound { diff --git a/ts/fixtures/task/expected/drops/inside.Shown.ts b/ts/fixtures/task/expected/drops/inside.Shown.ts index 9091db6d2..4ff0c5ad3 100644 --- a/ts/fixtures/task/expected/drops/inside.Shown.ts +++ b/ts/fixtures/task/expected/drops/inside.Shown.ts @@ -19,8 +19,7 @@ export class Shown { export function fmt$fmt_Debug(self: Shown, f: rs.Formatter): rs.Result { Guard.note(self._0, "shown"); const part = Guard.id(self._0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - return rs.fmtWriteFmt(f, [args2[0]]); + return rs.fmtWriteFmt(f, [(f: rs.Formatter) => rs.u32Display(part, f)]); } //# sourceMappingURL=inside.Shown.ts.map diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index c9931b0a8..9b3206797 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -32,15 +32,13 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const n: rs.u8 = _13; const _24: Log.Log = Log.clone$Clone(log); const _23: Listed.Listed = new Listed.Listed(id, _24, n); - const args2: rs.Fmt[] = [(f: rs.Formatter) => Listed.fmt$fmt_Debug(_23, f)]; - const _19: string = rs.fmtFormat(["listed ", args2[0]]); + const _19: string = rs.fmtFormat(["listed ", (f: rs.Formatter) => Listed.fmt$fmt_Debug(_23, f)]); _23[Symbol.dispose](); Log.note(log, _19); } const _36: Log.Log = Log.clone$Clone(log); const _35: Listed.Listed = new Listed.Listed(id, _36, 2); - const args4: rs.Fmt[] = [(f: rs.Formatter) => Listed.fmt$fmt_Debug(_35, f)]; - const _31: string = rs.fmtFormat(["pretty ", rs.fmtSpec({ alternate: true }, args4[0])]); + const _31: string = rs.fmtFormat(["pretty ", rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Listed.fmt$fmt_Debug(_35, f))]); _35[Symbol.dispose](); Log.note(log, _31); } else if (_8 === 1) { @@ -54,12 +52,10 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const r: rs.Range = new rs.Range(guard(8), guard(9)); const start: Guard.Guard = r.start; const part20 = Guard.id(start); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part20, f)]; - Log.note(log, rs.fmtFormat(["moved ", args6[0]])); + Log.note(log, rs.fmtFormat(["moved ", (f: rs.Formatter) => rs.u32Display(part20, f)])); const ranges: rs.Vec> = rs.vecFrom([new rs.Range(guard(10), guard(11)), new rs.Range(guard(12), guard(13))]); const part21 = ranges.items.length; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part21, f)]; - Log.note(log, rs.fmtFormat(["ranges ", args8[0]])); + Log.note(log, rs.fmtFormat(["ranges ", (f: rs.Formatter) => rs.usizeDisplay(part21, f)])); rs.dropVec(ranges, lib_drop$ops_Range_model_Guard); start[Symbol.dispose](); r.end[Symbol.dispose](); @@ -68,8 +64,8 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const taken: rs.Vec = rs.iterToVec(rs.dropAfter(new Spent.Spent(guard(10), 1, 3), (range12) => rs.vecDrain(v, rs.boundsOf(range12, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop), "fold", 8, true); const _136: rs.usize = taken.items.length; const _139: rs.usize = v.items.length; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_136, f), (f: rs.Formatter) => rs.usizeDisplay(_139, f)]; - Log.note(log, rs.fmtFormat(["drained ", args10[0], " ", args10[1]])); + const args79 = [(f: rs.Formatter) => rs.usizeDisplay(_136, f), (f: rs.Formatter) => rs.usizeDisplay(_139, f)]; + Log.note(log, rs.fmtFormat(["drained ", args79[0], " ", args79[1]])); const q: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(new rs.Range(6, 9), guard), undefined, 8, true), 8) as rs.VecDeque; const it: rs.Iter = rs.dropAfter(new Spent.Spent(guard(11), 0, 2), (range13) => rs.dequeDrain(q, rs.boundsOf(range13, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop); const part17 = option_map$06w9waf(rs.iterToOption(it.next()), (g12: Guard.Guard): rs.u32 => { @@ -77,15 +73,13 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { g12[Symbol.dispose](); return _012; }); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part17, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["deque ", args12[0]])); + Log.note(log, rs.fmtFormat(["deque ", (f: rs.Formatter) => rs.fmtOption(part17, f, rs.u32Debug)])); rs.drop(it); let s: string = "abcdef"; const _180: Spent.Spent = new Spent.Spent(guard(12), 1, 3); const s4 = rs.place(() => s, (value2) => s = value2); const part18 = rs.stringExtendChars("", rs.stringDrain(s4, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s4.v)), rs.drop)), true); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18)]; - Log.note(log, rs.fmtFormat(["text ", args14[0]])); + Log.note(log, rs.fmtFormat(["text ", (f: rs.Formatter) => rs.fmtPad(f, part18)])); const _190: Spent.Spent = new Spent.Spent(guard(13), 0, 1); s = rs.stringReplaceRange(s, rs.dropAfter(_190, (range15) => rs.boundsChecked(rs.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s)), rs.drop), "xy"); const _197: Spent.Spent = new Spent.Spent(guard(14), 2, 4); @@ -97,12 +91,11 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { [s, rs.byteSliceFrom(bytes)] as [string, rs.ByteSlice]; const _217: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s); const arg2 = rs.byteSliceFrom(bytes); - const args16: rs.Fmt[] = [_217, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; - Log.note(log, rs.fmtFormat(["edited ", args16[0], " ", args16[1]])); + const args82 = [_217, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; + Log.note(log, rs.fmtFormat(["edited ", args82[0], " ", args82[1]])); const none: rs.Vec = rs.iterToVec(rs.dropAfter(new Spent.Spent(guard(16), 1, 1), (range18) => rs.vecDrain(v, rs.boundsOf(range18, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop), "fold", 8, true); const part19 = none.items.length; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part19, f)]; - Log.note(log, rs.fmtFormat(["none ", args18[0]])); + Log.note(log, rs.fmtFormat(["none ", (f: rs.Formatter) => rs.usizeDisplay(part19, f)])); rs.dropVec(none); rs.dequeDrop(q, rs.drop); rs.dropVec(taken); @@ -110,8 +103,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { } else if (_8 === 3) { const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const part13 = rs.iterCount(rs.dropAfter(new Spent.Spent(guard(1), 0, 1), (range8) => rs.btreeRange(map, rs.boundsOf(range8, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop)); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part13, f)]; - Log.note(log, rs.fmtFormat(["empty ", args20[0]])); + Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.usizeDisplay(part13, f)])); let iterStart: rs.usize = 0; const iterEnd: rs.usize = 4; while ((_261 = iterStart++) < iterEnd) { @@ -120,8 +112,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(rs.btreeInsert(map, n2, _267)); } const part15 = rs.iterCount(rs.dropAfter(new Spent.Spent(guard(2), 1, 3), (range9) => rs.btreeRange(map, rs.boundsOf(range9, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop)); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part15, f)]; - Log.note(log, rs.fmtFormat(["map ", args22[0]])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.usizeDisplay(part15, f)])); const iter3: rs.Iter<[rs.usize, Guard.Guard]> = rs.dropAfter(new Spent.Spent(guard(3), 2, 9), (range10) => rs.btreeRange(map, rs.boundsOf(range10, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop); while (true) { const _298: [rs.usize, Guard.Guard] | rs.Done = iter3.next(); @@ -132,8 +123,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { } const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, new rs.Range(0, 5), true, undefined, undefined, 4, true); const part16 = rs.iterCount(rs.dropAfter(new Spent.Spent(guard(4), 3, 5), (range11) => rs.btreeRangeKeys(set, rs.boundsOf(range11, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop)); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part16, f)]; - Log.note(log, rs.fmtFormat(["set ", args24[0]])); + Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.usizeDisplay(part16, f)])); rs.btreeDrop(map, undefined, rs.drop); } else if (_8 === 4) { const map2: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; @@ -147,14 +137,13 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const part12 = rs.iterToVec(rs.iterMap(rs.dropAfter(new rs.Range(key(2), key(4)), (range5) => rs.btreeRange(map2, range5, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_Range_drops_Key), (_2: [Key.Key, rs.u32]): rs.u32 => { return _2[1]; }), "next", 4); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part12.items, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["keys ", args26[0]])); + Log.note(log, rs.fmtFormat(["keys ", (f: rs.Formatter) => rs.fmtList(part12.items, f, rs.u32Debug)])); const found2: rs.usize = rs.iterCount(rs.dropAfter(new rs.RangeInclusive(key(3), key(9)), (range6) => rs.btreeRange(map2, range6, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_RangeInclusive_drops_Key)); const _371: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; const none2: rs.usize = rs.iterCount(rs.dropAfter(new rs.Range(key(5), key(6)), (range7) => rs.btreeRange(_371, range7, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_Range_drops_Key)); rs.btreeDrop(_371, rs.drop); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(found2, f), (f: rs.Formatter) => rs.usizeDisplay(none2, f)]; - Log.note(log, rs.fmtFormat(["keys ", args28[0], " ", args28[1]])); + const args75 = [(f: rs.Formatter) => rs.usizeDisplay(found2, f), (f: rs.Formatter) => rs.usizeDisplay(none2, f)]; + Log.note(log, rs.fmtFormat(["keys ", args75[0], " ", args75[1]])); rs.btreeDrop(map2, rs.drop); } else if (_8 === 5) { const map3: (a0: rs.u32) => rs.HashMap = (n9: rs.u32): rs.HashMap => { @@ -167,12 +156,10 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { k2[Symbol.dispose](); return _07; }); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["next ", args30[0]])); + Log.note(log, rs.fmtFormat(["next ", (f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)])); const _421: Key.Key | undefined = rs.iterToOption(keys.next()); const part6 = _421 === undefined; - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; - const _415: string = rs.fmtFormat(["done ", args32[0]]); + const _415: string = rs.fmtFormat(["done ", (f: rs.Formatter) => rs.fmtBool(part6, f)]); rs.drop(_421); Log.note(log, _415); rs.iterForEach(rs.hashValues(map3(2), rs.drop, rs.drop), (g8: Guard.Guard): undefined => { @@ -181,8 +168,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, true); rs.iterFold(rs.hashKeys(map3(3), rs.drop, rs.drop), undefined, (_: undefined, k3: Key.Key): undefined => { const part7 = rs.u32Sub(k3.id, id); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["fold ", args58[0]])); + Log.note(log, rs.fmtFormat(["fold ", (f: rs.Formatter) => rs.u32Display(part7, f)])); k3[Symbol.dispose](); }, true); const part8 = option_map$06w9waf(rs.ownedLast(rs.hashValues(map3(4), rs.drop, rs.drop), rs.drop), (g9: Guard.Guard): rs.u32 => { @@ -190,11 +176,9 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { g9[Symbol.dispose](); return _08; }); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["last ", args34[0]])); + Log.note(log, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)])); const part9 = rs.ownedCount(rs.hashKeys(map3(5), rs.drop, rs.drop), rs.drop); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part9, f)]; - Log.note(log, rs.fmtFormat(["count ", args36[0]])); + Log.note(log, rs.fmtFormat(["count ", (f: rs.Formatter) => rs.usizeDisplay(part9, f)])); const _472: rs.Iter = rs.hashValues(map3(6), rs.drop, rs.drop); const found3: Guard.Guard | undefined = rs.iterFind(_472, (g10: Guard.Guard): boolean => { return Guard.id(g10) === rs.u32Add(id, 6); @@ -205,20 +189,18 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { g11[Symbol.dispose](); return _010; }); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["found ", args38[0]])); + Log.note(log, rs.fmtFormat(["found ", (f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)])); const part11 = rs.iterSum(rs.iterMap(rs.hashKeys(map3(7), rs.drop, rs.drop), (k4: Key.Key): rs.u32 => { const _011: rs.u32 = rs.u32Sub(k4.id, id); k4[Symbol.dispose](); return _011; }), rs.u32Add, 0, true); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; - Log.note(log, rs.fmtFormat(["sum ", args40[0]])); + Log.note(log, rs.fmtFormat(["sum ", (f: rs.Formatter) => rs.u32Display(part11, f)])); const taken2: rs.Vec = rs.iterToVec(rs.iterTake(rs.hashValues(map3(8), rs.drop, rs.drop), 0, rs.drop), "next", 8); const none3: rs.usize = rs.ownedCount(rs.hashKeys(rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap, rs.drop, rs.drop), rs.drop); const _522: rs.usize = taken2.items.length; - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_522, f), (f: rs.Formatter) => rs.usizeDisplay(none3, f)]; - Log.note(log, rs.fmtFormat(["taken ", args42[0], " ", args42[1]])); + const args73 = [(f: rs.Formatter) => rs.usizeDisplay(_522, f), (f: rs.Formatter) => rs.usizeDisplay(none3, f)]; + Log.note(log, rs.fmtFormat(["taken ", args73[0], " ", args73[1]])); rs.dropVec(taken2); rs.drop(keys); } else if (_8 === 6) { @@ -231,8 +213,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured3 = c; rs.iterForEach(_551, rs.closure((g2: Guard.Guard): undefined => { const part = Guard.id(captured3); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - const _49: string = rs.fmtFormat(["each ", args50[0]]); + const _49: string = rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part, f)]); Guard.note(g2, _49); g2[Symbol.dispose](); }, (): void => { @@ -251,8 +232,8 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const g4: Guard.Guard = _311[0]; const h: rs.u32 = _311[1]; const _155: rs.u32 = Guard.id(captured5); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(h, f), (f: rs.Formatter) => rs.u32Display(_155, f)]; - const _87: string = rs.fmtFormat(["fold ", args52[0], " ", args52[1]]); + const args55 = [(f: rs.Formatter) => rs.u32Display(h, f), (f: rs.Formatter) => rs.u32Display(_155, f)]; + const _87: string = rs.fmtFormat(["fold ", args55[0], " ", args55[1]]); Guard.note(g4, _87); const _04: rs.i32 = rs.i32Add(n7, 1); g4[Symbol.dispose](); @@ -260,14 +241,13 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured5[Symbol.dispose](); }), true, true); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["folded ", args44[0]])); + Log.note(log, rs.fmtFormat(["folded ", (f: rs.Formatter) => rs.i32Display(part2, f)])); const _576: rs.Iter = rs.iterSlice([1, 2]); const captured6 = e; rs.iterForEach(_576, rs.closure((n8: rs.u32): undefined => { const _88: rs.u32 = Guard.id(captured6); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8, f), (f: rs.Formatter) => rs.u32Display(_88, f)]; - Log.note(log, rs.fmtFormat(["plain ", args54[0], " ", args54[1]])); + const args59 = [(f: rs.Formatter) => rs.u32Display(n8, f), (f: rs.Formatter) => rs.u32Display(_88, f)]; + Log.note(log, rs.fmtFormat(["plain ", args59[0], " ", args59[1]])); }, (): void => { captured6[Symbol.dispose](); }), undefined, true); @@ -275,9 +255,8 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured7 = f; rs.iterForEach(_581, rs.closure((g5: Guard.Guard): undefined => { const part3 = Guard.id(captured7); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - const _413: string = rs.fmtFormat([args56[0]]); - Guard.note(g5, _413); + const _417: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part3, f)]); + Guard.note(g5, _417); g5[Symbol.dispose](); }, (): void => { captured7[Symbol.dispose](); @@ -305,8 +284,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _05; }); const part4 = Guard.id(kept); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["kept ", args46[0]])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.u32Display(part4, f)])); const _604: [Guard.Guard, rs.u32] = [guard(16), 0]; const k: Guard.Guard = _604[0]; let captured8 = 0; @@ -331,8 +309,8 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { if (!(Guard.id(g) !== rs.u32Add(captured, 2))) { const _134: rs.u32 = Guard.id(g); const _16: rs.u32 = Guard.id(captured2); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_134, f), (f: rs.Formatter) => rs.u32Display(_16, f)]; - rs.panicFmt(["g", args48[0], " with ", args48[1]]); + const args49 = [(f: rs.Formatter) => rs.u32Display(_134, f), (f: rs.Formatter) => rs.u32Display(_16, f)]; + rs.panicFmt(["g", args49[0], " with ", args49[1]]); } else { g[Symbol.dispose](); } diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index d930f6de5..ada1125bb 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -43,8 +43,7 @@ export function looped(log: Log.Log, id: rs.u32): void { } const g2: Guard.Guard = _45; const part = Guard.id(g2); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["array ", args2[0]])); + Log.note(log, rs.fmtFormat(["array ", (f: rs.Formatter) => rs.u32Display(part, f)])); g2[Symbol.dispose](); } rs.drop(iter2); @@ -56,8 +55,7 @@ export function looped(log: Log.Log, id: rs.u32): void { } const g3: Guard.Guard = _67; const part2 = Guard.id(g3); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["option ", args4[0]])); + Log.note(log, rs.fmtFormat(["option ", (f: rs.Formatter) => rs.u32Display(part2, f)])); g3[Symbol.dispose](); } rs.drop(iter3); @@ -74,8 +72,7 @@ export function looped(log: Log.Log, id: rs.u32): void { return rs.u32Rem(Guard.id(g4), 2) === 0; }, rs.drop), "next", 8, false, 8); const part3 = even.items.length; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; - Log.note(log, rs.fmtFormat(["even ", args6[0]])); + Log.note(log, rs.fmtFormat(["even ", (f: rs.Formatter) => rs.usizeDisplay(part3, f)])); const v3: rs.Vec = new rs.Vec(); const _127: Guard.Guard = guard(12); v3.items.push(_127); @@ -93,11 +90,9 @@ export function looped(log: Log.Log, id: rs.u32): void { g5[Symbol.dispose](); return _03; }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["next ", args8[0]])); + Log.note(log, rs.fmtFormat(["next ", (f: rs.Formatter) => rs.u32Display(part4, f)])); const part5 = rs.ownedCount(rest, rs.drop); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; - Log.note(log, rs.fmtFormat(["count ", args10[0]])); + Log.note(log, rs.fmtFormat(["count ", (f: rs.Formatter) => rs.usizeDisplay(part5, f)])); const v4: rs.Vec = new rs.Vec(); const _181: Guard.Guard = guard(17); v4.items.push(_181); @@ -112,8 +107,8 @@ export function looped(log: Log.Log, id: rs.u32): void { }); const _203: boolean = first !== undefined; const _206: boolean = second !== undefined; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_203, f), (f: rs.Formatter) => rs.fmtBool(_206, f)]; - Log.note(log, rs.fmtFormat(["peek ", args12[0], " ", args12[1]])); + const args30 = [(f: rs.Formatter) => rs.fmtBool(_203, f), (f: rs.Formatter) => rs.fmtBool(_206, f)]; + Log.note(log, rs.fmtFormat(["peek ", args30[0], " ", args30[1]])); rs.drop(peek); const v5: rs.Vec = new rs.Vec(); const _221: Guard.Guard = guard(20); @@ -127,8 +122,7 @@ export function looped(log: Log.Log, id: rs.u32): void { const _238: Guard.Guard = guard(23); v6.items.push(_238); const part6 = rs.ownedCount(rs.iterZip(_216, rs.vecIntoIter(v6, rs.drop), "len", rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part6, f)]; - Log.note(log, rs.fmtFormat(["zip ", args14[0]])); + Log.note(log, rs.fmtFormat(["zip ", (f: rs.Formatter) => rs.usizeDisplay(part6, f)])); const v7: rs.Vec = new rs.Vec(); const _261: Guard.Guard = guard(24); v7.items.push(_261); @@ -146,8 +140,7 @@ export function looped(log: Log.Log, id: rs.u32): void { g8[Symbol.dispose](); return _06; }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["nth ", args16[0]])); + Log.note(log, rs.fmtFormat(["nth ", (f: rs.Formatter) => rs.u32Display(part7, f)])); const v9: rs.Vec = new rs.Vec(); const _293: Guard.Guard = guard(27); v9.items.push(_293); @@ -177,8 +170,8 @@ export function looped(log: Log.Log, id: rs.u32): void { return _09; }); const _343: boolean = found !== undefined; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_341, f), (f: rs.Formatter) => rs.fmtBool(_343, f)]; - Log.note(log, rs.fmtFormat(["found ", args18[0], " ", args18[1]])); + const args33 = [(f: rs.Formatter) => rs.u32Display(_341, f), (f: rs.Formatter) => rs.fmtBool(_343, f)]; + Log.note(log, rs.fmtFormat(["found ", args33[0], " ", args33[1]])); const v11: rs.Vec = new rs.Vec(); const _356: Guard.Guard = guard(33); v11.items.push(_356); @@ -203,8 +196,8 @@ export function looped(log: Log.Log, id: rs.u32): void { g13[Symbol.dispose](); return _011; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(folded, f), (f: rs.Formatter) => rs.u32Display(_397, f)]; - Log.note(log, rs.fmtFormat(["fold ", args20[0], " ", args20[1]])); + const args34 = [(f: rs.Formatter) => rs.u32Display(folded, f), (f: rs.Formatter) => rs.u32Display(_397, f)]; + Log.note(log, rs.fmtFormat(["fold ", args34[0], " ", args34[1]])); const v13: rs.Vec> = new rs.Vec(); const v14: rs.Vec = new rs.Vec(); const _414: Guard.Guard = guard(39); @@ -233,8 +226,8 @@ export function looped(log: Log.Log, id: rs.u32): void { g15[Symbol.dispose](); return _013; }); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(front, f), (f: rs.Formatter) => rs.u32Display(back, f)]; - Log.note(log, rs.fmtFormat(["flat ", args22[0], " ", args22[1]])); + const args35 = [(f: rs.Formatter) => rs.u32Display(front, f), (f: rs.Formatter) => rs.u32Display(back, f)]; + Log.note(log, rs.fmtFormat(["flat ", args35[0], " ", args35[1]])); rs.drop(flat); const five: (a0: rs.u32) => rs.Vec = (n3: rs.u32): rs.Vec => { const v17: rs.Vec = new rs.Vec(); @@ -242,8 +235,8 @@ export function looped(log: Log.Log, id: rs.u32): void { v17.items.push(_610); const _103: Guard.Guard = guard(rs.u32Add(n3, 1)); v17.items.push(_103); - const _162: Guard.Guard = guard(rs.u32Add(n3, 2)); - v17.items.push(_162); + const _163: Guard.Guard = guard(rs.u32Add(n3, 2)); + v17.items.push(_163); const _222: Guard.Guard = guard(rs.u32Add(n3, 3)); v17.items.push(_222); const _283: Guard.Guard = guard(rs.u32Add(n3, 4)); @@ -285,8 +278,8 @@ export function looped(log: Log.Log, id: rs.u32): void { rs.drop(_509); const counted: rs.usize = rs.ownedCount(rs.iterTake(rs.iterRev(rs.vecIntoIter(five(74), rs.drop)), 3, rs.drop), rs.drop); const far: boolean = rs.iterNthBack(rs.iterStepBy(new rs.Range(0, 10), 4294967295), 4294967295) === undefined; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(skipped, f), (f: rs.Formatter) => rs.u32Display(stepped, f), (f: rs.Formatter) => rs.u32Display(taken, f), (f: rs.Formatter) => rs.u32Display(passed, f), (f: rs.Formatter) => rs.u32Display(strode, f), (f: rs.Formatter) => rs.usizeDisplay(counted, f), (f: rs.Formatter) => rs.fmtBool(far, f)]; - Log.note(log, rs.fmtFormat(["back ", args24[0], " ", args24[1], " ", args24[2], " ", args24[3], " ", args24[4], " ", args24[5], " ", args24[6]])); + const args36 = [(f: rs.Formatter) => rs.fmtBool(skipped, f), (f: rs.Formatter) => rs.u32Display(stepped, f), (f: rs.Formatter) => rs.u32Display(taken, f), (f: rs.Formatter) => rs.u32Display(passed, f), (f: rs.Formatter) => rs.u32Display(strode, f), (f: rs.Formatter) => rs.usizeDisplay(counted, f), (f: rs.Formatter) => rs.fmtBool(far, f)]; + Log.note(log, rs.fmtFormat(["back ", args36[0], " ", args36[1], " ", args36[2], " ", args36[3], " ", args36[4], " ", args36[5], " ", args36[6]])); rs.drop(found); rs.drop(second); rs.drop(first); @@ -336,8 +329,8 @@ export function collected(log: Log.Log, id: rs.u32): void { const _74: rs.usize = same.items.length; const _77: rs.usize = wider.items.length; const _80: rs.usize = chained.items.length; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_74, f), (f: rs.Formatter) => rs.usizeDisplay(_77, f), (f: rs.Formatter) => rs.usizeDisplay(_80, f)]; - Log.note(log, rs.fmtFormat(["vecs ", args2[0], " ", args2[1], " ", args2[2]])); + const args13 = [(f: rs.Formatter) => rs.usizeDisplay(_74, f), (f: rs.Formatter) => rs.usizeDisplay(_77, f), (f: rs.Formatter) => rs.usizeDisplay(_80, f)]; + Log.note(log, rs.fmtFormat(["vecs ", args13[0], " ", args13[1], " ", args13[2]])); const v5: rs.Vec = new rs.Vec(); const _95: Guard.Guard = guard(10); v5.items.push(_95); @@ -352,8 +345,7 @@ export function collected(log: Log.Log, id: rs.u32): void { return rs.Err(g2); }), (values: rs.Iter) => rs.iterToVec(values, "next", 8, false, 8), lib_drop$Vec_model_Guard); const part = results.ok; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - Log.note(log, rs.fmtFormat(["result ", args4[0]])); + Log.note(log, rs.fmtFormat(["result ", (f: rs.Formatter) => rs.fmtBool(part, f)])); lib_drop$Result_Vec_model_Guard_model_Guard(results); const v6: rs.Vec = new rs.Vec(); const _130: Guard.Guard = guard(13); @@ -369,8 +361,7 @@ export function collected(log: Log.Log, id: rs.u32): void { rs.dropVec(v12); return _06; }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; - Log.note(log, rs.fmtFormat(["option ", args6[0]])); + Log.note(log, rs.fmtFormat(["option ", (f: rs.Formatter) => rs.usizeDisplay(part2, f)])); const v7: rs.Vec<[rs.u32, Guard.Guard]> = new rs.Vec(); const _160: [rs.u32, Guard.Guard] = [2, guard(16)]; v7.items.push(_160); @@ -381,8 +372,7 @@ export function collected(log: Log.Log, id: rs.u32): void { const _155: rs.Iter<[rs.u32, Guard.Guard]> = rs.vecIntoIter(v7, lib_drop$tuple2_u32_model_Guard); const tree: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterToVec(_155, "next", 12, true, 12).items, 12, true, undefined, undefined, rs.drop); const part3 = rs.btreeLen(tree); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; - Log.note(log, rs.fmtFormat(["tree ", args8[0]])); + Log.note(log, rs.fmtFormat(["tree ", (f: rs.Formatter) => rs.usizeDisplay(part3, f)])); const v8: rs.Vec = new rs.Vec(); const _195: Guard.Guard = guard(24); v8.items.push(_195); @@ -393,8 +383,7 @@ export function collected(log: Log.Log, id: rs.u32): void { _2[Symbol.dispose](); return same.items[at]; }), "next", 4, true, 8).items.length; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part4, f)]; - Log.note(log, rs.fmtFormat(["refs ", args10[0]])); + Log.note(log, rs.fmtFormat(["refs ", (f: rs.Formatter) => rs.usizeDisplay(part4, f)])); const v9: rs.Vec = new rs.Vec(); const _223: Guard.Guard = guard(19); v9.items.push(_223); @@ -418,8 +407,8 @@ export function collected(log: Log.Log, id: rs.u32): void { const _267: rs.usize = queue.n; const _270: rs.usize = rs.hashLen(hashed); const _273: rs.usize = rs.hashLen(set); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_267, f), (f: rs.Formatter) => rs.usizeDisplay(_270, f), (f: rs.Formatter) => rs.usizeDisplay(_273, f)]; - Log.note(log, rs.fmtFormat(["collected ", args12[0], " ", args12[1], " ", args12[2]])); + const args18 = [(f: rs.Formatter) => rs.usizeDisplay(_267, f), (f: rs.Formatter) => rs.usizeDisplay(_270, f), (f: rs.Formatter) => rs.usizeDisplay(_273, f)]; + Log.note(log, rs.fmtFormat(["collected ", args18[0], " ", args18[1], " ", args18[2]])); rs.hashDrop(set, rs.drop); rs.hashDrop(hashed, undefined, rs.drop); rs.dequeDrop(queue, rs.drop); @@ -472,8 +461,8 @@ export function drained(log: Log.Log, id: rs.u32): void { g[Symbol.dispose](); return _04; }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_37, f), (f: rs.Formatter) => rs.u32Display(_40, f)]; - Log.note(log, rs.fmtFormat(["values ", args2[0], " ", args2[1]])); + const args19 = [(f: rs.Formatter) => rs.usizeDisplay(_37, f), (f: rs.Formatter) => rs.u32Display(_40, f)]; + Log.note(log, rs.fmtFormat(["values ", args19[0], " ", args19[1]])); rs.drop(values); const set: rs.BTreeSet = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeSet; const _53: Key.Key = key(13); @@ -486,8 +475,7 @@ export function drained(log: Log.Log, id: rs.u32): void { k[Symbol.dispose](); return _05; }); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - const _63: string = rs.fmtFormat(["set ", args4[0]]); + const _63: string = rs.fmtFormat(["set ", (f: rs.Formatter) => rs.u32Display(part, f)]); rs.drop(_70); Log.note(log, _63); const queue: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; @@ -503,8 +491,7 @@ export function drained(log: Log.Log, id: rs.u32): void { g2[Symbol.dispose](); return _06; }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["drain ", args6[0]])); + Log.note(log, rs.fmtFormat(["drain ", (f: rs.Formatter) => rs.u32Display(part2, f)])); rs.drop(range); const _113: rs.usize = queue.n; const _119: rs.Iter = rs.dequeIntoIter(queue, rs.drop); @@ -513,8 +500,8 @@ export function drained(log: Log.Log, id: rs.u32): void { g3[Symbol.dispose](); return _07; }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_113, f), (f: rs.Formatter) => rs.u32Display(_116, f)]; - const _109: string = rs.fmtFormat(["queue ", args8[0], " ", args8[1]]); + const args22 = [(f: rs.Formatter) => rs.usizeDisplay(_113, f), (f: rs.Formatter) => rs.u32Display(_116, f)]; + const _109: string = rs.fmtFormat(["queue ", args22[0], " ", args22[1]]); rs.drop(_119); Log.note(log, _109); const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; @@ -524,8 +511,7 @@ export function drained(log: Log.Log, id: rs.u32): void { const entries: rs.Iter<[Key.Key, Guard.Guard]> = rs.hashIter(map, rs.drop, rs.drop); const _145: [Key.Key, Guard.Guard] | undefined = rs.iterToOption(entries.next()); const part3 = _145 !== undefined; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - const _139: string = rs.fmtFormat(["entry ", args10[0]]); + const _139: string = rs.fmtFormat(["entry ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); lib_drop$Option_tuple2_drops_Key_model_Guard(_145); Log.note(log, _139); const map2: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; @@ -534,8 +520,7 @@ export function drained(log: Log.Log, id: rs.u32): void { rs.drop(rs.hashInsert(map2, _154, _157, rs.drop)); rs.drop(rs.hashDrain(map2, rs.drop, rs.drop)); const part4 = rs.hashLen(map2); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part4, f)]; - Log.note(log, rs.fmtFormat(["drained ", args12[0]])); + Log.note(log, rs.fmtFormat(["drained ", (f: rs.Formatter) => rs.usizeDisplay(part4, f)])); const set2: rs.HashSet = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashSet; const _178: Key.Key = key(22); rs.hashAdd(set2, _178, rs.drop); @@ -545,8 +530,7 @@ export function drained(log: Log.Log, id: rs.u32): void { k2[Symbol.dispose](); return _08; }); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - Log.note(log, rs.fmtFormat(["taken ", args14[0]])); + Log.note(log, rs.fmtFormat(["taken ", (f: rs.Formatter) => rs.u32Display(part5, f)])); const sink: Log.Log = Log.new(); const map3: rs.HashMap = rs.hashNew() as rs.HashMap; let iterStart2: rs.u32 = 23; @@ -560,14 +544,13 @@ export function drained(log: Log.Log, id: rs.u32): void { const one: Guard.Guard | undefined = rs.iterToOption(values2.next()); const _222: rs.usize = rs.ownedCount(values2, rs.drop); const _225: boolean = one !== undefined; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_222, f), (f: rs.Formatter) => rs.fmtBool(_225, f)]; - Log.note(log, rs.fmtFormat(["rest ", args16[0], " ", args16[1]])); + const args26 = [(f: rs.Formatter) => rs.usizeDisplay(_222, f), (f: rs.Formatter) => rs.fmtBool(_225, f)]; + Log.note(log, rs.fmtFormat(["rest ", args26[0], " ", args26[1]])); rs.drop(one); const part6 = rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(Log.text(sink)))), (_2: rs.u8): rs.u32 => { return _2 as rs.u32; }), rs.u32Add, 0); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Log.note(log, rs.fmtFormat(["sink ", args18[0]])); + Log.note(log, rs.fmtFormat(["sink ", (f: rs.Formatter) => rs.u32Display(part6, f)])); sink[Symbol.dispose](); rs.drop(taken); rs.hashDrop(set2, rs.drop); @@ -608,8 +591,7 @@ export function extended(log: Log.Log, id: rs.u32): void { }, rs.drop); rs.iterExtend(list, _35, "next", 8); const part = list.items.length; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; - Log.note(log, rs.fmtFormat(["list ", args2[0]])); + Log.note(log, rs.fmtFormat(["list ", (f: rs.Formatter) => rs.usizeDisplay(part, f)])); const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; const _71: Key.Key = key(8); const _74: Guard.Guard = guard(8); @@ -631,8 +613,8 @@ export function extended(log: Log.Log, id: rs.u32): void { rs.hashExtendKeys(set, rs.vecIntoIter(v5, rs.drop), rs.drop, "fold", 117440512); const _125: rs.usize = rs.hashLen(map); const _128: rs.usize = rs.hashLen(set); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_125, f), (f: rs.Formatter) => rs.usizeDisplay(_128, f)]; - Log.note(log, rs.fmtFormat(["hashed ", args4[0], " ", args4[1]])); + const args8 = [(f: rs.Formatter) => rs.usizeDisplay(_125, f), (f: rs.Formatter) => rs.usizeDisplay(_128, f)]; + Log.note(log, rs.fmtFormat(["hashed ", args8[0], " ", args8[1]])); const tree: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; const _138: Key.Key = key(12); const _141: Guard.Guard = guard(12); @@ -666,8 +648,8 @@ export function extended(log: Log.Log, id: rs.u32): void { const _221: rs.usize = rs.btreeLen(tree); const _224: rs.usize = rs.btreeLen(ordered); const _227: rs.usize = queue.n; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_221, f), (f: rs.Formatter) => rs.usizeDisplay(_224, f), (f: rs.Formatter) => rs.usizeDisplay(_227, f)]; - Log.note(log, rs.fmtFormat(["ordered ", args6[0], " ", args6[1], " ", args6[2]])); + const args9 = [(f: rs.Formatter) => rs.usizeDisplay(_221, f), (f: rs.Formatter) => rs.usizeDisplay(_224, f), (f: rs.Formatter) => rs.usizeDisplay(_227, f)]; + Log.note(log, rs.fmtFormat(["ordered ", args9[0], " ", args9[1], " ", args9[2]])); rs.dequeDrop(queue, rs.drop); rs.btreeDrop(ordered, rs.drop); rs.btreeDrop(tree, rs.drop, rs.drop); @@ -710,29 +692,26 @@ export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _16: rs.u8 = rs.u8Rem(arg, 9); if (_16 === 0) { const part8 = rs.iterEq(rs.vecIntoIter(keys(rs.sliceFrom([1, 2, 3])), rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([1, 5, 6])), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), true, true, true, undefined, rs.drop, rs.drop); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; - Log.note(log, rs.fmtFormat(["eq ", args2[0]])); + Log.note(log, rs.fmtFormat(["eq ", (f: rs.Formatter) => rs.fmtBool(part8, f)])); } else if (_16 === 1) { const eq2: boolean = rs.iterEq(rs.vecIntoIter(keys(rs.sliceFrom([1, 2, 3])), rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([1, 2])), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), true, true, true, undefined, rs.drop, rs.drop); const ne: boolean = !rs.iterEq(rs.vecIntoIter(keys(rs.sliceFrom([4])), rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([4, 5])), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), true, true, true, undefined, rs.drop, rs.drop); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(eq2, f), (f: rs.Formatter) => rs.fmtBool(ne, f)]; - Log.note(log, rs.fmtFormat(["eq ", args4[0], " ", args4[1]])); + const args26 = [(f: rs.Formatter) => rs.fmtBool(eq2, f), (f: rs.Formatter) => rs.fmtBool(ne, f)]; + Log.note(log, rs.fmtFormat(["eq ", args26[0], " ", args26[1]])); } else if (_16 === 2) { const part7 = rs.iterEq(rs.iterFilter(rs.vecIntoIter(keys(rs.sliceFrom([1, 2, 3])), rs.drop), (_210: Key.Key): boolean => { return true; }, rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([1, 2])), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), undefined, true, true, undefined, rs.drop, rs.drop); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part7, f)]; - Log.note(log, rs.fmtFormat(["eq ", args6[0]])); + Log.note(log, rs.fmtFormat(["eq ", (f: rs.Formatter) => rs.fmtBool(part7, f)])); } else if (_16 === 3) { const part6 = rs.iterCmp(rs.vecIntoIter(keys(rs.sliceFrom([1, 2])), rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([1, 2, 4])), rs.drop), rs.consuming(Key.cmp$cmp_Ord, rs.drop, rs.drop), true, true, undefined, rs.drop, rs.drop); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part6, f)]; - Log.note(log, rs.fmtFormat(["cmp ", args8[0]])); + Log.note(log, rs.fmtFormat(["cmp ", (f: rs.Formatter) => rs.i8Display(part6, f)])); } else if (_16 === 4) { const cmp2: rs.Ordering | undefined = rs.iterCmp(rs.vecIntoIter(keys(rs.sliceFrom([1, 3, 5])), rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([1, 2])), rs.drop), rs.consuming(Key.partialCmp$cmp_PartialOrd, rs.drop, rs.drop), true, true, undefined, rs.drop, rs.drop); const lt: boolean = rs.iterCmp(rs.vecIntoIter(keys(rs.sliceFrom([6])), rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([6])), rs.drop), rs.consuming(Key.partialCmp$cmp_PartialOrd, rs.drop, rs.drop), true, true, undefined, rs.drop, rs.drop) === -1; const _153: rs.i8 = _12(cmp2); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(_153, f), (f: rs.Formatter) => rs.fmtBool(lt, f)]; - Log.note(log, rs.fmtFormat(["partial_cmp ", args10[0], " ", args10[1]])); + const args23 = [(f: rs.Formatter) => rs.i8Display(_153, f), (f: rs.Formatter) => rs.fmtBool(lt, f)]; + Log.note(log, rs.fmtFormat(["partial_cmp ", args23[0], " ", args23[1]])); } else if (_16 === 5) { const _163: rs.Iter = rs.vecIntoIter(keys(rs.sliceFrom([1, 2])), rs.drop); const _169: rs.Vec = guards(rs.sliceFrom([1, 2, 5])); @@ -748,8 +727,7 @@ export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured3[Symbol.dispose](); }), true, true, true, rs.drop, rs.drop); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part5, f)]; - Log.note(log, rs.fmtFormat(["cmp_by ", args12[0]])); + Log.note(log, rs.fmtFormat(["cmp_by ", (f: rs.Formatter) => rs.i8Display(part5, f)])); } else if (_16 === 6) { const _188: rs.Iter = rs.vecIntoIter(keys(rs.sliceFrom([1, 2])), rs.drop); const _194: rs.Vec = guards(rs.sliceFrom([1])); @@ -764,8 +742,7 @@ export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured2[Symbol.dispose](); }), true, true, true, true, rs.drop, rs.drop); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; - Log.note(log, rs.fmtFormat(["eq_by ", args14[0]])); + Log.note(log, rs.fmtFormat(["eq_by ", (f: rs.Formatter) => rs.fmtBool(part4, f)])); } else if (_16 === 7) { const _211: rs.Iter = rs.vecIntoIter(keys(rs.sliceFrom([1, 2, 3])), rs.drop); const _217: rs.Vec = guards(rs.sliceFrom([1])); @@ -782,8 +759,7 @@ export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured[Symbol.dispose](); }), true, true, true, rs.drop, rs.drop); const part3 = _12(part2); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part3, f)]; - Log.note(log, rs.fmtFormat(["partial_cmp_by ", args16[0]])); + Log.note(log, rs.fmtFormat(["partial_cmp_by ", (f: rs.Formatter) => rs.i8Display(part3, f)])); } else { const _238: [rs.Iter, rs.Iter] = [rs.vecIntoIter(keys(rs.sliceFrom([1, 2, 3])), rs.drop), rs.vecIntoIter(keys(rs.sliceFrom([1, 4, 5])), rs.drop)]; const a: rs.Iter = _238[0]; @@ -791,8 +767,7 @@ export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _252: rs.Iter = a; const _254: rs.Iter = b; const part = rs.iterCmp(rs.iterBorrow(_252), rs.iterBorrow(_254), rs.consuming(Key.cmp$cmp_Ord, rs.drop, rs.drop), undefined, undefined, undefined, rs.drop, rs.drop); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part, f)]; - Log.note(log, rs.fmtFormat(["cmp ", args18[0]])); + Log.note(log, rs.fmtFormat(["cmp ", (f: rs.Formatter) => rs.i8Display(part, f)])); rs.drop(b); rs.drop(a); } diff --git a/ts/fixtures/task/expected/drops/lists.ts b/ts/fixtures/task/expected/drops/lists.ts index 555c2d3e7..ab19c0eb2 100644 --- a/ts/fixtures/task/expected/drops/lists.ts +++ b/ts/fixtures/task/expected/drops/lists.ts @@ -41,22 +41,19 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, "popped back"); rs.drop(rs.listPopFront(l)); const part11 = ids(id, l); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11)]; - Log.note(log, rs.fmtFormat(["left ", args2[0]])); + Log.note(log, rs.fmtFormat(["left ", (f: rs.Formatter) => rs.fmtPad(f, part11)])); rs.listDrop(l, rs.drop); } else if (_8 === 1) { let l2: rs.LinkedList = keys(rs.sliceFrom([1, 2, 3])); rs.listClear(l2, rs.drop); const part9 = l2.n; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part9, f)]; - Log.note(log, rs.fmtFormat(["cleared ", args4[0]])); + Log.note(log, rs.fmtFormat(["cleared ", (f: rs.Formatter) => rs.usizeDisplay(part9, f)])); rs.listPushBack(l2, key(4)); const _81: rs.LinkedList = keys(rs.sliceFrom([5, 6])); rs.listDrop(l2, rs.drop); l2 = _81; const part10 = ids(id, l2); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part10)]; - Log.note(log, rs.fmtFormat(["replaced ", args6[0]])); + Log.note(log, rs.fmtFormat(["replaced ", (f: rs.Formatter) => rs.fmtPad(f, part10)])); rs.listDrop(l2, rs.drop); } else if (_8 === 2) { const it: rs.Iter = rs.listIter(keys(rs.sliceFrom([1, 2, 3, 4, 5, 6])), rs.drop); @@ -64,15 +61,13 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(rs.iterToOption(it.next())); rs.drop(rs.iterToOption(it.nextBack())); const part7 = it.len(); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; - Log.note(log, rs.fmtFormat(["len ", args8[0]])); + Log.note(log, rs.fmtFormat(["len ", (f: rs.Formatter) => rs.usizeDisplay(part7, f)])); const part8 = option_map$0bmexgo(rs.iterNth(it, 1, rs.drop), (k6: Key.Key): rs.u32 => { const _09: rs.u32 = rs.u32Sub(k6.id, id); k6[Symbol.dispose](); return _09; }); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["nth ", args10[0]])); + Log.note(log, rs.fmtFormat(["nth ", (f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)])); rs.drop(it); } else if (_8 === 3) { const l3: rs.LinkedList = keys(rs.sliceFrom([1, 2, 3, 4, 5])); @@ -83,8 +78,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _160: string = ids(id, back); const _163: string = ids(id, none); const _166: string = ids(id, all); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _157), (f: rs.Formatter) => rs.fmtPad(f, _160), (f: rs.Formatter) => rs.fmtPad(f, _163), (f: rs.Formatter) => rs.fmtPad(f, _166)]; - Log.note(log, rs.fmtFormat(["split ", args12[0], " ", args12[1], " ", args12[2], " ", args12[3]])); + const args43 = [(f: rs.Formatter) => rs.fmtPad(f, _157), (f: rs.Formatter) => rs.fmtPad(f, _160), (f: rs.Formatter) => rs.fmtPad(f, _163), (f: rs.Formatter) => rs.fmtPad(f, _166)]; + Log.note(log, rs.fmtFormat(["split ", args43[0], " ", args43[1], " ", args43[2], " ", args43[3]])); rs.listDrop(all, rs.drop); Log.note(log, "front dropped"); rs.listDrop(back, rs.drop); @@ -96,8 +91,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.listAppend(l4, other); const _199: string = ids(id, l4); const _202: rs.usize = other.n; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _199), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; - Log.note(log, rs.fmtFormat(["appended ", args14[0], " ", args14[1]])); + const args41 = [(f: rs.Formatter) => rs.fmtPad(f, _199), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; + Log.note(log, rs.fmtFormat(["appended ", args41[0], " ", args41[1]])); const _211: Key.Key = key(5); rs.listPushBack(other, _211); rs.listAppend(l4, other); @@ -107,8 +102,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.listAppend(empty, l4); const _236: string = ids(id, empty); const _239: rs.usize = l4.n; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _236), (f: rs.Formatter) => rs.usizeDisplay(_239, f)]; - Log.note(log, rs.fmtFormat(["moved ", args16[0], " ", args16[1]])); + const args42 = [(f: rs.Formatter) => rs.fmtPad(f, _236), (f: rs.Formatter) => rs.usizeDisplay(_239, f)]; + Log.note(log, rs.fmtFormat(["moved ", args42[0], " ", args42[1]])); rs.listDrop(empty, rs.drop); rs.listDrop(l4, rs.drop); } else if (_8 === 5) { @@ -116,13 +111,11 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const source: rs.LinkedList = keys(rs.sliceFrom([5, 6])); rs.listCloneFrom(l5, source, Key.clone$Clone, rs.drop); const part5 = ids(id, l5); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5)]; - Log.note(log, rs.fmtFormat(["cloned ", args18[0]])); + Log.note(log, rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part5)])); const longer: rs.LinkedList = keys(rs.sliceFrom([7, 8, 9])); rs.listCloneFrom(l5, longer, Key.clone$Clone, rs.drop); const part6 = ids(id, l5); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part6)]; - Log.note(log, rs.fmtFormat(["cloned ", args20[0]])); + Log.note(log, rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part6)])); rs.listDrop(longer, rs.drop); rs.listDrop(source, rs.drop); rs.listDrop(l5, rs.drop); @@ -133,8 +126,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { }), "next", 12); const _307: rs.usize = taken.items.length; const _310: string = ids(id, l6); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_307, f), (f: rs.Formatter) => rs.fmtPad(f, _310)]; - Log.note(log, rs.fmtFormat(["taken ", args22[0], " left ", args22[1]])); + const args35 = [(f: rs.Formatter) => rs.usizeDisplay(_307, f), (f: rs.Formatter) => rs.fmtPad(f, _310)]; + Log.note(log, rs.fmtFormat(["taken ", args35[0], " left ", args35[1]])); rs.dropVec(taken); const first: Key.Key | undefined = rs.iterToOption(rs.listExtractIf(l6, (k3: Key.Key): boolean => { return rs.u32Sub(k3.id, id) > 1; @@ -143,8 +136,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { return rs.u32Sub(k4.id, id); }); const _336: string = ids(id, l6); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_330, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtPad(f, _336)]; - Log.note(log, rs.fmtFormat(["first ", args24[0], " left ", args24[1]])); + const args36 = [(f: rs.Formatter) => rs.fmtOption(_330, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtPad(f, _336)]; + Log.note(log, rs.fmtFormat(["first ", args36[0], " left ", args36[1]])); const captured = key(9); const it2: rs.Iter = rs.listExtractIf(l6, rs.closure((k5: Key.Key): boolean => { return k5.id > captured.id; @@ -153,14 +146,12 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { })); const _357: Key.Key | undefined = rs.iterToOption(it2.next()); const part3 = _357 === undefined; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - const _351: string = rs.fmtFormat(["none ", args26[0]]); + const _351: string = rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); rs.drop(_357); Log.note(log, _351); rs.drop(it2); const part4 = ids(id, l6); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; - Log.note(log, rs.fmtFormat(["kept ", args28[0]])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.fmtPad(f, part4)])); rs.drop(first); rs.listDrop(l6, rs.drop); } else { @@ -168,15 +159,13 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(rs.iterToOption(it3.next())); const copy: rs.Iter = it3.clone({ v: Key.clone$Clone }); const part = rs.ownedCount(it3, rs.drop); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; - Log.note(log, rs.fmtFormat(["counted ", args30[0]])); + Log.note(log, rs.fmtFormat(["counted ", (f: rs.Formatter) => rs.usizeDisplay(part, f)])); const part2 = option_map$0bmexgo(rs.ownedLast(copy, rs.drop), (k: Key.Key): rs.u32 => { const _04: rs.u32 = rs.u32Sub(k.id, id); k[Symbol.dispose](); return _04; }); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["last ", args32[0]])); + Log.note(log, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)])); } } diff --git a/ts/fixtures/task/expected/drops/objects.ts b/ts/fixtures/task/expected/drops/objects.ts index 27fbf5182..145528ae7 100644 --- a/ts/fixtures/task/expected/drops/objects.ts +++ b/ts/fixtures/task/expected/drops/objects.ts @@ -41,37 +41,32 @@ export function boxed(log: Log.Log, id: rs.u32): void { }), 0, (a0: rs.u32, a1: rs.u32): rs.u32 => { return rs.u32WrappingAdd(a0, a1); }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["ids ", args2[0]])); + Log.note(log, rs.fmtFormat(["ids ", (f: rs.Formatter) => rs.u32Display(part, f)])); let slot: Part.Part = new of$model_Guard(guard(6)); const part2 = slot.id$Part(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["slot ", args4[0]])); + Log.note(log, rs.fmtFormat(["slot ", (f: rs.Formatter) => rs.u32Display(part2, f)])); const _77: Held.Held = { tag: "Empty" }; rs.drop(slot); slot = new of$drops_Held(_77); const part3 = slot.id$Part(); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["slot ", args6[0]])); + Log.note(log, rs.fmtFormat(["slot ", (f: rs.Formatter) => rs.u32Display(part3, f)])); const _91: rs.u32 = 7; rs.drop(slot); slot = new of$u32(_91); const part4 = first.take$Part(); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["took ", args8[0]])); + Log.note(log, rs.fmtFormat(["took ", (f: rs.Formatter) => rs.u32Display(part4, f)])); const part5 = option_map$0aiphi9(rs.vecPop(parts), (a02: Part.Part): rs.u32 => { return a02.take$Part(); }); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["last ", args10[0]])); + Log.note(log, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)])); const kept: Part.Part | undefined = new of$model_Guard(guard(7)); rs.dropVec(parts); const _130: rs.u32 = option_mapOr$1uf7d6r(kept, 0, (p2: Part.Part): rs.u32 => { return p2.id$Part(); }); const _134: rs.u32 = slot.id$Part(); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_130, f), (f: rs.Formatter) => rs.u32Display(_134, f)]; - Log.note(log, rs.fmtFormat(["kept ", args12[0], " ", args12[1]])); + const args18 = [(f: rs.Formatter) => rs.u32Display(_130, f), (f: rs.Formatter) => rs.u32Display(_134, f)]; + Log.note(log, rs.fmtFormat(["kept ", args18[0], " ", args18[1]])); rs.drop(kept); rs.drop(slot); } @@ -91,13 +86,12 @@ export function shared(log: Log.Log, id: rs.u32): void { const second: rs.Arc = new rs.ArcDyn(_17, new of$drops_Held(_17.value)); const _25: rs.u32 = first.value.id$Part(); const _29: rs.usize = held.strong; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_25, f), (f: rs.Formatter) => rs.usizeDisplay(_29, f)]; - Log.note(log, rs.fmtFormat(["held ", args2[0], " ", args2[1]])); + const args13 = [(f: rs.Formatter) => rs.u32Display(_25, f), (f: rs.Formatter) => rs.usizeDisplay(_29, f)]; + Log.note(log, rs.fmtFormat(["held ", args13[0], " ", args13[1]])); rs.arcDrop(held, lib_drop$drops_Held); first[Symbol.dispose](); const part = second.strong; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; - Log.note(log, rs.fmtFormat(["count ", args4[0]])); + Log.note(log, rs.fmtFormat(["count ", (f: rs.Formatter) => rs.usizeDisplay(part, f)])); const kept: rs.Arc = new rs.Arc(guard(3)); const wrap: rs.Arc> = new rs.Arc(new Wrap.Wrap(rs.u32Add(id, 4), Log.clone$Clone(log), 0)); const parts: rs.Vec> = new rs.Vec(); @@ -116,8 +110,7 @@ export function shared(log: Log.Log, id: rs.u32): void { }), 0, (a0: rs.u32, a1: rs.u32): rs.u32 => { return rs.u32WrappingAdd(a0, a1); }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["ids ", args6[0]])); + Log.note(log, rs.fmtFormat(["ids ", (f: rs.Formatter) => rs.u32Display(part2, f)])); rs.arcDrop(wrap, lib_drop$drops_Wrap_u32); rs.dropVec(parts); const part3 = option_mapOr$1yfuqyd(rs.weakUpgrade(weak), 0, (p2: rs.Arc): rs.u32 => { @@ -125,13 +118,11 @@ export function shared(log: Log.Log, id: rs.u32): void { p2[Symbol.dispose](); return _04; }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["weak ", args8[0]])); + Log.note(log, rs.fmtFormat(["weak ", (f: rs.Formatter) => rs.u32Display(part3, f)])); kept[Symbol.dispose](); const _122: rs.Arc | undefined = rs.weakUpgrade(weak); const part4 = _122 === undefined; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; - const _116: string = rs.fmtFormat(["gone ", args10[0]]); + const _116: string = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part4, f)]); rs.drop(_122); Log.note(log, _116); const _132: rs.Arc> = new rs.Arc(new sharedFuture$closure1(guard(6))); @@ -139,8 +130,7 @@ export function shared(log: Log.Log, id: rs.u32): void { const other: rs.Arc> = rs.arcClone(future); future[Symbol.dispose](); const part5 = other.strong; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; - Log.note(log, rs.fmtFormat(["future ", args12[0]])); + Log.note(log, rs.fmtFormat(["future ", (f: rs.Formatter) => rs.usizeDisplay(part5, f)])); other[Symbol.dispose](); weak[Symbol.dispose](); } @@ -195,22 +185,19 @@ export function anys(log: Log.Log, id: rs.u32): void { return Guard.id(g2); }).ok; }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtBool)]; - Log.note(log, rs.fmtFormat(["last ", args2[0]])); + Log.note(log, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtBool)])); lib_drop$Option_Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(last); const _53: Any.Any = rs.vecRemove(boxes, 1); const held: rs.Result = _53 instanceof of$model_Guard ? rs.Ok(_53.v) : rs.Err(_53); const part2 = !held.ok; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; - Log.note(log, rs.fmtFormat(["held ", args4[0]])); + Log.note(log, rs.fmtFormat(["held ", (f: rs.Formatter) => rs.fmtBool(part2, f)])); let slot: Any.Any = new of$model_Guard(guard(5)); const _72: Held.Held = { tag: "Empty" }; rs.drop(slot); slot = new of$drops_Held(_72); const _81: Any.Any = slot; const arg = _81 instanceof of$drops_Held || _81 instanceof ofPlace$drops_Held; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg, f)]; - Log.note(log, rs.fmtFormat(["slot ", args6[0]])); + Log.note(log, rs.fmtFormat(["slot ", (f: rs.Formatter) => rs.fmtBool(arg, f)])); lib_drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(held); rs.dropVec(boxes); const _90: rs.Arc<[Guard.Guard, Guard.Guard]> = new rs.Arc([guard(6), guard(7)] as [Guard.Guard, Guard.Guard]); @@ -218,23 +205,20 @@ export function anys(log: Log.Log, id: rs.u32): void { const clones: rs.Arc[] = [rs.arcClone(hold), rs.arcClone(hold)]; hold[Symbol.dispose](); const part3 = clones[0].strong; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; - Log.note(log, rs.fmtFormat(["clones ", args8[0]])); + Log.note(log, rs.fmtFormat(["clones ", (f: rs.Formatter) => rs.usizeDisplay(part3, f)])); const a: rs.Arc = clones[0]; const b: rs.Arc = clones[1]; const typed: rs.Arc<[Guard.Guard, Guard.Guard]> | undefined = ok$1xmzatr(rs.arcDowncast(a, of$tuple2_model_Guard_model_Guard, (object) => object.v)); const part4 = option_map$0chhxcr(typed, (t: rs.Arc<[Guard.Guard, Guard.Guard]>): [rs.u32, rs.usize] => { return [Guard.id(t.value[0]), t.strong] as [rs.u32, rs.usize]; }); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u32, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["typed ", args10[0]])); + Log.note(log, rs.fmtFormat(["typed ", (f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u32, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f))])); lib_drop$Option_sync_Arc_tuple2_model_Guard_model_Guard(typed); Log.note(log, "dropped"); b[Symbol.dispose](); const _149: Any.Any = slot; const part5 = (_149 instanceof of$drops_Held ? _149.v : _149 instanceof ofPlace$drops_Held ? _149.v.v : undefined) !== undefined; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; - Log.note(log, rs.fmtFormat(["slot ", args12[0]])); + Log.note(log, rs.fmtFormat(["slot ", (f: rs.Formatter) => rs.fmtBool(part5, f)])); rs.drop(slot); } @@ -266,8 +250,7 @@ export function fns(log: Log.Log, id: rs.u32): void { captured2[Symbol.dispose](); }); const part = moved(); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["moved ", args2[0]])); + Log.note(log, rs.fmtFormat(["moved ", (f: rs.Formatter) => rs.u32Display(part, f)])); rs.drop(uncalled); const captured3 = guard(3); const part2 = rs.closure((): rs.u32 => { @@ -277,16 +260,14 @@ export function fns(log: Log.Log, id: rs.u32): void { }, (): void => { captured3[Symbol.dispose](); })(); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["once ", args4[0]])); + Log.note(log, rs.fmtFormat(["once ", (f: rs.Formatter) => rs.u32Display(part2, f)])); const captured4 = guard(4); const part3 = rs.once(rs.closure((): rs.u32 => { return rs.u32Add(Guard.id(captured4), 1); }, (): void => { captured4[Symbol.dispose](); }))(); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["up ", args6[0]])); + Log.note(log, rs.fmtFormat(["up ", (f: rs.Formatter) => rs.u32Display(part3, f)])); const captured5 = guard(5); let slot: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured5); @@ -294,8 +275,7 @@ export function fns(log: Log.Log, id: rs.u32): void { captured5[Symbol.dispose](); }); const part4 = slot(); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["slot ", args8[0]])); + Log.note(log, rs.fmtFormat(["slot ", (f: rs.Formatter) => rs.u32Display(part4, f)])); const captured6 = guard(6); const _88: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured6); @@ -305,8 +285,7 @@ export function fns(log: Log.Log, id: rs.u32): void { rs.drop(slot); slot = _88; const part5 = slot(); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - Log.note(log, rs.fmtFormat(["slot ", args10[0]])); + Log.note(log, rs.fmtFormat(["slot ", (f: rs.Formatter) => rs.u32Display(part5, f)])); const _104: [Guard.Guard, Guard.Guard] = [guard(7), guard(8)]; const g: Guard.Guard = _104[0]; const h: Guard.Guard = _104[1]; @@ -323,8 +302,7 @@ export function fns(log: Log.Log, id: rs.u32): void { captured8[Symbol.dispose](); })]); const part6 = rs.u32Add(list.items[rs.idx(list.items, 1)](), list.items[rs.idx(list.items, 0)]()); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Log.note(log, rs.fmtFormat(["list ", args12[0]])); + Log.note(log, rs.fmtFormat(["list ", (f: rs.Formatter) => rs.u32Display(part6, f)])); rs.dropVec(list); const captured9 = guard(9); const _143: rs.Arc<() => rs.u32> = new rs.Arc(rs.closure((): rs.u32 => { @@ -336,12 +314,10 @@ export function fns(log: Log.Log, id: rs.u32): void { const other: rs.Arc<() => rs.u32> = rs.arcClone(shared); shared[Symbol.dispose](); const part7 = other.value(); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["shared ", args14[0]])); + Log.note(log, rs.fmtFormat(["shared ", (f: rs.Formatter) => rs.u32Display(part7, f)])); other[Symbol.dispose](); const part8 = slot(); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; - Log.note(log, rs.fmtFormat(["slot ", args16[0]])); + Log.note(log, rs.fmtFormat(["slot ", (f: rs.Formatter) => rs.u32Display(part8, f)])); const captured10 = guard(10); const lent: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured10); @@ -350,20 +326,17 @@ export function fns(log: Log.Log, id: rs.u32): void { }); const boxed: () => rs.u32 = rs.lent(lent); const part9 = boxed(); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; - Log.note(log, rs.fmtFormat(["lent ", args18[0]])); + Log.note(log, rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.u32Display(part9, f)])); rs.drop(boxed); const part10 = lent(); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; - Log.note(log, rs.fmtFormat(["lent ", args20[0]])); + Log.note(log, rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.u32Display(part10, f)])); const captured11 = guard(11); const part11 = rs.once(rs.closure((): rs.u32 => { return Guard.id(captured11); }, (): void => { captured11[Symbol.dispose](); }))(); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; - Log.note(log, rs.fmtFormat(["outer ", args22[0]])); + Log.note(log, rs.fmtFormat(["outer ", (f: rs.Formatter) => rs.u32Display(part11, f)])); rs.drop(lent); const captured12 = guard(12); const _230: rs.Arc<() => rs.u32> = new rs.Arc(rs.closure((): rs.u32 => { @@ -377,8 +350,7 @@ export function fns(log: Log.Log, id: rs.u32): void { shared2[Symbol.dispose](); up3[Symbol.dispose](); const part12 = again.strong; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part12, f)]; - Log.note(log, rs.fmtFormat(["up ", args24[0]])); + Log.note(log, rs.fmtFormat(["up ", (f: rs.Formatter) => rs.usizeDisplay(part12, f)])); again[Symbol.dispose](); Log.note(log, "gone"); const _257: [Guard.Guard, Guard.Guard] = [guard(13), guard(14)]; @@ -390,16 +362,14 @@ export function fns(log: Log.Log, id: rs.u32): void { }, (): void => { captured13[Symbol.dispose](); })); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; - Log.note(log, rs.fmtFormat(["run ", args26[0]])); + Log.note(log, rs.fmtFormat(["run ", (f: rs.Formatter) => rs.u32Display(part13, f)])); const captured14 = o; const part14 = run$boxed_Box_drops_objects_fns_closure22(rs.closure((): rs.u32 => { return Guard.id(captured14); }, (): void => { captured14[Symbol.dispose](); })); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part14, f)]; - Log.note(log, rs.fmtFormat(["run ", args28[0]])); + Log.note(log, rs.fmtFormat(["run ", (f: rs.Formatter) => rs.u32Display(part14, f)])); Log.note(log, "ran"); const _296: [Guard.Guard, Guard.Guard] = [guard(15), guard(16)]; const p: Guard.Guard = _296[0]; @@ -409,8 +379,7 @@ export function fns(log: Log.Log, id: rs.u32): void { }, (): void => { captured15[Symbol.dispose](); })); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part15, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["map ", args30[0]])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtOption(part15, f, rs.u32Debug)])); const captured16 = guard(18); const scale: (a0: rs.u32) => rs.u32 = rs.closure((x3: rs.u32): rs.u32 => { return rs.u32Mul(x3, Guard.id(captured16)); @@ -418,8 +387,7 @@ export function fns(log: Log.Log, id: rs.u32): void { captured16[Symbol.dispose](); }); const part16 = rs.iterSum(rs.iterMap(rs.iterSlice([1, 2]), scale), rs.u32Add, 0, true); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part16, f)]; - Log.note(log, rs.fmtFormat(["sum ", args32[0]])); + Log.note(log, rs.fmtFormat(["sum ", (f: rs.Formatter) => rs.u32Display(part16, f)])); const captured17 = guard(17); const init: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured17); @@ -434,11 +402,9 @@ export function fns(log: Log.Log, id: rs.u32): void { }); const cell: rs.OnceCell = new rs.OnceCell(undefined); const part17 = rs.onceGetOrInit(cell, rs.once(init), rs.drop); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part17, f)]; - Log.note(log, rs.fmtFormat(["cell ", args34[0]])); + Log.note(log, rs.fmtFormat(["cell ", (f: rs.Formatter) => rs.u32Display(part17, f)])); const part18 = rs.onceGetOrInit(cell, rs.once(unused), rs.drop); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part18, f)]; - Log.note(log, rs.fmtFormat(["cell ", args36[0]])); + Log.note(log, rs.fmtFormat(["cell ", (f: rs.Formatter) => rs.u32Display(part18, f)])); const _376: [Guard.Guard, Guard.Guard] = [guard(19), guard(20)]; const u: Guard.Guard = _376[0]; const v: Guard.Guard = _376[1]; @@ -461,16 +427,14 @@ export function fns(log: Log.Log, id: rs.u32): void { rs.drop(fill); } const part19 = rs.place(() => lazy as rs.u32, (value4) => (lazy as rs.u32) = value4); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part19.v, f)]; - Log.note(log, rs.fmtFormat(["lazy ", args38[0]])); + Log.note(log, rs.fmtFormat(["lazy ", (f: rs.Formatter) => rs.u32Display(part19.v, f)])); if (lazy === undefined) { lazy = rs.callOnce(skip); } else { rs.drop(skip); } const part20 = rs.place(() => lazy as rs.u32, (value5) => (lazy as rs.u32) = value5); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part20.v, f)]; - Log.note(log, rs.fmtFormat(["lazy ", args40[0]])); + Log.note(log, rs.fmtFormat(["lazy ", (f: rs.Formatter) => rs.u32Display(part20.v, f)])); const captured21 = guard(21); const f2: (a0: Guard.Guard) => rs.u32 = rs.closure((g2: Guard.Guard): rs.u32 => { const _021: rs.u32 = rs.u32Add(Guard.id(g2), Guard.id(captured21)); @@ -481,17 +445,13 @@ export function fns(log: Log.Log, id: rs.u32): void { }); const borrowed: (a0: Guard.Guard) => rs.u32 = f2; const part21 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(22), guard(23)]), rs.drop), rs.lent(borrowed)), rs.u32Add, 0, true); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part21, f)]; - Log.note(log, rs.fmtFormat(["borrowed ", args42[0]])); + Log.note(log, rs.fmtFormat(["borrowed ", (f: rs.Formatter) => rs.u32Display(part21, f)])); const part22 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(24)]), rs.drop), rs.lent(f2)), rs.u32Add, 0, true); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part22, f)]; - Log.note(log, rs.fmtFormat(["by ref ", args44[0]])); + Log.note(log, rs.fmtFormat(["by ref ", (f: rs.Formatter) => rs.u32Display(part22, f)])); const part23 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(26)]), rs.drop), rs.lent(borrowed)), rs.u32Add, 0, true); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part23, f)]; - Log.note(log, rs.fmtFormat(["twice ", args46[0]])); + Log.note(log, rs.fmtFormat(["twice ", (f: rs.Formatter) => rs.u32Display(part23, f)])); const part24 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(27)]), rs.drop), rs.lent(f2)), rs.u32Add, 0, true); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part24, f)]; - Log.note(log, rs.fmtFormat(["boxed ", args48[0]])); + Log.note(log, rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.u32Display(part24, f)])); const captured22 = guard(28); let h2: (a0: Guard.Guard) => rs.u32 = rs.closure((g3: Guard.Guard): rs.u32 => { const _022: rs.u32 = rs.u32Add(Guard.id(g3), Guard.id(captured22)); @@ -501,18 +461,15 @@ export function fns(log: Log.Log, id: rs.u32): void { captured22[Symbol.dispose](); }); const part25 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(29)]), rs.drop), rs.lent(rs.place(() => h2, (value6) => h2 = value6).v)), rs.u32Add, 0, true); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part25, f)]; - Log.note(log, rs.fmtFormat(["mut ", args50[0]])); + Log.note(log, rs.fmtFormat(["mut ", (f: rs.Formatter) => rs.u32Display(part25, f)])); let p2: (a0: rs.u32) => rs.u32 = (a0: rs.u32): rs.u32 => { return a0; }; const part26 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([1, 2])), rs.place(() => p2, (value7) => p2 = value7).v), rs.u32Add, 0); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part26, f)]; - Log.note(log, rs.fmtFormat(["pointer ", args52[0]])); + Log.note(log, rs.fmtFormat(["pointer ", (f: rs.Formatter) => rs.u32Display(part26, f)])); const part27 = guard(25); const part28 = f2(part27); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part28, f)]; - Log.note(log, rs.fmtFormat(["kept ", args54[0]])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.u32Display(part28, f)])); rs.drop(h2); rs.drop(f2); rs.drop(slot); diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts index 8a678c2d0..c1c162b7a 100644 --- a/ts/fixtures/task/expected/drops/once.ts +++ b/ts/fixtures/task/expected/drops/once.ts @@ -19,28 +19,24 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _19: Guard.Guard = guard(1); const _17: rs.Result = rs.onceSet(cell, _19); const part13 = _17.ok; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part13, f)]; - const _11: string = rs.fmtFormat(["set ", args2[0]]); + const _11: string = rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtBool(part13, f)]); lib_drop$Result_unit_model_Guard(_17); Log.note(log, _11); const _28: Guard.Guard = guard(2); const refused: rs.Result = rs.onceSet(cell, _28); const part14 = !refused.ok; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part14, f)]; - Log.note(log, rs.fmtFormat(["refused ", args4[0]])); + Log.note(log, rs.fmtFormat(["refused ", (f: rs.Formatter) => rs.fmtBool(part14, f)])); lib_drop$Result_unit_model_Guard(refused); const part15 = option_mapOr$1re20rq(cell.v, 0, (g2: Guard.Guard): rs.u32 => { return rs.u32Sub(Guard.id(g2), id); }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part15, f)]; - Log.note(log, rs.fmtFormat(["held ", args6[0]])); + Log.note(log, rs.fmtFormat(["held ", (f: rs.Formatter) => rs.u32Display(part15, f)])); cell[Symbol.dispose](); const lock: rs.OnceLock = new rs.OnceLock({ tag: "Two", _0: guard(3), _1: guard(4) } as Held.Held); const _71 = { tag: "One", _0: guard(5) } as Held.Held; lib_drop$Result_unit_drops_Held(rs.onceSet(lock, _71)); const part16 = lock.v !== undefined; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part16, f)]; - Log.note(log, rs.fmtFormat(["kept ", args8[0]])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.fmtBool(part16, f)])); lib_drop$Option_drops_Held(lock.v); } else if (_6 === 1) { const cell2: rs.OnceLock = new rs.OnceLock(undefined); @@ -54,8 +50,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured3[Symbol.dispose](); }), rs.drop)), id); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; - Log.note(log, rs.fmtFormat(["made ", args10[0]])); + Log.note(log, rs.fmtFormat(["made ", (f: rs.Formatter) => rs.u32Display(part11, f)])); const captured5 = guard(13); const captured6 = guard; const part12 = rs.u32Sub(Guard.id(rs.onceGetOrInit(cell2, rs.closure((): Guard.Guard => { @@ -66,8 +61,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured5[Symbol.dispose](); }), rs.drop)), id); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part12, f)]; - Log.note(log, rs.fmtFormat(["kept ", args12[0]])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.u32Display(part12, f)])); const other: rs.OnceCell = new rs.OnceCell(undefined); const captured7 = guard(15); const captured8 = guard; @@ -99,21 +93,19 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const made2: rs.u32 = rs.u32Sub(Guard.id(rs.onceGetOrInit(fresh, rs.once(first2), rs.drop)), id); const _160: rs.u32 = rs.u32Sub(Guard.id(rs.onceGetOrInit(fresh, rs.once(second2), rs.drop)), id); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(made2, f), (f: rs.Formatter) => rs.u32Display(_160, f)]; - Log.note(log, rs.fmtFormat(["by ref ", args14[0], " ", args14[1]])); + const args49 = [(f: rs.Formatter) => rs.u32Display(made2, f), (f: rs.Formatter) => rs.u32Display(_160, f)]; + Log.note(log, rs.fmtFormat(["by ref ", args49[0], " ", args49[1]])); fresh[Symbol.dispose](); cell2[Symbol.dispose](); } else if (_6 === 2) { const cell3: rs.OnceCell = new rs.OnceCell(guard(21)); const taken: Guard.Guard | undefined = rs.onceTake(cell3); const part8 = taken !== undefined; - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; - Log.note(log, rs.fmtFormat(["taken ", args16[0]])); + Log.note(log, rs.fmtFormat(["taken ", (f: rs.Formatter) => rs.fmtBool(part8, f)])); rs.drop(taken); const _198: Guard.Guard | undefined = rs.onceTake(cell3); const part9 = _198 === undefined; - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part9, f)]; - const _192: string = rs.fmtFormat(["empty ", args18[0]]); + const _192: string = rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtBool(part9, f)]); rs.drop(_198); Log.note(log, _192); const _206: Guard.Guard = guard(22); @@ -124,8 +116,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { g[Symbol.dispose](); return _04; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; - Log.note(log, rs.fmtFormat(["inner ", args20[0]])); + Log.note(log, rs.fmtFormat(["inner ", (f: rs.Formatter) => rs.u32Display(part10, f)])); } else if (_6 === 3) { const cell4: rs.OnceCell = new rs.OnceCell(undefined); const owned3: Guard.Guard = guard(31); @@ -149,8 +140,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); shared[Symbol.dispose](); const part6 = other2.value.sweep.v !== undefined; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; - Log.note(log, rs.fmtFormat(["swept ", args22[0]])); + Log.note(log, rs.fmtFormat(["swept ", (f: rs.Formatter) => rs.fmtBool(part6, f)])); other2[Symbol.dispose](); const v: rs.Vec> = new rs.Vec(); const _274: rs.OnceCell = new rs.OnceCell(guard(63)); @@ -161,39 +151,32 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { v.items.push(_283); const cells: rs.Vec> = v; const part7 = cells.items.length; - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; - Log.note(log, rs.fmtFormat(["cells ", args24[0]])); + Log.note(log, rs.fmtFormat(["cells ", (f: rs.Formatter) => rs.usizeDisplay(part7, f)])); rs.dropVec(cells); rs.drop(new rs.OnceLock(guard(65))); } else { const cell5: rs.OnceCell = new rs.OnceCell(rs.None); const _315: rs.Result = rs.onceSet(cell5, undefined as Guard.Guard | undefined, rs.None); const part = _315.ok; - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; - const _309: string = rs.fmtFormat(["none ", args26[0]]); + const _309: string = rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part, f)]); lib_drop$Result_unit_Option_model_Guard(_315); Log.note(log, _309); const _332: Guard.Guard | undefined = guard(71); const _330: rs.Result = rs.onceSet(cell5, _332, rs.None); const part2 = !_330.ok; - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; - const _324: string = rs.fmtFormat(["full ", args28[0]]); + const _324: string = rs.fmtFormat(["full ", (f: rs.Formatter) => rs.fmtBool(part2, f)]); lib_drop$Result_unit_Option_model_Guard(_330); Log.note(log, _324); const unit: rs.OnceLock = new rs.OnceLock(rs.None); const part3 = rs.onceSet(unit, undefined, rs.None).ok; - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - Log.note(log, rs.fmtFormat(["unit ", args30[0]])); + Log.note(log, rs.fmtFormat(["unit ", (f: rs.Formatter) => rs.fmtBool(part3, f)])); const part4 = !rs.onceSet(unit, undefined, rs.None).ok; - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; - Log.note(log, rs.fmtFormat(["again ", args32[0]])); + Log.note(log, rs.fmtFormat(["again ", (f: rs.Formatter) => rs.fmtBool(part4, f)])); const part5 = cell5.v !== rs.None; - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; - Log.note(log, rs.fmtFormat(["got ", args34[0]])); + Log.note(log, rs.fmtFormat(["got ", (f: rs.Formatter) => rs.fmtBool(part5, f)])); cell5[Symbol.dispose](); } - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(id, f)]; - Log.note(log, rs.fmtFormat(["d", args36[0], " cells done"])); + Log.note(log, rs.fmtFormat(["d", (f: rs.Formatter) => rs.u32Display(id, f), " cells done"])); } //# sourceMappingURL=once.ts.map diff --git a/ts/fixtures/task/expected/drops/orders.Ranked.ts b/ts/fixtures/task/expected/drops/orders.Ranked.ts index 040b52238..e317b7383 100644 --- a/ts/fixtures/task/expected/drops/orders.Ranked.ts +++ b/ts/fixtures/task/expected/drops/orders.Ranked.ts @@ -26,8 +26,7 @@ export class Ranked { export function drop$ops_Drop(self: Ranked): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["k", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } @@ -35,8 +34,8 @@ export function eq$cmp_PartialEq(self: Ranked, other: Ranked): boolean { const arg = self.id; const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; - const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["eq ", args2[0], " ", args2[1]]); + const args3 = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; + const _5: string = rs.fmtFormat(["eq ", args3[0], " ", args3[1]]); Log.note(self.log, _5); return rs.u8Rem(self.rank, 3) === rs.u8Rem(other.rank, 3); } @@ -45,8 +44,8 @@ export function partialCmp$cmp_PartialOrd(self: Ranked, other: Ranked): rs.Order const arg = self.id; const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; - const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["partial_cmp ", args2[0], " ", args2[1]]); + const args3 = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; + const _5: string = rs.fmtFormat(["partial_cmp ", args3[0], " ", args3[1]]); Log.note(self.log, _5); return rs.cmp(rs.u8Div(self.rank, 2), rs.u8Div(other.rank, 2)); } @@ -55,8 +54,8 @@ export function cmp$cmp_Ord(self: Ranked, other: Ranked): rs.Ordering { const arg = self.id; const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; - const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["cmp ", args2[0], " ", args2[1]]); + const args5 = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; + const _5: string = rs.fmtFormat(["cmp ", args5[0], " ", args5[1]]); Log.note(self.log, _5); if (self.rank !== 99) { if (other.rank !== 99) { @@ -66,8 +65,8 @@ export function cmp$cmp_Ord(self: Ranked, other: Ranked): rs.Ordering { const arg3 = self.id; const _26: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg3, f); const arg4 = other.id; - const args4: rs.Fmt[] = [_26, (f: rs.Formatter) => rs.u32Display(arg4, f)]; - rs.panicFmt(["cmp of k", args4[0], " with k", args4[1]]); + const args6 = [_26, (f: rs.Formatter) => rs.u32Display(arg4, f)]; + rs.panicFmt(["cmp of k", args6[0], " with k", args6[1]]); } //# sourceMappingURL=orders.Ranked.ts.map diff --git a/ts/fixtures/task/expected/drops/orders.ts b/ts/fixtures/task/expected/drops/orders.ts index 8e8a5ee99..8541f6208 100644 --- a/ts/fixtures/task/expected/drops/orders.ts +++ b/ts/fixtures/task/expected/drops/orders.ts @@ -28,16 +28,16 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { }; const setIds: (a0: rs.BTreeSet) => string = (s: rs.BTreeSet): string => { return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeKeys(s), (k: Ranked.Ranked): string => { - const _48: rs.u32 = rs.u32Sub(k.id, id); - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_48, f)); + const _410: rs.u32 = rs.u32Sub(k.id, id); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_410, f)); }), undefined, 12, true).items, ","); }; const mapIds: (a0: rs.BTreeMap) => string = (m: rs.BTreeMap): string => { return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(m), (_26: [Ranked.Ranked, Guard.Guard]): string => { - const _97: rs.u32 = rs.u32Sub(_26[0].id, id); + const _98: rs.u32 = rs.u32Sub(_26[0].id, id); const _144: rs.u32 = rs.u32Sub(Guard.id(_26[1]), id); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_97, f), (f: rs.Formatter) => rs.u32Display(_144, f)]; - return rs.fmtFormat([args32[0], ":", args32[1]]); + const args33 = [(f: rs.Formatter) => rs.u32Display(_98, f), (f: rs.Formatter) => rs.u32Display(_144, f)]; + return rs.fmtFormat([args33[0], ":", args33[1]]); }), undefined, 12, true).items, ","); }; const short: Uint8Array = Uint8Array.of(3, 1, 3, 2, 1, 5, 4, 0); @@ -50,8 +50,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _24: rs.Iter = rs.vecIntoIter(keys(part29), rs.drop); const set: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_24, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part31 = setIds(set); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part31)]; - Log.note(log, rs.fmtFormat(["set ", args2[0]])); + Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part31)])); rs.btreeDrop(set, rs.drop); const _46: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of())), rs.drop); const none: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_46, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); @@ -59,8 +58,8 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const one: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_53, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const _65: rs.usize = rs.btreeLen(none); const _68: string = setIds(one); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_65, f), (f: rs.Formatter) => rs.fmtPad(f, _68)]; - Log.note(log, rs.fmtFormat(["small ", args4[0], " ", args4[1]])); + const args54 = [(f: rs.Formatter) => rs.usizeDisplay(_65, f), (f: rs.Formatter) => rs.fmtPad(f, _68)]; + Log.note(log, rs.fmtFormat(["small ", args54[0], " ", args54[1]])); rs.btreeDrop(one, rs.drop); rs.btreeDrop(none, rs.drop); } else if (_21 === 1) { @@ -68,20 +67,17 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _78: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part26), lib_drop$tuple2_drops_orders_Ranked_model_Guard); const map: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_78, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part28 = mapIds(map); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part28)]; - Log.note(log, rs.fmtFormat(["map ", args6[0]])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part28)])); rs.btreeDrop(map, rs.drop, rs.drop); } else if (_21 === 2) { const _99: Ranked.Ranked[] = [key(1, 4), key(2, 2), key(3, 4), key(4, 1), key(5, 2)]; const set2: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(rs.iterSlice(_99, rs.drop), "fold", 12, true).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part23 = setIds(set2); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23)]; - Log.note(log, rs.fmtFormat(["set ", args8[0]])); + Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part23)])); const _130: [Ranked.Ranked, Guard.Guard][] = [entry(1, 4), entry(2, 2), entry(3, 4), entry(4, 1), entry(5, 2)]; const map2: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(rs.iterSlice(_130, lib_drop$tuple2_drops_orders_Ranked_model_Guard), "fold", 20, true).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part25 = mapIds(map2); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25)]; - Log.note(log, rs.fmtFormat(["map ", args10[0]])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part25)])); rs.btreeDrop(map2, rs.drop, rs.drop); rs.btreeDrop(set2, rs.drop); } else if (_21 === 3) { @@ -89,8 +85,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _161: rs.Iter = rs.vecIntoIter(keys(part16), rs.drop); const set3: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_161, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part18 = setIds(set3); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18)]; - Log.note(log, rs.fmtFormat(["set ", args12[0]])); + Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part18)])); rs.iterForEach(rs.btreeKeys(set3, rs.drop), (a0: Ranked.Ranked): undefined => { a0[Symbol.dispose](); }, true); @@ -98,8 +93,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _184: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part19), lib_drop$tuple2_drops_orders_Ranked_model_Guard); const map3: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_184, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part21 = mapIds(map3); - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21)]; - Log.note(log, rs.fmtFormat(["map ", args14[0]])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part21)])); rs.iterForEach(rs.btreeIter(map3, rs.drop, rs.drop), (a02: [Ranked.Ranked, Guard.Guard]): undefined => { lib_drop$tuple2_drops_orders_Ranked_model_Guard(a02); }, true); @@ -111,20 +105,18 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const map4: rs.BTreeMap, Guard.Guard> = rs.btreeCollect(rs.btreeNew(rs.cellBy(Rank.cmp$cmp_Ord)) as rs.BTreeMap, Guard.Guard>, rs.iterToVec(_207, undefined, 12, true).items, 12, false, rs.cellBy(Rank.eq$cmp_PartialEq), undefined, rs.drop); const part15 = rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(map4), (_219: [rs.Cell, Guard.Guard]): string => { - const _912: Rank.Rank = _219[0].v; + const _913: Rank.Rank = _219[0].v; const _1111: rs.u32 = rs.u32Sub(Guard.id(_219[1]), id); - const arg2 = _912._0; - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; - return rs.fmtFormat([args36[0], ":", args36[1]]); + const arg2 = _913._0; + const args46 = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; + return rs.fmtFormat([args46[0], ":", args46[1]]); }), undefined, 12, true).items, ","); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15)]; - Log.note(log, rs.fmtFormat(["cells ", args16[0]])); + Log.note(log, rs.fmtFormat(["cells ", (f: rs.Formatter) => rs.fmtPad(f, part15)])); rs.btreeDrop(map4, undefined, rs.drop); } else if (_21 === 5) { const by: (a0: Guard.Guard) => Ranked.Ranked = (g: Guard.Guard): Ranked.Ranked => { const n7: rs.u32 = rs.u32Sub(Guard.id(g), id); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n7, f)]; - Log.note(log, rs.fmtFormat(["key ", args34[0]])); + Log.note(log, rs.fmtFormat(["key ", (f: rs.Formatter) => rs.u32Display(n7, f)])); return key(rs.u32Add(n7, 50), rs.u8Mul(rs.u32Rem(n7, 3) & 0xff, 2)); }; const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { @@ -137,15 +129,13 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { g2[Symbol.dispose](); return _018; }); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part13, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["max ", args18[0]])); + Log.note(log, rs.fmtFormat(["max ", (f: rs.Formatter) => rs.fmtOption(part13, f, rs.u32Debug)])); const part14 = option_map$06w9waf(rs.iterMinByKey(rs.vecIntoIter(guards(6, 11), rs.drop), by, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rs.drop, undefined, rs.drop), (g3: Guard.Guard): rs.u32 => { const _019: rs.u32 = rs.u32Sub(Guard.id(g3), id); g3[Symbol.dispose](); return _019; }); - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part14, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["min ", args20[0]])); + Log.note(log, rs.fmtFormat(["min ", (f: rs.Formatter) => rs.fmtOption(part14, f, rs.u32Debug)])); const one2: Guard.Guard | undefined = rs.iterMaxByKey(rs.vecIntoIter(guards(11, 12), rs.drop), by, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rs.drop, undefined, rs.drop); const none2: Guard.Guard | undefined = rs.iterMinByKey(rs.vecIntoIter(guards(12, 12), rs.drop), by, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rs.drop, undefined, rs.drop); const _292: rs.u32 | undefined = option_map$06w9waf(one2, (g4: Guard.Guard): rs.u32 => { @@ -154,8 +144,8 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { return _020; }); const _296: boolean = none2 === undefined; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_292, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_296, f)]; - Log.note(log, rs.fmtFormat(["one ", args22[0], " ", args22[1]])); + const args43 = [(f: rs.Formatter) => rs.fmtOption(_292, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_296, f)]; + Log.note(log, rs.fmtFormat(["one ", args43[0], " ", args43[1]])); rs.drop(none2); } else if (_21 === 6) { const part5 = rs.byteSliceFrom(short); @@ -165,8 +155,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { k2[Symbol.dispose](); return _012; }); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["max ", args24[0]])); + Log.note(log, rs.fmtFormat(["max ", (f: rs.Formatter) => rs.fmtOption(part6, f, rs.u32Debug)])); const part7 = rs.byteSliceFrom(short); const _326: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part7), lib_drop$tuple2_drops_orders_Ranked_model_Guard); const part8 = option_map$16oph0b(rs.ownedEnd(rs.btreeKeys(rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_326, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop), rs.drop, rs.drop, true), false), (k3: Ranked.Ranked): rs.u32 => { @@ -174,17 +163,14 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { k3[Symbol.dispose](); return _013; }); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["min ", args26[0]])); + Log.note(log, rs.fmtFormat(["min ", (f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)])); const _348: rs.Iter<[rs.u32, Guard.Guard]> = rs.iterMap(new rs.Range(1, 5), (n6: rs.u32): [rs.u32, Guard.Guard] => { return [n6, Guard.new(rs.u32Add(rs.u32Add(id, n6), 200), Log.clone$Clone(log))] as [rs.u32, Guard.Guard]; }); const part9 = rs.ownedEnd(rs.btreeKeys(rs.btreeCollect(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterToVec(_348, undefined, 12, true).items, 12, true, undefined, undefined, rs.drop), undefined, rs.drop, true), true); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["plain ", args28[0]])); + Log.note(log, rs.fmtFormat(["plain ", (f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)])); const part10 = rs.ownedEnd(rs.btreeKeys(rs.btreeNew(rs.cmp) as rs.BTreeMap, undefined, rs.drop, true), false); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["empty ", args30[0]])); + Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)])); } else { const _378: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of(2, 1, 99, 3))), rs.drop); rs.btreeDrop(rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_378, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop), rs.drop); diff --git a/ts/fixtures/task/expected/drops/released.ts b/ts/fixtures/task/expected/drops/released.ts index 5d66cda7e..2f3b06034 100644 --- a/ts/fixtures/task/expected/drops/released.ts +++ b/ts/fixtures/task/expected/drops/released.ts @@ -35,9 +35,8 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { _262 = true; _252 = true; const part27 = Guard.id(captured26); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part27, f)]; - const _626: string = rs.fmtFormat(["reduce ", args64[0]]); - Guard.note(y4, _626); + const _627: string = rs.fmtFormat(["reduce ", (f: rs.Formatter) => rs.u32Display(part27, f)]); + Guard.note(y4, _627); if (!(Guard.id(x4) < Guard.id(y4))) { _262 = false; _029 = x4; @@ -60,38 +59,36 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g18[Symbol.dispose](); return _030; }); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part28, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["reduced ", args2[0]])); + Log.note(log, rs.fmtFormat(["reduced ", (f: rs.Formatter) => rs.fmtOption(part28, f, rs.u32Debug)])); const b: Guard.Guard = guard(11); const _32: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(5, 7)), rs.drop), 0, rs.drop); const captured27 = b; - const none: Guard.Guard | undefined = rs.iterReduce(_32, rs.closure((x5: Guard.Guard, _339: Guard.Guard): Guard.Guard => { + const none: Guard.Guard | undefined = rs.iterReduce(_32, rs.closure((x5: Guard.Guard, _340: Guard.Guard): Guard.Guard => { Guard.note(captured27, "never"); - _339[Symbol.dispose](); + _340[Symbol.dispose](); return x5; }, (): void => { captured27[Symbol.dispose](); }), true, true); const part29 = none === undefined; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part29, f)]; - Log.note(log, rs.fmtFormat(["none ", args4[0]])); + Log.note(log, rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part29, f)])); const c: Guard.Guard = guard(12); const _53: rs.Iter = rs.iterMap(new rs.Range(13, 16), guard); const captured28 = c; const part30 = option_map$06w9waf(rs.iterReduce(_53, rs.closure((x6: Guard.Guard, y5: Guard.Guard): Guard.Guard => { let _032!: Guard.Guard; let _1211: boolean = false; - let _1116: boolean = false; + let _1120: boolean = false; _1211 = true; - _1116 = true; + _1120 = true; if (!(Guard.id(y5) === rs.u32Add(Guard.id(captured28), 2))) { _1211 = false; _032 = x6; } else { - _1116 = false; + _1120 = false; _032 = y5; } - if (_1116) { + if (_1120) { y5[Symbol.dispose](); } if (_1211) { @@ -106,12 +103,11 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g19[Symbol.dispose](); return _033; }); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part30, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["made ", args6[0]])); + Log.note(log, rs.fmtFormat(["made ", (f: rs.Formatter) => rs.fmtOption(part30, f, rs.u32Debug)])); const captured29 = guard(16); - const first: (a0: Guard.Guard, a1: Guard.Guard) => Guard.Guard = rs.closure((x7: Guard.Guard, _340: Guard.Guard): Guard.Guard => { + const first: (a0: Guard.Guard, a1: Guard.Guard) => Guard.Guard = rs.closure((x7: Guard.Guard, _344: Guard.Guard): Guard.Guard => { Guard.note(captured29, "first"); - _340[Symbol.dispose](); + _344[Symbol.dispose](); return x7; }, (): void => { captured29[Symbol.dispose](); @@ -121,8 +117,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g20[Symbol.dispose](); return _035; }); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part31, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["lent ", args8[0]])); + Log.note(log, rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.fmtOption(part31, f, rs.u32Debug)])); rs.drop(first); rs.drop(none); } else if (_6 === 1) { @@ -138,8 +133,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g16[Symbol.dispose](); return _025; }); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part24, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["max ", args10[0]])); + Log.note(log, rs.fmtFormat(["max ", (f: rs.Formatter) => rs.fmtOption(part24, f, rs.u32Debug)])); const b2: Guard.Guard = guard(11); const _113: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(5, 8)), rs.drop); const captured24 = b2; @@ -152,8 +146,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g17[Symbol.dispose](); return _027; }); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part25, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["min ", args12[0]])); + Log.note(log, rs.fmtFormat(["min ", (f: rs.Formatter) => rs.fmtOption(part25, f, rs.u32Debug)])); const c2: Guard.Guard = guard(12); const _132: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(13, 15)), rs.drop), 0, rs.drop); const captured25 = c2; @@ -163,8 +156,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured25[Symbol.dispose](); }), true, rs.drop, true); const part26 = none2 === undefined; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part26, f)]; - Log.note(log, rs.fmtFormat(["none ", args14[0]])); + Log.note(log, rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part26, f)])); rs.drop(none2); } else if (_6 === 2) { const a3: Guard.Guard = guard(10); @@ -179,8 +171,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g10[Symbol.dispose](); return _018; }); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part20, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["max ", args16[0]])); + Log.note(log, rs.fmtFormat(["max ", (f: rs.Formatter) => rs.fmtOption(part20, f, rs.u32Debug)])); const b3: Guard.Guard = guard(11); const _173: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(5, 8)), rs.drop); const captured20 = b3; @@ -193,8 +184,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g12[Symbol.dispose](); return _020; }); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part21, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["min ", args18[0]])); + Log.note(log, rs.fmtFormat(["min ", (f: rs.Formatter) => rs.fmtOption(part21, f, rs.u32Debug)])); const c3: Guard.Guard = guard(12); const _192: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(13, 15)), rs.drop), 0, rs.drop); const captured21 = c3; @@ -204,8 +194,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured21[Symbol.dispose](); }), rs.lt, true, rs.drop, true); const part22 = none3 === undefined; - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part22, f)]; - Log.note(log, rs.fmtFormat(["none ", args20[0]])); + Log.note(log, rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part22, f)])); const captured22 = guard(15); const key: (a0: Guard.Guard) => rs.u32 = rs.closure((g14: Guard.Guard): rs.u32 => { return rs.u32Add(Guard.id(g14), Guard.id(captured22)); @@ -217,8 +206,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { g15[Symbol.dispose](); return _023; }); - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part23, f, rs.u32Debug)]; - Log.note(log, rs.fmtFormat(["lent ", args22[0]])); + Log.note(log, rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.fmtOption(part23, f, rs.u32Debug)])); rs.drop(key); rs.drop(none3); } else if (_6 === 3) { @@ -227,8 +215,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured15 = a4; const part16 = rs.iterIsSortedBy(rs.iterMap(_235, rs.closure((g6: Guard.Guard): rs.u32 => { const part15 = Guard.id(captured15); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part15, f)]; - const _517: string = rs.fmtFormat(["key ", args62[0]]); + const _517: string = rs.fmtFormat(["key ", (f: rs.Formatter) => rs.u32Display(part15, f)]); Guard.note(g6, _517); const _013: rs.u32 = Guard.id(g6); g6[Symbol.dispose](); @@ -236,8 +223,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured15[Symbol.dispose](); })), rs.le, true); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part16, f)]; - Log.note(log, rs.fmtFormat(["sorted ", args24[0]])); + Log.note(log, rs.fmtFormat(["sorted ", (f: rs.Formatter) => rs.fmtBool(part16, f)])); const b4: Guard.Guard = guard(11); const _253: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(4, 8)), rs.drop); const captured16 = b4; @@ -248,8 +234,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured16[Symbol.dispose](); })), rs.le, true); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part17, f)]; - Log.note(log, rs.fmtFormat(["unsorted ", args26[0]])); + Log.note(log, rs.fmtFormat(["unsorted ", (f: rs.Formatter) => rs.fmtBool(part17, f)])); const c4: Guard.Guard = guard(12); const _271: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(13, 15)), rs.drop), 0, rs.drop); const captured17 = c4; @@ -260,8 +245,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured17[Symbol.dispose](); })), rs.le, true); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part18, f)]; - Log.note(log, rs.fmtFormat(["empty ", args28[0]])); + Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtBool(part18, f)])); const d3: Guard.Guard = guard(15); const _290: rs.Iter = rs.iterSlice([3, 1]); const captured18 = d3; @@ -270,8 +254,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured18[Symbol.dispose](); })), rs.le, true); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part19, f)]; - Log.note(log, rs.fmtFormat(["plain ", args30[0]])); + Log.note(log, rs.fmtFormat(["plain ", (f: rs.Formatter) => rs.fmtBool(part19, f)])); } else if (_6 === 4) { const id2: rs.u32 = id; const guard2: (a0: rs.u32) => Guard.Guard = (n3: rs.u32): Guard.Guard => { @@ -290,8 +273,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured9[Symbol.dispose](); }), rs.drop)); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; - Log.note(log, rs.fmtFormat(["hash occupied ", args32[0]])); + Log.note(log, rs.fmtFormat(["hash occupied ", (f: rs.Formatter) => rs.u32Display(part8, f)])); const _349: rs.Entry = rs.entry(map, 2); const captured10 = b5; const part9 = Guard.id(rs.entryOrInsertWith(_349, rs.closure((): Guard.Guard => { @@ -299,8 +281,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured10[Symbol.dispose](); }), rs.drop)); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; - Log.note(log, rs.fmtFormat(["hash vacant ", args34[0]])); + Log.note(log, rs.fmtFormat(["hash vacant ", (f: rs.Formatter) => rs.u32Display(part9, f)])); const captured11 = guard2(4); const made2: () => Guard.Guard = rs.closure((): Guard.Guard => { return Guard.new(rs.u32Add(Guard.id(captured11), 10), Log.clone$Clone(log)); @@ -308,8 +289,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured11[Symbol.dispose](); }); const part10 = Guard.id(rs.entryOrInsertWith(rs.entry(map, 3), rs.once(made2), rs.drop)); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; - Log.note(log, rs.fmtFormat(["hash made ", args36[0]])); + Log.note(log, rs.fmtFormat(["hash made ", (f: rs.Formatter) => rs.u32Display(part10, f)])); const captured12 = guard2(5); const keyed: (a0: rs.u32) => Guard.Guard = rs.closure((k4: rs.u32): Guard.Guard => { return Guard.new(rs.u32Add(Guard.id(captured12), k4), Log.clone$Clone(log)); @@ -317,8 +297,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured12[Symbol.dispose](); }); const part11 = Guard.id(rs.entryOrInsertWith(rs.entry(map, 4), rs.once(keyed), rs.drop)); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; - Log.note(log, rs.fmtFormat(["hash keyed ", args38[0]])); + Log.note(log, rs.fmtFormat(["hash keyed ", (f: rs.Formatter) => rs.u32Display(part11, f)])); const _396: [Guard.Guard, Guard.Guard] = [guard2(6), guard2(7)]; const e: Guard.Guard = _396[0]; f = _396[1]; @@ -326,8 +305,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured13 = e; rs.entryAndModify(_404, rs.closure((g4: Guard.Guard): undefined => { const part12 = Guard.id(captured13); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part12, f)]; - Guard.note(g4, rs.fmtFormat(["modified ", args58[0]])); + Guard.note(g4, rs.fmtFormat(["modified ", (f: rs.Formatter) => rs.u32Display(part12, f)])); captured13[Symbol.dispose](); }, (): void => { captured13[Symbol.dispose](); @@ -336,14 +314,12 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured14 = f; const part14 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_409, rs.closure((g5: Guard.Guard): undefined => { const part13 = Guard.id(captured14); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; - Guard.note(g5, rs.fmtFormat([args60[0]])); + Guard.note(g5, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part13, f)])); captured14[Symbol.dispose](); }, (): void => { captured14[Symbol.dispose](); }), rs.drop), guard2(8), rs.drop)); - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part14, f)]; - Log.note(log, rs.fmtFormat(["hash added ", args40[0]])); + Log.note(log, rs.fmtFormat(["hash added ", (f: rs.Formatter) => rs.u32Display(part14, f)])); let iterStart: rs.u32 = 1; const iterEnd: rs.u32 = 6; while ((_430 = iterStart++) < iterEnd) { @@ -368,8 +344,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured3[Symbol.dispose](); }), rs.drop)); - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["btree occupied ", args42[0]])); + Log.note(log, rs.fmtFormat(["btree occupied ", (f: rs.Formatter) => rs.u32Display(part, f)])); const _483: rs.Entry = rs.entry(map2, 2); const captured4 = b6; const part2 = Guard.id(rs.entryOrInsertWith(_483, rs.closure((): Guard.Guard => { @@ -377,8 +352,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured4[Symbol.dispose](); }), rs.drop)); - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["btree vacant ", args44[0]])); + Log.note(log, rs.fmtFormat(["btree vacant ", (f: rs.Formatter) => rs.u32Display(part2, f)])); const captured5 = guard3(4); const made3: () => Guard.Guard = rs.closure((): Guard.Guard => { return Guard.new(rs.u32Add(Guard.id(captured5), 10), Log.clone$Clone(log)); @@ -386,8 +360,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured5[Symbol.dispose](); }); const part3 = Guard.id(rs.entryOrInsertWith(rs.entry(map2, 3), rs.once(made3), rs.drop)); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["btree made ", args46[0]])); + Log.note(log, rs.fmtFormat(["btree made ", (f: rs.Formatter) => rs.u32Display(part3, f)])); const captured6 = guard3(5); const keyed2: (a0: rs.u32) => Guard.Guard = rs.closure((k3: rs.u32): Guard.Guard => { return Guard.new(rs.u32Add(Guard.id(captured6), k3), Log.clone$Clone(log)); @@ -395,8 +368,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured6[Symbol.dispose](); }); const part4 = Guard.id(rs.entryOrInsertWith(rs.entry(map2, 4), rs.once(keyed2), rs.drop)); - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; - Log.note(log, rs.fmtFormat(["btree keyed ", args48[0]])); + Log.note(log, rs.fmtFormat(["btree keyed ", (f: rs.Formatter) => rs.u32Display(part4, f)])); const _530: [Guard.Guard, Guard.Guard] = [guard3(6), guard3(7)]; const e2: Guard.Guard = _530[0]; const f2: Guard.Guard = _530[1]; @@ -404,8 +376,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured7 = e2; rs.entryAndModify(_538, rs.closure((g2: Guard.Guard): undefined => { const part5 = Guard.id(captured7); - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; - Guard.note(g2, rs.fmtFormat(["modified ", args54[0]])); + Guard.note(g2, rs.fmtFormat(["modified ", (f: rs.Formatter) => rs.u32Display(part5, f)])); captured7[Symbol.dispose](); }, (): void => { captured7[Symbol.dispose](); @@ -414,14 +385,12 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured8 = f2; const part7 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_543, rs.closure((g3: Guard.Guard): undefined => { const part6 = Guard.id(captured8); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; - Guard.note(g3, rs.fmtFormat([args56[0]])); + Guard.note(g3, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part6, f)])); captured8[Symbol.dispose](); }, (): void => { captured8[Symbol.dispose](); }), rs.drop), guard3(8), rs.drop)); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; - Log.note(log, rs.fmtFormat(["btree added ", args50[0]])); + Log.note(log, rs.fmtFormat(["btree added ", (f: rs.Formatter) => rs.u32Display(part7, f)])); let iterStart2: rs.u32 = 1; const iterEnd2: rs.u32 = 6; while ((_564 = iterStart2++) < iterEnd2) { @@ -437,8 +406,8 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { if (!(Guard.id(g) !== rs.u32Add(captured, 2))) { const _122: rs.u32 = Guard.id(g); const _142: rs.u32 = Guard.id(captured2); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_122, f), (f: rs.Formatter) => rs.u32Display(_142, f)]; - rs.panicFmt(["key of g", args52[0], " with g", args52[1]]); + const args53 = [(f: rs.Formatter) => rs.u32Display(_122, f), (f: rs.Formatter) => rs.u32Display(_142, f)]; + rs.panicFmt(["key of g", args53[0], " with g", args53[1]]); } else { return Guard.id(g); } diff --git a/ts/fixtures/task/expected/drops/searched.ts b/ts/fixtures/task/expected/drops/searched.ts index 515eb47cc..b24215c89 100644 --- a/ts/fixtures/task/expected/drops/searched.ts +++ b/ts/fixtures/task/expected/drops/searched.ts @@ -34,8 +34,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured55[Symbol.dispose](); }); const missing: boolean = rs.dropAfter(_19, () => rs.strContains(text, _19)); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(found, f), (f: rs.Formatter) => rs.fmtBool(missing, f)]; - Log.note(log, rs.fmtFormat(["contains ", args2[0], " ", args2[1]])); + const args201 = [(f: rs.Formatter) => rs.fmtBool(found, f), (f: rs.Formatter) => rs.fmtBool(missing, f)]; + Log.note(log, rs.fmtFormat(["contains ", args201[0], " ", args201[1]])); const _34: [Guard.Guard, Guard.Guard] = [guard(3), guard(4)]; const c: Guard.Guard = _34[0]; const d: Guard.Guard = _34[1]; @@ -71,8 +71,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured59[Symbol.dispose](); }); const part14 = [_42, rs.dropAfter(_45, () => rs.strRfind(text, _45))] as [rs.usize | undefined, rs.usize | undefined]; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part14[0], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part14[1], f, rs.usizeDebug)], f)]; - Log.note(log, rs.fmtFormat(["find ", args4[0]])); + Log.note(log, rs.fmtFormat(["find ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part14[0], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part14[1], f, rs.usizeDebug)], f)])); const _58: [Guard.Guard, Guard.Guard] = [guard(5), guard(6)]; const e: Guard.Guard = _58[0]; f = _58[1]; @@ -102,8 +101,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured62[Symbol.dispose](); }); const part15 = [_66, rs.dropAfter(_69, () => rs.strEndsWith(text, _69))] as [boolean, boolean]; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part15[0], f), (f: rs.Formatter) => rs.fmtBool(part15[1], f)], f)]; - Log.note(log, rs.fmtFormat(["ends ", args6[0]])); + Log.note(log, rs.fmtFormat(["ends ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part15[0], f), (f: rs.Formatter) => rs.fmtBool(part15[1], f)], f)])); const _82: [Guard.Guard, Guard.Guard] = [guard(7), guard(8)]; const g: Guard.Guard = _82[0]; const h: Guard.Guard = _82[1]; @@ -127,8 +125,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured64[Symbol.dispose](); }); const part16 = [_90, rs.dropAfter(_93, () => rs.strStripSuffix(text, _93))] as [string | undefined, string | undefined]; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part16[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(part16[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["strip ", args8[0]])); + Log.note(log, rs.fmtFormat(["strip ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part16[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(part16[1], f, rs.fmtStr)], f)])); const _106: [Guard.Guard, Guard.Guard] = [guard(9), guard(10)]; const i: Guard.Guard = _106[0]; const j: Guard.Guard = _106[1]; @@ -164,8 +161,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured68[Symbol.dispose](); }); const part17 = [_114, rs.dropAfter(_117, () => rs.strRsplitOnce(text, _117))] as [[string, string] | undefined, [string, string] | undefined]; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part17[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(part17[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rs.fmtFormat(["once ", args10[0]])); + Log.note(log, rs.fmtFormat(["once ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part17[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(part17[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)])); const _131: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(11), guard(12), guard(13)]; const k: Guard.Guard = _131[0]; const l: Guard.Guard = _131[1]; @@ -203,8 +199,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured71[Symbol.dispose](); }); const part18 = [_142, _145, rs.dropAfter(_150, () => rs.strTrimEndMatches(_149, _150))] as [string, string, string]; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part18[0], f), (f: rs.Formatter) => rs.fmtStr(part18[1], f), (f: rs.Formatter) => rs.fmtStr(part18[2], f)], f)]; - Log.note(log, rs.fmtFormat(["trim ", args12[0]])); + Log.note(log, rs.fmtFormat(["trim ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part18[0], f), (f: rs.Formatter) => rs.fmtStr(part18[1], f), (f: rs.Formatter) => rs.fmtStr(part18[2], f)], f)])); const _163: [Guard.Guard, Guard.Guard] = [guard(14), guard(15)]; const n: Guard.Guard = _163[0]; const o: Guard.Guard = _163[1]; @@ -242,8 +237,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const _176: string = "+"; const part19 = [_171, rs.dropAfter(_175, () => rs.strReplace(text, _175, _176, 2))] as [string, string]; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part19[0], f), (f: rs.Formatter) => rs.fmtStr(part19[1], f)], f)]; - Log.note(log, rs.fmtFormat(["replace ", args14[0]])); + Log.note(log, rs.fmtFormat(["replace ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part19[0], f), (f: rs.Formatter) => rs.fmtStr(part19[1], f)], f)])); } else if (_8 === 1) { const a2: Guard.Guard = guard(1); const captured32 = (c31: rs.char): boolean => { @@ -263,8 +257,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { })); const _198: string | undefined = rs.iterToOption(split.next()); const _201: string | undefined = rs.iterToOption(split.nextBack()); - const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_198, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_201, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split ", args16[0], " ", args16[1]])); + const args193 = [(f: rs.Formatter) => rs.fmtOption(_198, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_201, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args193[0], " ", args193[1]])); rs.drop(split); const b2: Guard.Guard = guard(2); const captured34 = (c33: rs.char): boolean => { @@ -282,8 +276,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured35[Symbol.dispose](); })), "next", 8); - const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part10.items, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["rsplit ", args18[0]])); + Log.note(log, rs.fmtFormat(["rsplit ", (f: rs.Formatter) => rs.fmtList(part10.items, f, rs.fmtStr)])); const _228: [Guard.Guard, Guard.Guard] = [guard(3), guard(4)]; const c2: Guard.Guard = _228[0]; const d2: Guard.Guard = _228[1]; @@ -317,8 +310,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured39[Symbol.dispose](); })))] as [rs.usize, string | undefined]; - const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(part11[0], f), (f: rs.Formatter) => rs.fmtOption(part11[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["splitn ", args20[0]])); + Log.note(log, rs.fmtFormat(["splitn ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(part11[0], f), (f: rs.Formatter) => rs.fmtOption(part11[1], f, rs.fmtStr)], f)])); const e2: Guard.Guard = guard(5); const captured40 = (c38: rs.char): boolean => { if (!(c38 === 44)) { @@ -341,8 +333,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { break; } const part: string = _259; - const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; - Log.note(log, rs.fmtFormat(["part ", args22[0]])); + Log.note(log, rs.fmtFormat(["part ", (f: rs.Formatter) => rs.fmtPad(f, part)])); if (part === "c") { break; } @@ -365,8 +356,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured43[Symbol.dispose](); })); const part12 = rs.iterNth(terminated, 1); - const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["rsplit_terminator ", args24[0]])); + Log.note(log, rs.fmtFormat(["rsplit_terminator ", (f: rs.Formatter) => rs.fmtOption(part12, f, rs.fmtStr)])); rs.drop(terminated); const g2: Guard.Guard = guard(7); const captured44 = (c42: rs.char): boolean => { @@ -386,8 +376,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }))), (s2: string): string => { return rs.strTrimEndMatches(s2, ","); }), "next", 8); - const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part13.items, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split_inclusive ", args26[0]])); + Log.note(log, rs.fmtFormat(["split_inclusive ", (f: rs.Formatter) => rs.fmtList(part13.items, f, rs.fmtStr)])); const _315: [Guard.Guard, Guard.Guard] = [guard(8), guard(9)]; const h2: Guard.Guard = _315[0]; const i2: Guard.Guard = _315[1]; @@ -424,8 +413,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const last: string | undefined = rs.iterToOption(_326.next()); rs.drop(_326); const _334: string | undefined = rs.iterToOption(matched.next()); - const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_334, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["matches ", args28[0], " ", args28[1]])); + const args199 = [(f: rs.Formatter) => rs.fmtOption(_334, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args199[0], " ", args199[1]])); rs.drop(matched); const _346: [Guard.Guard, Guard.Guard] = [guard(10), guard(11)]; const j2: Guard.Guard = _346[0]; @@ -464,8 +453,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const indices: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [_354, rs.iterToOption(_360.next())]; rs.drop(_360); rs.drop(_356); - const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rs.fmtFormat(["indices ", args30[0]])); + Log.note(log, rs.fmtFormat(["indices ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)])); } else if (_8 === 2) { const a3: Guard.Guard = guard(1); let s: string = text; @@ -477,16 +465,14 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { return true; }; const _378: (a0: rs.char) => boolean = rs.closure((c30: rs.char): boolean => { - const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(c30, f)]; - Guard.note(captured27, rs.fmtFormat(["retain ", args138[0]])); + Guard.note(captured27, rs.fmtFormat(["retain ", (f: rs.Formatter) => rs.fmtCharDisplay(c30, f)])); return !captured28(c30); }, (): void => { captured27[Symbol.dispose](); }); s = rs.stringRetain(s, _378); rs.drop(_378); - const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; - Log.note(log, rs.fmtFormat(["retained ", args32[0]])); + Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, s)])); const b3: Guard.Guard = guard(2); let captured29: rs.i32 = 0; const captured30 = b3; @@ -500,11 +486,9 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured30[Symbol.dispose](); }); s = rs.stringRetain(s, everyOther); - const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; - Log.note(log, rs.fmtFormat(["every other ", args34[0]])); + Log.note(log, rs.fmtFormat(["every other ", (f: rs.Formatter) => rs.fmtPad(f, s)])); s = rs.stringRetain(s, everyOther); - const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; - Log.note(log, rs.fmtFormat(["every other ", args36[0]])); + Log.note(log, rs.fmtFormat(["every other ", (f: rs.Formatter) => rs.fmtPad(f, s)])); rs.drop(everyOther); const c3: Guard.Guard = guard(3); let empty: string = ""; @@ -516,8 +500,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); empty = rs.stringRetain(empty, _427); rs.drop(_427); - const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(empty, f)]; - Log.note(log, rs.fmtFormat(["empty ", args38[0]])); + Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtStr(empty, f)])); } else if (_8 === 3) { const a4: Guard.Guard = guard(1); const captured25 = (c27: rs.char): boolean => { @@ -536,50 +519,48 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured26[Symbol.dispose](); }); const part7 = [rs.strContains(text, f3), rs.strFind(text, f3), rs.strRfind(text, f3)] as [boolean, rs.usize | undefined, rs.usize | undefined]; - const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part7[0], f), (f: rs.Formatter) => rs.fmtOption(part7[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part7[2], f, rs.usizeDebug)], f)]; - Log.note(log, rs.fmtFormat(["contains ", args40[0]])); + Log.note(log, rs.fmtFormat(["contains ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part7[0], f), (f: rs.Formatter) => rs.fmtOption(part7[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part7[2], f, rs.usizeDebug)], f)])); const ends2: [boolean, boolean] = [rs.strStartsWith(text, f3), rs.strEndsWith(text, f3)]; const stripped2: [string | undefined, string | undefined] = [rs.strStripPrefix(text, f3), rs.strStripSuffix(",a", f3)]; - const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends2[0], f), (f: rs.Formatter) => rs.fmtBool(ends2[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped2[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped2[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["ends ", args42[0], " ", args42[1]])); + const args177 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends2[0], f), (f: rs.Formatter) => rs.fmtBool(ends2[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped2[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped2[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["ends ", args177[0], " ", args177[1]])); const once2: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f3), rs.strRsplitOnce(text, f3)]; const trimmed2: [string, string, string] = [rs.strTrimMatches(",a,", f3), rs.strTrimStartMatches(",a,", f3), rs.strTrimEndMatches(",a,", f3)]; const replaced2: [string, string] = [rs.strReplace(text, f3, "+"), rs.strReplace(text, f3, "+", 2)]; - const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once2[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once2[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed2[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced2[0], f), (f: rs.Formatter) => rs.fmtStr(replaced2[1], f)], f)]; - Log.note(log, rs.fmtFormat(["once ", args44[0], " ", args44[1], " ", args44[2]])); + const args178 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once2[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once2[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed2[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced2[0], f), (f: rs.Formatter) => rs.fmtStr(replaced2[1], f)], f)]; + Log.note(log, rs.fmtFormat(["once ", args178[0], " ", args178[1], " ", args178[2]])); const split2: rs.Iter = rs.strSplit(text, rs.lent(f3)); const _526: string | undefined = rs.iterToOption(split2.next()); const _529: string | undefined = rs.iterToOption(split2.nextBack()); - const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_526, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_529, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split ", args46[0], " ", args46[1]])); + const args179 = [(f: rs.Formatter) => rs.fmtOption(_526, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_529, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args179[0], " ", args179[1]])); const rsplit2: rs.Vec = rs.iterToVec(rs.strRsplit(text, rs.lent(f3)), "next", 8); const counts2: [rs.usize, string | undefined] = [rs.iterCount(rs.strSplitn(text, 2, rs.lent(f3))), rs.iterLast(rs.strRsplitn(text, 3, rs.lent(f3)))]; - const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts2[0], f), (f: rs.Formatter) => rs.fmtOption(counts2[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["rsplit ", args48[0], " ", args48[1]])); + const args180 = [(f: rs.Formatter) => rs.fmtList(rsplit2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts2[0], f), (f: rs.Formatter) => rs.fmtOption(counts2[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args180[0], " ", args180[1]])); const terminated2: [string | undefined, string | undefined] = [rs.iterNth(rs.strSplitTerminator(text, rs.lent(f3)), 3), rs.iterNth(rs.strRsplitTerminator(text, rs.lent(f3)), 1)]; const inclusive2: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, rs.lent(f3))), "next", 8); - const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated2[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated2[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive2.items, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["terminated ", args50[0], " ", args50[1]])); + const args181 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated2[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated2[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive2.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["terminated ", args181[0], " ", args181[1]])); const matched2: rs.Iter = rs.strMatches(text, rs.lent(f3)); const last2: string | undefined = rs.iterToOption(rs.strRmatches(text, rs.lent(f3)).next()); const _597: string | undefined = rs.iterToOption(matched2.next()); - const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_597, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["matches ", args52[0], " ", args52[1]])); + const args182 = [(f: rs.Formatter) => rs.fmtOption(_597, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args182[0], " ", args182[1]])); const part8 = [rs.iterNth(rs.strMatchIndices(text, rs.lent(f3)), 2), rs.iterToOption(rs.strRmatchIndices(text, rs.lent(f3)).next())] as [[rs.usize, string] | undefined, [rs.usize, string] | undefined]; - const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part8[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(part8[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rs.fmtFormat(["indices ", args54[0]])); + Log.note(log, rs.fmtFormat(["indices ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part8[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(part8[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)])); const parts: rs.Iter = rs.strSplit(text, rs.lent(f3)); parts.next(); const rest: rs.Vec = rs.iterToVec(parts.clone(), "next", 8); const _639: string | undefined = rs.iterToOption(parts.next()); - const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rest.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_639, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["cloned ", args56[0], " ", args56[1]])); + const args184 = [(f: rs.Formatter) => rs.fmtList(rest.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_639, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["cloned ", args184[0], " ", args184[1]])); const spaced: rs.Vec = rs.iterToVec(rs.strSplit("a b\tc", (a02: rs.char): boolean => { return rs.charIsWhitespace(a02); }), "next", 8); const _659: boolean = f3(59); - const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(spaced.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_659, f)]; - Log.note(log, rs.fmtFormat(["spaced ", args58[0], " ", args58[1]])); + const args185 = [(f: rs.Formatter) => rs.fmtList(spaced.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_659, f)]; + Log.note(log, rs.fmtFormat(["spaced ", args185[0], " ", args185[1]])); rs.drop(f3); Log.note(log, "dropped"); } else if (_8 === 4) { @@ -605,50 +586,49 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const found3: [boolean, rs.usize | undefined, rs.usize | undefined] = [rs.strContains(text, f4), rs.strFind(text, f4), rs.strRfind(text, f4)]; const _689: boolean = f4(120); - const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found3[0], f), (f: rs.Formatter) => rs.fmtOption(found3[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found3[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_689, f)]; - Log.note(log, rs.fmtFormat(["contains ", args60[0], " ", args60[1]])); + const args167 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found3[0], f), (f: rs.Formatter) => rs.fmtOption(found3[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found3[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_689, f)]; + Log.note(log, rs.fmtFormat(["contains ", args167[0], " ", args167[1]])); const ends3: [boolean, boolean] = [rs.strStartsWith(text, f4), rs.strEndsWith(text, f4)]; const stripped3: [string | undefined, string | undefined] = [rs.strStripPrefix(",a", f4), rs.strStripSuffix(",a", f4)]; const _716: boolean = f4(120); - const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends3[0], f), (f: rs.Formatter) => rs.fmtBool(ends3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped3[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped3[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtBool(_716, f)]; - Log.note(log, rs.fmtFormat(["ends ", args62[0], " ", args62[1], " ", args62[2]])); + const args168 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends3[0], f), (f: rs.Formatter) => rs.fmtBool(ends3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped3[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped3[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtBool(_716, f)]; + Log.note(log, rs.fmtFormat(["ends ", args168[0], " ", args168[1], " ", args168[2]])); const once3: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f4), rs.strRsplitOnce(text, f4)]; const trimmed3: [string, string] = [rs.strTrimMatches(",,a,,", f4), rs.strTrimStartMatches(",,a", f4)]; const replaced3: [string, string] = [rs.strReplace(text, f4, "+"), rs.strReplace(text, f4, "+", 2)]; const end: string = rs.strTrimEndMatches(",a,,", f4); const _755: boolean = f4(120); - const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once3[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once3[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed3[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced3[0], f), (f: rs.Formatter) => rs.fmtStr(replaced3[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end, f), (f: rs.Formatter) => rs.fmtBool(_755, f)]; - Log.note(log, rs.fmtFormat(["once ", args64[0], " ", args64[1], " ", args64[2], " ", args64[3], " ", args64[4]])); + const args169 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once3[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once3[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed3[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced3[0], f), (f: rs.Formatter) => rs.fmtStr(replaced3[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end, f), (f: rs.Formatter) => rs.fmtBool(_755, f)]; + Log.note(log, rs.fmtFormat(["once ", args169[0], " ", args169[1], " ", args169[2], " ", args169[3], " ", args169[4]])); const split3: rs.Iter = rs.strSplit(text, rs.lent(f4)); const _778: string | undefined = rs.iterToOption(split3.next()); const _781: string | undefined = rs.iterToOption(split3.nextBack()); - const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_778, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_781, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split ", args66[0], " ", args66[1]])); + const args170 = [(f: rs.Formatter) => rs.fmtOption(_778, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_781, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args170[0], " ", args170[1]])); const rsplit3: rs.Vec = rs.iterToVec(rs.strRsplit(text, rs.lent(f4)), "next", 8); const n2: rs.usize = rs.iterCount(rs.strSplitn(text, 2, rs.lent(f4))); const last3: string | undefined = rs.iterLast(rs.strRsplitn(text, 3, rs.lent(f4))); const _805: boolean = f4(120); - const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtOption(last3, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_805, f)]; - Log.note(log, rs.fmtFormat(["rsplit ", args68[0], " ", args68[1], " ", args68[2], " ", args68[3]])); + const args171 = [(f: rs.Formatter) => rs.fmtList(rsplit3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtOption(last3, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_805, f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args171[0], " ", args171[1], " ", args171[2], " ", args171[3]])); const forward: string | undefined = rs.iterNth(rs.strSplitTerminator(text, rs.lent(f4)), 3); const back: string | undefined = rs.iterNth(rs.strRsplitTerminator(text, rs.lent(f4)), 1); const inclusive3: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, rs.lent(f4))), "next", 8); const _836: boolean = f4(120); - const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(forward, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(back, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(inclusive3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_836, f)]; - Log.note(log, rs.fmtFormat(["terminated ", args70[0], " ", args70[1], " ", args70[2], " ", args70[3]])); + const args172 = [(f: rs.Formatter) => rs.fmtOption(forward, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(back, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(inclusive3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_836, f)]; + Log.note(log, rs.fmtFormat(["terminated ", args172[0], " ", args172[1], " ", args172[2], " ", args172[3]])); const part6 = rs.iterToOption(rs.strMatches(text, rs.lent(f4)).next()); - const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["matches ", args72[0]])); + Log.note(log, rs.fmtFormat(["matches ", (f: rs.Formatter) => rs.fmtOption(part6, f, rs.fmtStr)])); const last4: string | undefined = rs.iterToOption(rs.strRmatches(text, rs.lent(f4)).next()); const indices3: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [rs.iterNth(rs.strMatchIndices(text, rs.lent(f4)), 2), rs.iterToOption(rs.strRmatchIndices(text, rs.lent(f4)).next())]; const _884: boolean = f4(120); - const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last4, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices3[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices3[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_884, f)]; - Log.note(log, rs.fmtFormat(["indices ", args74[0], " ", args74[1], " ", args74[2]])); + const args174 = [(f: rs.Formatter) => rs.fmtOption(last4, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices3[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices3[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_884, f)]; + Log.note(log, rs.fmtFormat(["indices ", args174[0], " ", args174[1], " ", args174[2]])); let lent: (a0: rs.char) => boolean = f4; const parts2: rs.Vec = rs.iterToVec(rs.strSplit(text, rs.lent(rs.place(() => lent, (value29) => lent = value29).v)), "next", 8); const _905: boolean = f4(120); - const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(parts2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_905, f)]; - Log.note(log, rs.fmtFormat(["lent ", args76[0], " ", args76[1]])); + const args175 = [(f: rs.Formatter) => rs.fmtList(parts2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_905, f)]; + Log.note(log, rs.fmtFormat(["lent ", args175[0], " ", args175[1]])); rs.drop(f4); Log.note(log, "dropped"); } else if (_8 === 5) { @@ -662,30 +642,30 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const found4: [boolean, rs.usize | undefined, rs.usize | undefined] = [rs.strContains(text, p), rs.strFind(text, p), rs.strRfind(text, p)]; const ends4: [boolean, boolean] = [rs.strStartsWith(text, p), rs.strEndsWith(text, p)]; const stripped4: [string | undefined, string | undefined] = [rs.strStripPrefix(",a", p), rs.strStripSuffix(",a", p)]; - const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found4[0], f), (f: rs.Formatter) => rs.fmtOption(found4[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found4[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends4[0], f), (f: rs.Formatter) => rs.fmtBool(ends4[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped4[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["contains ", args78[0], " ", args78[1], " ", args78[2]])); + const args161 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found4[0], f), (f: rs.Formatter) => rs.fmtOption(found4[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found4[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends4[0], f), (f: rs.Formatter) => rs.fmtBool(ends4[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped4[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["contains ", args161[0], " ", args161[1], " ", args161[2]])); const once4: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, p), rs.strRsplitOnce(text, p)]; const trimmed4: [string, string, string] = [rs.strTrimMatches(",a,", p), rs.strTrimStartMatches(",a,", p), rs.strTrimEndMatches(",a,", p)]; const replaced4: [string, string] = [rs.strReplace(text, p, "+"), rs.strReplace(text, p, "+", 2)]; - const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once4[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once4[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed4[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced4[0], f), (f: rs.Formatter) => rs.fmtStr(replaced4[1], f)], f)]; - Log.note(log, rs.fmtFormat(["once ", args80[0], " ", args80[1], " ", args80[2]])); + const args162 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once4[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once4[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed4[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced4[0], f), (f: rs.Formatter) => rs.fmtStr(replaced4[1], f)], f)]; + Log.note(log, rs.fmtFormat(["once ", args162[0], " ", args162[1], " ", args162[2]])); const split4: rs.Iter = rs.strSplit(text, p); const _998: string | undefined = rs.iterToOption(split4.next()); const _1001: string | undefined = rs.iterToOption(split4.nextBack()); - const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_998, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1001, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split ", args82[0], " ", args82[1]])); + const args163 = [(f: rs.Formatter) => rs.fmtOption(_998, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1001, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args163[0], " ", args163[1]])); const rsplit4: rs.Vec = rs.iterToVec(rs.strRsplit(text, p), "next", 8); const counts3: [rs.usize, string | undefined] = [rs.iterCount(rs.strSplitn(text, 2, p)), rs.iterLast(rs.strRsplitn(text, 3, p))]; - const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts3[0], f), (f: rs.Formatter) => rs.fmtOption(counts3[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["rsplit ", args84[0], " ", args84[1]])); + const args164 = [(f: rs.Formatter) => rs.fmtList(rsplit4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts3[0], f), (f: rs.Formatter) => rs.fmtOption(counts3[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args164[0], " ", args164[1]])); const terminated3: [string | undefined, string | undefined] = [rs.iterNth(rs.strSplitTerminator(text, p), 3), rs.iterNth(rs.strRsplitTerminator(text, p), 1)]; const inclusive4: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, p)), "next", 8); - const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated3[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated3[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive4.items, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["terminated ", args86[0], " ", args86[1]])); + const args165 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated3[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated3[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive4.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["terminated ", args165[0], " ", args165[1]])); const matched4: [string | undefined, string | undefined] = [rs.iterToOption(rs.strMatches(text, p).next()), rs.iterToOption(rs.strRmatches(text, p).next())]; const indices4: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [rs.iterNth(rs.strMatchIndices(text, p), 2), rs.iterToOption(rs.strRmatchIndices(text, p).next())]; - const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(matched4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(matched4[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices4[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices4[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rs.fmtFormat(["matches ", args88[0], " ", args88[1]])); + const args166 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(matched4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(matched4[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices4[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices4[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; + Log.note(log, rs.fmtFormat(["matches ", args166[0], " ", args166[1]])); } else if (_8 === 6) { const boxed: (a0: rs.u32) => (a0: rs.char) => boolean = (n5: rs.u32): (a0: rs.char) => boolean => { const g4: Guard.Guard = guard(n5); @@ -709,8 +689,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _1094: (a0: rs.char) => boolean = boxed(2); const _1098: (a0: rs.char) => boolean = boxed(3); const part5 = [rs.dropAfter(_1090, () => rs.strContains(text, _1090)), rs.dropAfter(_1094, () => rs.strFind(text, _1094)), rs.dropAfter(_1098, () => rs.strRfind(text, _1098))] as [boolean, rs.usize | undefined, rs.usize | undefined]; - const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part5[0], f), (f: rs.Formatter) => rs.fmtOption(part5[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part5[2], f, rs.usizeDebug)], f)]; - Log.note(log, rs.fmtFormat(["contains ", args90[0]])); + Log.note(log, rs.fmtFormat(["contains ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part5[0], f), (f: rs.Formatter) => rs.fmtOption(part5[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part5[2], f, rs.usizeDebug)], f)])); const _1113: (a0: rs.char) => boolean = boxed(4); const _1117: (a0: rs.char) => boolean = boxed(5); const _1122: string = ",a"; @@ -719,8 +698,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _1128: (a0: rs.char) => boolean = boxed(7); const ends5: [boolean, boolean] = [rs.dropAfter(_1113, () => rs.strStartsWith(text, _1113)), rs.dropAfter(_1117, () => rs.strEndsWith(text, _1117))]; const stripped5: [string | undefined, string | undefined] = [rs.dropAfter(_1123, () => rs.strStripPrefix(_1122, _1123)), rs.dropAfter(_1128, () => rs.strStripSuffix(_1127, _1128))]; - const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends5[0], f), (f: rs.Formatter) => rs.fmtBool(ends5[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped5[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped5[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["ends ", args92[0], " ", args92[1]])); + const args153 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends5[0], f), (f: rs.Formatter) => rs.fmtBool(ends5[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped5[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped5[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["ends ", args153[0], " ", args153[1]])); const _1145: (a0: rs.char) => boolean = boxed(8); const _1149: (a0: rs.char) => boolean = boxed(9); const _1154: string = ",a,"; @@ -736,18 +715,18 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const once5: [[string, string] | undefined, [string, string] | undefined] = [rs.dropAfter(_1145, () => rs.strSplitOnce(text, _1145)), rs.dropAfter(_1149, () => rs.strRsplitOnce(text, _1149))]; const trimmed5: [string, string, string] = [rs.dropAfter(_1155, () => rs.strTrimMatches(_1154, _1155)), rs.dropAfter(_1160, () => rs.strTrimStartMatches(_1159, _1160)), rs.dropAfter(_1165, () => rs.strTrimEndMatches(_1164, _1165))]; const replaced5: [string, string] = [rs.dropAfter(_1170, () => rs.strReplace(text, _1170, _1173)), rs.dropAfter(_1175, () => rs.strReplace(text, _1175, _1178, 2))]; - const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once5[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once5[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed5[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced5[0], f), (f: rs.Formatter) => rs.fmtStr(replaced5[1], f)], f)]; - Log.note(log, rs.fmtFormat(["once ", args94[0], " ", args94[1], " ", args94[2]])); + const args154 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once5[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once5[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed5[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced5[0], f), (f: rs.Formatter) => rs.fmtStr(replaced5[1], f)], f)]; + Log.note(log, rs.fmtFormat(["once ", args154[0], " ", args154[1], " ", args154[2]])); const split5: rs.Iter = rs.strSplit(text, boxed(15)); const _1203: string | undefined = rs.iterToOption(split5.next()); const _1206: string | undefined = rs.iterToOption(split5.nextBack()); - const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1203, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1206, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split ", args96[0], " ", args96[1]])); + const args155 = [(f: rs.Formatter) => rs.fmtOption(_1203, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1206, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args155[0], " ", args155[1]])); rs.drop(split5); const rsplit5: rs.Vec = rs.iterToVec(rs.strRsplit(text, boxed(16)), "next", 8); const counts4: [rs.usize, string | undefined] = [rs.ownedCount(rs.strSplitn(text, 2, boxed(17))), rs.ownedLast(rs.strRsplitn(text, 3, boxed(18)))]; - const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit5.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts4[0], f), (f: rs.Formatter) => rs.fmtOption(counts4[1], f, rs.fmtStr)], f)]; - Log.note(log, rs.fmtFormat(["rsplit ", args98[0], " ", args98[1]])); + const args156 = [(f: rs.Formatter) => rs.fmtList(rsplit5.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts4[0], f), (f: rs.Formatter) => rs.fmtOption(counts4[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args156[0], " ", args156[1]])); const _1246: rs.Iter = rs.strSplitTerminator(text, boxed(19)); const _1244: string | undefined = rs.iterNth(_1246, 3); const _1252: rs.Iter = rs.strRsplitTerminator(text, boxed(20)); @@ -755,15 +734,15 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(_1252); rs.drop(_1246); const inclusive5: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, boxed(21))), "next", 8); - const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated4[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive5.items, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["terminated ", args100[0], " ", args100[1]])); + const args157 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated4[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive5.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["terminated ", args157[0], " ", args157[1]])); const matched5: rs.Iter = rs.strMatches(text, boxed(22)); const _1280: rs.Iter = rs.strRmatches(text, boxed(23)); const last5: string | undefined = rs.iterToOption(_1280.next()); rs.drop(_1280); const _1290: string | undefined = rs.iterToOption(matched5.next()); - const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1290, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last5, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["matches ", args102[0], " ", args102[1]])); + const args158 = [(f: rs.Formatter) => rs.fmtOption(_1290, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last5, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args158[0], " ", args158[1]])); rs.drop(matched5); const _1303: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(text, boxed(24)); const _1301: [rs.usize, string] | undefined = rs.iterNth(_1303, 2); @@ -771,8 +750,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const indices5: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [_1301, rs.iterToOption(_1309.next())]; rs.drop(_1309); rs.drop(_1303); - const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices5[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices5[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rs.fmtFormat(["indices ", args104[0]])); + Log.note(log, rs.fmtFormat(["indices ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices5[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices5[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)])); const split6: rs.Iter = rs.strSplit(text, isSep); const _1327: (a0: rs.char) => boolean = (c24: rs.char): boolean => { if (!(c24 === 44)) { @@ -782,8 +760,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }; const found6: boolean = rs.dropAfter(_1327, () => rs.strContains(text, _1327)); const _1335: string | undefined = rs.iterToOption(split6.next()); - const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1335, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(found6, f)]; - Log.note(log, rs.fmtFormat(["plain ", args106[0], " ", args106[1]])); + const args160 = [(f: rs.Formatter) => rs.fmtOption(_1335, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(found6, f)]; + Log.note(log, rs.fmtFormat(["plain ", args160[0], " ", args160[1]])); rs.drop(split6); } else if (_8 === 7) { const a6: Guard.Guard = guard(1); @@ -808,45 +786,44 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const found7: [boolean, rs.usize | undefined, rs.usize | undefined] = [rs.strContains(text, rs.place(() => b4, (value4) => b4 = value4).v), rs.strFind(text, rs.place(() => b4, (value5) => b4 = value5).v), rs.strRfind(text, rs.place(() => b4, (value6) => b4 = value6).v)]; const _1364: boolean = b4(120); - const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found7[0], f), (f: rs.Formatter) => rs.fmtOption(found7[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found7[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_1364, f)]; - Log.note(log, rs.fmtFormat(["contains ", args108[0], " ", args108[1]])); + const args144 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found7[0], f), (f: rs.Formatter) => rs.fmtOption(found7[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found7[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_1364, f)]; + Log.note(log, rs.fmtFormat(["contains ", args144[0], " ", args144[1]])); const ends6: [boolean, boolean] = [rs.strStartsWith(text, rs.place(() => b4, (value7) => b4 = value7).v), rs.strEndsWith(text, rs.place(() => b4, (value8) => b4 = value8).v)]; const stripped6: [string | undefined, string | undefined] = [rs.strStripPrefix(",a", rs.place(() => b4, (value9) => b4 = value9).v), rs.strStripSuffix(",a", rs.place(() => b4, (value10) => b4 = value10).v)]; const _1391: boolean = b4(120); - const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends6[0], f), (f: rs.Formatter) => rs.fmtBool(ends6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped6[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped6[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtBool(_1391, f)]; - Log.note(log, rs.fmtFormat(["ends ", args110[0], " ", args110[1], " ", args110[2]])); + const args145 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends6[0], f), (f: rs.Formatter) => rs.fmtBool(ends6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped6[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped6[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtBool(_1391, f)]; + Log.note(log, rs.fmtFormat(["ends ", args145[0], " ", args145[1], " ", args145[2]])); const once6: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, rs.place(() => b4, (value11) => b4 = value11).v), rs.strRsplitOnce(text, rs.place(() => b4, (value12) => b4 = value12).v)]; const trimmed6: [string, string] = [rs.strTrimMatches(",,a,,", rs.place(() => b4, (value13) => b4 = value13).v), rs.strTrimStartMatches(",,a", rs.place(() => b4, (value14) => b4 = value14).v)]; const replaced6: [string, string] = [rs.strReplace(text, rs.place(() => b4, (value15) => b4 = value15).v, "+"), rs.strReplace(text, rs.place(() => b4, (value16) => b4 = value16).v, "+", 2)]; const end2: string = rs.strTrimEndMatches(",a,,", rs.place(() => b4, (value17) => b4 = value17).v); const _1430: boolean = b4(120); - const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once6[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once6[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed6[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced6[0], f), (f: rs.Formatter) => rs.fmtStr(replaced6[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end2, f), (f: rs.Formatter) => rs.fmtBool(_1430, f)]; - Log.note(log, rs.fmtFormat(["once ", args112[0], " ", args112[1], " ", args112[2], " ", args112[3], " ", args112[4]])); + const args146 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once6[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once6[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed6[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced6[0], f), (f: rs.Formatter) => rs.fmtStr(replaced6[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end2, f), (f: rs.Formatter) => rs.fmtBool(_1430, f)]; + Log.note(log, rs.fmtFormat(["once ", args146[0], " ", args146[1], " ", args146[2], " ", args146[3], " ", args146[4]])); const split7: rs.Iter = rs.strSplit(text, rs.lent(rs.place(() => b4, (value18) => b4 = value18).v)); const _1453: string | undefined = rs.iterToOption(split7.next()); const _1456: string | undefined = rs.iterToOption(split7.nextBack()); - const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1453, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1456, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split ", args114[0], " ", args114[1]])); + const args147 = [(f: rs.Formatter) => rs.fmtOption(_1453, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1456, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args147[0], " ", args147[1]])); const rsplit6: rs.Vec = rs.iterToVec(rs.strRsplit(text, rs.lent(rs.place(() => b4, (value19) => b4 = value19).v)), "next", 8); const n3: rs.usize = rs.iterCount(rs.strSplitn(text, 2, rs.lent(rs.place(() => b4, (value20) => b4 = value20).v))); const last6: string | undefined = rs.iterLast(rs.strRsplitn(text, 3, rs.lent(rs.place(() => b4, (value21) => b4 = value21).v))); const _1480: boolean = b4(120); - const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit6.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.fmtOption(last6, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1480, f)]; - Log.note(log, rs.fmtFormat(["rsplit ", args116[0], " ", args116[1], " ", args116[2], " ", args116[3]])); + const args148 = [(f: rs.Formatter) => rs.fmtList(rsplit6.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.fmtOption(last6, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1480, f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args148[0], " ", args148[1], " ", args148[2], " ", args148[3]])); const forward2: string | undefined = rs.iterNth(rs.strSplitTerminator(text, rs.lent(rs.place(() => b4, (value22) => b4 = value22).v)), 3); const back2: string | undefined = rs.iterNth(rs.strRsplitTerminator(text, rs.lent(rs.place(() => b4, (value23) => b4 = value23).v)), 1); const inclusive6: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, rs.lent(rs.place(() => b4, (value24) => b4 = value24).v))), "next", 8); const _1511: boolean = b4(120); - const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(forward2, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(back2, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(inclusive6.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1511, f)]; - Log.note(log, rs.fmtFormat(["terminated ", args118[0], " ", args118[1], " ", args118[2], " ", args118[3]])); + const args149 = [(f: rs.Formatter) => rs.fmtOption(forward2, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(back2, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(inclusive6.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1511, f)]; + Log.note(log, rs.fmtFormat(["terminated ", args149[0], " ", args149[1], " ", args149[2], " ", args149[3]])); const part4 = rs.iterToOption(rs.strMatches(text, rs.lent(rs.place(() => b4, (value25) => b4 = value25).v)).next()); - const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["matches ", args120[0]])); + Log.note(log, rs.fmtFormat(["matches ", (f: rs.Formatter) => rs.fmtOption(part4, f, rs.fmtStr)])); const last7: string | undefined = rs.iterToOption(rs.strRmatches(text, rs.lent(rs.place(() => b4, (value26) => b4 = value26).v)).next()); const indices6: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [rs.iterNth(rs.strMatchIndices(text, rs.lent(rs.place(() => b4, (value27) => b4 = value27).v)), 2), rs.iterToOption(rs.strRmatchIndices(text, rs.lent(rs.place(() => b4, (value28) => b4 = value28).v)).next())]; const _1559: boolean = b4(120); - const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last7, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices6[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices6[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_1559, f)]; - Log.note(log, rs.fmtFormat(["indices ", args122[0], " ", args122[1], " ", args122[2]])); + const args151 = [(f: rs.Formatter) => rs.fmtOption(last7, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices6[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices6[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_1559, f)]; + Log.note(log, rs.fmtFormat(["indices ", args151[0], " ", args151[1], " ", args151[2]])); rs.drop(b4); Log.note(log, "dropped"); } else { @@ -897,8 +874,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); const _1597: string = "+"; const replaced7: string = rs.dropAfter(_1595, () => rs.strReplace(text, _1595, _1597, 2)); - const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(found8, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtPad(f, replaced7)]; - Log.note(log, rs.fmtFormat(["contains ", args124[0], " ", args124[1], " ", args124[2]])); + const args137 = [(f: rs.Formatter) => rs.fmtBool(found8, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtPad(f, replaced7)]; + Log.note(log, rs.fmtFormat(["contains ", args137[0], " ", args137[1], " ", args137[2]])); const d3: Guard.Guard = guard(4); const captured6 = (c10: rs.char): boolean => { if (!(c10 === 44)) { @@ -917,8 +894,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { })); const _1624: string | undefined = rs.iterToOption(split8.next()); const _1627: string | undefined = rs.iterToOption(split8.nextBack()); - const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1624, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1627, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["split ", args126[0], " ", args126[1]])); + const args138 = [(f: rs.Formatter) => rs.fmtOption(_1624, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1627, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args138[0], " ", args138[1]])); rs.drop(split8); const e3: Guard.Guard = guard(5); const captured8 = (c12: rs.char): boolean => { @@ -936,8 +913,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured9[Symbol.dispose](); })), "next", 12); - const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))]; - Log.note(log, rs.fmtFormat(["indices ", args128[0]])); + Log.note(log, rs.fmtFormat(["indices ", (f: rs.Formatter) => rs.fmtList(part2.items, f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))])); const f5: Guard.Guard = guard(6); let captured10: rs.i32 = 0; const captured11 = (c14: rs.char): boolean => { @@ -961,8 +937,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const found9: [rs.usize | undefined, boolean] = [rs.strFind(text, rs.place(() => counted, (value) => counted = value).v), rs.strContains(text, rs.place(() => counted, (value2) => counted = value2).v)]; const parts3: rs.Vec = rs.iterToVec(rs.strSplit(text, rs.lent(rs.place(() => counted, (value3) => counted = value3).v)), "next", 8); const _1672: boolean = counted(120); - const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(found9[0], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(found9[1], f)], f), (f: rs.Formatter) => rs.fmtList(parts3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1672, f)]; - Log.note(log, rs.fmtFormat(["counted ", args130[0], " ", args130[1], " ", args130[2]])); + const args140 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(found9[0], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(found9[1], f)], f), (f: rs.Formatter) => rs.fmtList(parts3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1672, f)]; + Log.note(log, rs.fmtFormat(["counted ", args140[0], " ", args140[1], " ", args140[2]])); rs.drop(counted); const make = (captured13: rs.i32, captured14: (a0: rs.char) => boolean): (a0: rs.char) => boolean => { return rs.cloning((c17: rs.char): boolean => { @@ -981,12 +957,11 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { })); const cloned: rs.Iter = split9.clone({ f: rs.closureClone }); const part3 = rs.iterToOption(split9.next()); - const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["first ", args132[0]])); + Log.note(log, rs.fmtFormat(["first ", (f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtStr)])); const rest2: rs.Vec = rs.iterToVec(cloned, "next", 8); const _1709: string | undefined = rs.iterToOption(split9.next()); - const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rest2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1709, f, rs.fmtStr)]; - Log.note(log, rs.fmtFormat(["cloned ", args134[0], " ", args134[1]])); + const args142 = [(f: rs.Formatter) => rs.fmtList(rest2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1709, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["cloned ", args142[0], " ", args142[1]])); const g3: Guard.Guard = guard(7); const captured15 = (c18: rs.char): boolean => { if (!(c18 === 44)) { @@ -1007,8 +982,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const p2: (a0: rs.char) => boolean = isSep; const _1736: rs.usize | undefined = rs.strRfind(text, shared); const _1739: rs.usize | undefined = rs.strFind(text, p2); - const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1736, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(parts4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1739, f, rs.usizeDebug)]; - Log.note(log, rs.fmtFormat(["shared ", args136[0], " ", args136[1], " ", args136[2]])); + const args143 = [(f: rs.Formatter) => rs.fmtOption(_1736, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(parts4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1739, f, rs.usizeDebug)]; + Log.note(log, rs.fmtFormat(["shared ", args143[0], " ", args143[1], " ", args143[2]])); rs.drop(shared); Log.note(log, "dropped"); } diff --git a/ts/fixtures/task/expected/futures.ts b/ts/fixtures/task/expected/futures.ts index b81588340..75b592fb3 100644 --- a/ts/fixtures/task/expected/futures.ts +++ b/ts/fixtures/task/expected/futures.ts @@ -105,8 +105,8 @@ export class helpersFuture { const _392: boolean = isPending$04edpij(waiting); const _422: boolean = isReady$1wybfmi(polled); const _45: boolean = isPending$0mrvg1b(polled); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_392, f), (f: rs.Formatter) => rs.fmtBool(_422, f), (f: rs.Formatter) => rs.fmtBool(_45, f)]; - Guard.note(captured4, rs.fmtFormat(["pending ", args2[0], " ready ", args2[1], " pending ", args2[2]])); + const args3 = [(f: rs.Formatter) => rs.fmtBool(_392, f), (f: rs.Formatter) => rs.fmtBool(_422, f), (f: rs.Formatter) => rs.fmtBool(_45, f)]; + Guard.note(captured4, rs.fmtFormat(["pending ", args3[0], " ready ", args3[1], " pending ", args3[2]])); if (polled !== rs.Pending) { if (polled !== undefined) { if (rs.u64Rem(polled, 2) === 0) { @@ -271,9 +271,8 @@ export class wakersFuture { this.#checks = [rs.willWake(this.#a, this.#b), (this.#a.data as rs.Place) === this.#b.data as rs.Place, rs.willWake(this.#a, this.#other), (this.#a.data as rs.Place) === this.#other.data as rs.Place, this.#a.vtable === this.#other.vtable, this.#a.vtable === this.#plain.vtable, rs.willWake(this.#a, this.#noop), rs.willWake(this.#noop, rs.NOOP_WAKER), (this.#noop.data as rs.Place) === rs.NULL, rs.NULL === rs.DANGLING_UNIT, rs.DANGLING_UNIT === rs.DANGLING_UNIT, rs.DANGLING_UNIT === rs.DANGLING_UNIT, rs.DANGLING_UNIT === rs.DANGLING_UNIT]; put$unit(rs.DANGLING_UNIT, undefined); put$unit(rs.DANGLING_UNIT, undefined); - const arg = this.#checks; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(arg, f, rs.fmtBool)]; - const _88: string = rs.fmtFormat(["wakers ", args2[0]]); + const arg = rs.sliceFrom(this.#checks); + const _88: string = rs.fmtFormat(["wakers ", (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.fmtBool)]); Guard.note(this.#guard, _88); lib_drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker([this.#a, this.#b, this.#other, this.#plain] as [rs.Waker, rs.Waker, rs.Waker, rs.Waker]); this.#last = undefined as [rs.Place, rs.WakerVTable] | undefined; @@ -305,8 +304,8 @@ export class wakersFuture { const _153: boolean = polling(clone); const _183: boolean = rs.willWake(lent, waker); const _222: boolean = polling(waker); - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(same, f), (f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(inner[0], f), (f: rs.Formatter) => rs.fmtBool(inner[1], f)], f), (f: rs.Formatter) => rs.fmtBool(_222, f)]; - const _85: string = rs.fmtFormat(["same ", args4[0], " clone ", args4[1], " lent ", args4[2], " inner ", args4[3], " after ", args4[4]]); + const args6 = [(f: rs.Formatter) => rs.fmtBool(same, f), (f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(inner[0], f), (f: rs.Formatter) => rs.fmtBool(inner[1], f)], f), (f: rs.Formatter) => rs.fmtBool(_222, f)]; + const _85: string = rs.fmtFormat(["same ", args6[0], " clone ", args6[1], " lent ", args6[2], " inner ", args6[3], " after ", args6[4]]); Guard.note(this.#guard, _85); const _04: rs.Poll = this.#next.poll(cx); clone[Symbol.dispose](); @@ -520,8 +519,7 @@ export class boxedFuture { rs.drop(this.#awaitee); this.#first = option_unwrapOr$15hbiwd(result, 0); const arg = this.#first; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg, f)]; - const _17: string = rs.fmtFormat(["first ", args2[0]]); + const _17: string = rs.fmtFormat(["first ", (f: rs.Formatter) => rs.u64Display(arg, f)]); Guard.note(this.#guard, _17); const _28: [rs.u32, Log.Log] = [Guard.id(this.#guard), Log.clone$Clone(Guard.log(this.#guard))]; this.#id = _28[0]; @@ -580,8 +578,7 @@ export class boxedFuture { if (_81 !== rs.Pending) { this.#saved = rs.u64Add(this.#saved, _81); const arg2 = this.#saved; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg2, f)]; - const _92: string = rs.fmtFormat(["lent ", args4[0]]); + const _92: string = rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.u64Display(arg2, f)]); Guard.note(this.#guard, _92); this.#saved$5 = false; this.#lend[Symbol.dispose](); @@ -641,8 +638,7 @@ export class boxedFuture { this.#old[Symbol.dispose](); this.#moved = rs.u64Add(this.#moved, result8); const arg3 = this.#moved; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg3, f)]; - const _183: string = rs.fmtFormat(["moved ", args6[0]]); + const _183: string = rs.fmtFormat(["moved ", (f: rs.Formatter) => rs.u64Display(arg3, f)]); Guard.note(this.#guard, _183); const _197: [Guard.Guard, Guard.Guard, Guard.Guard] = [Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 700), Log.clone$Clone(this.#log))]; const block: Guard.Guard = _197[0]; @@ -708,8 +704,7 @@ export class boxedFuture { if (_248 !== rs.Pending) { const total: rs.u64 = _248; this.#awaitee$6[Symbol.dispose](); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(total, f)]; - const _258: string = rs.fmtFormat(["boxed ", args8[0]]); + const _258: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.u64Display(total, f)]); Guard.note(this.#guard, _258); this.#pinned[Symbol.dispose](); this.#saved$2 = false; @@ -760,8 +755,7 @@ export class boxedFuture$closure2 { const result: rs.u64 | undefined = _7; rs.drop(this.#awaitee); const value: rs.u64 = option_unwrapOr$15hbiwd(result, 0); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - const _17: string = rs.fmtFormat(["block ", args2[0]]); + const _17: string = rs.fmtFormat(["block ", (f: rs.Formatter) => rs.u64Display(value, f)]); Guard.note(this.#block, _17); const _30: rs.u64 = rs.u64Add(value, 1); this.#rx[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index 0929ac995..3b9abbdcc 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -45,8 +45,8 @@ export function log(self: Guard): Log.Log { /** Log `event` as this guard's. */ export function note(self: Guard, event: string): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, event)]; - const _5: string = rs.fmtFormat(["g", args2[0], " ", args2[1]]); + const args3 = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, event)]; + const _5: string = rs.fmtFormat(["g", args3[0], " ", args3[1]]); Log.note(self.log, _5); } @@ -65,8 +65,7 @@ export function unbox(self: Guard, event: string): rs.u32 { export function drop$ops_Drop(self: Guard): void { const arg = self.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _4: string = rs.fmtFormat(["g", args2[0], " drop"]); + const _4: string = rs.fmtFormat(["g", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index b237513e6..c4802d569 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -82,12 +82,11 @@ export class sumFuture { const value: rs.u64 = result; if (!(value !== 99)) { const arg2 = this.#guard.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f)]; - rs.panicFmt(["g", args2[0], " poisoned"]); + rs.panicFmt(["g", (f: rs.Formatter) => rs.u32Display(arg2, f), " poisoned"]); } else { const arg = this.#guard.id; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.u64Display(value, f)]; - const _32: string = rs.fmtFormat(["g", args4[0], " got ", args4[1]]); + const args5 = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.u64Display(value, f)]; + const _32: string = rs.fmtFormat(["g", args5[0], " got ", args5[1]]); Log.note(this.#inner.log, _32); this.#total = rs.u64Add(this.#total, value); bb0 = 4; @@ -224,8 +223,7 @@ export class watchFuture { this.#awaitee[Symbol.dispose](); rs.drop(this.#pinned); const arg = this.#first; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(arg, f, rs.u64Debug)]; - const _22: string = rs.fmtFormat(["first ", args2[0]]); + const _22: string = rs.fmtFormat(["first ", (f: rs.Formatter) => rs.fmtOption(arg, f, rs.u64Debug)]); Guard.note(this.#guard, _22); this.#saved$2 = false; this.#pending = Pending.new$model_Watch(new Watch.Watch(this.#rx, 1)); @@ -246,8 +244,7 @@ export class watchFuture { const result2: rs.u64 | undefined = _38; if (result2 !== undefined) { value = result2; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; - const _50: string = rs.fmtFormat(["watched ", args4[0]]); + const _50: string = rs.fmtFormat(["watched ", (f: rs.Formatter) => rs.u64Display(value, f)]); Guard.note(this.#guard, _50); this.#total = rs.u64Add(this.#total, value); const _62: Watch.Watch = Pending.derefMut$ops_DerefMut_model_Watch(this.#pending); @@ -280,8 +277,8 @@ export class watchFuture { const sent: rs.Result = _82; rs.drop(this.#awaitee$4); const arg2 = this.#watch.index; - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg2, f), (f: rs.Formatter) => rs.fmtResult(sent, f, rs.usizeDebug, (value: Closed.Closed, f: rs.Formatter) => Closed.fmt$fmt_Debug(value, f))]; - const _92: string = rs.fmtFormat(["watched to ", args6[0], " of ", args6[1]]); + const args9 = [(f: rs.Formatter) => rs.usizeDisplay(arg2, f), (f: rs.Formatter) => rs.fmtResult(sent, f, rs.usizeDebug, (value: Closed.Closed, f: rs.Formatter) => Closed.fmt$fmt_Debug(value, f))]; + const _92: string = rs.fmtFormat(["watched to ", args9[0], " of ", args9[1]]); Guard.note(this.#guard, _92); const _109: rs.u64 = this.#total; this.#watch[Symbol.dispose](); @@ -396,14 +393,13 @@ export class frontFuture { return rs.Pending; case 23: const arg = this.#listing; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(arg, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]; - const _32: string = rs.fmtFormat(["listing ", args2[0]]); + const _32: string = rs.fmtFormat(["listing ", (f: rs.Formatter) => rs.fmtOption(arg, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]); Guard.note(this.#guard, _32); this.#awaitee$2 = wait$model_front_closure0_closure0_usize((waiter: Waiter.Waiter): rs.Poll => { while (true) { - const _42: rs.Poll = Consumer.pollRecv(this.#rx, waiter); - if (_42 !== rs.Pending) { - const next: rs.u64 | undefined = _42; + const _43: rs.Poll = Consumer.pollRecv(this.#rx, waiter); + if (_43 !== rs.Pending) { + const next: rs.u64 | undefined = _43; if (next === undefined) { return this.#inFlight.items.length; } @@ -433,8 +429,8 @@ export class frontFuture { this.#awaitee$2[Symbol.dispose](); const _69: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(closed, f); const arg2 = this.#inFlight; - const args4: rs.Fmt[] = [_69, (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u64Debug)]; - const _60: string = rs.fmtFormat(["closed with ", args4[0], " in flight ", args4[1]]); + const args6 = [_69, (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u64Debug)]; + const _60: string = rs.fmtFormat(["closed with ", args6[0], " in flight ", args6[1]]); Guard.note(this.#guard, _60); const _79: rs.u64 = rs.iterSum(rs.iterSlice(this.#inFlight.items), rs.u64Add, 0); this.#guard[Symbol.dispose](); @@ -692,8 +688,7 @@ export class blocksFuture { this.#slots[result2][Symbol.dispose](); this.#slots[result2] = this.#saved; const arg = this.#waited; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg, f)]; - const _76: string = rs.fmtFormat(["slot after ", args2[0]]); + const _76: string = rs.fmtFormat(["slot after ", (f: rs.Formatter) => rs.u64Display(arg, f)]); Guard.note(this.#slots[0], _76); this.#tally = { n: this.#guard.id }; const seen: rs.Future = new blocksFuture$closure1(copy$model_Tally(this.#tally)); @@ -711,8 +706,8 @@ export class blocksFuture { const _98: rs.u32 = _100; rs.drop(this.#awaitee$3); const arg2 = this.#saved$2; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_98, f)]; - const _91: string = rs.fmtFormat(["tally ", args4[0], " then ", args4[1]]); + const args12 = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_98, f)]; + const _91: string = rs.fmtFormat(["tally ", args12[0], " then ", args12[1]]); Guard.note(this.#saved, _91); this.#mark = { n: 1 }; this.#awaitee$3 = new blocksFuture$closure2(this.#mark); @@ -728,8 +723,8 @@ export class blocksFuture { const arg3 = this.#saved$2; const _135: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg3, f); const arg4 = this.#mark.n; - const args6: rs.Fmt[] = [_135, (f: rs.Formatter) => rs.u32Display(arg4, f)]; - const _126: string = rs.fmtFormat(["mark ", args6[0], " ", args6[1]]); + const args13 = [_135, (f: rs.Formatter) => rs.u32Display(arg4, f)]; + const _126: string = rs.fmtFormat(["mark ", args13[0], " ", args13[1]]); Guard.note(this.#guard, _126); this.#count = this.#guard.id; this.#awaitee$3 = new blocksFuture$closure3(rs.place(() => this.#count, (value) => this.#count = value)); @@ -745,8 +740,8 @@ export class blocksFuture { const arg5 = this.#counted; const _161: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg5, f); const arg6 = this.#count; - const args8: rs.Fmt[] = [_161, (f: rs.Formatter) => rs.u32Display(arg6, f)]; - const _152: string = rs.fmtFormat(["count ", args8[0], " ", args8[1]]); + const args14 = [_161, (f: rs.Formatter) => rs.u32Display(arg6, f)]; + const _152: string = rs.fmtFormat(["count ", args14[0], " ", args14[1]]); Guard.note(this.#guard, _152); this.#nested = new Inner.Inner(new Outer.Outer(undefined, Guard.new(rs.u32Add(this.#guard.id, 800), Log.clone$Clone(this.#guard.log)))); const third: Guard.Guard = Guard.new(rs.u32Add(this.#guard.id, 400), Log.clone$Clone(this.#guard.log)); @@ -767,8 +762,7 @@ export class blocksFuture { this.#looped = _187; rs.drop(this.#awaitee$3); const arg7 = this.#looped; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg7, f)]; - const _197: string = rs.fmtFormat(["looped ", args10[0]]); + const _197: string = rs.fmtFormat(["looped ", (f: rs.Formatter) => rs.u32Display(arg7, f)]); Guard.note(this.#saved, _197); if (this.#moves) { this.#saved$3 = false; @@ -1139,8 +1133,7 @@ export function temporaries(log: Log.Log, id: rs.u32): void { }; const _11: Guard.Guard = guard(1000); const arg = _11.id; - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; - const _7: string = rs.fmtFormat(["temporary ", args2[0]]); + const _7: string = rs.fmtFormat(["temporary ", (f: rs.Formatter) => rs.u32Display(arg, f)]); _11[Symbol.dispose](); Log.note(log, _7); const _19: Guard.Guard | undefined = guard(1010); @@ -1159,13 +1152,12 @@ export function temporaries(log: Log.Log, id: rs.u32): void { } const _39: Guard.Guard = guard(1030); const arg2 = _39.id; - const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.i32Display(matched, f)]; - const _35: string = rs.fmtFormat(["boxed temporary ", args4[0], " ", args4[1]]); + const args14 = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.i32Display(matched, f)]; + const _35: string = rs.fmtFormat(["boxed temporary ", args14[0], " ", args14[1]]); _39[Symbol.dispose](); Log.note(log, _35); const part = first([guard(1040), guard(1050)] as [Guard.Guard, Guard.Guard]); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["skipped ", args6[0]])); + Log.note(log, rs.fmtFormat(["skipped ", (f: rs.Formatter) => rs.u32Display(part, f)])); const _69: Guard.Guard[] = [guard(1060), guard(1070), guard(1080)]; const head: Guard.Guard = _69[0]; const rest: Guard.Guard[] = _69.slice(1, 3); @@ -1173,16 +1165,14 @@ export function temporaries(log: Log.Log, id: rs.u32): void { Guard.note(rest[1], "rest"); guard(1090)[Symbol.dispose](); const part2 = rs.sliceFrom([]).length; - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; - Log.note(log, rs.fmtFormat(["empty ", args8[0]])); + Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.usizeDisplay(part2, f)])); const captured = guard(1100); const part3 = rs.closure((): rs.u32 => { return Guard.finish(captured, "closure"); }, (): void => { captured[Symbol.dispose](); })(); - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; - Log.note(log, rs.fmtFormat(["closed ", args10[0]])); + Log.note(log, rs.fmtFormat(["closed ", (f: rs.Formatter) => rs.u32Display(part3, f)])); let sum: rs.u32 = 0; const iter: Countdown.Countdown = new Countdown.Countdown(2, guard(1110)); while (true) { @@ -1193,8 +1183,7 @@ export function temporaries(log: Log.Log, id: rs.u32): void { sum = rs.u32Add(sum, _126); } iter[Symbol.dispose](); - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; - Log.note(log, rs.fmtFormat(["counted ", args12[0]])); + Log.note(log, rs.fmtFormat(["counted ", (f: rs.Formatter) => rs.u32Display(sum, f)])); rs.dropAll(rest); head[Symbol.dispose](); } @@ -1212,8 +1201,7 @@ export function read(t: Tally.Tally): rs.u32 { /** `i`, noted as picked. */ export function pick(log: Log.Log, i: rs.usize): rs.usize { - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f)]; - Log.note(log, rs.fmtFormat(["pick ", args2[0]])); + Log.note(log, rs.fmtFormat(["pick ", (f: rs.Formatter) => rs.usizeDisplay(i, f)])); return i; } @@ -1245,44 +1233,38 @@ export function turns(log: Log.Log, count: rs.u32): void { const _42: Guard.Guard = Guard.new(rs.u32Add(count, 90), Log.clone$Clone(log)); const scoped: rs.u32 = _42.id; _42[Symbol.dispose](); - const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(scoped, f)]; - Log.note(log, rs.fmtFormat(["after ", args2[0]])); + Log.note(log, rs.fmtFormat(["after ", (f: rs.Formatter) => rs.u32Display(scoped, f)])); const boxed: Guard.Guard = Guard.new(rs.u32Add(count, 100), Log.clone$Clone(log)); const once: rs.u32 = boxed.id; const _70: rs.Fmt = (f: rs.Formatter) => rs.u32Display(once, f); const arg = boxed.id; - const args4: rs.Fmt[] = [_70, (f: rs.Formatter) => rs.u32Display(arg, f)]; - Log.note(log, rs.fmtFormat(["boxed ", args4[0], " ", args4[1]])); + const args16 = [_70, (f: rs.Formatter) => rs.u32Display(arg, f)]; + Log.note(log, rs.fmtFormat(["boxed ", args16[0], " ", args16[1]])); const part = Guard.finish(Guard.new(rs.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); - const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; - Log.note(log, rs.fmtFormat(["finished ", args6[0]])); + Log.note(log, rs.fmtFormat(["finished ", (f: rs.Formatter) => rs.u32Display(part, f)])); const part2 = Guard.unbox(Guard.new(rs.u32Add(count, 120), Log.clone$Clone(log)), "unboxing"); - const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; - Log.note(log, rs.fmtFormat(["unboxed ", args8[0]])); + Log.note(log, rs.fmtFormat(["unboxed ", (f: rs.Formatter) => rs.u32Display(part2, f)])); if (rs.u32Rem(count, 2) === 0) { stacked = [Guard.new(rs.u32Add(count, 130), Log.clone$Clone(log)), Guard.new(rs.u32Add(count, 140), Log.clone$Clone(log))]; } else { stacked = undefined; } const part3 = stacked !== undefined; - const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; - Log.note(log, rs.fmtFormat(["stacked ", args10[0]])); + Log.note(log, rs.fmtFormat(["stacked ", (f: rs.Formatter) => rs.fmtBool(part3, f)])); if (rs.u32Rem(count, 2) === 0) { failed = rs.Err(Guard.new(rs.u32Add(count, 150), Log.clone$Clone(log))); } else { failed = rs.Ok(count); } const part4 = !failed.ok; - const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; - Log.note(log, rs.fmtFormat(["failed ", args12[0]])); + Log.note(log, rs.fmtFormat(["failed ", (f: rs.Formatter) => rs.fmtBool(part4, f)])); if (rs.u32Rem(count, 3) === 0) { flow = rs.Err(Guard.new(rs.u32Add(count, 160), Log.clone$Clone(log))); } else { flow = rs.Ok(count); } const part5 = !flow.ok; - const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; - Log.note(log, rs.fmtFormat(["flow ", args14[0]])); + Log.note(log, rs.fmtFormat(["flow ", (f: rs.Formatter) => rs.fmtBool(part5, f)])); const spares: Guard.Guard[] = [Guard.new(rs.u32Add(count, 70), Log.clone$Clone(log)), Guard.new(rs.u32Add(count, 80), Log.clone$Clone(log))]; const _179: rs.usize = pick(log, rs.usizeRem(count as rs.usize, 2)); if (!(_179 < 2)) { diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index 9e0238929..f4c095417 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -216,9 +216,10 @@ export function ptrUnerase(p: Place, type: string, align: number): un /** * A generic type's pointer or reference to a `T` that only an instance decides: the object, - * the `Place` of a value JS copies, or the `ByteSlice` of a `[u8; N]`'s bytes. + * the `Place` of a value JS copies, or the `Slice` of a `[T; N]`'s elements, a `ByteSlice` + * of a `[u8; N]`'s. */ -export type Ptr = T | Place | ByteSlice; +export type Ptr = T | Place | ByteSlice | (T extends readonly (infer E)[] ? Slice : never); /** A generic type's `[T; N]`: the array, or the `Uint8Array` of a `[u8; N]`. */ export type ArrayOf = T[] | Uint8Array; @@ -547,11 +548,14 @@ export function replaceIn(p: T, value: T, depth = 0): T { /** * A copy of the object `p`, one object deep: its fields, its bytes, or its items for a JS * array. Its items, and theirs to `depth` levels of arrays, are objects - * a write may land in, as a `sliceIn`'s, which a view of one copies too. + * a write may land in, as a `sliceIn`'s, which a view of one copies too, as are runs a + * view of runs holds. */ export function objectCopy(p: T, depth = 0): T { if (ArrayBuffer.isView(p)) return (p as unknown as Uint8Array).slice() as T; if (Array.isArray(p)) { + const view = (p as { [VIEW]?: View })[VIEW]; + if (isRuns(p) || (view !== undefined && isRuns(view.s))) return Array.from(p, copyRun) as T; const old: unknown[] = p.slice(); if (depth > 0 && writesIn(p)) for (let i = 0; i < old.length; i++) old[i] = objectCopy(old[i] as object, depth - 1); return old as T; @@ -711,12 +715,7 @@ export function sliceFrom(items: T[]): Slice { * is all of it, or else a copy, which nothing can tell from it while the borrow lives. */ export function sliceItems(s: Slice): T[] { - return itemsOf(s.data, s.start, s.start + s.length); -} - -/** Elements `start` to `end` of `data`, as `sliceItems` reads them: `data` itself where they are all of it. */ -function itemsOf(data: T[], start: number, end: number): T[] { - return start === 0 && end === data.length ? data : data.slice(start, end); + return s.start === 0 && s.length === s.data.length ? s.data : s.data.slice(s.start, s.start + s.length); } /** Elements in a row, as a slice reads them: the JS array of a `[T; N]`, a `Slice`, or a `Vec`. */ @@ -737,9 +736,30 @@ export function sliceLength(s: Elements): number { return s instanceof Vec ? s.items.length : s.length; } -/** A copy of the elements of `s`, as an array of its own, as `to_vec` of what JS copies makes one. */ -export function sliceToArray(s: Slice): T[] { - return s.data.slice(s.start, s.start + s.length); +/** + * A copy of the elements of `s`, as an array of its own, as `to_vec` of what JS copies makes + * one, and `*r` of a `&[T; N]` with each element made a value of its own by `copy`. + */ +export function sliceToArray(s: Slice, copy?: (value: T) => T): T[] { + const items = s.data.slice(s.start, s.start + s.length); + if (copy) for (let i = 0; i < items.length; i++) items[i] = copy(items[i]); + return items; +} + +/** `*r = items` of a `&mut [T; N]`: each element written where the slice holds it. */ +export function sliceSet(s: Slice, items: ArrayLike): void { + for (let i = 0; i < s.length; i++) s.data[s.start + i] = items[i]; +} + +/** + * Whether pointers to a `[T; N]`, slices of its elements, point at the same place: the same + * element of the same array, through any view of runs `as_chunks_mut` lends, or both null. + */ +export function sliceSame(a: Slice, b: Slice): boolean { + if (!(a instanceof Slice && b instanceof Slice)) return a === b; + const [x, y] = [(a.data as { [VIEW]?: View })[VIEW], (b.data as { [VIEW]?: View })[VIEW]]; + const [xs, ys] = [x ? x.s : a.data, y ? y.s : b.data]; + return xs === ys && (x ? x.start : 0) + a.start === (y ? y.start : 0) + b.start; } /** A bounds-checked index into a slice. */ @@ -778,12 +798,21 @@ export function slicePart(s: Slice, start: number, end: number = s.length) * same length, answers for the rest, such as `length` and the methods. A view of a view * reads the array beneath both. */ -export function arrayView(s: T[], start: number, end: number): T[] { +function arrayView(s: T[], start: number, end: number): T[] { const outer = (s as { [VIEW]?: View })[VIEW]; const view = outer ? outer.part(start, end - start) : new View(s, start, end - start); return new Proxy(new Array(end - start), view); } +/** + * The `[T; N]` a `&mut [T; N]`, `s`, points at, as a JS array read and written where the + * slice holds it, as a `ByteSlice`'s `Uint8Array` view is: the array itself where the slice + * is all of it, and else a view of its part. + */ +export function sliceView(s: Slice): T[] { + return s.start === 0 && s.length === s.data.length ? s.data : arrayView(s.data, s.start, s.start + s.length); +} + /** `Option::as_slice` of `o`, whose `None` is `none`: its payload, if any, as `slice::from_ref` makes a slice of one. */ export function optionAsSlice(o: T | undefined): Slice; export function optionAsSlice(o: T | None, none: None): Slice; @@ -815,24 +844,12 @@ export function sliceIn(p: T): Slice { return sliceOfPlace(partPlace(p)); } -/** `array::from_mut`: an array of the one value at `p`, read and written there, as an `arrayView` is. */ -export function arrayOfPlace(p: Place): T[] { - const s = sliceOfPlace(p); - return arrayView(s.data, s.start, s.start + 1); -} - -/** `array::from_mut` of the object a `&mut` is, as `sliceIn` makes a slice of it. */ -export function arrayIn(p: T): T[] { - return arrayOfPlace(partPlace(p)); -} - /** The arrays of one that `sliceOfPlace`'s slices of a place in no array read. */ const ONE = /* @__PURE__ */ new WeakSet(); /** * Whether a whole write of an element of `s`, an array a slice holds, may land in the object - * there, as one of `sliceIn`'s or `arrayIn`'s does, or of a place in one, which only - * `sliceOfPlace`'s and `arrayOfPlace`'s can be. + * there, as one of `sliceIn`'s does, or of a place in one, which only `sliceOfPlace`'s can be. */ function writesIn(s: object): boolean { const view = (s as { [VIEW]?: View })[VIEW]; @@ -1074,65 +1091,38 @@ export function sliceGetRange(s: Slice, start: number, end: number = s.len return start <= end && end <= s.length ? slicePart(s, start, end) : undefined; } -// A `[T; N]` of other values than bytes is a JS array of its own, which a slice lends as -// `sliceItems` reads it, or mutably as an `arrayView` of where it holds it. - -/** `first_chunk`: the first `n` elements, or `undefined` if fewer. */ -export function sliceFirstChunk(s: Slice, n: number): T[] | undefined { - return n > s.length ? undefined : itemsOf(s.data, s.start, s.start + n); -} - -/** `first_chunk_mut`: a view of the first `n` elements, or `undefined` if fewer. */ -export function sliceFirstChunkMut(s: Slice, n: number): T[] | undefined { - return n > s.length ? undefined : arrayView(s.data, s.start, s.start + n); -} - -/** `last_chunk`: the last `n` elements, or `undefined` if fewer. */ -export function sliceLastChunk(s: Slice, n: number): T[] | undefined { - const end = s.start + s.length; - return n > s.length ? undefined : itemsOf(s.data, end - n, end); -} - -/** `last_chunk_mut`: a view of the last `n` elements, or `undefined` if fewer. */ -export function sliceLastChunkMut(s: Slice, n: number): T[] | undefined { - const end = s.start + s.length; - return n > s.length ? undefined : arrayView(s.data, end - n, end); -} - -/** `split_first_chunk`: the first `n` elements and the rest, or `undefined` if fewer. */ -export function sliceSplitFirstChunk(s: Slice, n: number): [T[], Slice] | undefined { - return n > s.length ? undefined : [itemsOf(s.data, s.start, s.start + n), slicePart(s, n)]; +/** `last_chunk`, shared or mutable: the last `n` elements, or `undefined` if fewer. */ +export function sliceLastChunk(s: Slice, n: number): Slice | undefined { + return n > s.length ? undefined : slicePart(s, s.length - n); } -/** `split_first_chunk_mut`: a view of the first `n` elements and the rest, or `undefined` if fewer. */ -export function sliceSplitFirstChunkMut(s: Slice, n: number): [T[], Slice] | undefined { - return n > s.length ? undefined : [arrayView(s.data, s.start, s.start + n), slicePart(s, n)]; -} - -/** `split_last_chunk`: the rest and the last `n` elements, or `undefined` if fewer. */ -export function sliceSplitLastChunk(s: Slice, n: number): [Slice, T[]] | undefined { - const end = s.start + s.length; - return n > s.length ? undefined : [slicePart(s, 0, s.length - n), itemsOf(s.data, end - n, end)]; -} - -/** `split_last_chunk_mut`: the rest and a view of the last `n` elements, or `undefined` if fewer. */ -export function sliceSplitLastChunkMut(s: Slice, n: number): [Slice, T[]] | undefined { - const end = s.start + s.length; - return n > s.length ? undefined : [slicePart(s, 0, s.length - n), arrayView(s.data, end - n, end)]; +/** `split_last_chunk`, shared or mutable: the rest and the last `n` elements, or `undefined` if fewer. */ +export function sliceSplitLastChunk(s: Slice, n: number): [Slice, Slice] | undefined { + return n > s.length ? undefined : [slicePart(s, 0, s.length - n), slicePart(s, s.length - n)]; } /** `as_chunks`: copies of each run of `n` elements from the front, and the rest, panicking at a size of 0. */ export function sliceAsChunks(s: Slice, n: number, at?: Location): [Slice, Slice] { const count = chunkCount(s.length, n, at); - const from = (k: number) => s.start + k; - return [sliceFrom(runs(count, n, (start, end) => s.data.slice(from(start), from(end)))), slicePart(s, count * n)]; + return [sliceFrom(runs(count, n, (start, end) => runCopy(s.data, s.start + start, s.start + end))), slicePart(s, count * n)]; } /** `as_rchunks`: the rest, and copies of each run of `n` elements up to the back, panicking at a size of 0. */ export function sliceAsRchunks(s: Slice, n: number, at?: Location): [Slice, Slice] { const count = chunkCount(s.length, n, at); const rest = s.start + s.length - count * n; - return [slicePart(s, 0, s.length - count * n), sliceFrom(runs(count, n, (start, end) => s.data.slice(rest + start, rest + end)))]; + return [slicePart(s, 0, s.length - count * n), sliceFrom(runs(count, n, (start, end) => runCopy(s.data, rest + start, rest + end)))]; +} + +/** + * Elements `start` to `end` of `data`, a run a shared slice lends, as a copy, which + * nothing writes through: one that answers to its `View` of `data`, so pointers to it + * point where the run is. + */ +function runCopy(data: T[], start: number, end: number): T[] { + const outer = (data as { [VIEW]?: View })[VIEW]; + const view = outer ? outer.part(start, end - start) : new View(data, start, end - start); + return Object.defineProperty(data.slice(start, end), VIEW, { value: view }); } /** `as_chunks_mut`: each run of `n` elements from the front as an array, written where the slice holds it, and the rest, panicking at a size of 0. */ @@ -2100,10 +2090,10 @@ export function arrayFrom(a: ArrayLike): T[] { return Array.from(a); } -/** `<[T; N]>::each_mut` of elements JS copies: the place of each. */ -export function arrayPlaces(a: { [i: number]: T; length: number }): Place[] { +/** `<[T; N]>::each_mut` of elements JS copies, of the slice a `&mut [T; N]` is: the place of each. */ +export function slicePlaces(s: SliceLike): Place[] { const out: Place[] = []; - for (let i = 0; i < a.length; i++) out.push(new AtIndex(a, i)); + for (let i = 0; i < s.length; i++) out.push(new AtIndex(s.data, s.start + i)); return out; } diff --git a/ts/src/census.rs b/ts/src/census.rs index b71959f97..d064b37ad 100644 --- a/ts/src/census.rs +++ b/ts/src/census.rs @@ -175,6 +175,7 @@ const VERBATIM: &[&str] = &[ "Vec::spare_capacity_mut", "Vec::splice", "alloc", + "array::from_ref", "async fn", "become", "bool", diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 6051ed934..86ff10302 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -3095,8 +3095,7 @@ pub fn eq_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr } _ if let Some(pointee) = raw_pointee(tcx, ty) => match b.t.incomparable(pointee) { Some(why) => b.err(span, why), - None if b.t.pointee(pointee) == super::pointer::Pointee::Bytes => Expr::Rs("byteSliceSame".into()), - None => Expr::Rs("same".into()), + None => b.t.same_fn(pointee).unwrap_or_else(|| Expr::Rs("same".into())), }, ty::Adt(..) if let Some(inner) = option_of(b, ty) => match eq_fn(b, inner, span) { // `None` is no value of `inner`, so `===` tells it from each. @@ -3411,6 +3410,19 @@ pub fn clone_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> E b.t.clone_closure(*def_id); return Expr::Rs("closureClone".into()); } + // The runtime holds an array as its items, where its `clone` takes a slice of them. + if let ty::Array(elem, _) = ty.kind() { + let items = Expr::ident("a"); + let made = match clone_fn(b, *elem, span) { + Expr::Lit(l) if l == "undefined" => items.member("slice").call(Vec::new()), + clone => items.member("map").call(vec![clone]), + }; + let param = crate::ts::Param { + name: "a".into(), + ty: Some(b.t.ty(ty, span)), + }; + return Expr::Lambda(vec![param], Box::new(made)); + } let clone = trait_fn(tcx, "Clone", "clone"); b.fn_value(clone, tcx.mk_args(&[ty.into()]), span) } diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index 8db605534..e9744dbd3 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -77,7 +77,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { _ => Expr::rs("sliceFrom", vec![Expr::Array(items)]), } } - _ if super::byte_array(*inner) => Expr::rs("byteSliceFrom", vec![self.value(*inner, valtree, span)]), + _ if inner.is_array() => super::array_fn(*inner, "From").call(vec![self.value(*inner, valtree, span)]), _ => self.value(*inner, valtree, span), }, ty::Array(elem, _) => { diff --git a/ts/src/lower/copy.rs b/ts/src/lower/copy.rs index b88d3d26f..92ca19873 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -141,6 +141,36 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { self.changes(ty).then(|| self.shim(ty, span)).flatten() } + /// A copy of the `ty`, a `[T; N]`, that `s`, the slice a reference to one is, holds, as + /// a read through the reference copies it: an array of its own, with each element JS + /// keeps as an object the crate writes into copied too. + pub fn array_copy(&mut self, s: Expr, ty: Ty<'tcx>, span: Span) -> Expr { + let elem = match self.uninit_inner(ty).kind() { + ty::Array(elem, _) => *elem, + _ => unreachable!("an array's slice"), + }; + if super::byte(elem) { + return Expr::rs("byteSliceToArray", vec![s]); + } + let mut values = vec![s]; + values.extend(self.changes(elem).then(|| self.shim(elem, span)).flatten()); + Expr::rs("sliceToArray", values) + } + + /// The function [`Self::array_copy`] calls on a slice of a `ty`. + pub fn array_copy_fn(&mut self, ty: Ty<'tcx>, span: Span) -> Expr { + match self.array_copy(Expr::ident("s"), ty, span) { + Expr::Call(f, args) if args.len() == 1 => *f, + copy => Expr::Lambda( + vec![ts::Param { + name: "s".into(), + ty: None, + }], + Box::new(copy), + ), + } + } + /// `value`, copied if a `ty` is. pub fn copied(&mut self, value: Expr, ty: Ty<'tcx>, span: Span) -> Expr { match self.copy_fn(ty, span) { diff --git a/ts/src/lower/dynamic.rs b/ts/src/lower/dynamic.rs index 7d022b290..bfc60fb65 100644 --- a/ts/src/lower/dynamic.rs +++ b/ts/src/lower/dynamic.rs @@ -916,9 +916,9 @@ impl<'tcx> Body<'_, '_, 'tcx> { let view = self.tail_object(value, pointee, object, from.is_box(), span); return view.unwrap_or_else(|| unsupported(self)); } - // A box holds one as a `Uint8Array` and a reference as an `rs.ByteSlice`, which one + // A box holds an array as a JS array and a reference as an `rs.Slice` of it, which one // class's methods can't both take. - if super::byte_array(pointee) { + if pointee.is_array() { return self.err( span, format!("a trait object of `{pointee}`, which is not supported yet"), diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 01a0228b8..50e6b2ce6 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -332,9 +332,9 @@ pub fn std_impl<'tcx>( let rs = |name: &str, args: Vec| Expr::rs_of("fmt", name).call(args); let text = matches!(tr, Trait::Display | Trait::Debug); Some(match ty.kind() { - // A reference to an array of bytes is a slice of them, written as a slice is. - ty::Ref(_, inner, _) if super::byte_array(*inner) => { - b.fmt_call(tr, Ty::new_slice(tcx, tcx.types.u8), value, f, span) + // A reference to an array is a slice of it, written as a slice is. + ty::Ref(_, inner, _) if let ty::Array(elem, _) = inner.kind() => { + b.fmt_call(tr, Ty::new_slice(tcx, *elem), value, f, span) } ty::Ref(_, inner, _) => { let value = b.t.pointee_value(ty, value); diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 0f9bdd8cb..38349385b 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -546,10 +546,10 @@ fn own_methods<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, owned: bool, span let Some(instance) = own_method(b, ty, tr, name) else { continue; }; - // The closure is given a reference to each item, which std lends a `[u8; N]` to as + // The closure is given a reference to each item, which std lends a `[T; N]` to as // the array, where the crate's is a slice of it. if matches!(*name, "find" | "rfind" | "is_sorted_by") - && let Some(item) = item.filter(|&item| super::byte_array(item)) + && let Some(item) = item.filter(|&item| item.is_array()) { b.t.err( span, @@ -867,11 +867,11 @@ fn result_places(place: Expr) -> Expr { } /// `iter`, over the elements of a slice or `Vec` of `elem`s or the payload of an `Option` -/// or a `Result`, yielding references to them: a slice of each array of bytes. +/// or a `Result`, yielding references to them: a slice of each array. pub(super) fn by_ref(iter: Expr, elem: Ty<'_>) -> Expr { - match super::byte_array(elem) { - true => Expr::rs("iterLend", vec![iter, Expr::Rs("byteSliceFrom".into())]), - false => iter, + match elem.kind() { + ty::Array(..) => Expr::rs("iterLend", vec![iter, super::array_fn(elem, "From")]), + _ => iter, } } @@ -1342,7 +1342,20 @@ pub fn call<'tcx>( true => super::collections::eq_fn(b, item, span), false => { let by = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, expected); - super::collections::impl_eq(b, "eq", item, expected, [item, by], span) + let eq = super::collections::impl_eq(b, "eq", item, expected, [item, by], span); + // The mapping is given the array, where the impl's `eq` takes a slice of it. + match expected.is_array() { + true => { + let param = |name: &str| crate::ts::Param { + name: name.into(), + ty: None, + }; + let slice = super::array_fn(expected, "From").call(vec![Expr::ident("b")]); + let call = eq.call(vec![Expr::ident("a"), slice]); + Expr::Lambda(vec![param("a"), param("b")], Box::new(call)) + } + false => eq, + } } }; method(&camel, [rest, vec![eq], none.into_iter().collect()].concat()) @@ -1490,7 +1503,7 @@ pub fn call<'tcx>( // Each item through its `Clone`. _ if !copies => Some(clone(b)?), // Out of the slice each item is. - _ if super::byte_array(*inner) => Some(Expr::Rs("byteSliceToArray".into())), + _ if inner.is_array() => Some(b.t.array_copy_fn(*inner, span)), _ => b.t.copy_fn(*inner, span), }; // std's `copied` skips through its iterator's `nth`, and `cloned` by its own `next`. @@ -1604,7 +1617,7 @@ pub(super) fn size_of<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span /// Whether `copied` of an iterator of `&inner`s is that iterator itself, as JS reads an /// `inner` as its value already. pub(super) fn copies_itself<'tcx>(t: &Translator<'_, 'tcx>, inner: Ty<'tcx>) -> bool { - !super::byte_array(inner) && !t.needs_copy(inner) + !inner.is_array() && !t.needs_copy(inner) } /// Whether an iterator of type `ty` is a `FusedIterator`, which std's `fuse` and `flatten` diff --git a/ts/src/lower/lend.rs b/ts/src/lower/lend.rs index d7071de58..fb9f68fe8 100644 --- a/ts/src/lower/lend.rs +++ b/ts/src/lower/lend.rs @@ -1,11 +1,12 @@ -//! The references to `[u8; N]`s that cross between translated code and std. Such an array -//! is a `Uint8Array`, where a `&[u8; N]` is an `rs.ByteSlice` of its bytes, as a `&[u8]` -//! is, but std's mappings take and hand out a reference to an array as the array itself. -//! So each `&[u8; N]` std makes of an array it holds, which it returns or hands a closure, -//! is lent as a slice of it, and each std is given as a `&T` of a `T = [u8; N]` is given -//! as a view of the slice's bytes. The function's generic signature tells such a -//! reference from one std takes as it is, which is an `rs.ByteSlice` on both sides: a `&T` -//! where `T = [u8; N]`, not a `T` where `T = &[u8; N]`. +//! The references to `[T; N]`s that cross between translated code and std. Such an array +//! is a JS array, or a `Uint8Array` of bytes, where a `&[T; N]` is an `rs.Slice` of its +//! elements, as a `&[T]` is, or an `rs.ByteSlice` of bytes, but std's mappings take and +//! hand out a reference to an array as the array itself. So each `&[T; N]` std makes of an +//! array it holds, which it returns or hands a closure, is lent as a slice of all of it, +//! and each std is given as a `&T` of a `T = [T; N]` is given as its elements: a view of a +//! byte slice's bytes, and else the array where the slice is all of it, or a copy. The +//! function's generic signature tells such a reference from one std takes as it is, which +//! is a slice on both sides: a `&T` where `T = [T; N]`, not a `T` where `T = &[T; N]`. use rustc_hir::def_id::DefId; use rustc_middle::ty::{self, EarlyBinder, GenericArgsRef, Instance, Ty, TypingEnv}; @@ -16,7 +17,7 @@ use super::body::Body; use super::library::{self, Std}; use crate::ts::{Expr, Param, Stmt, StmtKind}; -/// What a call of std's function makes of the `[u8; N]`s it holds. +/// What a call of std's function makes of the `[T; N]`s it holds. pub enum Plan<'tcx> { /// It lends none, or its mapping makes each slice itself. Untouched, @@ -30,7 +31,7 @@ pub enum Plan<'tcx> { /// A type in std's generic code, and as instantiated. pub type Pair<'tcx> = (Ty<'tcx>, Ty<'tcx>); -/// Where a call lends `&[u8; N]`s, or is given them. +/// Where a call lends `&[T; N]`s, or is given them. pub struct Lent<'tcx> { /// The closures it lends them to. pub closures: Vec>, @@ -40,7 +41,7 @@ pub struct Lent<'tcx> { pub given: Vec<(usize, Pair<'tcx>)>, } -/// A closure std lends a `&[u8; N]` to. +/// A closure std lends a `&[T; N]` to. pub struct Closure<'tcx> { /// Its index among the call's inputs. pub index: usize, @@ -55,7 +56,7 @@ pub struct Closure<'tcx> { /// What a call of std's `def_id` lends. pub fn plan<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef<'tcx>) -> Plan<'tcx> { let tcx = t.tcx; - if t.translated(def_id, args) || !args.types().any(owns_bytes) { + if t.translated(def_id, args) || !args.types().any(owns_array) { return Plan::Untouched; } let self_ty = args.types().next(); @@ -74,7 +75,8 @@ pub fn plan<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef< ("mem", "swap" | "replace" | "take") | ("Clone", "clone_from") | ("ToOwned", "clone_into") - | ("raw" | "array" | "Cell" | "ptr", "from_mut") => true, + | ("raw" | "array" | "Cell" | "ptr", "from_mut") + | ("Option", "get_or_insert" | "get_or_insert_with" | "get_or_insert_default" | "insert") => true, // `Clone::clone`, which takes the slice, and an array as a slice, which it is. ("ToOwned", "to_owned") => true, // An array as a slice, which it is, and what a reference lends, which it is too. @@ -135,7 +137,7 @@ pub fn plan<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRef< } match lends(t, generic, ty) { Some(false) => {} - Some(true) if reads => {} + Some(true) if reads && reads_either(ty) => {} Some(true) if gives(t, generic, ty) => lent.given.push((i, (generic, ty))), _ => return Plan::Refused, } @@ -170,14 +172,22 @@ fn collection<'tcx>(t: &Translator<'_, 'tcx>, def_id: DefId, args: GenericArgsRe t.std_of(coll).is_some_and(super::collections::lending) } -/// Whether `ty` holds a `[u8; N]` other than behind a reference or in a closure, which std -/// only calls. -fn owns_bytes(ty: Ty<'_>) -> bool { +/// Whether every `&[T; N]` `ty` holds is of bytes, which a collection's runtime reads in +/// either form. +fn reads_either(ty: Ty<'_>) -> bool { + ty.walk() + .all(|arg| arg.as_type().and_then(super::array_ref).is_none_or(super::byte)) +} + +/// Whether `ty` holds a `[T; N]` other than behind a reference or in a closure, which std +/// only calls, or one a closure returns, which std may hold as an iterator's item. +fn owns_array(ty: Ty<'_>) -> bool { match ty.kind() { - _ if super::byte_array(ty) => true, - ty::Array(elem, _) | ty::Slice(elem) => owns_bytes(*elem), - ty::Tuple(tys) => tys.iter().any(owns_bytes), - ty::Adt(_, args) | ty::Alias(_, ty::AliasTy { args, .. }) => args.types().any(owns_bytes), + ty::Array(..) => true, + ty::Closure(_, args) => owns_array(args.as_closure().sig().skip_binder().output()), + ty::Slice(elem) => owns_array(*elem), + ty::Tuple(tys) => tys.iter().any(owns_array), + ty::Adt(_, args) | ty::Alias(_, ty::AliasTy { args, .. }) => args.types().any(owns_array), _ => false, } } @@ -250,7 +260,7 @@ fn normalize<'tcx, T: ty::TypeFoldable> + Copy>( .unwrap_or(value) } -/// Whether a `ty`, whose type in std's generic code is `generic`, holds a `&[u8; N]` std +/// Whether a `ty`, whose type in std's generic code is `generic`, holds a `&[T; N]` std /// made of an array it holds: `Some(true)` if it does, by itself or in a tuple, an /// `Option`, or an iterator's items, which [`lend`] reaches, `Some(false)` if it holds /// none, and `None` if it holds one [`lend`] cannot reach. @@ -258,7 +268,8 @@ pub fn lends<'tcx>(t: &Translator<'_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>) -> match (generic.kind(), ty.kind()) { // What std was given, as it was given it. (ty::Param(_) | ty::Alias(..), _) => Some(false), - (_, ty::Ref(_, inner, _)) if super::byte_array(*inner) => Some(true), + // A mapping that names the array takes and makes the slice of it itself. + (ty::Ref(_, generic, _), ty::Ref(_, inner, _)) if inner.is_array() => Some(!generic.is_array()), // A reference to what was given holds none std made. (ty::Ref(_, generic, _), ty::Ref(_, inner, _)) => lends(t, *generic, *inner).filter(|&lent| !lent), (ty::Tuple(generics), ty::Tuple(parts)) => std::iter::zip(generics.iter(), parts.iter()) @@ -273,7 +284,7 @@ pub fn lends<'tcx>(t: &Translator<'_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>) -> let held = std::iter::zip(generics.types(), args.types()).all(|(g, arg)| lends(t, g, arg) == Some(false)); held.then_some(false) } - _ => (!holds_bytes_ref(ty)).then_some(false), + _ => (!holds_array_ref(ty)).then_some(false), } } @@ -308,44 +319,46 @@ fn item<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>) -> Option<(Option Some((generic, item)) } -/// Whether `ty` holds a `&[u8; N]`, as a closure's signature does if it takes one. -pub fn holds_bytes_ref(ty: Ty<'_>) -> bool { - ty.walk().any(|arg| arg.as_type().is_some_and(super::bytes_ref)) +/// Whether `ty` holds a `&[T; N]`, as a closure's signature does if it takes one. +pub fn holds_array_ref(ty: Ty<'_>) -> bool { + ty.walk().any(|arg| arg.as_type().and_then(super::array_ref).is_some()) } /// `value`, a `ty` std's mapping hands out, whose type in std's generic code is `generic`, -/// as translated code reads it: each `&[u8; N]` std made of an array it holds, which the -/// mapping hands out as the `Uint8Array`, an `rs.ByteSlice` of it. It shares the bytes, -/// which nothing writes through a `&`, and a `&mut` writes where std holds them. +/// as translated code reads it: each `&[T; N]` std made of an array it holds, which the +/// mapping hands out as the JS array, a slice of all of it. It shares the elements, which +/// nothing writes through a `&`, and a `&mut` writes where std holds them. pub fn lend<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) -> Expr { cross(b, generic, ty, value, Way::Lent, span) } /// `value`, a `ty` translated code gives std's mapping as an input whose type in std's -/// generic code is `generic`, as the mapping reads it: each `&[u8; N]` where it takes a -/// `&T`, which it reads, copies, and writes through as the array, an `rs.byteSliceView` -/// of the `rs.ByteSlice`. It shares the bytes for as long as the reference lives, so -/// whatever the mapping keeps of it reads and writes where the reference does. +/// generic code is `generic`, as the mapping reads it: each `&[T; N]` where it takes a +/// `&T`, which it reads, copies, and writes through as the array: the `rs.byteSliceView` +/// of an `rs.ByteSlice`, or the `rs.sliceView` of an `rs.Slice` lent mutably, which share +/// the elements for as long as the reference lives, so whatever the mapping keeps of it +/// reads and writes where the reference does, or else the `rs.sliceItems`, which reads +/// them faster than a view where the slice is part of an array. pub fn give<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) -> Expr { cross(b, generic, ty, value, Way::Given, span) } -/// Which way a `&[u8; N]` crosses between translated code and std's mapping. +/// Which way a `&[T; N]` crosses between translated code and std's mapping. #[derive(Clone, Copy, PartialEq)] enum Way { - /// To translated code, from the `Uint8Array` std holds: [`lend`]. + /// To translated code, from the array std holds: [`lend`]. Lent, - /// To std's mapping, from the `rs.ByteSlice` translated code holds: [`give`]. + /// To std's mapping, from the slice translated code holds: [`give`]. Given, } -/// Whether [`give`] reaches each `&[u8; N]` std is given in a `ty`, whose type in std's +/// Whether [`give`] reaches each `&[T; N]` std is given in a `ty`, whose type in std's /// generic code is `generic`: by itself, or in a tuple or an `Option`. An iterator's items /// it does not reach, which std's own iterator holds as arrays already. fn gives<'tcx>(t: &Translator<'_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>) -> bool { match (generic.kind(), ty.kind()) { (ty::Param(_) | ty::Alias(..), _) => true, - (_, ty::Ref(_, inner, _)) if super::byte_array(*inner) => true, + (ty::Ref(..), ty::Ref(_, inner, _)) if inner.is_array() => true, (ty::Tuple(generics), ty::Tuple(parts)) => { std::iter::zip(generics.iter(), parts.iter()).all(|(g, part)| gives(t, g, part)) } @@ -378,18 +391,27 @@ fn cross<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, valu .collect(); return Expr::Array(parts); } - cross_fn(b, generic, ty, way, span).call(vec![value]) + match cross_fn(b, generic, ty, way, span) { + // The slice of the elements a slice was read as is that slice. + Expr::Rs(f) if f == "sliceFrom" => super::library::slice_from(value), + Expr::Rs(f) if f == "sliceItems" => super::library::slice_items(value), + Expr::Rs(f) if f == "sliceView" => super::library::slice_view(value), + f => f.call(vec![value]), + } } /// A function that [`cross`]es a `ty`. fn cross_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, way: Way, span: Span) -> Expr { - if let ty::Ref(_, inner, _) = ty.kind() - && super::byte_array(*inner) + if let ty::Ref(_, inner, mutability) = ty.kind() + && let ty::Array(elem, _) = inner.kind() { return Expr::Rs( - match way { - Way::Lent => "byteSliceFrom", - Way::Given => "byteSliceView", + match (way, super::byte(*elem), mutability) { + (Way::Lent, true, _) => "byteSliceFrom", + (Way::Given, true, _) => "byteSliceView", + (Way::Lent, false, _) => "sliceFrom", + (Way::Given, false, ty::Mutability::Mut) => "sliceView", + (Way::Given, false, ty::Mutability::Not) => "sliceItems", } .into(), ); @@ -445,12 +467,15 @@ pub fn lend_closure<'tcx>( } /// A function copying a `ty` out of what `Extend<&T>` and `Extend<(&K, &V)>` are given, -/// where each `[u8; N]` is the `rs.ByteSlice` a `&[u8; N]` is: `None` if a copy is the -/// value itself. +/// where each `[T; N]` is the slice a `&[T; N]` is: `None` if a copy is the value itself. pub fn copy_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option { match ty.kind() { - _ if super::byte_array(ty) => Some(Expr::Rs("byteSliceToArray".into())), - ty::Tuple(parts) if parts.iter().any(super::byte_array) => { + ty::Array(..) => { + let name = b.fresh("held"); + let copy = b.t.array_copy(Expr::ident(&name), ty, span); + Some(Expr::Lambda(vec![Param { name, ty: None }], Box::new(copy))) + } + ty::Tuple(parts) if parts.iter().any(|part| part.is_array()) => { let name = b.fresh("held"); let parts = (parts.iter().enumerate()) .map(|(i, part)| { diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index f715a883d..a6f9a1f03 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1857,9 +1857,10 @@ fn mapping<'tcx>( return Some(vec_clone(b, value.member("items"), args.type_at(0), span)); } _ if let Some(elem) = cow_slice(tcx, ty) => cow_cloned(b, "Clone", value, elem, span), - // Each element cloned in order, as `[T; N]`'s `Clone` does. + // Each element cloned in order, as `[T; N]`'s `Clone` does, through the + // reference, which is a slice of it. ty::Array(elem, _) if !clone_copies(b.t, b.t.typing_env_pub(), ty) => { - slice_clone(b, value, *elem, span) + items_clone(b, value, *elem, span) } ty::Tuple(tys) if !clone_copies(b.t, b.t.typing_env_pub(), ty) => { let clones = tys.iter().map(|t| super::collections::clone_fn(b, t, span)).collect(); @@ -1896,8 +1897,8 @@ fn mapping<'tcx>( } // Another that holds nothing. ty::Adt(adt, _) if empty_iter(tcx, adt.did()) => b.zero_sized_std(ty, Vec::new(), span).ok()?, - // Through the reference, a slice of the bytes. - _ if super::byte_array(ty) => Expr::rs("byteSliceToArray", vec![value]), + // Through the reference, a slice of the elements. + ty::Array(..) => b.t.array_copy(value, ty, span), _ if b.t.std_iter(ty) => return super::iter::clone(b, ty, value, span), ty::Closure(def_id, _) | ty::CoroutineClosure(def_id, _) if !clone_shares(b.t, b.t.typing_env_pub(), ty) => @@ -2169,12 +2170,6 @@ fn mapping<'tcx>( ) => { let n = gargs.consts().next()?.try_to_target_usize(tcx)?; let mut values = args; - // An array of other values is a JS array of its own: a copy, or lent mutably the - // runtime's view. - if !byte(targ(gargs, 0)) { - values.push(Expr::lit(n.to_string())); - return Some(rt2(values, "slice", &super::camel(&name))); - } let name = name.strip_suffix("_mut").unwrap_or(&name); if name.starts_with("first") { values.push(Expr::lit("0")); @@ -2185,7 +2180,7 @@ fn mapping<'tcx>( "split_first_chunk" => "split_at_checked", name => name, }; - rt2(values, "byteSlice", &super::camel(name)) + rt2(values, slice_of_elem(targ(gargs, 0)), &super::camel(name)) } // A slice or an array of the one value. ("raw" | "array", "from_ref") @@ -2197,7 +2192,6 @@ fn mapping<'tcx>( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![value])], ), - false if owner == "array" => Expr::Array(vec![value]), false => Expr::rs("sliceFrom", vec![Expr::Array(vec![value])]), } } @@ -3019,12 +3013,8 @@ fn mapping<'tcx>( (_, Some(len)) => len.binary("*", Expr::lit(size.to_string())), } } - // A reference to an array of bytes is an `rs.ByteSlice` already, and to one of other - // values its JS array, which an `rs.Slice` of all of it reads and writes. - ("array", "as_slice" | "as_mut_slice") => match byte(targ(gargs, 0)) { - true => args.pop()?, - false => Expr::rs("sliceFrom", vec![args.pop()?]), - }, + // A reference to an array is a slice of it already. + ("array", "as_slice" | "as_mut_slice") => args.pop()?, ("array", "from_fn") => { let n = gargs.consts().next()?.try_to_target_usize(tcx)?; let f = match targ(gargs, 0).kind() { @@ -3041,17 +3031,19 @@ fn mapping<'tcx>( Expr::rs(f, args) } // Each element lent as `first_mut` lends it: an element JS copies as its place, an - // array of bytes as its view, and an object as itself. + // array as the slice of it, and an object as itself. ("array", "each_ref" | "each_mut") => { let elem = targ(gargs, 0); - // A reference to an array of bytes is its `rs.ByteSlice`, and to one of others the array. + let s = args.pop()?; + if name == "each_mut" && b.t.needs_place(elem) { + return Some(Expr::rs("slicePlaces", vec![s])); + } let a = match byte(elem) { - true => Expr::rs("byteSliceView", vec![args.pop()?]), - false => args.pop()?, + true => Expr::rs("byteSliceView", vec![s]), + false => slice_items(s), }; - match () { - _ if name == "each_mut" && b.t.needs_place(elem) => Expr::rs("arrayPlaces", vec![a]), - _ if super::byte_array(elem) => Expr::rs("arrayMap", vec![a, Expr::Rs("byteSliceFrom".into())]), + match elem.kind() { + ty::Array(..) => Expr::rs("arrayMap", vec![a, b.t.array_rs(elem, "From")]), _ => Expr::rs("arrayFrom", vec![a]), } } @@ -3511,14 +3503,14 @@ fn items_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, sp } } -/// A clone of `value`, the JS array of an array or a `Vec` of `elem` other than bytes, as -/// a `Vec` with room for exactly its elements, as std's allocates one. +/// A clone of `value`, the JS array of a `Vec` of `elem` other than bytes, as a `Vec` with +/// room for exactly its elements, as std's allocates one. fn vec_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, elem: Ty<'tcx>, span: Span) -> Expr { Expr::rs("vecFrom", vec![slice_clone(b, value, elem, span)]) } -/// A clone of `value`, the JS array of an array or a `Vec` of `elem` other than bytes, as -/// an array: a copy of it if each element's clone is itself, or else each element cloned. +/// A clone of `value`, the JS array of a `Vec` of `elem` other than bytes, as an array: a +/// copy of it if each element's clone is itself, or else each element cloned. fn slice_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, elem: Ty<'tcx>, span: Span) -> Expr { match super::collections::clone_fn(b, elem, span) { Expr::Lit(l) if l == "undefined" => value.method("slice", Vec::new()), @@ -4005,6 +3997,7 @@ pub fn elements(v: Expr, ty: Ty<'_>) -> Expr { ty::Slice(elem) if byte(*elem) => Expr::rs("byteSliceView", vec![v]), ty::Slice(_) => slice_items(v), _ if super::bytes_ref(ty) => Expr::rs("byteSliceView", vec![v]), + _ if super::array_ref(ty).is_some() => slice_items(v), ty::Adt(adt, args) if adt.is_box() => elements(v, args.type_at(0)), ty::Adt(_, args) if args.types().next().is_some_and(byte) => Expr::rs("byteVecView", vec![v]), // A `Vec`'s items. @@ -4016,11 +4009,35 @@ pub fn elements(v: Expr, ty: Ty<'_>) -> Expr { /// The elements of `s`, an `rs.Slice`, as a JS array, as `rs.sliceItems` reads them: all of /// an array is the array. pub fn slice_items(s: Expr) -> Expr { + array_of(s, "sliceItems") +} + +/// The array of `s`, an `rs.Slice`, as `rs.sliceView` writes through it: all of an array is +/// the array. +pub fn slice_view(s: Expr) -> Expr { + array_of(s, "sliceView") +} + +/// `rs.{read}` of `s`, an `rs.Slice`: the array of an `rs.sliceFrom`. +fn array_of(s: Expr, read: &str) -> Expr { match s { Expr::Call(f, mut args) if matches!(&*f, Expr::Rs(n) if n == "sliceFrom") && args.len() == 1 => { args.pop().unwrap() } - s => Expr::rs("sliceItems", vec![s]), + s => Expr::rs(read, vec![s]), + } +} + +/// All of `items`, a JS array, as an `rs.Slice`, as `rs.sliceFrom` makes one: the elements +/// `rs.sliceItems` or `rs.sliceView` read of a slice are that slice. +pub fn slice_from(items: Expr) -> Expr { + match items { + Expr::Call(f, mut args) + if matches!(&*f, Expr::Rs(n) if n == "sliceItems" || n == "sliceView") && args.len() == 1 => + { + args.pop().unwrap() + } + items => Expr::rs("sliceFrom", vec![items]), } } @@ -4029,7 +4046,7 @@ pub fn slice_items(s: Expr) -> Expr { pub fn slice_of(v: Expr, ty: Ty<'_>) -> Expr { match ty.peel_refs().kind() { ty::Slice(_) => v, - _ if super::bytes_ref(ty) => v, + _ if super::array_ref(ty).is_some() => v, ty::Array(elem, _) if byte(*elem) => Expr::rs("byteSliceFrom", vec![v]), ty::Array(..) => Expr::rs("sliceFrom", vec![v]), ty::Adt(_, args) => vec_view(v, args.type_at(0)), diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 738125322..b32ff4e28 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -239,7 +239,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// An argument, which the callee copies if it changes it in place. fn operand_frozen(&mut self, op: &Operand<'tcx>, span: Span, out: &mut Vec) -> Expr { match op { - Operand::Copy(place) | Operand::Move(place) if !self.in_bytes(*place) => self.place_expr(*place, span, out), + Operand::Copy(place) | Operand::Move(place) if !self.in_array(*place) => self.place_expr(*place, span, out), _ => self.operand(op, span, out), } } @@ -652,6 +652,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let to = self.operand(target, span, out); let to = self.b.t.pointee_value(target.ty(&self.mir.local_decls, tcx), to); let source = self.operand(source, span, out); + // A reference to an array is a slice of it, cloned over element by element. + if let ty::Array(elem, _) = ty.kind() { + let fns = library::clone_from_fns(self.b, *elem, span); + return done(Expr::rs("sliceCloneFromSlice", [vec![to, source], fns].concat()), true); + } done(library::clone_from(self.b, to, source, ty, span), true) } // `*self = source.clone()`, as std's `Clone` for a `T: Clone` has `clone_from` and @@ -701,7 +706,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ("raw" | "array", "from_mut") | ("Cell", "from_mut") if owner != "raw" || library::std_path(tcx, def_id) == ["slice", "raw", "from_mut"] => { - let made = self.one_of(owner == "Cell", owner == "array", targ(0)?, &args[0].node, span, out)?; + let made = self.one_of(owner == "Cell", targ(0)?, &args[0].node, span, out)?; done(made, true) } // A range of numbers steps in place, with nothing between it and the loop. @@ -1168,10 +1173,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { return done(Expr::undefined(), false); } }; - // An array of bytes comes by reference, which is a slice of them. - let ty = match targ(0)? { - ty if crate::lower::byte_array(ty) => Ty::new_slice(tcx, tcx.types.u8), - ty => ty, + // An array comes by reference, which is a slice of it. + let ty = match targ(0)?.kind() { + ty::Array(elem, _) => Ty::new_slice(tcx, *elem), + _ => targ(0)?, }; let value = self.operand(&args[0].node, span, out); // The function reads it later, in a closure, where TypeScript no longer @@ -1199,7 +1204,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ); return done(Expr::undefined(), false); }; - let values = self.operand(&args[1].node, span, out); + // A reference to the arguments array, which is a slice of all of it. + let values = library::slice_items(self.operand(&args[1].node, span, out)); // The arguments array made once in place: each piece its function. let made: Option> = match &values { Expr::Ident(name) => self.local_named(name).and_then(|l| self.var_parts.get(&l).cloned()), @@ -1353,11 +1359,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { return None; } let deref = self.tcx.mk_place_deref(*place); - if self.in_bytes(deref) { + if self.in_array(deref) { // Named before the copy, as the store names it. let slice = self.place_expr(deref, span, out); let slice = self.slice_path(slice, out); - return Some((Expr::rs("byteSliceToArray", vec![slice]), Some(deref))); + let ty = deref.ty(&self.mir.local_decls, self.tcx).ty; + return Some((self.b.t.array_copy(slice, ty, span), Some(deref))); } let borrowed = match &self.slots[place.local] { Slot::Alias(Some(target)) if assignable(target) && self.alias_of_place(place.local) => { @@ -1389,7 +1396,6 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { fn one_of( &mut self, cell: bool, - array: bool, ty: Ty<'tcx>, op: &Operand<'tcx>, span: Span, @@ -1398,11 +1404,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let tcx = self.tcx; let place = op.place().filter(|p| p.projection.is_empty())?; let deref = tcx.mk_place_deref(place); - // `array::from_mut` makes a `[T; 1]`, an array of its own. - let (of_place, of_object) = match (cell, array) { - (true, _) => ("cellOfPlace", "cellIn"), - (false, true) => ("arrayOfPlace", "arrayIn"), - (false, false) => ("sliceOfPlace", "sliceIn"), + // `array::from_mut` makes a `&mut [T; 1]`, which is a slice as a `&mut [T]` is. + let (of_place, of_object) = match cell { + true => ("cellOfPlace", "cellIn"), + false => ("sliceOfPlace", "sliceIn"), }; let of = |made: Expr| Expr::rs(of_place, vec![made]); if !cell && crate::lower::byte(ty) { @@ -1411,10 +1416,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { "a slice of one byte's place, which a byte slice can view only in an array of bytes", )); } - if self.in_bytes(deref) { + if self.in_array(deref) { let slice = self.place_expr(deref, span, out); - let view = Expr::rs("byteSliceView", vec![slice]); - return Some(Expr::rs(of_object, vec![view])); + let mut made = vec![self.b.t.array_rs(ty, "View").call(vec![slice])]; + if cell { + made.extend(self.copy_depth(ty)); + } + return Some(Expr::rs(of_object, made)); } // A cell of an object reads a copy wherever it is, as its place may be one a write // lands in, such as an element of a slice of one. @@ -1651,6 +1659,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { out.push(StmtKind::If { cond, then, els }.at(None)); } let read = Expr::As(Box::new(target.clone()), self.b.t.ty(payload_ty, span)); + // A reference to an array is a slice of it. + if payload_ty.is_array() { + return Some(Some((self.b.t.array_rs(payload_ty, "From").call(vec![read]), true))); + } if let Some(local) = dest.as_local() && self.defs[local] == 1 && matches!(self.slots[local], Slot::Var(_)) @@ -1731,9 +1743,18 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { span: Span, out: &mut Vec, ) -> Expr { - // The object written in place gives what it held as an object of its own. - if place.1.is_some_and(|p| self.in_object(p)) { - let mut made = vec![place.0, value]; + // The object written in place gives what it held as an object of its own, as does + // the array a slice of other values than bytes holds. + let array = place.1.filter(|&p| self.in_array(p) && !self.in_bytes(p)); + if place.1.is_some_and(|p| self.in_object(p)) || array.is_some() { + let object = match array { + Some(p) => { + let slice = self.place_expr(p, span, out); + Expr::rs("sliceView", vec![slice]) + } + None => place.0, + }; + let mut made = vec![object, value]; made.extend(self.copy_depth(ty)); let old = Expr::rs("replaceIn", made); let Some(base) = base else { @@ -1897,15 +1918,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let checked = self.path(checked, "at", out); let place = match container.kind() { ty::Adt(..) if bytes => base.member("data").index(checked), - // An array's bytes come through a reference, which is a slice of them. - _ if container.is_slice() || crate::lower::byte_array(container) => { - super::place::slice_at(base, checked) - } + // An array comes through a reference, which is a slice of it. + _ if container.is_slice() || container.is_array() => super::place::slice_at(base, checked), _ => base.index(checked), }; - // A reference to an array of bytes is a slice of them. - if crate::lower::byte_array(elem_ty) { - return Some(Some((Expr::rs("byteSliceFrom", vec![place]), true))); + // A reference to an array is a slice of it. + if elem_ty.is_array() { + return Some(Some((self.b.t.array_rs(elem_ty, "From").call(vec![place]), true))); } // The reference reads and writes the element where it is. if let Some(local) = dest.as_local() @@ -1935,7 +1954,6 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let base = match container.kind() { ty::Adt(..) => library::vec_view(base, elem_ty), - ty::Array(..) if !bytes => Expr::rs("sliceFrom", vec![base]), _ => base, }; // All of a slice of other values is the slice itself. diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 67a340a22..45dc195cb 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -1095,10 +1095,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // A borrow: borrow checking keeps the place as it is but through the borrow, // unless the path to it goes through a reference held in a field or element, // which can be replaced while the borrow lives. - // A borrow of bytes not yet in a slice makes one, and one of a `MaybeUninit` of - // bytes in a slice a view of them. + // A borrow of an array not yet in a slice makes one, and one of a `MaybeUninit` of + // an array in a slice the array of its elements. (ty::Ref(..), Rvalue::Ref(_, _, place)) - if crate::lower::byte_array(place.ty(&mir.local_decls, self.tcx).ty) != self.in_bytes(*place) => + if place.ty(&mir.local_decls, self.tcx).ty.is_array() != self.in_array(*place) => { false } @@ -2546,7 +2546,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match self.slots[local] { Slot::Alias(_) => { let target = match rvalue { - Rvalue::Ref(_, kind, p) => match self.mut_subslice(*kind, *p, span, out) { + Rvalue::Ref(_, kind, p) => match self.array_subslice(*kind, *p, span, out) { // One view, however many times it is read. Some(e) => self.path(e, "view", out), None => match self.reborrowed(*kind, *p, span, out) { @@ -3642,7 +3642,24 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { } true } - Expr::Index(base, index) => subst(base, name, value) || subst(index, name, value), + Expr::Index(base, index) => { + if !(subst(base, name, value) || subst(index, name, value)) { + return false; + } + // An element of an array made in place, as `format_args!`'s are, of items that + // do nothing as they are made. + if let Expr::Index(base, index) = &*e + && let (Expr::Array(items), Expr::Lit(at)) = (base.unlocated(), index.unlocated()) + && let Ok(at) = at.parse::() + && at < items.len() + && items + .iter() + .all(|e| e.is_path() || matches!(e.unlocated(), Expr::Arrow(..) | Expr::Lambda(..))) + { + *e = items[at].clone(); + } + true + } Expr::Call(f, args) | Expr::New(f, args) => { if !(subst(f, name, value) || args.iter_mut().any(|e| subst(e, name, value))) { return false; diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 7c76ae280..f93619b65 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -17,7 +17,7 @@ use rustc_span::Span; use super::{Env, Fx, Pending, Slot}; use crate::lower::library::{self, Flow, Std}; use crate::lower::num::Int; -use crate::lower::{AdtRepr, ObjectKind, StructField, Translator, byte_array, bytes_ref}; +use crate::lower::{AdtRepr, ObjectKind, StructField, Translator, byte_array}; use crate::program::{SymKind, Symbol}; use crate::ts::{Expr, Item, Stmt, StmtKind, SymId}; @@ -189,7 +189,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let tcx = self.tcx; let decls = &self.mir.local_decls; // Whether `e` is an `rs.Slice` or `rs.ByteSlice` of the place's elements: a `[T]`, or - // a `[u8; N]` behind a reference or raw pointer. + // a `[T; N]` behind a reference or raw pointer. let mut in_slice = false; // The projections a union's field consumed with it, down to a slot. let mut consumed = 0; @@ -299,18 +299,21 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; } } - // Part of a `[u8; N]` behind a reference, as `[a, rest @ ..]` of a `&[u8; N]`. + // Part of a `[T; N]` behind a reference, as `[a, rest @ ..]` of a `&[T; N]`, or a + // `[T; N]` part of a slice, as `[a, rest @ ..]` of a `[T]` of known length. ProjectionElem::Subslice { from, to, from_end } if in_slice => { - let end = match (from_end, ty.kind()) { - (false, _) => to, - (true, ty::Array(_, len)) if let Some(len) = len.try_to_target_usize(tcx) => len - to, + let (elem, end) = match (from_end, ty.kind()) { + (false, ty::Array(elem, _) | ty::Slice(elem)) => (*elem, to), + (true, ty::Array(elem, len)) if let Some(len) = len.try_to_target_usize(tcx) => { + (*elem, len - to) + } _ => return self.err(span, format!("a subslice of `{ty}`")), }; let base = self.slice_path(e, out); e = match made_slice(&base) { // In bounds of the array's. Some([data, start, _]) => Expr::New( - Box::new(Expr::Rs("ByteSlice".into())), + Box::new(Expr::Rs(slice_class(elem).into())), vec![ data.clone(), super::scalar::add(start.clone(), Expr::lit(from.to_string())), @@ -319,7 +322,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ), None => { let values = vec![base, Expr::lit(from.to_string()), Expr::lit(end.to_string())]; - Expr::rs("byteSliceRange", values) + match crate::lower::byte(elem) { + true => Expr::rs("byteSliceRange", values), + false => Expr::rs("sliceRange", values), + } } }; } @@ -341,7 +347,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { | ProjectionElem::PhantomDeref => {} } in_slice = match elem { - ProjectionElem::Deref => self.bytes_behind(place.local, read, ty), + ProjectionElem::Deref => self.array_behind(place.local, read, ty), ProjectionElem::Subslice { .. } => in_slice, _ => false, }; @@ -398,29 +404,40 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { None } - /// Whether `place` is a `[u8; N]` read through a reference or raw pointer, or a - /// `MaybeUninit` of one through a raw pointer, whose JS value is an `rs.ByteSlice` of - /// its bytes rather than a `Uint8Array`, as [`Self::place_expr`] reads it. - pub(super) fn in_bytes(&self, place: Place<'tcx>) -> bool { - let mut in_bytes = false; + /// Whether `place` is a `[T; N]` read through a reference or raw pointer, or a + /// `MaybeUninit` of one through a raw pointer, or one a slice holds, whose JS value is + /// an `rs.Slice` of its elements, an `rs.ByteSlice` of bytes, rather than the array, as + /// [`Self::place_expr`] reads it. + pub(super) fn in_array(&self, place: Place<'tcx>) -> bool { + let mut in_array = false; for (at, (base, elem)) in place.iter_projections().enumerate() { let ty = base.ty(&self.mir.local_decls, self.tcx).ty; - in_bytes = match elem { - ProjectionElem::Deref => self.bytes_behind(place.local, at, ty), - ProjectionElem::Subslice { .. } => in_bytes || byte_slice(ty), + in_array = match elem { + ProjectionElem::Deref => self.array_behind(place.local, at, ty), + ProjectionElem::Subslice { .. } => in_array || ty.is_slice(), _ => false, }; } - in_bytes && byte_array(self.b.t.uninit_inner(place.ty(&self.mir.local_decls, self.tcx).ty)) + in_array + && self + .b + .t + .uninit_inner(place.ty(&self.mir.local_decls, self.tcx).ty) + .is_array() + } + + /// Whether `place` is a `[u8; N]` that [`Self::in_array`] reads as an `rs.ByteSlice`. + pub(super) fn in_bytes(&self, place: Place<'tcx>) -> bool { + self.in_array(place) && byte_array(self.b.t.uninit_inner(place.ty(&self.mir.local_decls, self.tcx).ty)) } - /// Whether `ty`, which projection `at` of a place of `local` derefs, is an - /// `rs.ByteSlice` of the bytes it points at: a reference or a raw pointer to a - /// `[u8; N]`, but not a box's pointer, which is the box. - fn bytes_behind(&self, local: Local, at: usize, ty: Ty<'tcx>) -> bool { + /// Whether `ty`, which projection `at` of a place of `local` derefs, is the slice of + /// the elements it points at: a reference or a raw pointer to a `[T; N]`, but not a + /// box's pointer, which is the box. + fn array_behind(&self, local: Local, at: usize, ty: Ty<'tcx>) -> bool { use crate::lower::pointer::Pointee; - bytes_ref(ty) - || matches!(ty.kind(), ty::RawPtr(pointee, _) if self.b.t.pointee(*pointee) == Pointee::Bytes) + crate::lower::array_ref(ty).is_some() + || matches!(ty.kind(), ty::RawPtr(pointee, _) if self.b.t.pointee(*pointee) == Pointee::Array) && !(at == 0 && self.box_pointer(local)) } @@ -435,36 +452,42 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } - /// A mutable borrow of a slice pattern's rest of other than bytes, which a JS array's - /// `slice` would copy: the runtime's view of it. - pub(super) fn mut_subslice( + /// A borrow of an array pattern's rest of other than bytes, which a JS array's `slice` + /// would copy: the slice of where the array holds it. + pub(super) fn array_subslice( &mut self, kind: mir::BorrowKind, place: Place<'tcx>, span: Span, out: &mut Vec, ) -> Option { - if !matches!(kind, mir::BorrowKind::Mut { .. }) { - return None; - } let (base, ty, from, to, from_end) = place.iter_projections().find_map(|(base, elem)| match elem { ProjectionElem::Subslice { from, to, from_end } => { let ty = base.ty(&self.mir.local_decls, self.tcx).ty; - // A part of a slice is a slice of the same storage already. + // A part of a slice, or of an array behind a reference, is a slice of the same + // storage already. match ty.kind() { - ty::Array(elem, _) if !crate::lower::byte(*elem) => Some((base, ty, from, to, from_end)), + ty::Array(elem, _) if !crate::lower::byte(*elem) && !self.in_array(base.to_place(self.tcx)) => { + Some((base, ty, from, to, from_end)) + } _ => None, } } _ => None, })?; if base.projection.len() + 1 != place.projection.len() { - return Some(self.err(span, format!("a mutable borrow within a subslice of `{ty}`"))); + return match kind { + mir::BorrowKind::Mut { .. } => { + Some(self.err(span, format!("a mutable borrow within a subslice of `{ty}`"))) + } + _ => None, + }; } let base = self.place_expr(base.to_place(self.tcx), span, out); - let base = self.path(base, "slice", out); let end = self.subslice_end(&base, ty, to, from_end); - Some(Expr::rs("arrayView", vec![base, Expr::lit(from.to_string()), end])) + let from = Expr::lit(from.to_string()); + let length = super::scalar::sub(end, from.clone()); + Some(Expr::New(Box::new(Expr::Rs("Slice".into())), vec![base, from, length])) } /// `base`, a `ty`, cast to its `variant`, which MIR reads without a switch where the @@ -692,10 +715,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// An operand's value, copied if it is a `Copy` aggregate read from a place that keeps it. pub fn operand(&mut self, op: &Operand<'tcx>, span: Span, out: &mut Vec) -> Expr { match op { - // An array of bytes read through a reference, copied out of its slice. - Operand::Copy(place) | Operand::Move(place) if self.in_bytes(*place) => { + // An array read through a reference, copied out of its slice. + Operand::Copy(place) | Operand::Move(place) if self.in_array(*place) => { let value = self.place_expr(*place, span, out); - Expr::rs("byteSliceToArray", vec![value]) + let ty = place.ty(&self.mir.local_decls, self.tcx).ty; + self.b.t.array_copy(value, ty, span) } // JS shares objects where Rust copies, so a `Copy` aggregate is copied where // either side could change in place: into a local changed in place, or out of a @@ -771,12 +795,19 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } return out; } - // Bytes through a reference are copied into the slice of them it holds. - if self.in_bytes(place) { + // An array through a reference is copied into the slice of it it holds. + if self.in_array(place) { let target = self.place_expr(place, span, &mut out); let target = self.slice_path(target, &mut out); - let set = target.clone().member("data").member("set"); - out.push(StmtKind::Expr(set.call(vec![value, target.member("start")])).at(self.b.t.loc(span))); + let e = match self.in_bytes(place) { + true => target + .clone() + .member("data") + .member("set") + .call(vec![value, target.member("start")]), + false => Expr::rs("sliceSet", vec![target, value]), + }; + out.push(StmtKind::Expr(e).at(self.b.t.loc(span))); return out; } // `*r = v` replaces the object `r` points at in place, which other references and @@ -853,6 +884,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { && self.b.t.object_kind(pointee).is_none(); let ok = !self.alias_of_place(place.local) && !lent + && !self.in_array(place) && self.b.t.place_pointee(ty).is_none() && !(place.local.as_u32() == 1 && matches!(self.env, Env::Closure(_))); ok.then_some(pointee) diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index d416527c1..6d127f34b 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -14,7 +14,7 @@ use crate::lower::dynamic; use crate::lower::library::Std; use crate::lower::num::{self, Int}; use crate::lower::pointer::Pointee; -use crate::lower::{AdtRepr, StructField, byte_array, field_name}; +use crate::lower::{AdtRepr, StructField, field_name}; use crate::ts::{Expr, Key, Param, Stmt, StmtKind, Type}; impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { @@ -36,7 +36,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.union_whole(*place, span).is_some() { return Some(self.err(span, "a reference to a union's field kept in more than one slot")); } - if let Some(e) = self.mut_subslice(*kind, *place, span, out) { + if let Some(e) = self.array_subslice(*kind, *place, span, out) { return Some(e); } if let mir::BorrowKind::Mut { .. } = kind { @@ -56,12 +56,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } let value = self.place_expr(*place, span, out); - // A borrow of an array of bytes is a slice of all of it, sharing its bytes. One of - // a `MaybeUninit` of them through a raw pointer is a view of the pointer's bytes. + // A borrow of an array is a slice of all of it, sharing its elements. One of a + // `MaybeUninit` of one through a raw pointer is the array of the pointer's + // elements: a view of bytes, and else the array where the slice is all of it. let pointee = place.ty(&self.mir.local_decls, tcx).ty; - match (byte_array(pointee), self.in_bytes(*place)) { - (true, false) => Expr::rs("byteSliceFrom", vec![value]), - (false, true) => Expr::rs("byteSliceView", vec![value]), + match (pointee.is_array(), self.in_array(*place)) { + (true, false) => self.b.t.array_rs(pointee, "From").call(vec![value]), + (false, true) if self.in_bytes(*place) => Expr::rs("byteSliceView", vec![value]), + (false, true) => crate::lower::library::slice_items(value), _ => value, } } @@ -100,12 +102,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } }, - // A slice of all of an array's bytes, as a borrow of it is. - Pointee::Bytes => { + // A slice of all of an array, as a borrow of it is. + Pointee::Array => { + if let Some(e) = self.array_subslice(mir::BorrowKind::Shared, *place, span, out) { + return Some(e); + } let value = self.place_expr(*place, span, out); - match self.in_bytes(*place) { + match self.in_array(*place) { true => value, - false => Expr::rs("byteSliceFrom", vec![value]), + false => self.b.t.array_rs(pointee, "From").call(vec![value]), } } // `&raw mut *p` is `p`. A pointer to `()` is an identity, which only another @@ -432,13 +437,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let value = self.operand(op, span, out); self.raw_unsize(value, from, span) } - // An array, as the slice of all of it. An `Arc`'s or `Rc`'s would need the slice made - // inside it, which every owner sharing its count would see. + // An array, as the slice of all of it: a reference to one is one already. PointerCoercion::Unsize if unsized_to(from, to).is_some_and(|t| t.is_slice()) => { match to.builtin_deref(true) { Some(pointee) if pointee.is_slice() => { let value = self.operand(op, span, out); - Expr::rs("sliceFrom", vec![value]) + match crate::lower::array_ref(from) { + Some(_) => value, + None => Expr::rs("sliceFrom", vec![value]), + } } _ => self.err(span, format!("a coercion to `{to}`")), } @@ -495,9 +502,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } - /// `arc`, an `Arc` of `pointee` unsized to one of `object`, a trait object or a struct - /// of one: an `rs.ArcDyn` sharing its count, over what a box of its value unsizes to, or - /// the same `Arc` upcast, or `Weak` that `ptr` names. + /// `arc`, an `Arc` of `pointee` unsized to one of `object`, a trait object, a struct of + /// one, or the slice of an array: an `rs.ArcDyn` sharing its count, over what a box of + /// its value unsizes to, or the same `Arc` upcast, or `Weak` that `ptr` names. fn arc_object( &mut self, ptr: &'static str, @@ -521,7 +528,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } }; let (from, to) = (Ty::new_box(tcx, pointee), Ty::new_box(tcx, object)); - let value = if self.b.t.dyn_future(object).is_some() { + let value = if pointee.is_array() && object.is_slice() { + crate::lower::array_fn(pointee, "From").call(vec![value]) + } else if self.b.t.dyn_future(object).is_some() { self.b.dyn_future(from, to, value, span) } else if self.b.t.dyn_iter(object).is_some() { self.b.dyn_iter(from, to, value, span) @@ -1147,17 +1156,23 @@ fn arc_object<'tcx>(tcx: TyCtxt<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> Option<( return None; }; let object = to_args.type_at(0); - (Std::of(tcx, adt.did()) == Some(Std::Arc) && dynamic::unsized_object(tcx, object)) + (Std::of(tcx, adt.did()) == Some(Std::Arc) && unsizes(tcx, from_args.type_at(0), object)) .then(|| (from_args.type_at(0), object)) } +/// Whether `pointee` unsizes to `object`, a trait object, a struct of one, or the slice of +/// an array. +fn unsizes<'tcx>(tcx: TyCtxt<'tcx>, pointee: Ty<'tcx>, object: Ty<'tcx>) -> bool { + dynamic::unsized_object(tcx, object) || pointee.is_array() && object.is_slice() +} + /// What a `Weak` unsized as `arc_object` is points at, and that object or struct. fn weak_object<'tcx>(tcx: TyCtxt<'tcx>, from: Ty<'tcx>, to: Ty<'tcx>) -> Option<(Ty<'tcx>, Ty<'tcx>)> { let (ty::Adt(adt, from_args), ty::Adt(_, to_args)) = (from.kind(), to.kind()) else { return None; }; let object = to_args.type_at(0); - (Std::of(tcx, adt.did()) == Some(Std::Weak) && dynamic::unsized_object(tcx, object)) + (Std::of(tcx, adt.did()) == Some(Std::Weak) && unsizes(tcx, from_args.type_at(0), object)) .then(|| (from_args.type_at(0), object)) } diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index 1f6b6b6ce..a4336162f 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -20,8 +20,8 @@ fn array_iter<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option> { let path = library::std_path(tcx, adt.did()); let path: Vec<&str> = path.iter().map(String::as_str).collect(); match path.as_slice() { - // A reference to an array of bytes is a slice of it made as the item is read. - ["slice", "iter", "Iter" | "IterMut"] if args.types().next().is_some_and(crate::lower::byte_array) => None, + // A reference to an array is a slice of it made as the item is read. + ["slice", "iter", "Iter" | "IterMut"] if args.types().next().is_some_and(|t| t.is_array()) => None, ["slice", "iter", "Iter" | "IterMut"] | ["vec", "into_iter", "IntoIter"] => args.types().next(), _ => None, } diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 51e76b99c..e110030e1 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -1390,7 +1390,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(library::Std::AssertUnwindSafe) => self.object_kind(args.type_at(0)), // A place, unless a pointer to what it holds is that object. Some(library::Std::MaybeUninit | library::Std::ManuallyDrop) => match self.pointee(args.type_at(0)) { - pointer::Pointee::Object | pointer::Pointee::Bytes => self.object_kind(args.type_at(0)), + pointer::Pointee::Object | pointer::Pointee::Array => self.object_kind(args.type_at(0)), pointer::Pointee::Place | pointer::Pointee::Slice => None, }, Some(_) => None, @@ -1529,7 +1529,11 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Type::Rs("Place", vec![self.ty(*inner, span)]) } ty::RawPtr(inner, _) => self.pointer_ty(*inner, span), - ty::Ref(..) if bytes_ref(ty) => Type::Rs("ByteSlice", vec![]), + ty::Ref(..) if let Some(elem) = array_ref(ty) => match byte(elem) { + true => Type::Rs("ByteSlice", vec![]), + false if self.open_elem(elem) => Type::Rs("SliceOf", vec![self.ty(elem, span)]), + false => Type::Rs("Slice", vec![self.ty(elem, span)]), + }, ty::Ref(_, inner, _) => self.ty(*inner, span), ty::Array(elem, _) if self.open_elem(*elem) => Type::Rs("ArrayOf", vec![self.ty(*elem, span)]), ty::Slice(elem) if self.open_elem(*elem) => Type::Rs("SliceOf", vec![self.ty(*elem, span)]), @@ -2283,6 +2287,26 @@ pub fn bytes_ref(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Ref(..)) && byte_array(ty.peel_refs()) } +/// The runtime's function `name` of the slice a reference to `ty`, a `[T; N]`, is: +/// `byteSlice{name}` of bytes, and else `slice{name}`. +pub fn array_fn(ty: Ty<'_>, name: &str) -> ts::Expr { + let prefix = match byte_array(ty) { + true => "byteSlice", + false => "slice", + }; + ts::Expr::Rs(format!("{prefix}{name}")) +} + +/// The element of the `[T; N]` that `ty` is a reference to, if it is one: an `rs.Slice` of +/// its elements, as a `&[T]` is, or an `rs.ByteSlice` of bytes, so a part a slice lends as +/// an array is read and written where the slice holds it. +pub fn array_ref(ty: Ty<'_>) -> Option> { + match (ty.kind(), ty.peel_refs().kind()) { + (ty::Ref(..), ty::Array(elem, _)) => Some(*elem), + _ => None, + } +} + /// Whether `ty` is a form only an instance of a generic definition decides, which the /// definition types as every form it may be. pub fn instanced(ty: &Type) -> bool { diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index 255b31af6..087e48216 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -1,8 +1,9 @@ //! Raw pointers, `NonNull`, `MaybeUninit`, and `ManuallyDrop`. //! //! A raw pointer is what a `&mut` to its pointee is where JS keeps the pointee where Rust -//! does: the object, a tuple's or array's or the crate's own struct's, or the -//! `rs.ByteSlice` of a `[u8; N]`'s bytes, which may be part of a larger array or a slice. +//! does: the object, a tuple's or the crate's own struct's, or the `rs.Slice` of a +//! `[T; N]`'s elements, an `rs.ByteSlice` of bytes, which may be part of a larger array or +//! a slice. //! To anything else it is an `rs.Place` of the place holding the value, as a `&mut` to a //! value JS copies is, which a `Vec` or an `Arc` also is here: its JS object is what it //! owns, not where Rust keeps it. Null is `rs.NULL`, and a dangling pointer `rs.DANGLING`. @@ -44,9 +45,9 @@ pub enum Pointee { Place, /// The object it points at. Object, - /// An `rs.ByteSlice` of the `[u8; N]` it points at, as a reference to one is, which - /// compares by where its bytes are. - Bytes, + /// An `rs.Slice` of the `[T; N]` it points at, or an `rs.ByteSlice` of bytes, as a + /// reference to one is, which compares by where its elements are. + Array, /// An `rs.RawSlice` of a `[T]`: the pointer to its first element and its length, which /// a read through it makes the slice of. Slice, @@ -60,14 +61,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { return Pointee::Object; } let ty = self.uninit_inner(ty); - if super::byte_array(ty) { - return Pointee::Bytes; + if ty.is_array() { + return Pointee::Array; } if ty.is_slice() { return Pointee::Slice; } let object = match (self.object_kind(ty), ty.kind()) { - (Some(ObjectKind::Array | ObjectKind::Bytes), ty::Array(..) | ty::Tuple(_)) => true, + (Some(ObjectKind::Array), ty::Tuple(_)) => true, // An async body passes its context as a pointer to it, and a waker's vtable is // one that is its identity. (Some(ObjectKind::Class), ty::Adt(adt, _)) => match Std::of(self.tcx, adt.did()) { @@ -84,15 +85,21 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } + /// The runtime's function `name` of the slice a pointer or reference to `ty`, a + /// `[T; N]` through any `MaybeUninit`s, is: `byteSlice{name}` of bytes, and else + /// `slice{name}`. + pub fn array_rs(&self, ty: Ty<'tcx>, name: &str) -> Expr { + super::array_fn(self.uninit_inner(ty), name) + } + /// Whether a pointer to `ty` is an identity: one to `()`, through any `MaybeUninit`s. pub fn identity_pointee(&self, ty: Ty<'tcx>) -> bool { self.uninit_inner(ty).is_unit() } - /// Why pointers to `ty` that are not null don't compare as their JS values, if they - /// don't. Two `rs.Place`s of one place are two objects, and Rust leaves where a value of - /// no bytes is unspecified, but a pointer to `()` is an identity. Notes the comparison of - /// those that do, for [`Self::taken`]. + /// Why pointers to `ty` that are not null can't compare, if they can't: Rust leaves + /// where a value of no bytes is unspecified, but a pointer to `()` is an identity. Notes + /// the comparison of objects, for [`Self::taken`]. pub fn incomparable(&mut self, ty: Ty<'tcx>) -> Option { if self.identity_pointee(ty) { return None; @@ -102,22 +109,23 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { "comparing pointers to `{ty}`, which has no bytes and so no address of its own" )); } - // A slice lends a run of other values as an array of its own, by `first_chunk` or - // `as_chunks`, so where one points says nothing of where the slice holds it. - if let ty::Array(..) = self.uninit_inner(ty).kind() - && self.pointee(ty) == Pointee::Object - { - return Some(format!( - "comparing pointers to `{ty}`, which a slice lends as a copy of its own" - )); - } if ty.is_trait() { return Some(format!( "comparing pointers to `{ty}`, each an object JS makes of its own as it unsizes" )); } match self.pointee(ty) { - Pointee::Object | Pointee::Bytes => { + // `from_ref`, `from_mut` of a variable, and `Option::as_slice` make an array of + // one of their own for a value, so only longer arrays are always where Rust's are. + Pointee::Array + if let ty::Array(_, len) = self.uninit_inner(ty).kind() + && len.try_to_target_usize(self.tcx).is_none_or(|n| n == 1) => + { + Some(format!( + "comparing pointers to `{ty}`, an array of one JS may make of its own for a value, as `array::from_ref` does" + )) + } + Pointee::Object | Pointee::Array => { self.compare(ty); None } @@ -130,6 +138,12 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } + /// What tells whether two pointers to `ty` point at the same place where `===` can't: + /// the slices' of an array. + pub fn same_fn(&self, ty: Ty<'tcx>) -> Option { + (self.pointee(ty) == Pointee::Array).then(|| self.array_rs(ty, "Same")) + } + /// What a `MaybeUninit` or `ManuallyDrop` holds, through any number of them, or `ty` /// itself: JS keeps each as what it holds, and an `UninitSlice` as its slice. pub fn uninit_inner(&self, ty: Ty<'tcx>) -> Ty<'tcx> { @@ -165,7 +179,11 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { match self.pointee(pointee) { Pointee::Place => Type::Rs("Place", vec![self.ty(pointee, span)]), Pointee::Object => self.ty(pointee, span), - Pointee::Bytes => Type::Rs("ByteSlice", Vec::new()), + Pointee::Array => match self.uninit_inner(pointee).kind() { + ty::Array(elem, _) if super::byte(*elem) => Type::Rs("ByteSlice", Vec::new()), + ty::Array(elem, _) => Type::Rs("Slice", vec![self.ty(*elem, span)]), + _ => unreachable!("an array's pointee"), + }, Pointee::Slice => match self.uninit_inner(pointee).kind() { ty::Slice(elem) => Type::Rs("RawSlice", vec![self.ty(*elem, span)]), _ => unreachable!("a slice's pointee"), @@ -223,12 +241,12 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let ty = self.uninit_inner(ty); match (self.pointee(ty), ty.kind()) { (Pointee::Object, ty::Tuple(tys)) => Expr::Array(tys.iter().map(|t| self.shell(t, span)).collect()), - (Pointee::Object | Pointee::Bytes, ty::Array(elem, len)) => { + (Pointee::Array, ty::Array(elem, len)) => { let len = Expr::lit(len.try_to_target_usize(self.tcx).unwrap_or(0).to_string()); match (super::byte(*elem), self.pointee(*elem)) { (true, _) => Expr::New(Box::new(Expr::ident("Uint8Array")), vec![len]), (_, Pointee::Place) => Expr::New(Box::new(Expr::ident("Array")), vec![len]), - (_, Pointee::Object | Pointee::Bytes | Pointee::Slice) => { + (_, Pointee::Object | Pointee::Array | Pointee::Slice) => { let elem_ty = self.ty(*elem, span); let each = Expr::Arrow( Vec::new(), @@ -480,11 +498,17 @@ pub fn call<'tcx>( let gargs = call.args; let pointee = || targ(gargs, 0); let kind = |b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>| Some(b.t.pointee(ty)); - // A mapping holds a `[u8; N]`, and hands out a reference to one, as the `Uint8Array`, - // which a pointer to it is an `rs.ByteSlice` of. - let bytes = |b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>| b.t.pointee(ty) == Pointee::Bytes; - let to_pointer = |e: Expr| Expr::rs("byteSliceFrom", vec![e]); - let to_reference = |e: Expr| Expr::rs("byteSliceView", vec![e]); + // A mapping holds a `[T; N]`, and hands out a reference to one, as the JS array, which a + // pointer to it is an `rs.Slice` of, or an `rs.ByteSlice` of bytes. + let array = |b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>| b.t.pointee(ty) == Pointee::Array; + let to_pointer = |b: &Body<'_, '_, 'tcx>, e: Expr| match super::byte_array(b.t.uninit_inner(pointee())) { + true => Expr::rs("byteSliceFrom", vec![e]), + false => super::library::slice_from(e), + }; + let to_reference = |b: &Body<'_, '_, 'tcx>, e: Expr| match super::byte_array(b.t.uninit_inner(pointee())) { + true => Expr::rs("byteSliceView", vec![e]), + false => super::library::slice_view(e), + }; // A raw pointer to a slice, from a reference to one, and the slice a read through it // makes, shared if nothing writes through it. let raw_of = |ty: Ty<'tcx>, s: Expr| match slice_of_bytes(ty) { @@ -533,6 +557,10 @@ pub fn call<'tcx>( ), ), (true, Some(Pointee::Place)) => Expr::Object(vec![(Key::Name("v".into()), b.t.shell(pointee(), span))]), + (true, Some(Pointee::Array)) => { + let array = b.t.uninit(pointee(), span); + to_pointer(b, array) + } (true, _) => b.t.uninit(pointee(), span), } } @@ -555,7 +583,7 @@ pub fn call<'tcx>( ("NonNull", "as_ref" | "as_mut") if kind(b, pointee()) == Some(Pointee::Slice) => { deref(pointee(), arg(), name == "as_ref") } - ("NonNull", "as_mut") if bytes(b, pointee()) => to_reference(arg()), + ("NonNull", "as_mut") if array(b, pointee()) => to_reference(b, arg()), // The same pointer, as another type of the same pointee. ("ptr", "cast_const" | "cast_mut") | ("NonNull", "as_ptr" | "new_unchecked" | "cast_const" | "cast_mut") @@ -574,8 +602,8 @@ pub fn call<'tcx>( (Some(Pointee::Place), ty::Ref(_, _, ty::Mutability::Not)) => { Expr::Object(vec![(crate::ts::Key::Name("v".into()), arg())]) } - // A reference to a `MaybeUninit` of bytes is the `Uint8Array`. - (Some(Pointee::Bytes), _) if !super::bytes_ref(from) => to_pointer(arg()), + // A reference to a `MaybeUninit` of an array is the JS array. + (Some(Pointee::Array), _) if super::array_ref(from).is_none() => to_pointer(b, arg()), (Some(Pointee::Slice), _) => raw_of(ty, arg()), _ => arg(), } @@ -584,7 +612,7 @@ pub fn call<'tcx>( ("ptr", "from_ref" | "from_mut") if kind(b, pointee()) == Some(Pointee::Slice) => raw_of(pointee(), arg()), ("ptr", "from_ref") => match kind(b, pointee()) { Some(Pointee::Place) => Expr::Object(vec![(crate::ts::Key::Name("v".into()), arg())]), - Some(Pointee::Bytes) => to_pointer(arg()), + Some(Pointee::Array) => to_pointer(b, arg()), _ => arg(), }, ("NonNull", "new") => { @@ -613,7 +641,7 @@ pub fn call<'tcx>( let shared = name == "as_ref" && kind(b, pointee()) == Some(super::pointer::Pointee::Place); let (some, none) = match shared { true => (p.clone().member("v"), b.t.none(pointee())), - false if bytes(b, pointee()) => (to_reference(p.clone()), Expr::undefined()), + false if array(b, pointee()) => (to_reference(b, p.clone()), Expr::undefined()), false => (p.clone(), Expr::undefined()), }; Expr::Cond( @@ -624,7 +652,7 @@ pub fn call<'tcx>( } ("NonNull", "as_ref") | ("MaybeUninit", "assume_init_ref") => match kind(b, pointee()) { Some(Pointee::Place) if owner == "NonNull" => arg().member("v"), - Some(Pointee::Bytes) if owner == "NonNull" => to_reference(arg()), + Some(Pointee::Array) if owner == "NonNull" => to_reference(b, arg()), _ => arg(), }, // An `rs.Arc` is its allocation, which has one place of its value: the pointer to a @@ -636,16 +664,16 @@ pub fn call<'tcx>( { b.err(span, format!("a raw pointer to the `{}` an `Arc` holds", pointee())) } - ("Arc" | "Rc", "as_ptr") if matches!(kind(b, pointee()), Some(Pointee::Slice | Pointee::Bytes)) => { + ("Arc" | "Rc", "as_ptr") if matches!(kind(b, pointee()), Some(Pointee::Slice | Pointee::Array)) => { let value = arg().member("value"); match kind(b, pointee()) { Some(Pointee::Slice) => raw_of(pointee(), value), - _ => to_pointer(value), + _ => to_pointer(b, value), } } // A raw pointer `from_raw` takes back to its `Arc` is one JS keeps the identity of. ("Arc" | "Rc", "into_raw" | "from_raw" | "increment_strong_count" | "decrement_strong_count") - if matches!(kind(b, pointee()), Some(Pointee::Slice | Pointee::Bytes)) => + if matches!(kind(b, pointee()), Some(Pointee::Slice | Pointee::Array)) => { b.err( span, @@ -690,13 +718,13 @@ pub fn call<'tcx>( ("Box", "into_raw" | "leak") => match kind(b, pointee()) { Some(Pointee::Slice) if name == "into_raw" => raw_of(pointee(), arg()), Some(Pointee::Place) => Expr::Object(vec![(crate::ts::Key::Name("v".into()), arg())]), - Some(Pointee::Bytes) if name == "into_raw" => to_pointer(arg()), + Some(Pointee::Array) if name == "into_raw" => to_pointer(b, arg()), _ => arg(), }, ("Box", "from_raw") => match kind(b, pointee()) { Some(Pointee::Slice) => deref(pointee(), arg(), false), Some(Pointee::Place) => arg().member("v"), - Some(Pointee::Bytes) => to_reference(arg()), + Some(Pointee::Array) => to_reference(b, arg()), _ => arg(), }, ("ptr", "read" | "read_unaligned" | "read_volatile") => { @@ -771,12 +799,12 @@ pub fn call<'tcx>( ("MaybeUninit", "as_ptr") if kind(b, pointee()) == Some(Pointee::Place) => { Expr::Object(vec![(crate::ts::Key::Name("v".into()), arg())]) } - ("MaybeUninit", "as_ptr" | "as_mut_ptr") if bytes(b, pointee()) => to_pointer(arg()), + ("MaybeUninit", "as_ptr" | "as_mut_ptr") if array(b, pointee()) => to_pointer(b, arg()), ("MaybeUninit", "as_ptr" | "as_mut_ptr") => arg(), ("MaybeUninit", "write") => { let p = b.spill(arg(), "uninit", out); let value = arg(); - let write = match bytes(b, pointee()) { + let write = match array(b, pointee()) { true => Expr::rs("ptrWrite", vec![p.clone(), value]), false => write(b, p.clone(), value, pointee(), span), }; @@ -806,7 +834,7 @@ pub fn call<'tcx>( // and holds the object a pointer to any other is. ("UnsafeCell", "new") => Expr::New(Box::new(Expr::Rs("Cell".into())), vec![arg()]), ("UnsafeCell", "get") | ("Cell", "as_ptr") if kind(b, pointee()) == Some(Pointee::Place) => arg(), - ("UnsafeCell", "get") | ("Cell", "as_ptr") if bytes(b, pointee()) => to_pointer(arg().member("v")), + ("UnsafeCell", "get") | ("Cell", "as_ptr") if array(b, pointee()) => to_pointer(b, arg().member("v")), ("UnsafeCell" | "Cell", "get_mut") if b.t.needs_place(pointee()) => arg(), ("UnsafeCell", "get" | "get_mut" | "into_inner") | ("Cell", "as_ptr" | "get_mut") => arg().member("v"), // Pointers into an array: `rs.AtIndex`es, which a `Vec`'s and a slice's give. @@ -941,7 +969,7 @@ pub fn unerasable<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option } Pointee::Place => return None, Pointee::Slice => "a place", - Pointee::Bytes => "a view", + Pointee::Array => "a view", }; Some(format!("{erase}, whose JS value is {what} of its own each borrow")) } @@ -1000,7 +1028,7 @@ fn unmodeled<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, what: &str) -> Option None, - Pointee::Object | Pointee::Bytes | Pointee::Slice => Some(format!( + Pointee::Object | Pointee::Array | Pointee::Slice => Some(format!( "{what} `{ty}`, which JS keeps as an object that knows no array it is in" )), } @@ -1052,11 +1080,10 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, from: Ty<'tcx>, to: Ty<'t return b.err(span, why); } // A pointer to a slice holds the pointer to its first element, and one to an array is - // the array, or the `rs.ByteSlice` of its bytes. + // the slice of its elements. match b.t.pointee(inner) { Pointee::Slice => p.member("ptr"), - Pointee::Bytes => Expr::rs("byteSliceAsPtr", vec![p]), - _ => Expr::rs("arrayAsPtr", vec![p]), + _ => b.t.array_rs(inner, "AsPtr").call(vec![p]), } } @@ -1080,7 +1107,10 @@ fn read<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, ty: Ty<'tcx>, span: Span) -> let value = match b.t.pointee(ty) { Pointee::Place => p.member("v"), Pointee::Object => p, - Pointee::Bytes => return Expr::rs("byteSliceToArray", vec![p]), + Pointee::Array => { + let ty = b.t.uninit_inner(ty); + return b.t.array_copy(p, ty, span); + } Pointee::Slice => return b.err(span, format!("a read of `{ty}`, which has no size")), }; b.t.snapshot(value, ty, span) @@ -1094,7 +1124,7 @@ fn write<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, value: Expr, ty: Ty<'tcx>, s match b.t.pointee(ty) { Pointee::Place => p.member("v").assign(value), Pointee::Object => Expr::rs("ptrWrite", vec![p, value]), - Pointee::Bytes => Expr::rs("byteSliceSet", vec![p, value]), + Pointee::Array => b.t.array_rs(ty, "Set").call(vec![p, value]), Pointee::Slice => b.err(span, format!("a write of `{ty}`, which has no size")), } } @@ -1116,7 +1146,12 @@ pub fn compare<'tcx>(b: &mut Body<'_, '_, 'tcx>, x: Expr, y: Expr, ty: Ty<'tcx>, let null = |e: &Expr| matches!(e, Expr::Rs(n) if n == "NULL"); match b.t.incomparable(ty) { Some(why) if !null(&x) && !null(&y) => b.err(span, why), - _ if b.t.pointee(ty) == Pointee::Bytes && !null(&x) && !null(&y) => Expr::rs("byteSliceSame", vec![x, y]), + _ if !null(&x) + && !null(&y) + && let Some(same) = b.t.same_fn(ty) => + { + same.call(vec![x, y]) + } // Each is a view of the struct it was made from. _ if !ty.is_trait() && super::dynamic::unsized_object(b.t.tcx, ty) => Expr::rs("tailSame", vec![x, y]), _ => x.binary("===", y), diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index 21b53a4fd..a404f6834 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -223,9 +223,9 @@ pub fn call<'tcx>( } ("Arc" | "Rc", "strong_count") => first(args).member("strong"), ("Arc" | "Rc", "weak_count") => first(args).member("weak"), - // Two `Arc`s of trait objects, or of structs of them, are views of the `Arc`s they - // were made from. - ("Arc" | "Rc", "ptr_eq") if self_ty.is_some_and(|t| super::dynamic::unsized_object(tcx, t)) => { + // Two `Arc`s of trait objects, of structs of them, or of slices are views of the + // `Arc`s they were made from, of the array where it is a slice of one. + ("Arc" | "Rc", "ptr_eq") if self_ty.is_some_and(|t| t.is_slice() || super::dynamic::unsized_object(tcx, t)) => { Expr::rs("arcPtrEq", args) } ("Arc" | "Rc", "ptr_eq") => { @@ -235,7 +235,7 @@ pub fn call<'tcx>( ("Weak", "upgrade") => Expr::rs("weakUpgrade", args), ("Weak", "strong_count") => first(args).member("arc").member("strong"), ("Weak", "weak_count") => Expr::rs("weakWeakCount", args), - ("Weak", "ptr_eq") if self_ty.is_some_and(|t| super::dynamic::unsized_object(tcx, t)) => { + ("Weak", "ptr_eq") if self_ty.is_some_and(|t| t.is_slice() || super::dynamic::unsized_object(tcx, t)) => { let [l, r] = two(args); Expr::rs("arcPtrEq", vec![l.member("arc"), r.member("arc")]) } @@ -496,7 +496,7 @@ fn atomic<'tcx>( Expr::rs("atomicFetch", args) }; // A pointer compares as `ptr::eq` does only where it is the object it points at, or - // a slice of the bytes it points at, which `rs.byteSliceSame` compares. + // a slice of the array it points at, which `rs.sliceSame` compares. let generics = tcx.generics_of(imp).count(); let atomic = tcx .type_of(imp) @@ -521,12 +521,12 @@ fn atomic<'tcx>( format!("comparing pointers to `{pointee}` in an atomic, which JS has no address of"), ))); } - let bytes = pointee.is_some_and(|p| b.t.pointee(p) == crate::lower::pointer::Pointee::Bytes); + let same = pointee.and_then(|p| b.t.same_fn(p)); // A compare-exchange, given what compares a wide integer, whose limbs `===` can't, or - // pointers to bytes. + // pointers `===` can't. let exchange = |f: &str, mut args: Vec| { args.extend(int.filter(|int| int.big()).map(|int| int.func("eq"))); - args.extend(bytes.then(|| Expr::Rs("byteSliceSame".into()))); + args.extend(same.clone()); Expr::rs(f, args) }; let e = match name {