diff --git a/quest/m3/README.md b/quest/m3/README.md index 73adb9533..47ffb0a20 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -18,11 +18,12 @@ generic std gap is planned here even when moq never calls it. - [Unsafe code the translator can model](/quest/m3/ts-unsafe/README.md) - a dependency using only `unsafe` the translator can model translates from source - [Waiting: drop the lang fixture's mul_add allowance](/quest/m3/ts-fma-allowance.md) - the differential fails on any `mul_add` difference again once wasm32's `fma` rounds exactly - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library -- [rs.Slice](/quest/m3/ts-slice-object.md) - references to arrays of other values are a runtime slice too, and pointers compare by where they point +- [Parts of arrays without arrayView](/quest/m3/ts-slice-object.md) - a `&mut [T; N]` to part of an array is taken where it is, with no `Proxy` - [Writes through iter_mut without a Place per item](/quest/m3/ts-iter-mut-places.md) - a loop over `iter_mut()` of copy values writes the slice's array by index - [Throw only where Rust panics](/quest/m3/ts-runtime-throws.md) - no runtime `rust2-ts:` error where native Rust goes on: an exact slower path, or a refusal at translation - [rust2-ts with no ts.toml](/quest/m3/ts-configless.md) - a crate's whole `pub` API translates with no config and no bound items - [std's panic messages hold std's capacity](/quest/m3/ts-panic-payload-capacity.md) - a hook reads native's `String` capacity from std's own formatted panics +- [A slice of one byte's place](/quest/m3/ts-byte-slice-place.md) - `slice::from_mut` of a `&mut u8` writes the byte where the caller holds it - [Browser APIs through wasm-bindgen](/quest/m3/ts-wasm-bindgen/README.md) - web-sys and js-sys imports become direct JS calls, so idiomatic crates such as web-rs's web-codecs translate as stock crates - [BufMut on a byte slice](/quest/m3/ts-bufmut-slices.md) - `bytes`' `BufMut` for `&mut [u8]` and `&mut [MaybeUninit]` translates - [Fields typed by an associated type](/quest/m3/ts-assoc-type-fields.md) - a generic struct's field of `::Item` translates at each instance diff --git a/quest/m3/ts-byte-slice-place.md b/quest/m3/ts-byte-slice-place.md new file mode 100644 index 000000000..8fccdc4a7 --- /dev/null +++ b/quest/m3/ts-byte-slice-place.md @@ -0,0 +1,24 @@ +# [S] A slice of one byte's place + +## Goal + +[rust2-ts](/ts/README.md) translates `slice::from_mut` and `array::from_mut` of a +`&mut u8`, of a local, a field, or an element of an array of bytes alike, which it refuses +today: the slice writes the byte where the caller holds it. Proven by differential tests +against native Rust. + +## Plan + +✅ Decided with the maintainer on 2026-11-06 in +[moq-dev/rust2#608](https://github.com/moq-dev/rust2/pull/608): keep it, deferred to this +quest of its own, as rust2 aims to support all of std. The options were to drop it until +a consumer appears, since moq has none at its pin, or to keep it and measure the +`rs.Place`-backed `rs.ByteSlice` below (picked). + +A slice of one over a `&mut u8` was found fragile when it meant a one-byte buffer for each +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))`, against +the `rs.ByteSlice` over a `Uint8Array` every other byte slice is. + +Public API: the translator's output, and what a hand-written caller may receive as a +`rs.ByteSlice`. diff --git a/quest/m3/ts-iter-mut-places.md b/quest/m3/ts-iter-mut-places.md index 8ba0568d7..93de87841 100644 --- a/quest/m3/ts-iter-mut-places.md +++ b/quest/m3/ts-iter-mut-places.md @@ -16,4 +16,4 @@ iterator can yield the index instead. ## Related -- [rs.Slice](/quest/m3/ts-slice-object.md) - the slice these loops index +- [Parts of arrays without arrayView](/quest/m3/ts-slice-object.md) - the slices these loops index diff --git a/quest/m3/ts-runtime-throws.md b/quest/m3/ts-runtime-throws.md index 974300d95..94f502750 100644 --- a/quest/m3/ts-runtime-throws.md +++ b/quest/m3/ts-runtime-throws.md @@ -35,6 +35,26 @@ comparisons [#584](https://github.com/moq-dev/rust2/pull/584) refuses at transla JS may make two `rs.Place`s for one place, are out of scope: addresses were their route, and addresses stay refused (decided 2026-11-07 in [the model epic](/quest/m2/ts-model/README.md)). +✅ Decided with the maintainer on 2026-11-06 in +[moq-dev/rust2#608](https://github.com/moq-dev/rust2/pull/608): comparing `*const [T]` of +values JS copies moved here from [rs.Slice](/quest/m3/ts-slice-object.md). The options +were to wait on rs.String ([moq-dev/rust2#574](https://github.com/moq-dev/rust2/pull/574)) and run only if `&str` shares +its bytes, or to move it here with the other comparisons left refused (picked). Its only +consumer in moq-net is form_urlencoded 1.2.2's `src/lib.rs:417`, +`debug_assert!(ptr::eq(s.as_bytes(), vec))`, of the `&str` that +`String::from_utf8_lossy(&vec)` borrowed. Under +[moq-dev/rust2#574](https://github.com/moq-dev/rust2/pull/574)'s decision a `&str` stays a +JS string, so `as_bytes` makes fresh bytes and today's refusal is exact; comparing by array +and offset would answer `false` where Rust answers `true`. Look for an exact slower path. + +✅ Decided with the maintainer on 2026-11-07 in +[moq-dev/rust2#608](https://github.com/moq-dev/rust2/pull/608): `ptr::eq` of an array that +`as_chunks` split from one flat slice, as std lends it to a callback, moved here. Such an +array has no JS array of its own, so `rs.arraySliceItems` gives std a copy of it, and +`ptr::eq` with the array lent elsewhere answers `false` where Rust answers `true`. Arrays +that are each a JS array of their own keep their identity. Look for an exact slower path +with the `*const [T]` comparisons above. + Public API: the translator's output, and which crates translate. ## Related diff --git a/quest/m3/ts-slice-object.md b/quest/m3/ts-slice-object.md index f20b41438..8b0a4f81f 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -1,42 +1,55 @@ -# [M] rs.Slice +# [M] Parts of arrays without arrayView ## Goal -[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. +[rust2-ts](/ts/README.md) holds a slice of arrays as an `rs.ArraySlice` of the slice each array +is, with no `Proxy`. What remains is the runtime's `arrayView`, a `Proxy` JS array over +part of another, which `rs.sliceView` makes where a `&mut [T; N]` to part of an array is +taken whole as a JS array: by `mem::replace` and `mem::swap` of an element of a slice of +arrays, `Cell::from_mut` of one, std's mappings given one to write through, and a raw +pointer's `as_mut` or `Box::from_raw`. Each takes the slice where it is instead, or a +copy written back as `rs.arraySliceBy` writes arrays back, and `arrayView` and its `View` traps +go. Proven by differential tests against native Rust. ## Plan +✅ Decided with the maintainer on 2026-11-06 in +[moq-dev/rust2#608](https://github.com/moq-dev/rust2/pull/608), which made `rs.ArraySlice`: + +1. How a `&mut [[T; N]]` holds its arrays: + - ✅ (a) A runtime type for every slice of arrays, nested or flat, whose element `i` is + the slice of array `i`, which replaces the `Runs` and `ByteRuns` `Proxy` views and + `arrayView`. + - (b) Bytes only: `as_chunks_mut` makes eager `subarray` views, keeping the `Proxy` + path for other elements. + - (c) Keep the `Proxy` views and drop the item. +2. `slice::from_mut` of a `&mut u8`: kept, deferred to + [a quest of its own](/quest/m3/ts-byte-slice-place.md). +3. Comparing `*const [T]` of values JS copies: moved to + [Throw only where Rust panics](/quest/m3/ts-runtime-throws.md). + +✅ Decided with the maintainer on 2026-11-07 at the round-3 design checkpoint of +[moq-dev/rust2#608](https://github.com/moq-dev/rust2/pull/608): + +4. Conversions that copied arrays where Rust borrows them: ✅ continue, with local fixes + (rejected: merge as is; `rs.ArraySlice` only for what `as_chunks` splits, keeping + `rs.Slice` for other slices of arrays; drop). Where each array of an array slice is + a JS array of its own, `rs.arraySliceItems` slices the list of them rather than copying + each, so a std callback's `ptr::eq` sees the array it was lent, and `join` reads its + array separator without copying it, since it clones it anyway. The arrays `as_chunks` + splits from one flat slice have none of their own, so a callback still gets a copy: + that `ptr::eq` gap moved to [Throw only where Rust panics](/quest/m3/ts-runtime-throws.md). +5. The type's name: ✅ `rs.ArraySlice`, as `rs.ByteSlice` and `rs.RawSlice` are named, + with its helpers `rs.arraySlice*` (rejected: `rs.Slices`, `rs.Chunks`, keep `rs.Runs`). + Decided with the maintainer on 2026-11-03: Rust types the runtime can't hold as std's do 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 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; 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). +`rs.replaceIn` and `rs.cellIn` of a JS array write a whole value into it, and copy its +elements to a depth where a write lands in them; a slice's form needs the same, as +`rs.arraySliceReplace` and `rs.cellOfArraySlice` do for arrays. A raw pointer to an array of arrays +that std's mapping gives back as a reference is refused today. Public API: the translator's output and what a hand-written caller passes for a slice of arrays. diff --git a/ts/README.md b/ts/README.md index a64f2f0b1..db6e3d647 100644 --- a/ts/README.md +++ b/ts/README.md @@ -105,10 +105,10 @@ 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`; a generic type's `Option` is an `rs.OptionOf`, either as each instance's `T` decides, as a generic `Poll` is an `rs.PollOf` | | `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, 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 | +| tuple, `[T; N]`, `&[T; N]` | an array, and `rs.Slice` of all of it for `&[T; N]`, `rs.ArraySlice` for an array of arrays; 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; `rs.ArraySlice` of the slice each array is for a slice of arrays | | `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 `rs.String` it owns or an `rs.Borrowed` holding the string it borrows, whose text `rs.strCowStr` reads | +| `Cow<[T]>`, `Cow` | `rs.Cow`: the `Vec` it owns, or an `rs.Borrowed` holding the slice it borrows, `rs.Cow>` holding the arrays of a slice of arrays; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the `rs.String` it owns or an `rs.Borrowed` holding the string it borrows, whose text `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`, 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.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 but for a `Vec`'s room up to its capacity, 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 pointer to a slice cast to one to an array of its elements is the `rs.Slice` or `rs.ByteSlice` of that many from its first, read through only where Rust reads. 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`, as each of `Box::new_uninit_slice`'s is; a slice's `write_clone_of_slice` clones into its slots without dropping what they held | @@ -173,14 +173,20 @@ same array. A caller passes one as `rs.sliceFrom(array)` and reads one it gets a 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 -reads, and the runtime's swaps, rotations, and sorts move copies of the runs. +through one writes each element in place. A slice of arrays, a `&[[T; N]]`, +`&mut [[T; N]]`, `&[[T; N]; M]`, or `Box<[[T; N]]>`, is an `rs.ArraySlice` of the slice each +array is, `rs.ArraySlice>`, `rs.ArraySlice` for bytes, and +`rs.ArraySlice` of `rs.ArraySlice` for arrays of arrays: its element `i` is the slice of array `i`, read and written +where the arrays are, whether each is a JS array of its own, as a `Vec<[T; N]>` or a +`[[T; N]; M]` holds them, or a part of one slice, as `as_chunks_mut` and `as_rchunks_mut` +split it. A caller passes one as `rs.arraySliceFrom(arrays, rs.sliceFrom)`, `rs.byteSliceFrom` +for bytes and `rs.arraySliceOf(rs.sliceFrom)` for arrays of arrays, and reads one as +`rs.arraySliceItems(slice)`: the arrays themselves, or copies of the ones a split of one +slice holds, which have no array of their own. std's methods that lend arrays or parts of +the slice, such as `iter_mut`, `split_at_mut`, `chunks_mut`, and `swap`, take them where +they are; any other reads them as `rs.arraySliceItems` does, or for a `&mut` one, such as +`sort` or `rotate_left`, reads copies of the arrays, which it writes back once it returns, +as Rust moves their elements. `usize` is 32 bits, as on wasm32, so it is exact in a `number`. Arithmetic is checked as a debug build checks it, so translated code panics where native code would: it never diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 296997354..0870df6e4 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -680,7 +680,7 @@ export function packets(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v let _32!: rs.u8; let cc!: rs.u8; const packets: rs.ByteVec = rs.byteVecOf(0, rs.usizeMul(rs.u64Low(rs.u64Min(takeU64(data)[0], 4096)), 188)); - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rs.byteSliceAsChunksMut(rs.byteVecSlice(packets), 188)[0])), rs.byteSliceFrom)); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.arraySliceIter(rs.sliceAsChunks(rs.byteVecSlice(packets), 188)[0])); while (true) { const _21: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_21 === rs.DONE) { @@ -699,7 +699,7 @@ export function packets(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v } const counters: Uint8Array = rs.bytes(3); let sum: rs.u64 = 0; - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(rs.byteSliceAsChunksMut(rs.byteVecSlice(packets), 188)[0])), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.sliceAsChunks(rs.byteVecSlice(packets), 188)[0]); while (true) { const _48: rs.ByteSlice | rs.Done = iter2.next(); if (_48 === rs.DONE) { diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index 5f6dccd39..ad2b01845 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -79,9 +79,9 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { }); }); const named: rs.u16[] = rs.arrayFromFn(4, doubled); - 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 _97: rs.ArraySlice = rs.arraySliceFrom(grid, rs.byteSliceFrom); + [_97, rs.sliceFrom(named)] as [rs.ArraySlice, rs.Slice]; + const _100: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_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]]); @@ -229,14 +229,14 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { } same2[_124][0] = same2[_124][0] ^ 128; 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 _135: rs.ArraySlice = rs.arraySliceFrom(grid, rs.byteSliceFrom); + const _136: rs.ArraySlice = rs.arraySliceFrom(flipped, rs.byteSliceFrom); + const _138: rs.ArraySlice = rs.arraySliceFrom(same2, rs.byteSliceFrom); + [_133, _135, _136, rs.sliceFrom(sums), _138] as [rs.Slice, rs.ArraySlice, rs.ArraySlice, rs.Slice, rs.ArraySlice]; + const _140: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_135), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const _141: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_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)]; + const args15 = [_140, _141, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_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.v)); @@ -304,7 +304,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.stringPush(_49[_51], rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_21 === 3) { - const rows: rs.ByteSlice[] = rs.arrayMap(grid, rs.byteSliceFrom); + const rows: rs.ByteSlice[] = rs.arraySliceEach(rs.arraySliceFrom(grid, rs.byteSliceFrom)); const _61: rs.usize = rs.usizeRem(i, 2); if (!(_61 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _61); @@ -320,7 +320,7 @@ 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.Slice[] = rs.arrayMap(pairs, rs.sliceFrom); + const _78: rs.Slice[] = rs.arraySliceEach(rs.arraySliceFrom(pairs, rs.sliceFrom)); const _80: rs.u32 = op as rs.u32; const _83: rs.usize = rs.usizeRem(i, 2); if (!(_83 < 2)) { @@ -341,10 +341,10 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const lens: Uint8Array = rs.bytesMap(rs.arrayFrom(words), (w: rs.String): rs.u8 => { return w.len & 0xff; }); - const rows2: Uint8Array = rs.bytesMap(rs.arrayMap(grid, rs.byteSliceFrom), (row: rs.ByteSlice): rs.u8 => { + const rows2: Uint8Array = rs.bytesMap(rs.arraySliceEach(rs.arraySliceFrom(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.arrayMap(pairs, rs.sliceFrom), (pair: rs.Slice): rs.u32 => { + const sums: rs.u32[] = rs.arrayMap(rs.arraySliceEach(rs.arraySliceFrom(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)); @@ -366,17 +366,17 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2]]).v)); } } - [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]; + [rs.byteSliceFrom(bytes), rs.sliceFrom(wide), rs.sliceFrom(words), rs.arraySliceFrom(grid, rs.byteSliceFrom), rs.arraySliceFrom(pairs, rs.sliceFrom)] as [rs.ByteSlice, rs.Slice, rs.Slice, rs.ArraySlice, rs.ArraySlice>]; 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, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)); - 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))]; + const arg5 = rs.arraySliceFrom(grid, rs.byteSliceFrom); + const _161: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(arg5), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const arg6 = rs.arraySliceFrom(pairs, rs.sliceFrom); + const args6 = [_158, _159, _160, _161, (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(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]]).v)); } @@ -422,15 +422,14 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_46, _48); rs.stringPush(_46.data[_46.start + _48], rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_22 === 3) { - const _59: rs.Slice = rs.sliceFrom(grid); + const _59: rs.ArraySlice = rs.arraySliceFrom(grid, rs.byteSliceFrom); const _61: rs.usize = rs.usizeRem(i, 3); rs.idx(_59, _61); - const row: rs.ByteSlice = rs.byteSliceFrom(_59.data[_59.start + _61]); - const _66: rs.ByteSlice = row; + const _66: rs.ByteSlice = rs.arraySliceAt(_59, _61); const _67: rs.usize = rs.usizeRem(i, 2); rs.idx(_66, _67); _66.data[_66.start + _67] = op; - const _73: rs.ByteSlice = row; + const _73: rs.ByteSlice = rs.arraySliceAt(_59, _61); const _75: rs.usize = rs.usizeRem(rs.usizeAdd(i, 1), 2); rs.idx(_73, _75); const read: rs.u8 = _73.data[_73.start + _75]; @@ -440,11 +439,11 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { } grid[_81][0] = grid[_81][0] ^ read; } else if (_22 === 4) { - const all: rs.Slice = rs.sliceFrom(pairs); + const all: rs.ArraySlice> = rs.arraySliceFrom(pairs, rs.sliceFrom); const _93: rs.usize = rs.usizeRem(i, 2); rs.idx(all, _93); - rs.sliceCopyFromSlice(rs.sliceFrom(all.data[all.start + _93]), rs.sliceFrom([op as rs.u32, ((op as rs.u32) << 20) >>> 0])); - rs.sliceSwap(all, 0, 1); + rs.sliceCopyFromSlice(rs.arraySliceAt(all, _93), rs.sliceFrom([op as rs.u32, ((op as rs.u32) << 20) >>> 0])); + rs.arraySliceSwap(all, 0, 1, undefined); } else if (_22 === 5) { rs.sliceReverse(rs.sliceFrom([])); rs.byteSliceFill(rs.byteSliceFrom(Uint8Array.of()), op); @@ -461,11 +460,11 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const _143: rs.ByteSlice = rs.byteSliceFrom(bytes); const _146: rs.Slice = rs.sliceFrom(wide); const _149: rs.Slice = rs.sliceFrom(words); - const _152: rs.Slice = rs.sliceFrom(grid); - const _155: rs.Slice = rs.sliceFrom(pairs); + const _152: rs.ArraySlice = rs.arraySliceFrom(grid, rs.byteSliceFrom); + const _155: rs.ArraySlice> = rs.arraySliceFrom(pairs, rs.sliceFrom); const _158: rs.Slice = rs.sliceFrom([]); const _161: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of()); - 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, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (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)]; + 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, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_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]]).v)); } @@ -552,8 +551,8 @@ export function bytesAt$5(data: rs.ByteSlice, at: rs.usize): Uint8Array { } /** Each array's bytes, in order. */ -export function put$0(out: rs.ByteVec, arrays: rs.Slice): void { - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(arrays)), rs.byteSliceFrom); +export function put$0(out: rs.ByteVec, arrays: rs.ArraySlice): void { + const iter: rs.Iter = rs.arraySliceIter(arrays); while (true) { const _5: rs.ByteSlice | rs.Done = iter.next(); if (_5 === rs.DONE) { @@ -564,8 +563,8 @@ export function put$0(out: rs.ByteVec, arrays: rs.Slice): void { } /** Each array's bytes, in order. */ -export function put$1(out: rs.ByteVec, arrays: rs.Slice): void { - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(arrays)), rs.byteSliceFrom); +export function put$1(out: rs.ByteVec, arrays: rs.ArraySlice): void { + const iter: rs.Iter = rs.arraySliceIter(arrays); while (true) { const _5: rs.ByteSlice | rs.Done = iter.next(); if (_5 === rs.DONE) { @@ -576,8 +575,8 @@ export function put$1(out: rs.ByteVec, arrays: rs.Slice): void { } /** Each array's bytes, in order. */ -export function put$3(out: rs.ByteVec, arrays: rs.Slice): void { - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(arrays)), rs.byteSliceFrom); +export function put$3(out: rs.ByteVec, arrays: rs.ArraySlice): void { + const iter: rs.Iter = rs.arraySliceIter(arrays); while (true) { const _5: rs.ByteSlice | rs.Done = iter.next(); if (_5 === rs.DONE) { @@ -588,8 +587,8 @@ export function put$3(out: rs.ByteVec, arrays: rs.Slice): void { } /** Each array's bytes, in order. */ -export function put$32(out: rs.ByteVec, arrays: rs.Slice): void { - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(arrays)), rs.byteSliceFrom); +export function put$32(out: rs.ByteVec, arrays: rs.ArraySlice): void { + const iter: rs.Iter = rs.arraySliceIter(arrays); while (true) { const _5: rs.ByteSlice | rs.Done = iter.next(); if (_5 === rs.DONE) { @@ -600,8 +599,8 @@ export function put$32(out: rs.ByteVec, arrays: rs.Slice): void { } /** Each array's bytes, in order. */ -export function put$40(out: rs.ByteVec, arrays: rs.Slice): void { - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(arrays)), rs.byteSliceFrom); +export function put$40(out: rs.ByteVec, arrays: rs.ArraySlice): void { + const iter: rs.Iter = rs.arraySliceIter(arrays); while (true) { const _5: rs.ByteSlice | rs.Done = iter.next(); if (_5 === rs.DONE) { @@ -612,8 +611,8 @@ export function put$40(out: rs.ByteVec, arrays: rs.Slice): void { } /** Each array's bytes, in order. */ -export function put$5(out: rs.ByteVec, arrays: rs.Slice): void { - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(arrays)), rs.byteSliceFrom); +export function put$5(out: rs.ByteVec, arrays: rs.ArraySlice): void { + const iter: rs.Iter = rs.arraySliceIter(arrays); while (true) { const _5: rs.ByteSlice | rs.Done = iter.next(); if (_5 === rs.DONE) { @@ -682,7 +681,7 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { if (_16 !== undefined) { _16.v = _16.v ^ 2; } - put$0(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$0(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); putSome$0(out, copied); putSome$0(out, cloned); rs.byteSliceFrom(a); @@ -691,7 +690,7 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { if (_32 !== undefined) { _32.v = rs.u8WrappingAdd(_32.v, 1); } - put$0(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$0(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { return bytesAt$0(data, rs.usizeMul(k, 2)); }), undefined, 0, true); @@ -700,23 +699,31 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceFrom(v.items[rs.idx(v.items, 2)]); const old: Uint8Array = copy$array_u8(b); rs.byteSliceFill(rs.byteSliceFrom(b), 187); - put$0(out, rs.sliceFrom([old, copy$array_u8(a), copy$array_u8(b)])); - put$0(out, rs.sliceFrom(v.items)); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(rs.sliceFrom(v.items), 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { + put$0(out, rs.arraySliceFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$0(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); + const _73: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.arraySliceAsSlice(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.arraySliceAsSlice(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, 1); + const _84: rs.ByteSlice = rs.byteSliceFrom(old); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_72, _76, rs.sliceContains(rs.arraySliceAsSlice(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [rs.Slice, rs.Slice] = rs.sliceSplitAt(rs.sliceFrom(v.items), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); - rs.byteSliceFrom(_87[0].data[_87[0].start]); rs.idx(_87[1], 1); - rs.byteSliceFrom(_87[1].data[_87[1].start + 1]); - put$0(out, rs.sliceFrom(v.items)); + put$0(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 0, 1)), (i: rs.usize): rs.u8 => { return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rs.byteVecPush(out, rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0))), rs.eqBytes) ? 1 : 0); + const _115: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0)); + rs.byteVecPush(out, rs.sliceContains(rs.arraySliceAsSlice(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 0); const part: Uint8Array | undefined = copy$Option_array0_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 0), rs.byteSliceView)); const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 0); if (_126 !== undefined) { @@ -736,7 +743,7 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { putSome$0(out, old2); putSome$0(out, cloned2); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); - const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); rs.byteVecPush(out, one.length & 0xff); put$0(out, one); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); @@ -744,10 +751,10 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$0(out, rs.sliceFrom([copy$array_u8(b)])); - const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + put$0(out, rs.arraySliceFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - 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))]; + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -777,7 +784,7 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { if (_16 !== undefined) { _16.v = _16.v ^ 2; } - put$1(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$1(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); putSome$1(out, copied); putSome$1(out, cloned); const _30: rs.ByteSlice = rs.byteSliceFrom(a); @@ -789,7 +796,7 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { if (_32 !== undefined) { _32.v = rs.u8WrappingAdd(_32.v, 1); } - put$1(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$1(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { return bytesAt$1(data, rs.usizeMul(k, 2)); }), undefined, 1, true); @@ -804,26 +811,36 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { _54.data.set(_56, _54.start); const old: Uint8Array = old3; rs.byteSliceFill(rs.byteSliceFrom(b), 187); - put$1(out, rs.sliceFrom([old, copy$array_u8(a), copy$array_u8(b)])); - put$1(out, rs.sliceFrom(v.items)); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(rs.sliceFrom(v.items), 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { + put$1(out, rs.arraySliceFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$1(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); + const _73: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.arraySliceAsSlice(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.arraySliceAsSlice(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, 1); + const _84: rs.ByteSlice = rs.byteSliceFrom(old); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_72, _76, rs.sliceContains(rs.arraySliceAsSlice(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [rs.Slice, rs.Slice] = rs.sliceSplitAt(rs.sliceFrom(v.items), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); - const _91: rs.ByteSlice = rs.byteSliceFrom(_87[0].data[_87[0].start]); rs.idx(_87[1], 1); - const _96: rs.ByteSlice = rs.byteSliceFrom(_87[1].data[_87[1].start + 1]); - const swapped3 = rs.byteSliceToArray(_91); - _91.data.set(rs.byteSliceToArray(_96), _91.start); - _96.data.set(swapped3, _96.start); - put$1(out, rs.sliceFrom(v.items)); + const slice3 = rs.arraySliceAt(_87[0], 0); + const slice4 = rs.arraySliceAt(_87[1], 1); + const swapped3 = rs.byteSliceToArray(slice3); + slice3.data.set(rs.byteSliceToArray(slice4), slice3.start); + slice4.data.set(swapped3, slice4.start); + put$1(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 1, 1)), (i: rs.usize): rs.u8 => { return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rs.byteVecPush(out, rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1))), rs.eqBytes) ? 1 : 0); + const _115: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1)); + rs.byteVecPush(out, rs.sliceContains(rs.arraySliceAsSlice(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 0); const part: Uint8Array | undefined = copy$Option_array1_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 1), rs.byteSliceView)); const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 1); if (_126 !== undefined) { @@ -851,7 +868,7 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { putSome$1(out, old2); putSome$1(out, cloned2); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); - const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); rs.byteVecPush(out, one.length & 0xff); put$1(out, one); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); @@ -859,10 +876,10 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$1(out, rs.sliceFrom([copy$array_u8(b)])); - const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + put$1(out, rs.arraySliceFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - 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))]; + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -892,7 +909,7 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { if (_16 !== undefined) { _16.v = _16.v ^ 2; } - put$3(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$3(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); putSome$3(out, copied); putSome$3(out, cloned); const _30: rs.ByteSlice = rs.byteSliceFrom(a); @@ -904,7 +921,7 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { if (_32 !== undefined) { _32.v = rs.u8WrappingAdd(_32.v, 1); } - put$3(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$3(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { return bytesAt$3(data, rs.usizeMul(k, 2)); }), undefined, 3, true); @@ -919,26 +936,36 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { _54.data.set(_56, _54.start); const old: Uint8Array = old3; rs.byteSliceFill(rs.byteSliceFrom(b), 187); - put$3(out, rs.sliceFrom([old, copy$array_u8(a), copy$array_u8(b)])); - put$3(out, rs.sliceFrom(v.items)); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(rs.sliceFrom(v.items), 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { + put$3(out, rs.arraySliceFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$3(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); + const _73: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.arraySliceAsSlice(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.arraySliceAsSlice(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, 1); + const _84: rs.ByteSlice = rs.byteSliceFrom(old); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_72, _76, rs.sliceContains(rs.arraySliceAsSlice(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [rs.Slice, rs.Slice] = rs.sliceSplitAt(rs.sliceFrom(v.items), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); - const _91: rs.ByteSlice = rs.byteSliceFrom(_87[0].data[_87[0].start]); rs.idx(_87[1], 1); - const _96: rs.ByteSlice = rs.byteSliceFrom(_87[1].data[_87[1].start + 1]); - const swapped3 = rs.byteSliceToArray(_91); - _91.data.set(rs.byteSliceToArray(_96), _91.start); - _96.data.set(swapped3, _96.start); - put$3(out, rs.sliceFrom(v.items)); + const slice3 = rs.arraySliceAt(_87[0], 0); + const slice4 = rs.arraySliceAt(_87[1], 1); + const swapped3 = rs.byteSliceToArray(slice3); + slice3.data.set(rs.byteSliceToArray(slice4), slice3.start); + slice4.data.set(swapped3, slice4.start); + put$3(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 3, 1)), (i: rs.usize): rs.u8 => { return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rs.byteVecPush(out, rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3))), rs.eqBytes) ? 1 : 0); + const _115: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3)); + rs.byteVecPush(out, rs.sliceContains(rs.arraySliceAsSlice(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 0); const part: Uint8Array | undefined = copy$Option_array3_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 3), rs.byteSliceView)); const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 3); if (_126 !== undefined) { @@ -966,7 +993,7 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { putSome$3(out, old2); putSome$3(out, cloned2); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); - const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); rs.byteVecPush(out, one.length & 0xff); put$3(out, one); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); @@ -974,10 +1001,10 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$3(out, rs.sliceFrom([copy$array_u8(b)])); - const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + put$3(out, rs.arraySliceFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - 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))]; + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -1007,7 +1034,7 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { if (_16 !== undefined) { _16.v = _16.v ^ 2; } - put$40(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$40(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); putSome$40(out, copied); putSome$40(out, cloned); const _30: rs.ByteSlice = rs.byteSliceFrom(a); @@ -1019,7 +1046,7 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { if (_32 !== undefined) { _32.v = rs.u8WrappingAdd(_32.v, 1); } - put$40(out, rs.sliceFrom([copy$array_u8(a), copy$array_u8(b)])); + put$40(out, rs.arraySliceFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { return bytesAt$40(data, rs.usizeMul(k, 2)); }), undefined, 40, true); @@ -1034,26 +1061,36 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { _54.data.set(_56, _54.start); const old: Uint8Array = old3; rs.byteSliceFill(rs.byteSliceFrom(b), 187); - put$40(out, rs.sliceFrom([old, copy$array_u8(a), copy$array_u8(b)])); - put$40(out, rs.sliceFrom(v.items)); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(rs.sliceFrom(v.items), 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { + put$40(out, rs.arraySliceFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$40(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); + const _73: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.arraySliceAsSlice(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.arraySliceAsSlice(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, 1); + const _84: rs.ByteSlice = rs.byteSliceFrom(old); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_72, _76, rs.sliceContains(rs.arraySliceAsSlice(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [rs.Slice, rs.Slice] = rs.sliceSplitAt(rs.sliceFrom(v.items), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); - const _91: rs.ByteSlice = rs.byteSliceFrom(_87[0].data[_87[0].start]); rs.idx(_87[1], 1); - const _96: rs.ByteSlice = rs.byteSliceFrom(_87[1].data[_87[1].start + 1]); - const swapped3 = rs.byteSliceToArray(_91); - _91.data.set(rs.byteSliceToArray(_96), _91.start); - _96.data.set(swapped3, _96.start); - put$40(out, rs.sliceFrom(v.items)); + const slice3 = rs.arraySliceAt(_87[0], 0); + const slice4 = rs.arraySliceAt(_87[1], 1); + const swapped3 = rs.byteSliceToArray(slice3); + slice3.data.set(rs.byteSliceToArray(slice4), slice3.start); + slice4.data.set(swapped3, slice4.start); + put$40(out, rs.arraySliceFrom(v.items, rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 40, 1)), (i: rs.usize): rs.u8 => { return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rs.byteVecPush(out, rs.sliceContains(rs.sliceFrom(v.items), rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 40))), rs.eqBytes) ? 1 : 0); + const _115: rs.ArraySlice = rs.arraySliceFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 40)); + rs.byteVecPush(out, rs.sliceContains(rs.arraySliceAsSlice(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 0); const part: Uint8Array | undefined = copy$Option_array40_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 40), rs.byteSliceView)); const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 40); if (_126 !== undefined) { @@ -1081,7 +1118,7 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { putSome$40(out, old2); putSome$40(out, cloned2); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); - const one: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); rs.byteVecPush(out, one.length & 0xff); put$40(out, one); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); @@ -1089,10 +1126,10 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$40(out, rs.sliceFrom([copy$array_u8(b)])); - const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + put$40(out, rs.arraySliceFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); const _192: rs.ByteSlice = rs.byteSliceFrom(a); - 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))]; + const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -1126,13 +1163,13 @@ export function fields(data: rs.ByteSlice, out: rs.ByteVec): void { _10.data.set(_11, _10.start); const old: Uint8Array = old2; held.bytes[0] = held.bytes[0] ^ 16; - put$3(out, rs.sliceFrom([copy$array_u8(a), old, copy$array_u8(held.bytes)])); + put$3(out, rs.arraySliceFrom([copy$array_u8(a), old, copy$array_u8(held.bytes)], rs.byteSliceFrom)); const part = { _0: copy$array_u8(held.bytes) }; const shown: rs.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); - put$3(out, rs.sliceFrom([taken2, copy$array_u8(held.bytes)])); + put$3(out, rs.arraySliceFrom([taken2, copy$array_u8(held.bytes)], rs.byteSliceFrom)); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown.v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d: rs.u8): boolean => { return rs.u8Rem(d, 3) === 1; @@ -1152,7 +1189,7 @@ export function fields(data: rs.ByteSlice, out: rs.ByteVec): void { export function taken$0(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$0(data, 1)); rs.byteSliceFrom(a); - put$0(out, rs.sliceFrom([rs.bytes(0), copy$array_u8(a)])); + put$0(out, rs.arraySliceFrom([rs.bytes(0), copy$array_u8(a)], rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(0).fill(119))), undefined, true); const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0); if (_17 !== undefined) { @@ -1168,7 +1205,7 @@ export function taken$1(data: rs.ByteSlice, out: rs.ByteVec): void { const _5: rs.ByteSlice = rs.byteSliceFrom(a); const taken = rs.byteSliceToArray(_5); _5.data.set(rs.bytes(1), _5.start); - put$1(out, rs.sliceFrom([taken, copy$array_u8(a)])); + put$1(out, rs.arraySliceFrom([taken, copy$array_u8(a)], rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(1).fill(119))), undefined, true); const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1); if (_17 !== undefined) { @@ -1186,7 +1223,7 @@ export function taken$3(data: rs.ByteSlice, out: rs.ByteVec): void { const _5: rs.ByteSlice = rs.byteSliceFrom(a); const taken = rs.byteSliceToArray(_5); _5.data.set(rs.bytes(3), _5.start); - put$3(out, rs.sliceFrom([taken, copy$array_u8(a)])); + put$3(out, rs.arraySliceFrom([taken, copy$array_u8(a)], rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(3).fill(119))), undefined, true); const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3); if (_17 !== undefined) { @@ -1204,7 +1241,7 @@ export function taken$32(data: rs.ByteSlice, out: rs.ByteVec): void { const _5: rs.ByteSlice = rs.byteSliceFrom(a); const taken = rs.byteSliceToArray(_5); _5.data.set(rs.bytes(32), _5.start); - put$32(out, rs.sliceFrom([taken, copy$array_u8(a)])); + put$32(out, rs.arraySliceFrom([taken, copy$array_u8(a)], rs.byteSliceFrom)); const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(32).fill(119))), undefined, true); const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 32); if (_17 !== undefined) { @@ -1424,7 +1461,7 @@ export function flattenedN$0(data: rs.ByteSlice, out: rs.ByteVec): void { 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, (held2) => rs.byteSliceToArray(held2)), "next", 0); - put$0(out, rs.sliceFrom(copied.items)); + put$0(out, rs.arraySliceFrom(copied.items, rs.byteSliceFrom)); 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); while (true) { @@ -1451,9 +1488,9 @@ export function flattenedN$0(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecExtendFromSlice(out, _351); } - const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): rs.Slice => { - return rs.sliceFrom(v.items); - }), undefined, 8, true)), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true); + const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): rs.ArraySlice => { + return rs.arraySliceFrom(v.items, rs.byteSliceFrom); + }), undefined, 8, true)), (value: rs.ArraySlice) => rs.arraySliceIter(value), true); while (true) { const _366: rs.ByteSlice | rs.Done = iter20.next(); if (_366 === rs.DONE) { @@ -1465,9 +1502,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.iterLend(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array0_u8(_373); - })), rs.sliceFrom), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true, 2); + }), rs.arraySliceOf(rs.byteSliceFrom))), (value: rs.ArraySlice) => rs.arraySliceIter(value), true, 2); while (true) { const _381: rs.ByteSlice | rs.Done = iter21.next(); if (_381 === rs.DONE) { @@ -1673,7 +1710,7 @@ export function flattenedN$1(data: rs.ByteSlice, out: rs.ByteVec): void { 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, (held2) => rs.byteSliceToArray(held2)), "next", 1); - put$1(out, rs.sliceFrom(copied.items)); + put$1(out, rs.arraySliceFrom(copied.items, rs.byteSliceFrom)); 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); while (true) { @@ -1700,9 +1737,9 @@ export function flattenedN$1(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecExtendFromSlice(out, _351); } - const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): rs.Slice => { - return rs.sliceFrom(v.items); - }), undefined, 8, true)), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true); + const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): rs.ArraySlice => { + return rs.arraySliceFrom(v.items, rs.byteSliceFrom); + }), undefined, 8, true)), (value: rs.ArraySlice) => rs.arraySliceIter(value), true); while (true) { const _366: rs.ByteSlice | rs.Done = iter20.next(); if (_366 === rs.DONE) { @@ -1714,9 +1751,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.iterLend(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array1_u8(_373); - })), rs.sliceFrom), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true, 2); + }), rs.arraySliceOf(rs.byteSliceFrom))), (value: rs.ArraySlice) => rs.arraySliceIter(value), true, 2); while (true) { const _381: rs.ByteSlice | rs.Done = iter21.next(); if (_381 === rs.DONE) { @@ -1922,7 +1959,7 @@ export function flattenedN$5(data: rs.ByteSlice, out: rs.ByteVec): void { 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, (held2) => rs.byteSliceToArray(held2)), "next", 5); - put$5(out, rs.sliceFrom(copied.items)); + put$5(out, rs.arraySliceFrom(copied.items, rs.byteSliceFrom)); 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); while (true) { @@ -1949,9 +1986,9 @@ export function flattenedN$5(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecExtendFromSlice(out, _351); } - const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): rs.Slice => { - return rs.sliceFrom(v.items); - }), undefined, 8, true)), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true); + const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): rs.ArraySlice => { + return rs.arraySliceFrom(v.items, rs.byteSliceFrom); + }), undefined, 8, true)), (value: rs.ArraySlice) => rs.arraySliceIter(value), true); while (true) { const _366: rs.ByteSlice | rs.Done = iter20.next(); if (_366 === rs.DONE) { @@ -1963,9 +2000,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.iterLend(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array5_u8(_373); - })), rs.sliceFrom), (value: rs.Slice) => rs.iterLend(rs.iterSlice(rs.sliceItems(value)), rs.byteSliceFrom), true, 2); + }), rs.arraySliceOf(rs.byteSliceFrom))), (value: rs.ArraySlice) => rs.arraySliceIter(value), true, 2); while (true) { const _381: rs.ByteSlice | rs.Done = iter21.next(); if (_381 === rs.DONE) { @@ -1996,4 +2033,30 @@ export function putOptions$5(out: rs.ByteVec, options: rs.Slice Uint8Array = (at: rs.usize): Uint8Array => { + return Uint8Array.of(option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeMul(2, at)), at & 0xff), option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeMul(2, at), 1)), kind)); + }; + const grid: Uint8Array[] = [copy$array_u8(row(0)), copy$array_u8(row(1)), copy$array_u8(row(2))]; + const rest: rs.ArraySlice = rs.arraySlicePart(rs.arraySliceFrom(grid, rs.byteSliceFrom), 1, 3); + const slice = rs.arraySliceAt(rest, 0); + const slice2 = rs.arraySliceAt(rest, 0); + slice2.data[slice2.start] = slice.data[slice.start] ^ 119; + const slice3 = rs.arraySliceAt(rest, 1); + const _22: rs.u8 = rs.u8WrappingAdd(slice3.data[slice3.start + 1], 3); + const slice4 = rs.arraySliceAt(rest, 1); + slice4.data[slice4.start + 1] = _22; + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const front: rs.ArraySlice = rs.arraySlicePart(rs.arraySliceFrom(grid, rs.byteSliceFrom), 0, 2); + const slice5 = rs.arraySliceAt(front, 1); + const _34: rs.u8 = slice5.data[slice5.start]; + const slice6 = rs.arraySliceAt(front, 0); + slice6.data[slice6.start + 1] = _34; + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); +} + //# sourceMappingURL=arrays.ts.map diff --git a/ts/fixtures/lang/arrays/expected/lib.ts b/ts/fixtures/lang/arrays/expected/lib.ts index 3c236cbae..72e96d1db 100644 --- a/ts/fixtures/lang/arrays/expected/lib.ts +++ b/ts/fixtures/lang/arrays/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { fromFns, maps, lent, asSlices, given, flattened } from "./arrays.ts"; +import { fromFns, maps, lent, asSlices, given, flattened, rests } from "./arrays.ts"; export function copy$Option_Option_array0_u8(v: Uint8Array | undefined | rs.None): Uint8Array | undefined | rs.None { return v === rs.None ? v : copy$Option_array0_u8(v); @@ -76,15 +76,15 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { * their count, so a case added at the end moves no other. */ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { - return rs.vecFrom([["arrays::from_fns", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { + return rs.vecFrom([["arrays::from_fns", (_24: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { fromFns(data, out); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::as_slices", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::as_slices", (_25: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { asSlices(data2, out2); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::maps", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::maps", (_26: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { maps(data3, out3); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::lent", (_25: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::lent", (_27: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { lent(data4, out4); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::given", given as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::flattened", flattened as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::given", given as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::flattened", flattened as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::rests", rests 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/arrays/src/arrays.rs b/ts/fixtures/lang/arrays/src/arrays.rs index 1767b1bc1..3a7d62ddf 100644 --- a/ts/fixtures/lang/arrays/src/arrays.rs +++ b/ts/fixtures/lang/arrays/src/arrays.rs @@ -574,3 +574,23 @@ fn put_options(out: &mut Vec, options: &[Option<[u8; N]>]) { put_some(out, a); } } + +/// An array pattern's rest of an owned array of arrays, borrowed mutably and written +/// through, from the front and from the back. +pub fn rests(kind: u8, data: &[u8], out: &mut Vec) { + let row = |at: usize| { + [ + data.get(2 * at).copied().unwrap_or(at as u8), + data.get(2 * at + 1).copied().unwrap_or(kind), + ] + }; + let mut grid = [row(0), row(1), row(2)]; + let [_, ref mut rest @ ..] = grid; + rest[0][0] ^= 0x77; + let [.., last] = rest; + last[1] = last[1].wrapping_add(3); + out.extend(grid.iter().flatten()); + let [ref mut front @ .., _] = grid; + front[0][1] = front[1][0]; + out.extend(grid.iter().flatten()); +} diff --git a/ts/fixtures/lang/arrays/src/lib.rs b/ts/fixtures/lang/arrays/src/lib.rs index ca11865d1..c1a9ccf8f 100644 --- a/ts/fixtures/lang/arrays/src/lib.rs +++ b/ts/fixtures/lang/arrays/src/lib.rs @@ -22,5 +22,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("arrays::lent", |_, data, out| arrays::lent(data, out)), ("arrays::given", arrays::given), ("arrays::flattened", arrays::flattened), + ("arrays::rests", arrays::rests), ] } diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index e85443637..60e8f3e48 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -361,14 +361,14 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const fromArray3: rs.Slice<[rs.u8, rs.u16]> = rs.sliceFrom(copy$array_tuple2_u8_u16(array3)); rs.idx(fromArray3, 0); fromArray3.data[fromArray3.start][0] = 9; - const quads: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data2, 2), (c: rs.ByteSlice): Uint8Array => { + const quads: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data2, 2), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); const _3: rs.u8 = c.data[c.start]; rs.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); - }), undefined, 2, true).items); - const quadsV: rs.Vec = rs.vecFrom(rs.sliceItems(quads).map(copy$array_u8)); - const _554: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(rs.sliceFrom(quadsV.items)), rs.byteSliceFrom); + }), undefined, 2, true).items, rs.byteSliceFrom); + const quadsV: rs.Vec = rs.vecFrom(rs.arraySliceItems(rs.arraySliceFrom(rs.arraySliceItems(quads).map(copy$array_u8), rs.byteSliceFrom))); + const _554: rs.ByteSlice | undefined = rs.arraySliceFirst(rs.arraySliceFrom(quadsV.items, rs.byteSliceFrom)); if (_554 !== undefined) { _554.data[_554.start] = 119; } @@ -381,7 +381,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _576[0]); rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_576[1]).reverse()), undefined, true); } - const iter5: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(quads)), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(quadsV.items), rs.byteSliceFrom)); + const iter5: rs.Iter = rs.iterChain(rs.arraySliceIter(quads), rs.arraySliceIter(rs.arraySliceFrom(quadsV.items, rs.byteSliceFrom))); while (true) { const _594: rs.ByteSlice | rs.Done = iter5.next(); if (_594 === rs.DONE) { diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 78c9e7375..622120dcd 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -136,7 +136,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else if (_39 === 11) { rs.iterExtend(v, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, 1280, true); } else if (_39 === 12) { - rs.vecExtendFromSlice(v, rs.sliceFrom(rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 24) as rs.usize, copy$array_u64).items), 1280, copy$array_u64); + rs.vecExtendFromSlice(v, rs.arraySliceAsSlice(rs.arraySliceFrom(rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 24) as rs.usize, copy$array_u64).items, rs.sliceFrom)), 1280, copy$array_u64); } else if (_39 === 13) { rs.vecTruncate(v, 0); } else if (_39 === 14) { @@ -151,7 +151,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else if (_39 === 16) { v = rs.vecFrom(v.items.map(copy$array_u64)); } else if (_39 === 17) { - v = rs.vecFrom(v.items); + v = rs.vecFrom(rs.arraySliceItems(rs.arraySliceFrom(v.items, rs.sliceFrom))); } else if (_39 === 18) { const keep2: () => boolean = alternate(); v = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), rs.lending((_27: rs.Slice): boolean => { @@ -208,7 +208,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } 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) { - v = rs.iterToVec(rs.iterSlice(v.items), "next", 1280, true, 1280); + v = rs.iterToVec(rs.iterSlice(rs.arraySliceItems(rs.arraySliceFrom(v.items, rs.sliceFrom))), "next", 1280, true, 1280); } else if (_39 === 28) { const own: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 1280); const _225: rs.u64[] = copy$array_u64(make(arg)); @@ -291,16 +291,16 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d }, (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); + const iter4: rs.Iter>> = rs.arraySliceChunksExact(rs.arraySliceFrom(v.items, rs.sliceFrom), 2); while (true) { - const _392: rs.Slice | rs.Done = iter4.next(); + const _392: rs.ArraySlice> | rs.Done = iter4.next(); if (_392 === rs.DONE) { break; } rs.idx(_392, 0); - const _399: rs.u64[] = copy$array_u64(_392.data[_392.start].slice()); + const _399: rs.u64[] = copy$array_u64(rs.sliceToArray(rs.arraySliceAt(_392, 0))); rs.idx(_392, 1); - const _398: rs.u64[][] = [_399, copy$array_u64(_392.data[_392.start + 1].slice())]; + const _398: rs.u64[][] = [_399, copy$array_u64(rs.sliceToArray(rs.arraySliceAt(_392, 1)))]; pairs.items.push(_398); } const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 1280); diff --git a/ts/fixtures/lang/chunks/expected/chunks.ts b/ts/fixtures/lang/chunks/expected/chunks.ts index 5158e6f29..a6270a1fd 100644 --- a/ts/fixtures/lang/chunks/expected/chunks.ts +++ b/ts/fixtures/lang/chunks/expected/chunks.ts @@ -170,7 +170,7 @@ export function chunks(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pairs.items[rs.idx(pairs.items, 0)])); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pairs.items[rs.idx(pairs.items, 1)])); } - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); while (true) { const _219: rs.ByteSlice | rs.Done = iter2.next(); if (_219 === rs.DONE) { @@ -186,10 +186,10 @@ export function chunks(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } _234.data[_234.start] = _234.data[_234.start + 1]; } - const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true); - rs.iterExtendBytes(out, rs.iterChain(rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p: rs.ByteSlice): rs.u8 => { + const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p: rs.ByteSlice): rs.u8 => { return p.data[p.start]; - }), rs.iterMap(rs.iterLend(rs.iterSlice(copies.items), rs.byteSliceFrom), (p2: rs.ByteSlice): rs.u8 => { + }), rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(copies.items, rs.byteSliceFrom)), (p2: rs.ByteSlice): rs.u8 => { return p2.data[p2.start + 1]; })), undefined, true); } else { diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index aef9b0caf..c14365ce2 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { drop$Vec_clones_Logged, drop$array1_clones_Logged, drop$array2_clones_Kept, drop$array2_clones_Logged, drop$clones_Slot, drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged, drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_clones_Logged, drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_clones_Logged_String, drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair, drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged, drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String, drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged, drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged, drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clones_Logged, drop$tuple3_array2_clones_Logged_String_clones_Logged, drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clones_Logged, drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged, 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 } from "./lib.ts"; +import { copy$clones_Kept, copy$clones_Logged, drop$Vec_clones_Logged, drop$array1_clones_Logged, drop$array2_clones_Kept, drop$array2_clones_Logged, drop$clones_Slot, drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged, drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_clones_Logged, drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_clones_Logged_String, drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair, drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged, drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String, drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged, drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged, drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clones_Logged, drop$tuple3_array2_clones_Logged_String_clones_Logged, drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clones_Logged, drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged, 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 } from "./lib.ts"; import * as Countdown from "./clones.Countdown.ts"; import * as Counted from "./clones.Counted.ts"; import * as Fussy from "./clones.Fussy.ts"; @@ -6672,12 +6672,12 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(c10, 0); return c10.data[c10.start]; }, out); - turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_closure33(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c11: rs.ByteSlice): Uint8Array => { + turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_closure33(rs.arraySliceIter(rs.arraySliceFrom(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c11: rs.ByteSlice): Uint8Array => { rs.idx(c11, 0); const _328: rs.u8 = c11.data[c11.start]; rs.idx(c11, 1); return Uint8Array.of(_328, c11.data[c11.start + 1]); - }), undefined, 2, true).items), rs.byteSliceFrom), (it74: rs.Iter): rs.ByteSlice | undefined => { + }), undefined, 2, true).items, rs.byteSliceFrom)), (it74: rs.Iter): rs.ByteSlice | undefined => { return rs.iterToOption(it74.nextBack()); }, plan, (a6: rs.ByteSlice): rs.u8 => { return a6.data[a6.start] ^ a6.data[a6.start + 1]; @@ -7751,7 +7751,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((a: Logged.Logged[]) => a.map(Logged.clone$Clone)); + const copy2: Logged.Logged[][] = rs.arraySliceItems(rs.arraySliceFrom(grid, rs.sliceFrom)).map((a: Logged.Logged[]) => a.map(Logged.clone$Clone)); flush(log.value, out); rs.dropAll(grid, drop$array2_clones_Logged); flush(log.value, out); @@ -7786,7 +7786,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { 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.iterLend(rs.iterSlice(rows.items), rs.sliceFrom), (a0: rs.Slice): Logged.Logged[] => { + const iter: rs.Iter = rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.sliceFrom)), (a0: rs.Slice): Logged.Logged[] => { return rs.sliceItems(a0).map(Logged.clone$Clone); }); while (true) { @@ -7931,12 +7931,14 @@ 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.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)); + const _247: rs.ArraySlice> = rs.arraySliceFrom(grid, rs.sliceFrom); + const _248: rs.ArraySlice> = rs.arraySliceFrom(other, rs.sliceFrom); + rs.arraySliceBy(_247, (arrays6) => rs.sliceCloneFromSlice(arrays6, rs.arraySliceAsSlice(_248), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); flush(log.value, out); const part44 = rs.sliceFrom(grid[1]); _14(part44, out); - 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)); + const _260: rs.ArraySlice> = rs.arraySliceFrom(other, rs.sliceFrom); + rs.arraySliceBy(rs.arraySliceFrom(grid, rs.sliceFrom), (arrays7) => rs.sliceCloneFromSlice(arrays7, rs.arraySliceAsSlice(_260), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); 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); @@ -7958,23 +7960,29 @@ 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), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + const _330: rs.ArraySlice> = rs.arraySliceFrom(rows.items, rs.sliceFrom); + const _332: rs.ArraySlice> = rs.arraySliceFrom(other2, rs.sliceFrom); + rs.arraySliceBy(_330, (arrays2) => rs.sliceCloneFromSlice(arrays2, rs.arraySliceAsSlice(_332), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); flush(log.value, out); - 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)); + const _338: rs.ArraySlice> = rs.arraySliceRange(rs.arraySliceFrom(rows.items, rs.sliceFrom), 0, 1); + const _341: Logged.Logged[] = other2[1].map(Logged.clone$Clone); + rs.arraySliceBy(_338, (arrays3) => rs.sliceFill(arrays3, _341, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); flush(log.value, out); - const _349: rs.Slice = rs.sliceFrom(rows.items); + const _349: rs.ArraySlice> = rs.arraySliceFrom(rows.items, rs.sliceFrom); const part31 = at(8); const _352: Logged.Logged = logged(part31); const part32 = at(9); - 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)); + const _351: Logged.Logged[] = [_352, logged(part32)]; + rs.arraySliceBy(_349, (arrays4) => rs.sliceFill(arrays4, _351, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); flush(log.value, out); const part33 = rs.sliceFrom(rows.items[rs.idx(rows.items, 0)]); _14(part33, out); - const _375: rs.Slice = rs.sliceFrom([]); + const _375: rs.ArraySlice> = rs.arraySliceFrom([], rs.sliceFrom); const part34 = at(10); const _378: Logged.Logged = logged(part34); const part35 = at(11); - 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)); + const _377: Logged.Logged[] = [_378, logged(part35)]; + rs.arraySliceBy(_375, (arrays5) => rs.sliceFill(arrays5, _377, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); 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); @@ -8021,19 +8029,19 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo a5 = rs.boxSliceCloneFrom(a5, b4, Logged.clone$Clone, rs.drop); flush(log.value, 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[] => { + const ones: (a0: rs.usize, a1: rs.usize) => rs.ArraySlice> = (from2: rs.usize, n3: rs.usize): rs.ArraySlice> => { + return rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n3), (i10: rs.usize): Logged.Logged[] => { return [logged(at(rs.usizeAdd(from2, i10)))]; - }), undefined, 8, true).items); + }), undefined, 8, true).items, rs.sliceFrom); }; const part12 = len(8); - let c3: rs.Slice = ones(8, part12); + let c3: rs.ArraySlice> = ones(8, part12); const part13 = len(12); - const d2: rs.Slice = ones(12, part13); + const d2: rs.ArraySlice> = ones(12, part13); flush(log.value, out); - c3 = rs.boxSliceCloneFrom(c3, d2, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array1_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + c3 = rs.arraySliceBoxCloneFrom(c3, d2, rs.sliceFrom, (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([a5, 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.ArraySlice>, rs.ArraySlice>]); flush(log.value, out); } else { const kept: (a0: rs.usize) => Kept.Kept = (i5: rs.usize): Kept.Kept => { @@ -8049,9 +8057,10 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo 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 _584: rs.ArraySlice> = rs.arraySliceFrom(grid2, rs.sliceFrom); const _586: Kept.Kept[][] = [[kept(7), kept(8)]]; - 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))); + const _585: rs.ArraySlice> = rs.arraySliceFrom(_586, rs.sliceFrom); + rs.arraySliceBy(_584, (arrays) => rs.sliceCloneFromSlice(arrays, rs.arraySliceAsSlice(_585), (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))), copy$clones_Kept); rs.dropAll(_586, drop$array2_clones_Kept); flush(log.value, out); let some: Kept.Kept | undefined = kept(9); @@ -8142,7 +8151,7 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part15 = at(1); 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.iterLend(rs.iterSlice(v3.items), rs.sliceFrom), (row3: rs.Slice): undefined => { + rs.iterForEach(rs.arraySliceIter(rs.arraySliceFrom(v3.items, rs.sliceFrom)), (row3: rs.Slice): undefined => { _11(row3, out); }); rs.dropVec(v3, drop$array2_clones_Logged); diff --git a/ts/fixtures/lang/clones/expected/lib.ts b/ts/fixtures/lang/clones/expected/lib.ts index 017f79ec3..8e81ec1a4 100644 --- a/ts/fixtures/lang/clones/expected/lib.ts +++ b/ts/fixtures/lang/clones/expected/lib.ts @@ -2,11 +2,19 @@ import * as rs from "./rs.ts"; import { iters, arrays, cloneFroms, repeats, sources } from "./clones.ts"; -import type * as Kept from "./clones.Kept.ts"; -import type * as Logged from "./clones.Logged.ts"; +import * as Kept from "./clones.Kept.ts"; +import * as Logged from "./clones.Logged.ts"; import type * as Pair from "./clones.Pair.ts"; import type * as Slot from "./clones.Slot.ts"; +export function copy$clones_Kept(v: Kept.Kept): Kept.Kept { + return new Kept.Kept(copy$clones_Logged(v._0)); +} + +export function copy$clones_Logged(v: Logged.Logged): Logged.Logged { + return new Logged.Logged(v.id, v.log); +} + export function drop$Vec_clones_Logged(value: rs.Vec): void { rs.dropVec(value); } @@ -108,7 +116,7 @@ export function drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clo rs.dropAll(_1[2]); } -export function drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged(_1: [rs.Slice, rs.Slice, rs.Slice, rs.Slice]): void { +export function drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged(_1: [rs.Slice, rs.Slice, rs.ArraySlice>, rs.ArraySlice>]): void { rs.dropAll(_1[0]); rs.dropAll(_1[1]); rs.dropAll(_1[2], drop$array1_clones_Logged); diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index d27c4a9f5..49f4eae5d 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -3739,7 +3739,7 @@ export function unlikeEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(c, 1); return Uint8Array.of(_36, c.data[c.start + 1]); }), undefined, 2, true); - const _148: rs.Slice = rs.sliceFrom(pairs.items); + const _148: rs.ArraySlice = rs.arraySliceFrom(pairs.items, rs.byteSliceFrom); const part = rs.min(pairs.items.length, rights_.items.length); const _150: rs.Slice = rs.sliceRange(rs.sliceFrom(rights_.items), 0, part); putEq(rs.eqSeq((a15: Uint8Array, b20: Right.Right): boolean => { @@ -4716,12 +4716,12 @@ export function unlikeCompares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec) rs.idx(c, 1); return Uint8Array.of(_35, c.data[c.start + 1]); }), undefined, 2, true); - putEq(rs.iterEq(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.vecIntoIter(rights_()), (a: Uint8Array, b3: Right.Right): boolean => { + putEq(rs.iterEq(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), rs.vecIntoIter(rights_()), (a: Uint8Array, b3: Right.Right): boolean => { return ((a0: rs.ByteSlice, a1: Right.Right): boolean => { return eq$cmp_PartialEq_collections_Right_array2_u8(a0.data, a0.start, a0.length, a1); })(rs.byteSliceFrom(a), b3); }, true), log, out); - putEq(rs.iterEq(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterSlice(theirs.items), (a02: rs.ByteSlice, a12: Right.Right): boolean => { + putEq(rs.iterEq(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.iterSlice(theirs.items), (a02: rs.ByteSlice, a12: Right.Right): boolean => { return eq$cmp_PartialEq_collections_Right_array2_u8(a02.data, a02.start, a02.length, a12); }, true), log, out); const part3 = rs.iterCmp(rs.iterSlice(mine.items), rs.iterSlice(theirs.items), Left.partialCmp$cmp_PartialOrd_collections_Right); @@ -4731,13 +4731,13 @@ export function unlikeCompares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec) putEq(rs.iterCmp(rs.vecIntoIter(lefts()), rs.vecIntoIter(rights_()), Left.partialCmp$cmp_PartialOrd_collections_Right) === -1, log, out); const order = rs.iterCmp(rs.iterSlice(mine.items), rs.iterSlice(theirs.items), Left.partialCmp$cmp_PartialOrd_collections_Right); putEq(order !== undefined && order >= 0, log, out); - const part7 = rs.iterCmp(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.vecIntoIter(rights_()), (a2: Uint8Array, b4: Right.Right): rs.Ordering | undefined => { + const part7 = rs.iterCmp(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), rs.vecIntoIter(rights_()), (a2: Uint8Array, b4: Right.Right): rs.Ordering | undefined => { return ((a03: rs.ByteSlice, a13: Right.Right): rs.Ordering | undefined => { return partialCmp$cmp_PartialOrd_collections_Right_array2_u8(a03.data, a03.start, a03.length, a13); })(rs.byteSliceFrom(a2), b4); }); _9(part7, log, out); - const part9 = rs.iterCmp(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterSlice(theirs.items), (a04: rs.ByteSlice, a14: Right.Right): rs.Ordering | undefined => { + const part9 = rs.iterCmp(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.iterSlice(theirs.items), (a04: rs.ByteSlice, a14: Right.Right): rs.Ordering | undefined => { return partialCmp$cmp_PartialOrd_collections_Right_array2_u8(a04.data, a04.start, a04.length, a14); }); _9(part9, log, out); diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index 0988e8a82..7cb3d4fe4 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { copy$array_Option_u16, copy$array_array0_u8, copy$array_array1_u8, copy$array_array2_u32, copy$array_array3_u8, copy$array_array40_u8, copy$array_u32, copy$array_u64, copy$array_u8, drop$tuple2_conversions_Logged_u8 } from "./lib.ts"; +import { copy$array_Option_u16, copy$array_array0_u8, copy$array_array1_u8, copy$array_array2_u32, copy$array_array3_u8, copy$array_array40_u8, copy$array_u32, copy$array_u64, copy$array_u8, copy$conversions_Logged, copy$conversions_Named, drop$tuple2_conversions_Logged_u8 } from "./lib.ts"; import * as Held from "./conversions.Held.ts"; import * as Kept from "./conversions.Kept.ts"; import * as Logged from "./conversions.Logged.ts"; @@ -517,72 +517,74 @@ export function writeFirst$Vec_u8(s: rs.Slice, value: rs.ByteVec): r } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$array0_u8(s: rs.Slice, value: Uint8Array): Uint8Array { +export function writeFirst$array0_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); - rs.byteSliceFrom(s.data[s.start]); const old: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); const _10: Uint8Array = value; rs.idx(s, 0); - s.data[s.start] = _10; + const slice = rs.arraySliceAt(s, 0); + slice.data.set(_10, slice.start); return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$array1_u8(s: rs.Slice, value: Uint8Array): Uint8Array { +export function writeFirst$array1_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); - const _3: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const old2 = rs.byteSliceToArray(_3); - _3.data.set(_8, _3.start); + const slice = rs.arraySliceAt(s, 0); + const old2 = rs.byteSliceToArray(slice); + slice.data.set(_8, slice.start); const old: Uint8Array = old2; const _10: Uint8Array = value; rs.idx(s, 0); - s.data[s.start] = _10; + const slice2 = rs.arraySliceAt(s, 0); + slice2.data.set(_10, slice2.start); return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$array2_u32(s: rs.Slice, value: rs.u32[]): rs.u32[] { +export function writeFirst$array2_u32(s: rs.ArraySlice>, value: rs.u32[]): rs.u32[] { value = copy$array_u32(value); rs.idx(s, 0); - 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 old: rs.u32[] = rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), _8); const _10: rs.u32[] = value; rs.idx(s, 0); - s.data[s.start] = _10; + rs.sliceSet(rs.arraySliceAt(s, 0), _10); return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$array3_u8(s: rs.Slice, value: Uint8Array): Uint8Array { +export function writeFirst$array3_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); - const _3: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const old2 = rs.byteSliceToArray(_3); - _3.data.set(_8, _3.start); + const slice = rs.arraySliceAt(s, 0); + const old2 = rs.byteSliceToArray(slice); + slice.data.set(_8, slice.start); const old: Uint8Array = old2; const _10: Uint8Array = value; rs.idx(s, 0); - s.data[s.start] = _10; + const slice2 = rs.arraySliceAt(s, 0); + slice2.data.set(_10, slice2.start); return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$array40_u8(s: rs.Slice, value: Uint8Array): Uint8Array { +export function writeFirst$array40_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); - const _3: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const old2 = rs.byteSliceToArray(_3); - _3.data.set(_8, _3.start); + const slice = rs.arraySliceAt(s, 0); + const old2 = rs.byteSliceToArray(slice); + slice.data.set(_8, slice.start); const old: Uint8Array = old2; const _10: Uint8Array = value; rs.idx(s, 0); - s.data[s.start] = _10; + const slice2 = rs.arraySliceAt(s, 0); + slice2.data.set(_10, slice2.start); return old; } @@ -636,82 +638,81 @@ 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 { +export function replaceFirst$Option_u16(s: rs.ArraySlice>, value: Array): Array { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_Option_u16(value)); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), 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: rs.String[]): rs.String[] { +export function replaceFirst$String(s: rs.ArraySlice>, value: rs.String[]): rs.String[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), value, 1); } /** `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[] { +export function replaceFirst$Vec_u32(s: rs.ArraySlice>>, value: rs.Vec[]): rs.Vec[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), 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[] { +export function replaceFirst$Vec_u8(s: rs.ArraySlice>, value: rs.ByteVec[]): rs.ByteVec[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), 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[] { +export function replaceFirst$array0_u8(s: rs.ArraySlice>, 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[] { +export function replaceFirst$array1_u8(s: rs.ArraySlice>, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array1_u8(value), 1); + return rs.arraySliceReplace(rs.arraySliceAt(s, 0), copy$array_array1_u8(value)); } /** `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[][] { +export function replaceFirst$array2_u32(s: rs.ArraySlice>>, value: rs.u32[][]): rs.u32[][] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array2_u32(value), 1); + return rs.arraySliceReplace(rs.arraySliceAt(s, 0), copy$array_array2_u32(value)); } /** `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[] { +export function replaceFirst$array3_u8(s: rs.ArraySlice>, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array3_u8(value), 1); + return rs.arraySliceReplace(rs.arraySliceAt(s, 0), copy$array_array3_u8(value)); } /** `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[] { +export function replaceFirst$array40_u8(s: rs.ArraySlice>, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_array40_u8(value), 1); + return rs.arraySliceReplace(rs.arraySliceAt(s, 0), copy$array_array40_u8(value)); } /** `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[] { +export function replaceFirst$conversions_Logged(s: rs.ArraySlice>, value: Logged.Logged[]): Logged.Logged[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), 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[] { +export function replaceFirst$conversions_Named(s: rs.ArraySlice>, value: Named.Named[]): Named.Named[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), 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[] { +export function replaceFirst$u32(s: rs.ArraySlice>, value: rs.u32[]): rs.u32[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_u32(value)); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), 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[] { +export function replaceFirst$u64(s: rs.ArraySlice>, value: rs.u64[]): rs.u64[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), copy$array_u64(value)); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), copy$array_u64(value)); } /** @@ -776,11 +777,11 @@ export function lentParam$Option_u16(to: rs.Place, data: rs. rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - 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); + put$conversions_Value_Option_u16(replaceFirst$Option_u16(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [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.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); + put$conversions_Value_Option_u16(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(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); @@ -838,11 +839,11 @@ export function lentParam$String(to: rs.String, data: rs.ByteSlice, out: rs.Byte rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)))), [make$conversions_Value_String(data, 27)])[0], out); + put$conversions_Value_String(replaceFirst$String(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [make$conversions_Value_String(data, 27)])[0], out); rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))))), 2), [[make$conversions_Value_String(data, 28)]])[0][0], out); + put$conversions_Value_String(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), rs.objectCopy), [[make$conversions_Value_String(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = rs.stringCloneFrom(s.data[s.start], other); rs.idx(s, 0); @@ -900,11 +901,11 @@ export function lentParam$Vec_u32(to: rs.Vec, data: rs.ByteSlice, out: r rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - 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); + put$conversions_Value_Vec_u32(replaceFirst$Vec_u32(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.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); + put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), rs.objectCopy), [[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); @@ -962,11 +963,11 @@ export function lentParam$Vec_u8(to: rs.ByteVec, data: rs.ByteSlice, out: rs.Byt rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - 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); + put$conversions_Value_Vec_u8(replaceFirst$Vec_u8(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.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); + put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), rs.objectCopy), [[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); @@ -980,37 +981,31 @@ export function lentParam$Vec_u8(to: rs.ByteVec, data: rs.ByteSlice, out: rs.Byt * arrays, and written in place. */ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(to)); + const s: rs.ArraySlice = rs.arraySliceOne(to, 0); put$conversions_Value_array0_u8(rs.byteSliceFrom(writeFirst$array0_u8(s, make$conversions_Value_array0_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 19)); rs.idx(s, 0); - rs.byteSliceFrom(s.data[s.start]); rs.byteSliceFrom(other); put$conversions_Value_array0_u8(rs.byteSliceFrom(other), out); rs.byteSliceFrom(other); rs.idx(s, 0); - rs.byteSliceFrom(s.data[s.start]); put$conversions_Value_array0_u8(rs.byteSliceFrom(other), out); - const t: rs.Slice = rs.sliceFrom(rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 20), make$conversions_Value_array0_u8(data, 21)]).map(copy$array_u8)).items); + const t: rs.ArraySlice = rs.arraySliceFrom(rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 20), make$conversions_Value_array0_u8(data, 21)]).map(copy$array_u8)).items, rs.byteSliceFrom); rs.idx(s, 0); - rs.byteSliceFrom(s.data[s.start]); rs.idx(t, 1); - rs.byteSliceFrom(t.data[t.start + 1]); rs.idx(t, 0); - rs.byteSliceFrom(t.data[t.start]); rs.idx(s, 0); - rs.byteSliceFrom(s.data[s.start]); rs.idx(t, 0); - put$conversions_Value_array0_u8(rs.byteSliceFrom(t.data[t.start]), out); + put$conversions_Value_array0_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array0_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); + put$conversions_Value_array0_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + rs.arraySliceOne(rs.arraySliceAt(s, 0), 0); 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]); + let r: rs.ByteSlice = rs.arraySliceAt(s, 0); 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(rs.sliceView(_89), _91); @@ -1018,21 +1013,21 @@ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r _88[0].data.set(_93, _88[0].start); put$conversions_Value_array0_u8(r, out); rs.idx(s, 0); - put$conversions_Value_array0_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array0_u8(rs.arraySliceAt(s, 0), out); 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); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.arraySliceAt(s, 0))), 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.sliceView(rs.sliceIn(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.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceAt(s, 0), 0)), [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.sliceView(rs.sliceIn(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.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 0), 1), [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.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); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 0), 1)), [[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); - _154.data.set(rs.byteSliceToArray(_159), _154.start); + const slice = rs.arraySliceAt(s, 0); + slice.data.set(rs.byteSliceToArray(_159), slice.start); rs.idx(s, 0); - put$conversions_Value_array0_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array0_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1042,49 +1037,49 @@ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r * arrays, and written in place. */ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(to)); + const s: rs.ArraySlice = rs.arraySliceOne(to, 1); put$conversions_Value_array1_u8(rs.byteSliceFrom(writeFirst$array1_u8(s, make$conversions_Value_array1_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 19)); rs.idx(s, 0); - const _11: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _16: rs.ByteSlice = rs.byteSliceFrom(other); - const swapped = rs.byteSliceToArray(_11); - _11.data.set(rs.byteSliceToArray(_16), _11.start); + const slice = rs.arraySliceAt(s, 0); + const swapped = rs.byteSliceToArray(slice); + slice.data.set(rs.byteSliceToArray(_16), slice.start); _16.data.set(swapped, _16.start); put$conversions_Value_array1_u8(rs.byteSliceFrom(other), out); const _20: rs.ByteSlice = rs.byteSliceFrom(other); rs.idx(s, 0); - const _21: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); + const slice2 = rs.arraySliceAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); - _20.data.set(rs.byteSliceToArray(_21), _20.start); - _21.data.set(swapped2, _21.start); + _20.data.set(rs.byteSliceToArray(slice2), _20.start); + slice2.data.set(swapped2, slice2.start); put$conversions_Value_array1_u8(rs.byteSliceFrom(other), out); - const t: rs.Slice = rs.sliceFrom(rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 20), make$conversions_Value_array1_u8(data, 21)]).map(copy$array_u8)).items); + const t: rs.ArraySlice = rs.arraySliceFrom(rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 20), make$conversions_Value_array1_u8(data, 21)]).map(copy$array_u8)).items, rs.byteSliceFrom); rs.idx(s, 0); - const _35: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); rs.idx(t, 1); - const _40: rs.ByteSlice = rs.byteSliceFrom(t.data[t.start + 1]); - const swapped3 = rs.byteSliceToArray(_35); - _35.data.set(rs.byteSliceToArray(_40), _35.start); - _40.data.set(swapped3, _40.start); + const slice3 = rs.arraySliceAt(s, 0); + const slice4 = rs.arraySliceAt(t, 1); + const swapped3 = rs.byteSliceToArray(slice3); + slice3.data.set(rs.byteSliceToArray(slice4), slice3.start); + slice4.data.set(swapped3, slice4.start); rs.idx(t, 0); - const _46: rs.ByteSlice = rs.byteSliceFrom(t.data[t.start]); rs.idx(s, 0); - const _51: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); - const swapped4 = rs.byteSliceToArray(_46); - _46.data.set(rs.byteSliceToArray(_51), _46.start); - _51.data.set(swapped4, _51.start); + const slice5 = rs.arraySliceAt(t, 0); + const slice6 = rs.arraySliceAt(s, 0); + const swapped4 = rs.byteSliceToArray(slice5); + slice5.data.set(rs.byteSliceToArray(slice6), slice5.start); + slice6.data.set(swapped4, slice6.start); rs.idx(t, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(t.data[t.start]), out); + put$conversions_Value_array1_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array1_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); + put$conversions_Value_array1_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.ArraySlice = rs.arraySliceOne(rs.arraySliceAt(s, 0), 1); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array1_u8(data, 22))]; - put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.arraySliceReplace(a, _77)[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]); + let r: rs.ByteSlice = rs.arraySliceAt(s, 0); 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(rs.sliceView(_89), _91); @@ -1092,21 +1087,21 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r _88[0].data.set(_93, _88[0].start); put$conversions_Value_array1_u8(r, out); rs.idx(s, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array1_u8(rs.arraySliceAt(s, 0), out); 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); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.arraySliceAt(s, 0))), 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.sliceView(rs.sliceIn(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.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceAt(s, 0), 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.sliceView(rs.sliceIn(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.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 1), 1), [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.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); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 1), 1)), [[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); - _154.data.set(rs.byteSliceToArray(_159), _154.start); + const slice7 = rs.arraySliceAt(s, 0); + slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array1_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1116,41 +1111,40 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r * arrays, and written in place. */ export function lentParam$array2_u32(to: rs.Slice, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceIn(rs.sliceView(to)); + const s: rs.ArraySlice> = rs.arraySliceOne(to, 2); 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))); + rs.sliceSet(_16, rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), 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))); + const slice2 = rs.arraySliceAt(s, 0); + rs.sliceSet(slice2, rs.replaceIn(rs.sliceView(_20), rs.sliceToArray(slice2))); 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); + const t: rs.ArraySlice> = rs.arraySliceFrom(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.sliceFrom); rs.idx(s, 0); - const _35: rs.Slice = rs.sliceFrom(s.data[s.start]); rs.idx(t, 1); - const _40: rs.Slice = rs.sliceFrom(t.data[t.start + 1]); - rs.sliceSet(_40, rs.replaceIn(rs.sliceView(_35), rs.sliceToArray(_40))); + const slice3 = rs.arraySliceAt(s, 0); + const slice4 = rs.arraySliceAt(t, 1); + rs.sliceSet(slice4, rs.replaceIn(rs.sliceView(slice3), rs.sliceToArray(slice4))); rs.idx(t, 0); - const _46: rs.Slice = rs.sliceFrom(t.data[t.start]); rs.idx(s, 0); - const _51: rs.Slice = rs.sliceFrom(s.data[s.start]); - rs.sliceSet(_51, rs.replaceIn(rs.sliceView(_46), rs.sliceToArray(_51))); + const slice5 = rs.arraySliceAt(t, 0); + const slice6 = rs.arraySliceAt(s, 0); + rs.sliceSet(slice6, rs.replaceIn(rs.sliceView(slice5), rs.sliceToArray(slice6))); rs.idx(t, 0); - put$conversions_Value_array2_u32(rs.sliceFrom(t.data[t.start]), out); + put$conversions_Value_array2_u32(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array2_u32(rs.sliceFrom(t.data[t.start + 1]), out); + put$conversions_Value_array2_u32(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.sliceView(rs.sliceFrom(s.data[s.start]))); + const a: rs.ArraySlice> = rs.arraySliceOne(rs.arraySliceAt(s, 0), 2); const _77: rs.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 22))]; - put$conversions_Value_array2_u32(rs.sliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.arraySliceReplace(a, _77)[0]), out); const by: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 23)); rs.idx(s, 0); - let r: rs.Slice = rs.sliceFrom(s.data[s.start]); + let r: rs.Slice = rs.arraySliceAt(s, 0); 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); @@ -1158,21 +1152,20 @@ export function lentParam$array2_u32(to: rs.Slice, data: rs.ByteSlice, o rs.sliceSet(_88[0], _93); put$conversions_Value_array2_u32(r, out); rs.idx(s, 0); - put$conversions_Value_array2_u32(rs.sliceFrom(s.data[s.start]), out); + put$conversions_Value_array2_u32(rs.arraySliceAt(s, 0), out); rs.idx(s, 0); - 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); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.arraySliceAt(s, 0))), copy$array_u32(make$conversions_Value_array2_u32(data, 25)))), out); rs.idx(s, 0); - 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); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceAt(s, 0), 2)), [copy$array_u32(make$conversions_Value_array2_u32(data, 26))])[0]), out); rs.idx(s, 0); - 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); + put$conversions_Value_array2_u32(rs.sliceFrom(replaceFirst$array2_u32(rs.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 2), 1), [make$conversions_Value_array2_u32(data, 27)])[0]), out); rs.idx(s, 0); - 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); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 2), 1)), [[copy$array_u32(make$conversions_Value_array2_u32(data, 28))]])[0][0]), out); rs.idx(s, 0); - 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.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), rs.sliceToArray(_159)); rs.idx(s, 0); - put$conversions_Value_array2_u32(rs.sliceFrom(s.data[s.start]), out); + put$conversions_Value_array2_u32(rs.arraySliceAt(s, 0), out); } /** @@ -1182,49 +1175,49 @@ export function lentParam$array2_u32(to: rs.Slice, data: rs.ByteSlice, o * arrays, and written in place. */ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(to)); + const s: rs.ArraySlice = rs.arraySliceOne(to, 3); put$conversions_Value_array3_u8(rs.byteSliceFrom(writeFirst$array3_u8(s, make$conversions_Value_array3_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 19)); rs.idx(s, 0); - const _11: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _16: rs.ByteSlice = rs.byteSliceFrom(other); - const swapped = rs.byteSliceToArray(_11); - _11.data.set(rs.byteSliceToArray(_16), _11.start); + const slice = rs.arraySliceAt(s, 0); + const swapped = rs.byteSliceToArray(slice); + slice.data.set(rs.byteSliceToArray(_16), slice.start); _16.data.set(swapped, _16.start); put$conversions_Value_array3_u8(rs.byteSliceFrom(other), out); const _20: rs.ByteSlice = rs.byteSliceFrom(other); rs.idx(s, 0); - const _21: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); + const slice2 = rs.arraySliceAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); - _20.data.set(rs.byteSliceToArray(_21), _20.start); - _21.data.set(swapped2, _21.start); + _20.data.set(rs.byteSliceToArray(slice2), _20.start); + slice2.data.set(swapped2, slice2.start); put$conversions_Value_array3_u8(rs.byteSliceFrom(other), out); - const t: rs.Slice = rs.sliceFrom(rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 20), make$conversions_Value_array3_u8(data, 21)]).map(copy$array_u8)).items); + const t: rs.ArraySlice = rs.arraySliceFrom(rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 20), make$conversions_Value_array3_u8(data, 21)]).map(copy$array_u8)).items, rs.byteSliceFrom); rs.idx(s, 0); - const _35: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); rs.idx(t, 1); - const _40: rs.ByteSlice = rs.byteSliceFrom(t.data[t.start + 1]); - const swapped3 = rs.byteSliceToArray(_35); - _35.data.set(rs.byteSliceToArray(_40), _35.start); - _40.data.set(swapped3, _40.start); + const slice3 = rs.arraySliceAt(s, 0); + const slice4 = rs.arraySliceAt(t, 1); + const swapped3 = rs.byteSliceToArray(slice3); + slice3.data.set(rs.byteSliceToArray(slice4), slice3.start); + slice4.data.set(swapped3, slice4.start); rs.idx(t, 0); - const _46: rs.ByteSlice = rs.byteSliceFrom(t.data[t.start]); rs.idx(s, 0); - const _51: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); - const swapped4 = rs.byteSliceToArray(_46); - _46.data.set(rs.byteSliceToArray(_51), _46.start); - _51.data.set(swapped4, _51.start); + const slice5 = rs.arraySliceAt(t, 0); + const slice6 = rs.arraySliceAt(s, 0); + const swapped4 = rs.byteSliceToArray(slice5); + slice5.data.set(rs.byteSliceToArray(slice6), slice5.start); + slice6.data.set(swapped4, slice6.start); rs.idx(t, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(t.data[t.start]), out); + put$conversions_Value_array3_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array3_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); + put$conversions_Value_array3_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.ArraySlice = rs.arraySliceOne(rs.arraySliceAt(s, 0), 3); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array3_u8(data, 22))]; - put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.arraySliceReplace(a, _77)[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]); + let r: rs.ByteSlice = rs.arraySliceAt(s, 0); 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(rs.sliceView(_89), _91); @@ -1232,21 +1225,21 @@ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r _88[0].data.set(_93, _88[0].start); put$conversions_Value_array3_u8(r, out); rs.idx(s, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array3_u8(rs.arraySliceAt(s, 0), out); 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); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.arraySliceAt(s, 0))), 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.sliceView(rs.sliceIn(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.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceAt(s, 0), 3)), [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.sliceView(rs.sliceIn(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.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 3), 1), [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.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); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 3), 1)), [[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); - _154.data.set(rs.byteSliceToArray(_159), _154.start); + const slice7 = rs.arraySliceAt(s, 0); + slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array3_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1256,49 +1249,49 @@ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r * arrays, and written in place. */ export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(to)); + const s: rs.ArraySlice = rs.arraySliceOne(to, 40); put$conversions_Value_array40_u8(rs.byteSliceFrom(writeFirst$array40_u8(s, make$conversions_Value_array40_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 19)); rs.idx(s, 0); - const _11: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _16: rs.ByteSlice = rs.byteSliceFrom(other); - const swapped = rs.byteSliceToArray(_11); - _11.data.set(rs.byteSliceToArray(_16), _11.start); + const slice = rs.arraySliceAt(s, 0); + const swapped = rs.byteSliceToArray(slice); + slice.data.set(rs.byteSliceToArray(_16), slice.start); _16.data.set(swapped, _16.start); put$conversions_Value_array40_u8(rs.byteSliceFrom(other), out); const _20: rs.ByteSlice = rs.byteSliceFrom(other); rs.idx(s, 0); - const _21: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); + const slice2 = rs.arraySliceAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); - _20.data.set(rs.byteSliceToArray(_21), _20.start); - _21.data.set(swapped2, _21.start); + _20.data.set(rs.byteSliceToArray(slice2), _20.start); + slice2.data.set(swapped2, slice2.start); put$conversions_Value_array40_u8(rs.byteSliceFrom(other), out); - const t: rs.Slice = rs.sliceFrom(rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 20), make$conversions_Value_array40_u8(data, 21)]).map(copy$array_u8)).items); + const t: rs.ArraySlice = rs.arraySliceFrom(rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 20), make$conversions_Value_array40_u8(data, 21)]).map(copy$array_u8)).items, rs.byteSliceFrom); rs.idx(s, 0); - const _35: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); rs.idx(t, 1); - const _40: rs.ByteSlice = rs.byteSliceFrom(t.data[t.start + 1]); - const swapped3 = rs.byteSliceToArray(_35); - _35.data.set(rs.byteSliceToArray(_40), _35.start); - _40.data.set(swapped3, _40.start); + const slice3 = rs.arraySliceAt(s, 0); + const slice4 = rs.arraySliceAt(t, 1); + const swapped3 = rs.byteSliceToArray(slice3); + slice3.data.set(rs.byteSliceToArray(slice4), slice3.start); + slice4.data.set(swapped3, slice4.start); rs.idx(t, 0); - const _46: rs.ByteSlice = rs.byteSliceFrom(t.data[t.start]); rs.idx(s, 0); - const _51: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); - const swapped4 = rs.byteSliceToArray(_46); - _46.data.set(rs.byteSliceToArray(_51), _46.start); - _51.data.set(swapped4, _51.start); + const slice5 = rs.arraySliceAt(t, 0); + const slice6 = rs.arraySliceAt(s, 0); + const swapped4 = rs.byteSliceToArray(slice5); + slice5.data.set(rs.byteSliceToArray(slice6), slice5.start); + slice6.data.set(swapped4, slice6.start); rs.idx(t, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(t.data[t.start]), out); + put$conversions_Value_array40_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array40_u8(rs.byteSliceFrom(t.data[t.start + 1]), out); + put$conversions_Value_array40_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.ArraySlice = rs.arraySliceOne(rs.arraySliceAt(s, 0), 40); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array40_u8(data, 22))]; - put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.replaceIn(rs.sliceView(a), _77, 1)[0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.arraySliceReplace(a, _77)[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]); + let r: rs.ByteSlice = rs.arraySliceAt(s, 0); 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(rs.sliceView(_89), _91); @@ -1306,21 +1299,21 @@ export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: _88[0].data.set(_93, _88[0].start); put$conversions_Value_array40_u8(r, out); rs.idx(s, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array40_u8(rs.arraySliceAt(s, 0), 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); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.arraySliceAt(s, 0))), 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.sliceView(rs.sliceIn(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.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceAt(s, 0), 40)), [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.sliceView(rs.sliceIn(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.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 40), 1), [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.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); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.arraySliceOne(rs.arraySliceAt(s, 0), 40), 1)), [[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); - _154.data.set(rs.byteSliceToArray(_159), _154.start); + const slice7 = rs.arraySliceAt(s, 0); + slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array40_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1385,12 +1378,12 @@ export function lentParam$conversions_Logged(to: Logged.Logged, data: rs.ByteSli rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - 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]; + const old2: Logged.Logged = replaceFirst$conversions_Logged(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))))), 2), [[Logged.make$conversions_Value(data, 28)]])[0][0]; + const old3: Logged.Logged = rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), copy$conversions_Logged), [[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](); @@ -1455,11 +1448,11 @@ export function lentParam$conversions_Named(to: Named.Named, data: rs.ByteSlice, rs.idx(s, 0); const borrowed5 = s.data; const borrowed6 = s.start; - 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); + Named.put$conversions_Value(replaceFirst$conversions_Named(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.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); + Named.put$conversions_Value(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), copy$conversions_Named), [[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); @@ -1528,11 +1521,11 @@ export function lentParam$u32(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - 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); + put$conversions_Value_u32(replaceFirst$u32(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [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.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); + put$conversions_Value_u32(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(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); @@ -1601,11 +1594,11 @@ export function lentParam$u64(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - 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); + put$conversions_Value_u64(replaceFirst$u64(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [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.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); + put$conversions_Value_u64(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(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); @@ -2389,10 +2382,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: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); 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 copied: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(one, 0)); + put$conversions_Value_array0_u8(rs.arraySliceAt(one, 0), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2408,19 +2401,20 @@ export function converted$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array0_u8(data, 17))); put$conversions_Value_array0_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array0_u8(data, 13)), copy$array_u8(make$conversions_Value_array0_u8(data, 14)), copy$array_u8(make$conversions_Value_array0_u8(data, 15))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(array).length, rs.sliceFrom(array).length], (n: rs.usize): rs.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(array, rs.byteSliceFrom).length, rs.arraySliceFrom(array, rs.byteSliceFrom).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _116: rs.Slice = rs.sliceFrom(array); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.arraySliceAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); - const _123: rs.ByteSlice = rs.byteSliceFrom(_124.data[_124.start + 2]); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - _123.data.set(rs.byteSliceToArray(_130), _123.start); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); + const slice2 = rs.arraySliceAt(_124, 2); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2430,26 +2424,27 @@ export function converted$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { } const list: rs.Vec = rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 13), make$conversions_Value_array0_u8(data, 14)]).map(copy$array_u8)); const none: rs.Vec = new rs.Vec(); - 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 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(list.items, rs.byteSliceFrom).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _165: rs.Slice = rs.sliceFrom(list.items); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice3 = rs.arraySliceAt(_165, 0); + slice3.data.set(_163, slice3.start); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); - const _172: rs.ByteSlice = rs.byteSliceFrom(_173.data[_173.start + 1]); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - _172.data.set(rs.byteSliceToArray(_179), _172.start); - rs.sliceSwap(rs.sliceFrom(list.items), 0, 1); + const slice4 = rs.arraySliceAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); + rs.arraySliceSwap(rs.arraySliceFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 15)); _184.items.push(_186); const _188: rs.Vec = none; const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(list.items, rs.byteSliceFrom)), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { const _199: rs.ByteSlice | rs.Done = iter2.next(); if (_199 === rs.DONE) { @@ -2497,10 +2492,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: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); 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 copied: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(one, 0)); + put$conversions_Value_array1_u8(rs.arraySliceAt(one, 0), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2516,19 +2511,20 @@ export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array1_u8(data, 17))); put$conversions_Value_array1_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array1_u8(data, 13)), copy$array_u8(make$conversions_Value_array1_u8(data, 14)), copy$array_u8(make$conversions_Value_array1_u8(data, 15))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(array).length, rs.sliceFrom(array).length], (n: rs.usize): rs.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(array, rs.byteSliceFrom).length, rs.arraySliceFrom(array, rs.byteSliceFrom).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _116: rs.Slice = rs.sliceFrom(array); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.arraySliceAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); - const _123: rs.ByteSlice = rs.byteSliceFrom(_124.data[_124.start + 2]); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - _123.data.set(rs.byteSliceToArray(_130), _123.start); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); + const slice2 = rs.arraySliceAt(_124, 2); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2538,26 +2534,27 @@ export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { } const list: rs.Vec = rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 13), make$conversions_Value_array1_u8(data, 14)]).map(copy$array_u8)); const none: rs.Vec = new rs.Vec(); - 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 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(list.items, rs.byteSliceFrom).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _165: rs.Slice = rs.sliceFrom(list.items); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice3 = rs.arraySliceAt(_165, 0); + slice3.data.set(_163, slice3.start); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); - const _172: rs.ByteSlice = rs.byteSliceFrom(_173.data[_173.start + 1]); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - _172.data.set(rs.byteSliceToArray(_179), _172.start); - rs.sliceSwap(rs.sliceFrom(list.items), 0, 1); + const slice4 = rs.arraySliceAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); + rs.arraySliceSwap(rs.arraySliceFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 15)); _184.items.push(_186); const _188: rs.Vec = none; const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(list.items, rs.byteSliceFrom)), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { const _199: rs.ByteSlice | rs.Done = iter2.next(); if (_199 === rs.DONE) { @@ -2604,10 +2601,10 @@ export function converted$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void 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]); + const one: rs.ArraySlice> = rs.arraySliceFrom([b], rs.sliceFrom); 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 copied: rs.u32[] = rs.sliceToArray(rs.arraySliceAt(one, 0)); + put$conversions_Value_array2_u32(rs.arraySliceAt(one, 0), out); const _70: rs.Slice = rs.sliceFrom(a); const _71: rs.Slice = rs.sliceFrom(copied); rs.replaceIn(rs.sliceView(_70), rs.sliceToArray(_71)); @@ -2623,19 +2620,18 @@ export function converted$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void 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 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(array, rs.sliceFrom).length, rs.arraySliceFrom(array, rs.sliceFrom).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: rs.u32[] = copy$array_u32(b.slice()); - const _116: rs.Slice = rs.sliceFrom(array); + const _116: rs.ArraySlice> = rs.arraySliceFrom(array, rs.sliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + rs.sliceSet(rs.arraySliceAt(_116, 0), _114); + const _124: rs.ArraySlice> = rs.arraySliceFrom(array, rs.sliceFrom); rs.idx(_124, 2); - 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); + rs.replaceIn(rs.sliceView(rs.arraySliceAt(_124, 2)), rs.sliceToArray(_130)); + const iter: rs.Iter> = rs.arraySliceIter(rs.arraySliceFrom(array, rs.sliceFrom)); while (true) { const _134: rs.Slice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2645,26 +2641,25 @@ export function converted$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void } 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)); const none: rs.Vec = new rs.Vec(); - 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 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(list.items, rs.sliceFrom).length, list.items.length, rs.arraySliceFrom(none.items, rs.sliceFrom).length, rs.arraySliceFrom(none.items, rs.sliceFrom).length, rs.arraySliceFrom(list.items, rs.sliceFrom).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: rs.u32[] = copy$array_u32(b.slice()); - const _165: rs.Slice = rs.sliceFrom(list.items); + const _165: rs.ArraySlice> = rs.arraySliceFrom(list.items, rs.sliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + rs.sliceSet(rs.arraySliceAt(_165, 0), _163); + const _173: rs.ArraySlice> = rs.arraySliceFrom(list.items, rs.sliceFrom); rs.idx(_173, 1); - 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); + rs.replaceIn(rs.sliceView(rs.arraySliceAt(_173, 1)), rs.sliceToArray(_179)); + rs.arraySliceSwap(rs.arraySliceFrom(list.items, rs.sliceFrom), 0, 1, undefined); 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(a.slice()); _188.items.push(_190); - const iter2: rs.Iter> = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.sliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.sliceFrom)); + const iter2: rs.Iter> = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(list.items, rs.sliceFrom)), rs.iterLend(rs.iterSlice(none.items), rs.sliceFrom)); while (true) { const _199: rs.Slice | rs.Done = iter2.next(); if (_199 === rs.DONE) { @@ -2711,10 +2706,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: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); 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 copied: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(one, 0)); + put$conversions_Value_array3_u8(rs.arraySliceAt(one, 0), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2730,19 +2725,20 @@ export function converted$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array3_u8(data, 17))); put$conversions_Value_array3_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array3_u8(data, 13)), copy$array_u8(make$conversions_Value_array3_u8(data, 14)), copy$array_u8(make$conversions_Value_array3_u8(data, 15))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(array).length, rs.sliceFrom(array).length], (n: rs.usize): rs.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(array, rs.byteSliceFrom).length, rs.arraySliceFrom(array, rs.byteSliceFrom).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _116: rs.Slice = rs.sliceFrom(array); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.arraySliceAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); - const _123: rs.ByteSlice = rs.byteSliceFrom(_124.data[_124.start + 2]); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - _123.data.set(rs.byteSliceToArray(_130), _123.start); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); + const slice2 = rs.arraySliceAt(_124, 2); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2752,26 +2748,27 @@ export function converted$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, 13), make$conversions_Value_array3_u8(data, 14)]).map(copy$array_u8)); const none: rs.Vec = new rs.Vec(); - 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 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(list.items, rs.byteSliceFrom).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _165: rs.Slice = rs.sliceFrom(list.items); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice3 = rs.arraySliceAt(_165, 0); + slice3.data.set(_163, slice3.start); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); - const _172: rs.ByteSlice = rs.byteSliceFrom(_173.data[_173.start + 1]); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - _172.data.set(rs.byteSliceToArray(_179), _172.start); - rs.sliceSwap(rs.sliceFrom(list.items), 0, 1); + const slice4 = rs.arraySliceAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); + rs.arraySliceSwap(rs.arraySliceFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 15)); _184.items.push(_186); const _188: rs.Vec = none; const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(list.items, rs.byteSliceFrom)), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { const _199: rs.ByteSlice | rs.Done = iter2.next(); if (_199 === rs.DONE) { @@ -2820,10 +2817,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: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); + const one: rs.ArraySlice = rs.arraySliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); 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 copied: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(one, 0)); + put$conversions_Value_array40_u8(rs.arraySliceAt(one, 0), out); const _70: rs.ByteSlice = rs.byteSliceFrom(a); const _71: rs.ByteSlice = rs.byteSliceFrom(copied); _70.data.set(rs.byteSliceToArray(_71), _70.start); @@ -2839,19 +2836,20 @@ export function converted$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array40_u8(data, 17))); put$conversions_Value_array40_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array40_u8(data, 13)), copy$array_u8(make$conversions_Value_array40_u8(data, 14)), copy$array_u8(make$conversions_Value_array40_u8(data, 15))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(array).length, rs.sliceFrom(array).length], (n: rs.usize): rs.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(array, rs.byteSliceFrom).length, rs.arraySliceFrom(array, rs.byteSliceFrom).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _116: rs.Slice = rs.sliceFrom(array); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.arraySliceAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); - const _123: rs.ByteSlice = rs.byteSliceFrom(_124.data[_124.start + 2]); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - _123.data.set(rs.byteSliceToArray(_130), _123.start); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); + const slice2 = rs.arraySliceAt(_124, 2); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2861,26 +2859,27 @@ export function converted$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void } const list: rs.Vec = rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 13), make$conversions_Value_array40_u8(data, 14)]).map(copy$array_u8)); const none: rs.Vec = new rs.Vec(); - 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 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.arraySliceFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(none.items, rs.byteSliceFrom).length, rs.arraySliceFrom(list.items, rs.byteSliceFrom).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - const _165: rs.Slice = rs.sliceFrom(list.items); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice3 = rs.arraySliceAt(_165, 0); + slice3.data.set(_163, slice3.start); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); - const _172: rs.ByteSlice = rs.byteSliceFrom(_173.data[_173.start + 1]); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - _172.data.set(rs.byteSliceToArray(_179), _172.start); - rs.sliceSwap(rs.sliceFrom(list.items), 0, 1); + const slice4 = rs.arraySliceAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); + rs.arraySliceSwap(rs.arraySliceFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 15)); _184.items.push(_186); const _188: rs.Vec = none; const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(list.items, rs.byteSliceFrom)), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { const _199: rs.ByteSlice | rs.Done = iter2.next(); if (_199 === rs.DONE) { @@ -3673,15 +3672,15 @@ export function boxed$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array0_u8(rs.byteSliceFrom(_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): Uint8Array => { + const whole: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { return make$conversions_Value_array0_u8(data, rs.usizeAdd(26, i)); - }), undefined, 0, true).items); - let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + }), undefined, 0, true).items, rs.byteSliceFrom); + let into: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array0_u8(data, rs.usizeAdd(29, i2)); - }), undefined, 0, true).items); - into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + }), undefined, 0, true).items, rs.byteSliceFrom); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(into)), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(rs.sliceItems(whole)), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(into), rs.arraySliceIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3725,15 +3724,15 @@ export function boxed$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array1_u8(rs.byteSliceFrom(_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): Uint8Array => { + const whole: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { return make$conversions_Value_array1_u8(data, rs.usizeAdd(26, i)); - }), undefined, 1, true).items); - let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + }), undefined, 1, true).items, rs.byteSliceFrom); + let into: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array1_u8(data, rs.usizeAdd(29, i2)); - }), undefined, 1, true).items); - into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + }), undefined, 1, true).items, rs.byteSliceFrom); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(into)), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(rs.sliceItems(whole)), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(into), rs.arraySliceIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3777,15 +3776,15 @@ export function boxed$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { 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[] => { + const whole: rs.ArraySlice> = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u32[] => { return make$conversions_Value_array2_u32(data, rs.usizeAdd(26, i)); - }), undefined, 8, true).items); - let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u32[] => { + }), undefined, 8, true).items, rs.sliceFrom); + let into: rs.ArraySlice> = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u32[] => { return make$conversions_Value_array2_u32(data, rs.usizeAdd(29, i2)); - }), undefined, 8, true).items); - into = rs.boxSliceCloneFrom(into, whole, copy$array_u32); + }), undefined, 8, true).items, rs.sliceFrom); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.sliceFrom, copy$array_u32); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter> = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(into)), rs.sliceFrom), rs.iterLend(rs.iterSlice(rs.sliceItems(whole)), rs.sliceFrom)); + const iter2: rs.Iter> = rs.iterChain(rs.arraySliceIter(into), rs.arraySliceIter(whole)); while (true) { const _108: rs.Slice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3829,15 +3828,15 @@ export function boxed$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array3_u8(rs.byteSliceFrom(_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): Uint8Array => { + const whole: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { return make$conversions_Value_array3_u8(data, rs.usizeAdd(26, i)); - }), undefined, 3, true).items); - let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + }), undefined, 3, true).items, rs.byteSliceFrom); + let into: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array3_u8(data, rs.usizeAdd(29, i2)); - }), undefined, 3, true).items); - into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + }), undefined, 3, true).items, rs.byteSliceFrom); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(into)), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(rs.sliceItems(whole)), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(into), rs.arraySliceIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3881,15 +3880,15 @@ export function boxed$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array40_u8(rs.byteSliceFrom(_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): Uint8Array => { + const whole: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { return make$conversions_Value_array40_u8(data, rs.usizeAdd(26, i)); - }), undefined, 40, true).items); - let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + }), undefined, 40, true).items, rs.byteSliceFrom); + let into: rs.ArraySlice = rs.arraySliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array40_u8(data, rs.usizeAdd(29, i2)); - }), undefined, 40, true).items); - into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + }), undefined, 40, true).items, rs.byteSliceFrom); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(into)), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(rs.sliceItems(whole)), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(into), rs.arraySliceIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -4359,18 +4358,19 @@ export function lentOne$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array0_u8(data, 1))); const v: rs.Vec = rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 2), make$conversions_Value_array0_u8(data, 4)]).map(copy$array_u8)); - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 0); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); - rs.byteSliceFrom(s.data[s.start]); put$conversions_Value_array0_u8(rs.byteSliceFrom(copy$array_u8(make$conversions_Value_array0_u8(data, 5))), out); 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(writeFirst$array0_u8(rs.arraySliceOne(rs.byteSliceFrom(held.value), 0), 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.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(writeFirst$array0_u8(rs.arraySliceOne(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), 0), 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.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 0); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.arraySliceBy(_53, (arrays) => rs.sliceFill(arrays, _55, copy$array_u8)); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceOne(rs.byteSliceFrom(a), 0)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4393,21 +4393,23 @@ export function lentOne$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array1_u8(data, 1))); const v: rs.Vec = rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 2), make$conversions_Value_array1_u8(data, 4)]).map(copy$array_u8)); - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 1); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); - const _23: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 5)); - const old4 = rs.byteSliceToArray(_23); - _23.data.set(_28, _23.start); + const slice = rs.arraySliceAt(s, 0); + const old4 = rs.byteSliceToArray(slice); + slice.data.set(_28, slice.start); put$conversions_Value_array1_u8(rs.byteSliceFrom(old4), out); 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(writeFirst$array1_u8(rs.arraySliceOne(rs.byteSliceFrom(held.value), 1), 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.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(writeFirst$array1_u8(rs.arraySliceOne(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), 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.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 1); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.arraySliceBy(_53, (arrays) => rs.sliceFill(arrays, _55, copy$array_u8)); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceOne(rs.byteSliceFrom(a), 1)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4430,19 +4432,20 @@ export function lentOne$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { 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.sliceIn(rs.sliceView(rs.sliceFrom(a))); + const s: rs.ArraySlice> = rs.arraySliceOne(rs.sliceFrom(a), 2); 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.sliceFrom(rs.replaceIn(rs.sliceView(_23), _28)), out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), _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(writeFirst$array2_u32(rs.arraySliceOne(rs.sliceFrom(held.value), 2), 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(writeFirst$array2_u32(rs.arraySliceOne(rs.sliceFrom(v.items[rs.idx(v.items, 1)]), 2), 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); + const _53: rs.ArraySlice> = rs.arraySliceOne(rs.sliceFrom(c), 2); + const _55: rs.u32[] = copy$array_u32(b.slice()); + rs.arraySliceBy(_53, (arrays) => rs.sliceFill(arrays, _55, copy$array_u32)); + const iter: rs.Iter> = rs.arraySliceIter(rs.arraySliceOne(rs.sliceFrom(a), 2)); while (true) { const _61: rs.Slice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4465,21 +4468,23 @@ export function lentOne$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array3_u8(data, 1))); const v: rs.Vec = rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 2), make$conversions_Value_array3_u8(data, 4)]).map(copy$array_u8)); - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 3); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); - const _23: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 5)); - const old4 = rs.byteSliceToArray(_23); - _23.data.set(_28, _23.start); + const slice = rs.arraySliceAt(s, 0); + const old4 = rs.byteSliceToArray(slice); + slice.data.set(_28, slice.start); put$conversions_Value_array3_u8(rs.byteSliceFrom(old4), out); 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(writeFirst$array3_u8(rs.arraySliceOne(rs.byteSliceFrom(held.value), 3), 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.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(writeFirst$array3_u8(rs.arraySliceOne(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), 3), 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.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 3); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.arraySliceBy(_53, (arrays) => rs.sliceFill(arrays, _55, copy$array_u8)); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceOne(rs.byteSliceFrom(a), 3)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4502,21 +4507,23 @@ export function lentOne$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array40_u8(data, 1))); const v: rs.Vec = rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 2), make$conversions_Value_array40_u8(data, 4)]).map(copy$array_u8)); - const s: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 40); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); - const _23: rs.ByteSlice = rs.byteSliceFrom(s.data[s.start]); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 5)); - const old4 = rs.byteSliceToArray(_23); - _23.data.set(_28, _23.start); + const slice = rs.arraySliceAt(s, 0); + const old4 = rs.byteSliceToArray(slice); + slice.data.set(_28, slice.start); put$conversions_Value_array40_u8(rs.byteSliceFrom(old4), out); 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(writeFirst$array40_u8(rs.arraySliceOne(rs.byteSliceFrom(held.value), 40), 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.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(writeFirst$array40_u8(rs.arraySliceOne(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), 40), 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.sliceItems(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))))), rs.byteSliceFrom); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 40); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.arraySliceBy(_53, (arrays) => rs.sliceFill(arrays, _55, copy$array_u8)); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceOne(rs.byteSliceFrom(a), 40)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4932,8 +4939,8 @@ export function searched$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array0_u8(data, i2); }), undefined, 0, true); - rs.sliceSort(rs.sliceFrom(v.items), rs.cmpLt(rs.cmpBytes), 0, true); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 1, true); + rs.arraySliceBy(rs.arraySliceFrom(v.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 0, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(v.items, rs.byteSliceFrom)), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 1, 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(); @@ -4941,7 +4948,7 @@ export function searched$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = rs.min(_24, v.items.length); - const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); + const s: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, part); const t: rs.Slice<[Uint8Array, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); let iterStart: rs.usize = 0; @@ -4951,6 +4958,7 @@ export function searched$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { continue l1; } const x: Uint8Array = make$conversions_Value_array0_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _56: rs.ByteSlice = rs.byteSliceFrom(x); const _59: rs.ByteSlice = rs.byteSliceFrom(x); const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array0_u8(e, out); @@ -4961,11 +4969,11 @@ export function searched$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array0_u8(e3, out); return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(rs.arraySliceAsSlice(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.arraySliceAsSlice(s), (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); rs.byteVecPush(out, _2[1]); return rs.byteSliceToArray(e2); - }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(rs.arraySliceAsSlice(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -4994,8 +5002,8 @@ export function searched$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array1_u8(data, i2); }), undefined, 1, true); - rs.sliceSort(rs.sliceFrom(v.items), rs.cmpLt(rs.cmpBytes), 1, true); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 2, true); + rs.arraySliceBy(rs.arraySliceFrom(v.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 1, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(v.items, rs.byteSliceFrom)), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 2, 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(); @@ -5003,7 +5011,7 @@ export function searched$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = rs.min(_24, v.items.length); - const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); + const s: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, part); const t: rs.Slice<[Uint8Array, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); let iterStart: rs.usize = 0; @@ -5013,6 +5021,7 @@ export function searched$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { continue l1; } const x: Uint8Array = make$conversions_Value_array1_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _56: rs.ByteSlice = rs.byteSliceFrom(x); const _59: rs.ByteSlice = rs.byteSliceFrom(x); const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array1_u8(e, out); @@ -5023,11 +5032,11 @@ export function searched$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array1_u8(e3, out); return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(rs.arraySliceAsSlice(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.arraySliceAsSlice(s), (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); rs.byteVecPush(out, _2[1]); return rs.byteSliceToArray(e2); - }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(rs.arraySliceAsSlice(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5056,8 +5065,8 @@ export function searched$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.u32[] => { 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.iterLend(rs.iterSlice(v.items), rs.sliceFrom), rs.sliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 12, true); + rs.arraySliceBy(rs.arraySliceFrom(v.items, rs.sliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpSlice(rs.cmp)), 8, true)); + const tagged: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(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(); @@ -5065,7 +5074,7 @@ export function searched$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = rs.min(_24, v.items.length); - const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); + const s: rs.ArraySlice> = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.sliceFrom), 0, part); const t: rs.Slice<[rs.u32[], rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); let iterStart: rs.usize = 0; @@ -5075,6 +5084,7 @@ 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 _56: rs.Slice = rs.sliceFrom(x); 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); @@ -5085,11 +5095,11 @@ export function searched$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { 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 iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(rs.arraySliceAsSlice(s), rs.sliceItems(_56), rs.cmpSlice(rs.cmp)), rs.sliceBinarySearchBy(rs.arraySliceAsSlice(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 rs.sliceToArray(e2); - }, rs.cmpSlice(rs.cmp)), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.sliceFrom(held2))))]); + }, rs.cmpSlice(rs.cmp)), rs.Ok(rs.slicePartitionPoint(rs.arraySliceAsSlice(s), (held2) => _65(rs.sliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5118,8 +5128,8 @@ export function searched$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array3_u8(data, i2); }), undefined, 3, true); - rs.sliceSort(rs.sliceFrom(v.items), rs.cmpLt(rs.cmpBytes), 3, true); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 4, true); + rs.arraySliceBy(rs.arraySliceFrom(v.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 3, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(v.items, rs.byteSliceFrom)), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 4, 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(); @@ -5127,7 +5137,7 @@ export function searched$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = rs.min(_24, v.items.length); - const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); + const s: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, part); const t: rs.Slice<[Uint8Array, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); let iterStart: rs.usize = 0; @@ -5137,6 +5147,7 @@ export function searched$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { continue l1; } const x: Uint8Array = make$conversions_Value_array3_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _56: rs.ByteSlice = rs.byteSliceFrom(x); const _59: rs.ByteSlice = rs.byteSliceFrom(x); const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array3_u8(e, out); @@ -5147,11 +5158,11 @@ export function searched$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array3_u8(e3, out); return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(rs.arraySliceAsSlice(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.arraySliceAsSlice(s), (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); rs.byteVecPush(out, _2[1]); return rs.byteSliceToArray(e2); - }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(rs.arraySliceAsSlice(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5180,8 +5191,8 @@ export function searched$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array40_u8(data, i2); }), undefined, 40, true); - rs.sliceSort(rs.sliceFrom(v.items), rs.cmpLt(rs.cmpBytes), 40, true); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 41, true); + rs.arraySliceBy(rs.arraySliceFrom(v.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 40, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(v.items, rs.byteSliceFrom)), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 41, 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(); @@ -5189,7 +5200,7 @@ export function searched$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = rs.min(_24, v.items.length); - const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); + const s: rs.ArraySlice = rs.arraySliceRange(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 0, part); const t: rs.Slice<[Uint8Array, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); let iterStart: rs.usize = 0; @@ -5199,6 +5210,7 @@ export function searched$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { continue l1; } const x: Uint8Array = make$conversions_Value_array40_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _56: rs.ByteSlice = rs.byteSliceFrom(x); const _59: rs.ByteSlice = rs.byteSliceFrom(x); const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array40_u8(e, out); @@ -5209,11 +5221,11 @@ export function searched$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { put$conversions_Value_array40_u8(e3, out); return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(rs.arraySliceAsSlice(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.arraySliceAsSlice(s), (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); rs.byteVecPush(out, _2[1]); return rs.byteSliceToArray(e2); - }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(rs.arraySliceAsSlice(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5768,14 +5780,14 @@ export function referenced$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { export function referenced$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array3_u8(data, 13)), copy$array_u8(make$conversions_Value_array3_u8(data, 14)), copy$array_u8(make$conversions_Value_array3_u8(data, 15))]; 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(rs.sliceFrom(array), out); + readAs$array3_u8_ref_slice_array3_u8(rs.arraySliceFrom(array, rs.byteSliceFrom), out); + readAs$array3_u8_ref_ref_slice_array3_u8(rs.arraySliceRange(rs.arraySliceFrom(array, rs.byteSliceFrom), 1), out); + readAs$array3_u8_ref_array3_array3_u8(rs.arraySliceFrom(array, rs.byteSliceFrom), 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)); - writeAs$array3_u8_mut_array3_array3_u8(rs.sliceFrom(array), make$conversions_Value_array3_u8(data, 19)); + writeAs$array3_u8_mut_slice_array3_u8(rs.arraySliceFrom(array, rs.byteSliceFrom), make$conversions_Value_array3_u8(data, 18)); + writeAs$array3_u8_mut_array3_array3_u8(rs.arraySliceFrom(array, rs.byteSliceFrom), 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; @@ -5802,8 +5814,8 @@ export function referenced$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void put$conversions_Value_array3_u8(compared$ref_array3_u8(rs.byteSliceFrom(array[0]), rs.byteSliceFrom(array[1]), out), out); put$conversions_Value_array3_u8(compared$ref_ref_array3_u8(rs.byteSliceFrom(list.items[rs.idx(list.items, 1)]), rs.byteSliceFrom(array[2]), out), out); put$conversions_Value_array3_u8(compared$mut_array3_u8(rs.byteSliceFrom(copy$array_u8(make$conversions_Value_array3_u8(data, 22))), rs.byteSliceFrom(copy$array_u8(make$conversions_Value_array3_u8(data, 23))), out), out); - rs.byteVecPush(out, compared$ref_slice_array3_u8(rs.sliceFrom(array), rs.sliceFrom(list.items), out).length & 0xff); - const iter: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom)); + rs.byteVecPush(out, compared$ref_slice_array3_u8(rs.arraySliceFrom(array, rs.byteSliceFrom), rs.arraySliceFrom(list.items, rs.byteSliceFrom), out).length & 0xff); + const iter: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(array, rs.byteSliceFrom)), rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom)); while (true) { const _125: rs.ByteSlice | rs.Done = iter.next(); if (_125 === rs.DONE) { @@ -6299,9 +6311,9 @@ export function readAs$Vec_u8_ref_slice_Vec_u8(b: rs.Slice, out: rs. /** What `b` reads as a slice: its length, then each element. */ export function readAs$array3_u8_mut_Vec_array3_u8(b: rs.Vec, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b.items); + const s: rs.ArraySlice = rs.arraySliceFrom(b.items, rs.byteSliceFrom); rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(s)), rs.byteSliceFrom); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6313,9 +6325,9 @@ export function readAs$array3_u8_mut_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_Vec_array3_u8(b: rs.Vec, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b.items); + const s: rs.ArraySlice = rs.arraySliceFrom(b.items, rs.byteSliceFrom); rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(s)), rs.byteSliceFrom); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6326,10 +6338,10 @@ 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: rs.Slice, out: rs.ByteVec): void { - const s: rs.Slice = b; +export function readAs$array3_u8_ref_array3_array3_u8(b: rs.ArraySlice, out: rs.ByteVec): void { + const s: rs.ArraySlice = b; rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(s)), rs.byteSliceFrom); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6341,9 +6353,9 @@ export function readAs$array3_u8_ref_array3_array3_u8(b: rs.Slice, o /** What `b` reads as a slice: its length, then each element. */ export function readAs$array3_u8_ref_mut_Vec_array3_u8(b: rs.Vec, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b.items); + const s: rs.ArraySlice = rs.arraySliceFrom(b.items, rs.byteSliceFrom); rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(s)), rs.byteSliceFrom); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6354,10 +6366,10 @@ export function readAs$array3_u8_ref_mut_Vec_array3_u8(b: rs.Vec, ou } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$array3_u8_ref_ref_slice_array3_u8(b: rs.Slice, out: rs.ByteVec): void { - const s: rs.Slice = b; +export function readAs$array3_u8_ref_ref_slice_array3_u8(b: rs.ArraySlice, out: rs.ByteVec): void { + const s: rs.ArraySlice = b; rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(s)), rs.byteSliceFrom); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6368,10 +6380,10 @@ export function readAs$array3_u8_ref_ref_slice_array3_u8(b: rs.Slice } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$array3_u8_ref_slice_array3_u8(b: rs.Slice, out: rs.ByteVec): void { - const s: rs.Slice = b; +export function readAs$array3_u8_ref_slice_array3_u8(b: rs.ArraySlice, out: rs.ByteVec): void { + const s: rs.ArraySlice = b; rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(s)), rs.byteSliceFrom); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6750,16 +6762,16 @@ export function writeAs$Vec_u8_mut_slice_Vec_u8(b: rs.Slice, value: /** Writes `value` over the last element of what `b` lends as a slice. */ export function writeAs$array3_u8_mut_Vec_array3_u8(b: rs.Vec, value: Uint8Array): void { value = copy$array_u8(value); - const _3: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(rs.sliceFrom(b.items)), rs.byteSliceFrom); + const _3: rs.ByteSlice | undefined = rs.arraySliceLast(rs.arraySliceFrom(b.items, rs.byteSliceFrom)); if (_3 !== undefined) { _3.data.set(value, _3.start); } } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$array3_u8_mut_array3_array3_u8(b: rs.Slice, value: Uint8Array): void { +export function writeAs$array3_u8_mut_array3_array3_u8(b: rs.ArraySlice, value: Uint8Array): void { value = copy$array_u8(value); - const _3: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(b), rs.byteSliceFrom); + const _3: rs.ByteSlice | undefined = rs.arraySliceLast(b); if (_3 !== undefined) { _3.data.set(value, _3.start); } @@ -6768,16 +6780,16 @@ export function writeAs$array3_u8_mut_array3_array3_u8(b: rs.Slice, /** Writes `value` over the last element of what `b` lends as a slice. */ export function writeAs$array3_u8_mut_mut_Vec_array3_u8(b: rs.Place>, value: Uint8Array): void { value = copy$array_u8(value); - const _3: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(rs.sliceFrom(b.v.items)), rs.byteSliceFrom); + const _3: rs.ByteSlice | undefined = rs.arraySliceLast(rs.arraySliceFrom(b.v.items, rs.byteSliceFrom)); if (_3 !== undefined) { _3.data.set(value, _3.start); } } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$array3_u8_mut_slice_array3_u8(b: rs.Slice, value: Uint8Array): void { +export function writeAs$array3_u8_mut_slice_array3_u8(b: rs.ArraySlice, value: Uint8Array): void { value = copy$array_u8(value); - const _3: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(b), rs.byteSliceFrom); + const _3: rs.ByteSlice | undefined = rs.arraySliceLast(b); if (_3 !== undefined) { _3.data.set(value, _3.start); } @@ -7689,7 +7701,7 @@ export function compared$ref_slice_Vec_u8(a: rs.Slice, b: rs.Slice, b: rs.Slice, out: rs.ByteVec): rs.Slice { +export function compared$ref_slice_array3_u8(a: rs.ArraySlice, b: rs.ArraySlice, out: rs.ByteVec): rs.ArraySlice { const _5: boolean = rs.eqSlice(rs.eqBytes)(a, b); const _8: boolean = !rs.eqSlice(rs.eqBytes)(a, b); const _11: boolean = rs.cmpSlice(rs.cmpBytes)(a, b) === -1; diff --git a/ts/fixtures/lang/defaults/expected/defaults.ts b/ts/fixtures/lang/defaults/expected/defaults.ts index d2a57343e..618645e44 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.ts @@ -60,10 +60,10 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { }); 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]; + [_33, rs.arraySliceFrom(grid, rs.sliceFrom), rs.byteSliceFrom(bytes)] as [rs.Slice, rs.ArraySlice>, 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 arg3 = rs.arraySliceFrom(grid, rs.sliceFrom); + const _38: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.arraySliceItems(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]]); diff --git a/ts/fixtures/lang/dyns/expected/ids.ts b/ts/fixtures/lang/dyns/expected/ids.ts index c637605f5..ccf239675 100644 --- a/ts/fixtures/lang/dyns/expected/ids.ts +++ b/ts/fixtures/lang/dyns/expected/ids.ts @@ -42,12 +42,12 @@ export function idOfVal$dyn_Any(_1: Any.Any): rs.TypeId { /** The `TypeId` of what `x` is, through a type parameter that may be a trait object. */ export function idOfVal$dyn_ids_Marked(_1: Marked.Marked): rs.TypeId { - return "d356aeac368968f265dedab8a8d72ad8"; + return "25e58479a985a0390f094b8a47a772ec"; } /** The `TypeId` of what `x` is, through a type parameter that may be a trait object. */ export function idOfVal$ids_Mood(_1: Mood.Mood): rs.TypeId { - return "328e59b82c6cb0a6eb720af972265604"; + return "180954c559d9dbe8afcd63c1da176c31"; } /** The `TypeId` of what `x` is, through a type parameter that may be a trait object. */ @@ -116,8 +116,8 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou mood = "Calm" as Mood.Mood; } const byte: Byte.Byte = { _0: b }; - const ids: rs.TypeId[] = ["cfb1622e7734f8af272d8d182905dc25", "79f19461b401588885a89e43144b08f1", "8f5d7517f5a241dab4213252fd0d53e8", "328e59b82c6cb0a6eb720af972265604", "24c161f26c70c1f1b9f602dc5fe9f65c", "b7381ee5f3fdfc9d7fa709f37e151622", "05fc01408e45e7cddf9e041e3391eafc", "3801bd64778907c7633cf473fe556a70", "513ce68a38c017b0c2e73410455cb3b0", "f48384178e2341267f2bcf8f82c035ac", "37a732caafaf8e089d3a9d4c07b2ec78", "d356aeac368968f265dedab8a8d72ad8", "25ff997ce0b3a76fb5ce30b55accc57f"]; - const found: rs.TypeId[] = [idOf$u8(), "cfb1622e7734f8af272d8d182905dc25", "cfb1622e7734f8af272d8d182905dc25", "8f5d7517f5a241dab4213252fd0d53e8", "cfb1622e7734f8af272d8d182905dc25", "79f19461b401588885a89e43144b08f1", "8f5d7517f5a241dab4213252fd0d53e8", idOfVal$str("str"), idOfVal$ids_Mood(mood), idOfVal$dyn_Any(new of$u8(a)), idOf$Option_u8()]; + const ids: rs.TypeId[] = ["cfb1622e7734f8af272d8d182905dc25", "79f19461b401588885a89e43144b08f1", "eb8e0be2af5c781063b1d1468b15a0f1", "180954c559d9dbe8afcd63c1da176c31", "24c161f26c70c1f1b9f602dc5fe9f65c", "b7381ee5f3fdfc9d7fa709f37e151622", "05fc01408e45e7cddf9e041e3391eafc", "3801bd64778907c7633cf473fe556a70", "513ce68a38c017b0c2e73410455cb3b0", "f48384178e2341267f2bcf8f82c035ac", "37a732caafaf8e089d3a9d4c07b2ec78", "25e58479a985a0390f094b8a47a772ec", "25ff997ce0b3a76fb5ce30b55accc57f"]; + const found: rs.TypeId[] = [idOf$u8(), "cfb1622e7734f8af272d8d182905dc25", "cfb1622e7734f8af272d8d182905dc25", "eb8e0be2af5c781063b1d1468b15a0f1", "cfb1622e7734f8af272d8d182905dc25", "79f19461b401588885a89e43144b08f1", "eb8e0be2af5c781063b1d1468b15a0f1", idOfVal$str("str"), idOfVal$ids_Mood(mood), idOfVal$dyn_Any(new of$u8(a)), idOf$Option_u8()]; const iter: rs.Iter = rs.iterSlice(found); while (true) { const _53: rs.TypeId | rs.Done = iter.next(); @@ -168,7 +168,7 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou return i5 === _165.typeId$Any(); }); const _187: boolean = _165.typeId$Any() === any.typeId$Any(); - const _193: boolean = idOfVal$dyn_ids_Marked(_165) === "d356aeac368968f265dedab8a8d72ad8"; + const _193: boolean = idOfVal$dyn_ids_Marked(_165) === "25e58479a985a0390f094b8a47a772ec"; const args43 = [(f: rs.Formatter) => rs.u8Display(_178, f), (f: rs.Formatter) => rs.fmtOption(_180, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(_187, f), (f: rs.Formatter) => rs.fmtBool(_193, f)]; put(out, rs.fmtFormat([args43[0], " ", args43[1], " ", args43[2], " ", args43[3], " "]).v); } @@ -196,7 +196,7 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou const _259: rs.Arc = new rs.Arc(byte); const shared: rs.Arc = new rs.ArcDyn(_259, new of$ids_Byte(_259.value)); const boxed: Marked.Marked = new of$u8(a); - const _270: boolean = shared.value.typeId$Any() === "8f5d7517f5a241dab4213252fd0d53e8"; + const _270: boolean = shared.value.typeId$Any() === "eb8e0be2af5c781063b1d1468b15a0f1"; const _278: boolean = "6864f1ad0ca168ae5e502d6898f6f9c3" === "6864f1ad0ca168ae5e502d6898f6f9c3"; const _285: boolean = boxed.typeId$Any() === "cfb1622e7734f8af272d8d182905dc25"; const args45 = [(f: rs.Formatter) => rs.fmtBool(_270, f), (f: rs.Formatter) => rs.fmtBool(_278, f), (f: rs.Formatter) => rs.fmtBool(_285, f)]; @@ -349,7 +349,7 @@ export function ids(dataData: Uint8Array, dataStart: number, dataLen: number, ou const _580: rs.usize = rs.hashLen(hashed); const args57 = [(f: rs.Formatter) => rs.fmtBool(ordered, f), (f: rs.Formatter) => rs.usizeDisplay(_577, f), (f: rs.Formatter) => rs.usizeDisplay(_580, f)]; put(out, rs.fmtFormat([args57[0], " ", args57[1], " ", args57[2], " "]).v); - const _590: rs.Iter<[rs.TypeId, string]> = rs.iterSlice([["cfb1622e7734f8af272d8d182905dc25", "u8"] as [rs.TypeId, string], ["8f5d7517f5a241dab4213252fd0d53e8", "byte"] as [rs.TypeId, string], ["328e59b82c6cb0a6eb720af972265604", "mood"] as [rs.TypeId, string]]); + const _590: rs.Iter<[rs.TypeId, string]> = rs.iterSlice([["cfb1622e7734f8af272d8d182905dc25", "u8"] as [rs.TypeId, string], ["eb8e0be2af5c781063b1d1468b15a0f1", "byte"] as [rs.TypeId, string], ["180954c559d9dbe8afcd63c1da176c31", "mood"] as [rs.TypeId, string]]); const names: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.typeIdHash, rs.same)) as rs.HashMap, _590, undefined, undefined, undefined, 58720256); for (const _603 of boxes.items) { const part8 = rs.hashGet(names, _603.typeId$Any()); diff --git a/ts/fixtures/lang/dyns/expected/lib.ts b/ts/fixtures/lang/dyns/expected/lib.ts index 28cc47b27..35b5212b6 100644 --- a/ts/fixtures/lang/dyns/expected/lib.ts +++ b/ts/fixtures/lang/dyns/expected/lib.ts @@ -583,7 +583,7 @@ export class of$dyns_Noisy { } typeId$Any(): rs.TypeId { - return "8abb48f5c9ad521e17c8b05ce0f1d679"; + return "629ea3d0db74a6a4121c4b5c2ea86c5d"; } } @@ -659,7 +659,7 @@ export class of$dyns_Square { } typeId$Any(): rs.TypeId { - return "0ba6291209e997830eaef6cade61afd2"; + return "4d27e589f80a9b722ffd015b418dab46"; } } @@ -751,7 +751,7 @@ export class of$dyns_Tri { } typeId$Any(): rs.TypeId { - return "66772eb3554749a10355c03efd41f5ad"; + return "db6a2678079cd6de1063f521a32772c0"; } } @@ -859,7 +859,7 @@ export class of$ids_Byte { } typeId$Any(): rs.TypeId { - return "8f5d7517f5a241dab4213252fd0d53e8"; + return "eb8e0be2af5c781063b1d1468b15a0f1"; } } @@ -871,7 +871,7 @@ export class of$ids_Mood { } typeId$Any(): rs.TypeId { - return "328e59b82c6cb0a6eb720af972265604"; + return "180954c559d9dbe8afcd63c1da176c31"; } } @@ -1341,7 +1341,7 @@ export class ofPlace$dyns_Tri { } typeId$Any(): rs.TypeId { - return "66772eb3554749a10355c03efd41f5ad"; + return "db6a2678079cd6de1063f521a32772c0"; } } @@ -1353,7 +1353,7 @@ export class ofPlace$ids_Mood { } typeId$Any(): rs.TypeId { - return "328e59b82c6cb0a6eb720af972265604"; + return "180954c559d9dbe8afcd63c1da176c31"; } } diff --git a/ts/fixtures/lang/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 9b562e3bd..e59c6f97d 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -1094,7 +1094,7 @@ 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.Slice]> = rs.iterEnumerate(rs.iterChain(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom), rs.iterLend(rs.iterSlice(moved.items), rs.sliceFrom))); + const iter4: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.sliceFrom)), rs.arraySliceIter(rs.arraySliceFrom(moved.items, rs.sliceFrom)))); while (true) { const _309: [rs.usize, rs.Slice] | rs.Done = iter4.next(); if (_309 === rs.DONE) { @@ -1116,7 +1116,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.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); + const iter6: rs.Iter = rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(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) { @@ -1140,7 +1140,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.vecResize(keys, _369, _375, 2, copy$array_u8); rs.vecExtendFromWithin(keys, undefined, 2, copy$array_u8); const rest: rs.Vec = rs.vecSplitOff(keys, rs.usizeDiv(keys.items.length, 3)); - const iter8: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterStepBy(rs.iterEnumerate(rs.iterChain(rs.iterLend(rs.iterSlice(keys.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(rest.items), rs.byteSliceFrom))), 2); + const iter8: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterStepBy(rs.iterEnumerate(rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(keys.items, rs.byteSliceFrom)), rs.arraySliceIter(rs.arraySliceFrom(rest.items, rs.byteSliceFrom)))), 2); while (true) { const _395: [rs.usize, rs.ByteSlice] | rs.Done = iter8.next(); if (_395 === rs.DONE) { @@ -1153,7 +1153,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void _395[1].data[_395[1].start + _400] = _395[1].data[_395[1].start + _400] ^ 255; } rs.vecAppend(keys, rest, 2); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(keys.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(keys.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); } else if (_12 === 2) { const iter9: rs.Iter = rs.iterChain(rs.iterMap(new rs.Range(0, rs.min(data.length, 3)), (n3: rs.usize): rs.ByteSlice => { return rs.byteSliceRange(data, 0, n3); @@ -1360,7 +1360,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void _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.iterLend(rs.iterSlice(rs.dequeToVec(pairs2).items), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); + const iter16: rs.Iter = rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(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) { @@ -1710,7 +1710,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void 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]]).v))), 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.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom)); + const iter5: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.sliceFrom))); while (true) { const _372: [rs.usize, rs.Slice] | rs.Done = iter5.next(); if (_372 === rs.DONE) { @@ -1723,7 +1723,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } _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.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); + const iter6: rs.Iter = rs.iterFlatten(rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(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) { diff --git a/ts/fixtures/lang/hints/expected/hints.ts b/ts/fixtures/lang/hints/expected/hints.ts index 30b4f7f32..115ad5e27 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -1950,10 +1950,10 @@ export function hints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return Uint8Array.of(_245); }), (value: Uint8Array) => rs.iterSlice(value), true, 1, true), steps, out); } else { - walk$iter_Flatten_slice_Iter_array2_u8(rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_244: rs.u8): Uint8Array => { + walk$iter_Flatten_slice_Iter_array2_u8(rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_244: rs.u8): Uint8Array => { const b5: rs.u8 = _244; return Uint8Array.of(b5, b5); - }), undefined, 2, true).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), steps, out); + }), undefined, 2, true).items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), steps, out); } } else if (_37 === 14) { const _312: rs.u8 = rs.u8Rem(arm, 6); diff --git a/ts/fixtures/lang/holds/expected/holds.ts b/ts/fixtures/lang/holds/expected/holds.ts index 97a373af1..9e3344cd7 100644 --- a/ts/fixtures/lang/holds/expected/holds.ts +++ b/ts/fixtures/lang/holds/expected/holds.ts @@ -69,7 +69,7 @@ export function places(a: rs.u8, b: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): set(rs.place(() => grid[_30][_32], (value) => grid[_30][_32] = value), k); set(rs.place(() => rows[_35].cells[_39], (value2) => rows[_35].cells[_39] = value2), k ^ 1); } - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 4), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 4), undefined, true); for (const _61 of rows) { rs.iterExtendBytes(out, rs.iterSlice(_61.cells), undefined, true); } diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index 62496fbb6..e0ac42616 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -137,12 +137,12 @@ export function adaptors(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const b3: rs.u8 = _2; return Uint8Array.of(b3, ~b3 & 0xff); }), undefined, 2, true); - const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true); + const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true); if (!(copies.items.length === 0)) { const _174: rs.ByteSlice = rs.byteSliceFrom(copies.items[rs.idx(copies.items, 0)]); _174.data[_174.start] = 85; } - const iter4: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(copies.items), rs.byteSliceFrom)); + const iter4: rs.Iter = rs.iterChain(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.arraySliceIter(rs.arraySliceFrom(copies.items, rs.byteSliceFrom))); while (true) { const _187: rs.ByteSlice | rs.Done = iter4.next(); if (_187 === rs.DONE) { @@ -1008,10 +1008,10 @@ export function skips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _28[0] ^ _28[1]; })); rs.byteVecPush(out, rest14.len() & 0xff); - const rest15: rs.Iter = rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): Uint8Array => { + const rest15: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): Uint8Array => { const b5: rs.u8 = _29; return Uint8Array.of(b5, ~b5 & 0xff); - }), undefined, 2, true).items), rs.byteSliceFrom); + }), undefined, 2, true).items, rs.byteSliceFrom)); const it30: rs.Iter = rs.iterCopied(rs.iterTake(rs.iterBorrow(rest15), limit), rs.byteSliceToArray); if (!back) { item28 = rs.iterNth(it30, n); diff --git a/ts/fixtures/lang/joins/expected/joins.ts b/ts/fixtures/lang/joins/expected/joins.ts index eab66a700..5cf590089 100644 --- a/ts/fixtures/lang/joins/expected/joins.ts +++ b/ts/fixtures/lang/joins/expected/joins.ts @@ -80,26 +80,26 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const hashB: Uint8Array = rs.bytesFromFn(8, (i6: rs.usize): rs.u8 => { return at(rs.usizeAdd(i6, 8)); }); - bytes(rs.byteSlicesJoin(rs.sliceFrom([hashA, hashB]), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom([hashA, hashB]), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom([hashA, hashB]), seps, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom([hashA, hashB], rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom([hashA, hashB], rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom([hashA, hashB], rs.byteSliceFrom)), seps, rs.byteSliceFrom), out); const quads: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (p6: rs.ByteSlice): Uint8Array => { const _423: rs.ByteSlice = p6; return rs.bytesFromFn(4, (i7: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(_423, i7), 0); }); }), undefined, 4, true); - bytes(rs.byteSlicesJoin(rs.sliceFrom(quads.items), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom(quads.items), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom(quads.items), seps, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(quads.items, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(quads.items, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(quads.items, rs.byteSliceFrom)), seps, rs.byteSliceFrom), out); const zeros: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (_228: rs.ByteSlice): Uint8Array => { return Uint8Array.of(); }), undefined, 0, true); - bytes(rs.byteSlicesJoin(rs.sliceFrom(zeros.items), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom(zeros.items), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom(zeros.items), seps, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom([]), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.sliceFrom([]), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros.items, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros.items, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros.items, rs.byteSliceFrom)), seps, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom([], rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom([], rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); } else if (_26 === 2) { const sep2: rs.u16 = (((sep as rs.u16) << 8) & 0xffff) | 1; const wide: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (p5: rs.ByteSlice): rs.Vec => { @@ -130,14 +130,16 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(slices.items), (s2: rs.Slice): rs.u16[] => { return [s2.length & 0xffff, option_unwrapOr$1szdyfq(rs.sliceFirst(s2), 0)]; }), undefined, 4, true); - wides(rs.slicesJoin(rs.sliceFrom(pairs.items), 2, undefined, rs.sliceFrom), out); - wides(rs.slicesJoin(rs.sliceFrom(pairs.items), 2, rs.sliceFrom([sep2]), rs.sliceFrom), out); - wides(rs.slicesJoin(rs.sliceFrom(pairs.items), 2, rs.sliceFrom(wideSeps.items), rs.sliceFrom), out); + wides(rs.slicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(pairs.items, rs.sliceFrom)), 2, undefined, rs.sliceFrom), out); + wides(rs.slicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(pairs.items, rs.sliceFrom)), 2, rs.sliceFrom([sep2]), rs.sliceFrom), out); + const _231: rs.ArraySlice> = rs.arraySliceFrom(pairs.items, rs.sliceFrom); + const _233: rs.Slice = rs.sliceFrom(wideSeps.items); + wides(rs.slicesJoin(rs.arraySliceAsSlice(_231), 2, _233, rs.sliceFrom), out); const zeros2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (_227: rs.ByteSlice): rs.u16[] => { return []; }), undefined, 0, true); - wides(rs.slicesJoin(rs.sliceFrom(zeros2.items), 2, undefined, rs.sliceFrom), out); - wides(rs.slicesJoin(rs.sliceFrom(zeros2.items), 2, rs.sliceFrom([sep2]), rs.sliceFrom), out); + wides(rs.slicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros2.items, rs.sliceFrom)), 2, undefined, rs.sliceFrom), out); + wides(rs.slicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(zeros2.items, rs.sliceFrom)), 2, rs.sliceFrom([sep2]), rs.sliceFrom), out); const none: rs.Vec> = new rs.Vec(); wides(rs.slicesJoin(rs.sliceFrom(none.items), 2, undefined, rs.vecSlice), out); wides(rs.slicesJoin(rs.sliceFrom(none.items), 2, rs.sliceFrom([sep2]), rs.vecSlice), out); @@ -174,9 +176,11 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.dropVec(boxed3, drop$boxed_Box_slice_joins_Logged); flush(log.value, out); const pairs2: Logged.Logged[][] = [[logged(2), logged(4)], [logged(6), logged(8)]]; - ids(rs.slicesJoin(rs.sliceFrom(pairs2), 8, undefined, rs.sliceFrom, Logged.clone$Clone), log.value, out); - ids(rs.slicesJoin(rs.sliceFrom(pairs2), 8, rs.sliceFrom([sep3]), rs.sliceFrom, Logged.clone$Clone), log.value, out); - ids(rs.slicesJoin(rs.sliceFrom(pairs2), 8, rs.sliceFrom(seps2.items), rs.sliceFrom, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(pairs2, rs.sliceFrom)), 8, undefined, rs.sliceFrom, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(rs.arraySliceAsSlice(rs.arraySliceFrom(pairs2, rs.sliceFrom)), 8, rs.sliceFrom([sep3]), rs.sliceFrom, Logged.clone$Clone), log.value, out); + const _383: rs.ArraySlice> = rs.arraySliceFrom(pairs2, rs.sliceFrom); + const _385: rs.Slice = rs.sliceFrom(seps2.items); + ids(rs.slicesJoin(rs.arraySliceAsSlice(_383), 8, _385, rs.sliceFrom, Logged.clone$Clone), log.value, out); drop$tuple4_Vec_Vec_joins_Logged_array2_array2_joins_Logged_joins_Logged_Vec_joins_Logged([vecs, pairs2, sep3, seps2] as [rs.Vec>, Logged.Logged[][], Logged.Logged, rs.Vec]); flush(log.value, out); log[Symbol.dispose](); diff --git a/ts/fixtures/lang/keys/expected/keys.ts b/ts/fixtures/lang/keys/expected/keys.ts index 8a1c5b499..42dc0061b 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -929,12 +929,12 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const boxed: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; - const _151: rs.Iter = rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), (w: rs.ByteSlice): Uint8Array => { + const _151: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), (w: rs.ByteSlice): Uint8Array => { rs.idx(w, 0); const _3: rs.u8 = rs.u8Rem(w.data[w.start], 4); rs.idx(w, 1); return Uint8Array.of(_3, rs.u8Rem(w.data[w.start + 1], 4)); - }), undefined, 2, true).items), rs.byteSliceFrom); + }), undefined, 2, true).items, rs.byteSliceFrom)); const borrowed: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, _151, undefined, undefined, 234881024); const iter2: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceWindows(data, 2)); while (true) { @@ -1087,7 +1087,7 @@ export function lentKeys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet; const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom)); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom))); while (true) { const _24: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_24 === rs.DONE) { @@ -1225,7 +1225,7 @@ export function lentKeys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.entryKey(_294))); } const members: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashKeys(set), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); - rs.sliceSort(rs.sliceFrom(members.items), rs.cmpLt(rs.cmpBytes), 2, true); + rs.arraySliceBy(rs.arraySliceFrom(members.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 2, true)); const iter8: rs.Iter = rs.iterLend(rs.iterSlice(members.items), rs.byteSliceFrom); while (true) { const _312: rs.ByteSlice | rs.Done = iter8.next(); @@ -1504,7 +1504,7 @@ export function lentValues(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo _124[1].data[_124[1].start] = _128; } const values: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashValues(map), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); - rs.sliceSort(rs.sliceFrom(values.items), rs.cmpLt(rs.cmpBytes), 2, true); + rs.arraySliceBy(rs.arraySliceFrom(values.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 2, true)); const iter4: rs.Iter = rs.iterLend(rs.iterSlice(values.items), rs.byteSliceFrom); while (true) { const _147: rs.ByteSlice | rs.Done = iter4.next(); @@ -4155,28 +4155,28 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r const vec: rs.Vec = new rs.Vec(); 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); + const _14: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); 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), (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), (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); + const _28: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); 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] => { + const _34: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(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, (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]); + const _41: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), [false, false]); 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); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); while (true) { const _51: rs.ByteSlice | rs.Done = iter.next(); if (_51 === rs.DONE) { @@ -4187,7 +4187,7 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r _55.v = _55.v ^ 16; } } - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)); while (true) { const _64: rs.ByteSlice | rs.Done = iter2.next(); if (_64 === rs.DONE) { @@ -4231,13 +4231,13 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r _104.v = _104.v ^ 8; } } - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.heapIntoSortedVec(heap, rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rs.heapIntoSortedVec(heap, rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); const members: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashKeys(set), rs.byteSliceFrom), rs.byteSliceToArray), "next", 0); - 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.arraySliceBy(rs.arraySliceFrom(members.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 0, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(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), (held12): [rs.ByteSlice, rs.ByteSlice] => { return [rs.byteSliceFrom(held12[0]), rs.byteSliceFrom(held12[1])]; @@ -4266,11 +4266,11 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r 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) => (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 => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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) => (held15) => f4(rs.byteSliceFrom(held15)))), "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) => (held16) => f6(rs.byteSliceFrom(held16))))); @@ -4287,30 +4287,30 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r } rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterToOption(rest.next())), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); 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 => { + const taken: rs.Vec = rs.iterToVec(rs.iterTakeWhile(rs.iterInspect(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)), rs.byteSliceToArray), rs.lending((p5: rs.ByteSlice): undefined => { seen = rs.u8WrappingAdd(seen, p5.length & 0xff); }, (f7) => (held17) => f7(rs.byteSliceFrom(held17)))), rs.lending((p6: rs.ByteSlice): boolean => { return rs.byteSliceLast(p6) !== 35; }, (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 _255: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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, (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 _264: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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, (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 _274: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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, (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 _281: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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; @@ -4323,7 +4323,7 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r 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); + const _299: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)), rs.byteSliceToArray); const captured = first; const sorted: boolean = rs.iterIsSortedBy(_299, rs.lending(rs.closure((a4: rs.ByteSlice, b5: rs.ByteSlice): boolean => { if (!Dropped.live(captured)) { @@ -4374,11 +4374,11 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r return [_24[0], _24[1].length & 0xff] as [rs.ByteSlice, rs.u8]; }); rs.byteVecPush(out, rs.hashLen(rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _357, undefined, undefined, undefined, 117440512)) & 0xff); - const _365: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p11: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + const _365: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p11: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { return [p11, rs.byteSliceToArray(p11)] as [rs.ByteSlice, Uint8Array]; }); const refs: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _365, undefined, undefined, undefined, 234881024); - const _370: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p12: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + const _370: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p12: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { 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); @@ -4406,7 +4406,7 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r _399.v = rs.u8WrappingAdd(_399.v, 1); } } - const probe: Uint8Array = option_mapOr$172961h(rs.optionMap(rs.sliceFirst(rs.sliceFrom(pairs.items)), rs.byteSliceFrom), rs.bytes(0), (p13: rs.ByteSlice): Uint8Array => { + const probe: Uint8Array = option_mapOr$172961h(rs.arraySliceFirst(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.bytes(0), (p13: rs.ByteSlice): Uint8Array => { return rs.byteSliceToArray(p13); }); 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); @@ -4423,8 +4423,8 @@ export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: r rs.sliceSort(rs.sliceFrom(keys.items), rs.cmpLt(rs.cmpBytes), 4, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(keys.items), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); 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); + rs.arraySliceBy(rs.arraySliceFrom(values.items, rs.byteSliceFrom), (arrays2) => rs.sliceSort(arrays2, rs.cmpLt(rs.cmpBytes), 0, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(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), (held33): [rs.ByteSlice, rs.ByteSlice] => { return [held33[0], rs.byteSliceFrom(held33[1])]; }); @@ -4456,28 +4456,28 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r const vec: rs.Vec = new rs.Vec(); 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); + const _14: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); 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), (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), (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); + const _28: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); 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] => { + const _34: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(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, (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]); + const _41: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), [false, false]); 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); + const iter: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); while (true) { const _51: rs.ByteSlice | rs.Done = iter.next(); if (_51 === rs.DONE) { @@ -4488,7 +4488,7 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r _55.v = _55.v ^ 16; } } - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)); while (true) { const _64: rs.ByteSlice | rs.Done = iter2.next(); if (_64 === rs.DONE) { @@ -4532,13 +4532,13 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r _104.v = _104.v ^ 8; } } - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.heapIntoSortedVec(heap, rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rs.heapIntoSortedVec(heap, rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const members: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashKeys(set), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); - 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.arraySliceBy(rs.arraySliceFrom(members.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(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), (held12): [rs.ByteSlice, rs.ByteSlice] => { return [rs.byteSliceFrom(held12[0]), rs.byteSliceFrom(held12[1])]; @@ -4567,11 +4567,11 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r 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) => (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 => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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) => (held15) => f4(rs.byteSliceFrom(held15)))), "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) => (held16) => f6(rs.byteSliceFrom(held16))))); @@ -4588,30 +4588,30 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r } rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterToOption(rest.next())), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); 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 => { + const taken: rs.Vec = rs.iterToVec(rs.iterTakeWhile(rs.iterInspect(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)), rs.byteSliceToArray), rs.lending((p5: rs.ByteSlice): undefined => { seen = rs.u8WrappingAdd(seen, p5.length & 0xff); }, (f7) => (held17) => f7(rs.byteSliceFrom(held17)))), rs.lending((p6: rs.ByteSlice): boolean => { return rs.byteSliceLast(p6) !== 35; }, (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 _255: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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, (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 _264: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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, (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 _274: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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, (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 _281: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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; @@ -4624,7 +4624,7 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r 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); + const _299: rs.Iter = rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(vec.items, rs.byteSliceFrom)), rs.byteSliceToArray); const captured = first; const sorted: boolean = rs.iterIsSortedBy(_299, rs.lending(rs.closure((a4: rs.ByteSlice, b5: rs.ByteSlice): boolean => { if (!Dropped.live(captured)) { @@ -4675,11 +4675,11 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r return [_24[0], _24[1].length & 0xff] as [rs.ByteSlice, rs.u8]; }); rs.byteVecPush(out, rs.hashLen(rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _357, undefined, undefined, undefined, 117440512)) & 0xff); - const _365: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p11: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + const _365: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p11: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { return [p11, rs.byteSliceToArray(p11)] as [rs.ByteSlice, Uint8Array]; }); const refs: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _365, undefined, undefined, undefined, 117440512); - const _370: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p12: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + const _370: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p12: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { 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); @@ -4707,7 +4707,7 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r _399.v = rs.u8WrappingAdd(_399.v, 1); } } - const probe: Uint8Array = option_mapOr$172961h(rs.optionMap(rs.sliceFirst(rs.sliceFrom(pairs.items)), rs.byteSliceFrom), rs.bytes(2), (p13: rs.ByteSlice): Uint8Array => { + const probe: Uint8Array = option_mapOr$172961h(rs.arraySliceFirst(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.bytes(2), (p13: rs.ByteSlice): Uint8Array => { return rs.byteSliceToArray(p13); }); 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); @@ -4724,8 +4724,8 @@ export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: r rs.sliceSort(rs.sliceFrom(keys.items), rs.cmpLt(rs.cmpBytes), 4, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(keys.items), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); 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); + rs.arraySliceBy(rs.arraySliceFrom(values.items, rs.byteSliceFrom), (arrays2) => rs.sliceSort(arrays2, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(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), (held33): [rs.ByteSlice, rs.ByteSlice] => { return [held33[0], rs.byteSliceFrom(held33[1])]; }); diff --git a/ts/fixtures/lang/lengths/expected/lengths.ts b/ts/fixtures/lang/lengths/expected/lengths.ts index a711456e3..45832e90a 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.ts @@ -40,7 +40,7 @@ export function each$0(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 0, true); - const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (r: rs.ByteSlice): rs.u32[] => { return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); @@ -49,8 +49,8 @@ export function each$0(data: rs.ByteSlice, out: rs.ByteVec): void { joined$0(data, rs.vecFrom(copy$array_array0_u8([rs.bytes(0).fill(165), rs.bytesFromFn(0, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); - retagged$0(rs.sliceFrom(rows.items), out); - recloned$u32_0(rs.sliceFrom(wide.items), out); + retagged$0(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_0(rs.arraySliceFrom(wide.items, rs.sliceFrom), out); filled$u8_0(data, rs.bytesFromFn(0, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); @@ -65,8 +65,8 @@ export function each$0(data: rs.ByteSlice, out: rs.ByteVec): void { filled$lengths_Tagged_u32_0(data, rs.arrayFromFn(0, (i6: rs.usize): Tagged.Tagged => { return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); - swapped$u8_0(data, rs.sliceFrom(rows.items), out); - swapped$u32_0(data, rs.sliceFrom(wide.items), out); + swapped$u8_0(data, rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_0(data, rs.arraySliceFrom(wide.items, rs.sliceFrom), out); } export function each$1(data: rs.ByteSlice, out: rs.ByteVec): void { @@ -75,7 +75,7 @@ export function each$1(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 1, true); - const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (r: rs.ByteSlice): rs.u32[] => { return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); @@ -84,8 +84,8 @@ export function each$1(data: rs.ByteSlice, out: rs.ByteVec): void { joined$1(data, rs.vecFrom(copy$array_array1_u8([rs.bytes(1).fill(165), rs.bytesFromFn(1, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); - retagged$1(rs.sliceFrom(rows.items), out); - recloned$u32_1(rs.sliceFrom(wide.items), out); + retagged$1(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_1(rs.arraySliceFrom(wide.items, rs.sliceFrom), out); filled$u8_1(data, rs.bytesFromFn(1, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); @@ -100,8 +100,8 @@ export function each$1(data: rs.ByteSlice, out: rs.ByteVec): void { filled$lengths_Tagged_u32_1(data, rs.arrayFromFn(1, (i6: rs.usize): Tagged.Tagged => { return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); - swapped$u8_1(data, rs.sliceFrom(rows.items), out); - swapped$u32_1(data, rs.sliceFrom(wide.items), out); + swapped$u8_1(data, rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_1(data, rs.arraySliceFrom(wide.items, rs.sliceFrom), out); } export function each$17(data: rs.ByteSlice, out: rs.ByteVec): void { @@ -110,7 +110,7 @@ export function each$17(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 17, true); - const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (r: rs.ByteSlice): rs.u32[] => { return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); @@ -119,8 +119,8 @@ export function each$17(data: rs.ByteSlice, out: rs.ByteVec): void { joined$17(data, rs.vecFrom(copy$array_array17_u8([rs.bytes(17).fill(165), rs.bytesFromFn(17, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); - retagged$17(rs.sliceFrom(rows.items), out); - recloned$u32_17(rs.sliceFrom(wide.items), out); + retagged$17(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_17(rs.arraySliceFrom(wide.items, rs.sliceFrom), out); filled$u8_17(data, rs.bytesFromFn(17, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); @@ -135,8 +135,8 @@ export function each$17(data: rs.ByteSlice, out: rs.ByteVec): void { filled$lengths_Tagged_u32_17(data, rs.arrayFromFn(17, (i6: rs.usize): Tagged.Tagged => { return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); - swapped$u8_17(data, rs.sliceFrom(rows.items), out); - swapped$u32_17(data, rs.sliceFrom(wide.items), out); + swapped$u8_17(data, rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_17(data, rs.arraySliceFrom(wide.items, rs.sliceFrom), out); } export function each$3(data: rs.ByteSlice, out: rs.ByteVec): void { @@ -145,7 +145,7 @@ export function each$3(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 3, true); - const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (r: rs.ByteSlice): rs.u32[] => { return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); @@ -154,8 +154,8 @@ export function each$3(data: rs.ByteSlice, out: rs.ByteVec): void { joined$3(data, rs.vecFrom(copy$array_array3_u8([rs.bytes(3).fill(165), rs.bytesFromFn(3, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); - retagged$3(rs.sliceFrom(rows.items), out); - recloned$u32_3(rs.sliceFrom(wide.items), out); + retagged$3(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_3(rs.arraySliceFrom(wide.items, rs.sliceFrom), out); filled$u8_3(data, rs.bytesFromFn(3, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); @@ -170,36 +170,36 @@ export function each$3(data: rs.ByteSlice, out: rs.ByteVec): void { filled$lengths_Tagged_u32_3(data, rs.arrayFromFn(3, (i6: rs.usize): Tagged.Tagged => { return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); - swapped$u8_3(data, rs.sliceFrom(rows.items), out); - swapped$u32_3(data, rs.sliceFrom(wide.items), out); + swapped$u8_3(data, rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_3(data, rs.arraySliceFrom(wide.items, rs.sliceFrom), out); } /** The bytes of `data` and then of each row, as one run. */ export function joined$0(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { - rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ export function joined$1(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { - rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ export function joined$17(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { - rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ export function joined$3(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { - rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), undefined, true); } /** * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$0(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.byteSliceFrom)); +export function retagged$0(rows: rs.ArraySlice, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -228,8 +228,8 @@ export function retagged$0(rows: rs.Slice, out: rs.ByteVec): void { * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$1(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.byteSliceFrom)); +export function retagged$1(rows: rs.ArraySlice, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -258,8 +258,8 @@ export function retagged$1(rows: rs.Slice, out: rs.ByteVec): void { * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$17(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.byteSliceFrom)); +export function retagged$17(rows: rs.ArraySlice, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -288,8 +288,8 @@ export function retagged$17(rows: rs.Slice, out: rs.ByteVec): void { * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$3(rows: rs.Slice, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.byteSliceFrom)); +export function retagged$3(rows: rs.ArraySlice, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -315,8 +315,8 @@ 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.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); +export function recloned$u32_0(rows: rs.ArraySlice>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -344,8 +344,8 @@ 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.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); +export function recloned$u32_1(rows: rs.ArraySlice>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -373,8 +373,8 @@ 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.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); +export function recloned$u32_17(rows: rs.ArraySlice>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -402,8 +402,8 @@ 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.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(rows)), rs.sliceFrom)); +export function recloned$u32_3(rows: rs.ArraySlice>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.arraySliceIter(rows)); while (true) { const _7: [rs.usize, rs.Slice] | rs.Done = iter.next(); if (_7 === rs.DONE) { @@ -457,7 +457,7 @@ export function filled$array0_u8_0(data: rs.ByteSlice, fill: Uint8Array[], out: uninit; } const picks: rs.Vec = new rs.Vec(); - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)); while (true) { const _26: rs.ByteSlice | rs.Done = iter2.next(); if (_26 === rs.DONE) { @@ -495,7 +495,7 @@ export function filled$array0_u8_0(data: rs.ByteSlice, fill: Uint8Array[], out: rs.ptrWrite(uninit3, [copy$array_array0_u8(_65[1]), [17, 0] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)), rs.byteSliceToArray), [false, false]); while (true) { const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); if (_85 === rs.DONE) { @@ -514,7 +514,9 @@ export function filled$array0_u8_0(data: rs.ByteSlice, fill: Uint8Array[], out: rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; - rs.sliceRotateLeft(rs.sliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(0, 1))); + const _108: rs.ArraySlice = rs.arraySliceFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(0, 1)); + rs.arraySliceBy(_108, (arrays) => rs.sliceRotateLeft(arrays, _110)); const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; tags[1] = rs.u8WrappingAdd(tags[1], byte); @@ -522,7 +524,7 @@ export function filled$array0_u8_0(data: rs.ByteSlice, fill: Uint8Array[], out: } for (const _124 of slots) { const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; - rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { + rs.iterForEach(rs.arraySliceIter(rs.arraySliceFrom(_131[0], rs.byteSliceFrom)), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array0_u8(v4, out); }); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); @@ -556,7 +558,7 @@ export function filled$array17_u8_17(data: rs.ByteSlice, fill: Uint8Array[], out uninit; } const picks: rs.Vec = new rs.Vec(); - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)); while (true) { const _26: rs.ByteSlice | rs.Done = iter2.next(); if (_26 === rs.DONE) { @@ -594,7 +596,7 @@ export function filled$array17_u8_17(data: rs.ByteSlice, fill: Uint8Array[], out rs.ptrWrite(uninit3, [copy$array_array17_u8(_65[1]), [17, 17] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)), rs.byteSliceToArray), [false, false]); while (true) { const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); if (_85 === rs.DONE) { @@ -613,7 +615,9 @@ export function filled$array17_u8_17(data: rs.ByteSlice, fill: Uint8Array[], out rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; - rs.sliceRotateLeft(rs.sliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(17, 1))); + const _108: rs.ArraySlice = rs.arraySliceFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(17, 1)); + rs.arraySliceBy(_108, (arrays) => rs.sliceRotateLeft(arrays, _110)); const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; tags[1] = rs.u8WrappingAdd(tags[1], byte); @@ -621,7 +625,7 @@ export function filled$array17_u8_17(data: rs.ByteSlice, fill: Uint8Array[], out } for (const _124 of slots) { const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; - rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { + rs.iterForEach(rs.arraySliceIter(rs.arraySliceFrom(_131[0], rs.byteSliceFrom)), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array17_u8(v4, out); }); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); @@ -655,7 +659,7 @@ export function filled$array1_u8_1(data: rs.ByteSlice, fill: Uint8Array[], out: uninit; } const picks: rs.Vec = new rs.Vec(); - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)); while (true) { const _26: rs.ByteSlice | rs.Done = iter2.next(); if (_26 === rs.DONE) { @@ -693,7 +697,7 @@ export function filled$array1_u8_1(data: rs.ByteSlice, fill: Uint8Array[], out: rs.ptrWrite(uninit3, [copy$array_array1_u8(_65[1]), [17, 1] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)), rs.byteSliceToArray), [false, false]); while (true) { const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); if (_85 === rs.DONE) { @@ -712,7 +716,9 @@ export function filled$array1_u8_1(data: rs.ByteSlice, fill: Uint8Array[], out: rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; - rs.sliceRotateLeft(rs.sliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(1, 1))); + const _108: rs.ArraySlice = rs.arraySliceFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(1, 1)); + rs.arraySliceBy(_108, (arrays) => rs.sliceRotateLeft(arrays, _110)); const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; tags[1] = rs.u8WrappingAdd(tags[1], byte); @@ -720,7 +726,7 @@ export function filled$array1_u8_1(data: rs.ByteSlice, fill: Uint8Array[], out: } for (const _124 of slots) { const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; - rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { + rs.iterForEach(rs.arraySliceIter(rs.arraySliceFrom(_131[0], rs.byteSliceFrom)), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array1_u8(v4, out); }); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); @@ -754,7 +760,7 @@ export function filled$array3_u8_3(data: rs.ByteSlice, fill: Uint8Array[], out: uninit; } const picks: rs.Vec = new rs.Vec(); - const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); + const iter2: rs.Iter = rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)); while (true) { const _26: rs.ByteSlice | rs.Done = iter2.next(); if (_26 === rs.DONE) { @@ -792,7 +798,7 @@ export function filled$array3_u8_3(data: rs.ByteSlice, fill: Uint8Array[], out: rs.ptrWrite(uninit3, [copy$array_array3_u8(_65[1]), [17, 3] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(fill, rs.byteSliceFrom)), rs.byteSliceToArray), [false, false]); while (true) { const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); if (_85 === rs.DONE) { @@ -811,7 +817,9 @@ export function filled$array3_u8_3(data: rs.ByteSlice, fill: Uint8Array[], out: rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; - rs.sliceRotateLeft(rs.sliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(3, 1))); + const _108: rs.ArraySlice = rs.arraySliceFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(3, 1)); + rs.arraySliceBy(_108, (arrays) => rs.sliceRotateLeft(arrays, _110)); const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; tags[1] = rs.u8WrappingAdd(tags[1], byte); @@ -819,7 +827,7 @@ export function filled$array3_u8_3(data: rs.ByteSlice, fill: Uint8Array[], out: } for (const _124 of slots) { const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; - rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { + rs.iterForEach(rs.arraySliceIter(rs.arraySliceFrom(_131[0], rs.byteSliceFrom)), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array3_u8(v4, out); }); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); @@ -1946,17 +1954,15 @@ export function put$lengths_Put_array3_u8(self: rs.ByteSlice, out: rs.ByteVec): * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { - return [rs.sliceFrom(held[0]), held[1]]; - }); +export function swapped$u32_0(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { 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.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); @@ -1981,13 +1987,13 @@ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Slice, out: const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.sliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - 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 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 0)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1999,17 +2005,15 @@ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Slice, out: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { - return [rs.sliceFrom(held[0]), held[1]]; - }); +export function swapped$u32_1(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { 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.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); @@ -2034,13 +2038,13 @@ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Slice, out: const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.sliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - 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 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 1)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2052,17 +2056,15 @@ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Slice, out: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { - return [rs.sliceFrom(held[0]), held[1]]; - }); +export function swapped$u32_17(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { 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.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); @@ -2087,13 +2089,13 @@ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Slice, out const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.sliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - 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 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 17)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2105,17 +2107,15 @@ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Slice, out * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_3(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.Slice, rs.Slice] => { - return [rs.sliceFrom(held[0]), held[1]]; - }); +export function swapped$u32_3(data: rs.ByteSlice, rows: rs.ArraySlice>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.ArraySlice>] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { 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.Slice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.sliceFrom); + const _9: rs.Slice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: rs.u32[] = rs.sliceToArray(_9); grid[1] = copy$array_u32(next); @@ -2140,13 +2140,13 @@ export function swapped$u32_3(data: rs.ByteSlice, rows: rs.Slice, out: const _32: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.sliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - 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 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 3)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2158,17 +2158,15 @@ export function swapped$u32_3(data: rs.ByteSlice, rows: rs.Slice, out: * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_0(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, rs.Slice] => { - return [rs.byteSliceFrom(held[0]), held[1]]; - }); +export function swapped$u8_0(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2193,13 +2191,13 @@ export function swapped$u8_0(data: rs.ByteSlice, rows: rs.Slice, out const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), (_2: rs.u8): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), (_2: rs.u8): rs.u8 => { return (_2 as rs.u32) & 0xff; }), undefined, true); } @@ -2211,17 +2209,15 @@ export function swapped$u8_0(data: rs.ByteSlice, rows: rs.Slice, out * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_1(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, rs.Slice] => { - return [rs.byteSliceFrom(held[0]), held[1]]; - }); +export function swapped$u8_1(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2246,13 +2242,13 @@ export function swapped$u8_1(data: rs.ByteSlice, rows: rs.Slice, out const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), (_2: rs.u8): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), (_2: rs.u8): rs.u8 => { return (_2 as rs.u32) & 0xff; }), undefined, true); } @@ -2264,17 +2260,15 @@ export function swapped$u8_1(data: rs.ByteSlice, rows: rs.Slice, out * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_17(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, rs.Slice] => { - return [rs.byteSliceFrom(held[0]), held[1]]; - }); +export function swapped$u8_17(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2299,13 +2293,13 @@ export function swapped$u8_17(data: rs.ByteSlice, rows: rs.Slice, ou const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), (_2: rs.u8): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), (_2: rs.u8): rs.u8 => { return (_2 as rs.u32) & 0xff; }), undefined, true); } @@ -2317,17 +2311,15 @@ export function swapped$u8_17(data: rs.ByteSlice, rows: rs.Slice, ou * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_3(data: rs.ByteSlice, rows: rs.Slice, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Slice] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, rs.Slice] => { - return [rs.byteSliceFrom(held[0]), held[1]]; - }); +export function swapped$u8_3(data: rs.ByteSlice, rows: rs.ArraySlice, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.ArraySlice] | undefined = rs.arraySliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2352,13 +2344,13 @@ export function swapped$u8_3(data: rs.ByteSlice, rows: rs.Slice, out const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceFrom(grid[_35])); const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); rs.idx(rows, _42); - const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows.data[rows.start + _42]))]; + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.arraySliceAt(rows, _42))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), (_2: rs.u8): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), (_2: rs.u8): rs.u8 => { return (_2 as rs.u32) & 0xff; }), undefined, true); } diff --git a/ts/fixtures/lang/orders/expected/orders.ts b/ts/fixtures/lang/orders/expected/orders.ts index d37902d2e..5758896ac 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -521,13 +521,13 @@ export function bytes(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u8Rem(b2, 4); })); }), undefined, 2, true); - rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.iterMax(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.cmpLt(rs.cmpBytes)), Uint8Array.of(9, 9), (a4: rs.ByteSlice): Uint8Array => { + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.iterMax(rs.arraySliceIter(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom)), rs.cmpLt(rs.cmpBytes)), Uint8Array.of(9, 9), (a4: rs.ByteSlice): Uint8Array => { return rs.byteSliceToArray(a4); })), undefined, true); - rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.iterMin(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.cmpLt(rs.cmpBytes)), Uint8Array.of(9, 9), (a5: rs.ByteSlice): Uint8Array => { + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.iterMin(rs.arraySliceIter(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom)), rs.cmpLt(rs.cmpBytes)), Uint8Array.of(9, 9), (a5: rs.ByteSlice): Uint8Array => { return rs.byteSliceToArray(a5); })), undefined, true); - const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterCopied(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)); + const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)); while (true) { const _179: Uint8Array | undefined = rs.heapPop(heap, rs.cmpLe(rs.cmpBytes)); if (_179 !== undefined) { @@ -536,15 +536,15 @@ export function bytes(data: rs.ByteSlice, out: rs.ByteVec): void { break; } } - const _185: rs.Iter<[Uint8Array, rs.usize]> = rs.iterMap(rs.iterEnumerate(rs.iterCopied(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.byteSliceToArray)), (_2: [rs.usize, Uint8Array]): [Uint8Array, rs.usize] => { + const _185: rs.Iter<[Uint8Array, rs.usize]> = rs.iterMap(rs.iterEnumerate(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom)), rs.byteSliceToArray)), (_2: [rs.usize, Uint8Array]): [Uint8Array, rs.usize] => { return [_2[1], _2[0]] as [Uint8Array, rs.usize]; }); rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _185, true, undefined, undefined, undefined, 8, true)), (_22: [Uint8Array, rs.usize]): Uint8Array => { const k: Uint8Array = _22[0]; return Uint8Array.of(k[0], k[1], _22[1] & 0xff); }, (value: Uint8Array) => rs.iterSlice(value), true, 3), undefined, true); - rs.sliceSort(rs.sliceFrom(arrays.items), rs.cmpLt(rs.cmpBytes), 2, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.arraySliceBy(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom), (arrays2) => rs.sliceSort(arrays2, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const slices: rs.Vec = rs.iterToVec(rs.byteSliceChunks(data, 3), undefined, 8, true); rs.sliceSort(rs.sliceFrom(slices.items), rs.cmpLt((a7: rs.ByteSlice, b3: rs.ByteSlice): rs.Ordering => { return rs.cmpBytes(b3, a7); diff --git a/ts/fixtures/lang/panics/hook/expected/lib.ts b/ts/fixtures/lang/panics/hook/expected/lib.ts index b72d52964..e45940e1c 100644 --- a/ts/fixtures/lang/panics/hook/expected/lib.ts +++ b/ts/fixtures/lang/panics/hook/expected/lib.ts @@ -81,7 +81,7 @@ export class of$panics_Point { } typeId$Any(): rs.TypeId { - return "8e48006f0a085ab0ca68bcd6079f396f"; + return "37e450afe4d41be326161cb6b122df94"; } } diff --git a/ts/fixtures/lang/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index ee9a363b1..8c106dfcd 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ts @@ -2885,7 +2885,7 @@ export function arrays(data: rs.ByteSlice, out: rs.ByteVec): void { 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)); + const read: rs.u32[][] = copy$array_array2_u32(rs.arraySliceToArray(rs.arraySliceFrom(nested, rs.sliceFrom), rs.sliceToArray)); 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); @@ -2900,7 +2900,7 @@ export function runs(n: rs.u8): Uint8Array { return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_44, f), 0); }), [rs.stringNew(), rs.stringFrom("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 last: rs.Slice = rs.optionUnwrap(rs.arraySliceLast(rs.arraySliceFrom(v.items, rs.sliceFrom))); const _20: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); rs.stringPush(_20.data[_20.start], 121); const _24: rs.u8 = rs.sliceSame(first, rs.sliceFrom(v.items[rs.idx(v.items, 0)])) ? 1 : 0; @@ -2919,11 +2919,11 @@ export function lent(n: rs.u8): rs.ByteVec { 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; + const _25: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.arraySliceFirst(rs.sliceAsChunks(rs.sliceFrom(a), 2)[0])), 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; + const _41: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.arraySliceLast(rs.sliceAsRchunks(rs.sliceFrom(a), 2)[1])), 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; + const _57: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.iterNth(rs.arraySliceIter(rs.sliceAsChunks(rs.sliceFrom(v.items), 2)[0]), 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); @@ -2938,7 +2938,7 @@ export function lent(n: rs.u8): rs.ByteVec { 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; + const _178: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.iterToOption(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.sliceFrom)).next())), rs.optionUnwrap(rs.arraySliceFirst(rs.arraySliceFrom(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; @@ -2969,7 +2969,7 @@ export function lent(n: rs.u8): rs.ByteVec { 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; + const _296: rs.u8 = rs.sliceSame(rs.optionUnwrap(rs.arraySliceLast(rs.arraySliceFrom(nested, rs.sliceFrom))), rs.optionUnwrap(rs.iterNth(rs.arraySliceIter(rs.arraySliceFrom(nested, rs.sliceFrom)), 1))) ? 1 : 0; rs.byteVecPush(o, _296); un[Symbol.dispose](); held[Symbol.dispose](); @@ -3043,12 +3043,16 @@ export function arrayCasts(data: rs.ByteSlice, out: rs.ByteVec): void { return Uint8Array.of(b2, ~b2 & 0xff); }), undefined, 2, true); if (pairs.items.length >= 3) { - const _142: rs.Slice = rs.rawSliceOf(rs.sliceRange(rs.sliceFrom(pairs.items), 1)).array(2); - _142.data[_142.start][1] = _142.data[_142.start][1] ^ _142.data[_142.start + 1][0]; - rs.sliceSwap(_142, 0, 1); - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.sliceToArray(rs.rawSliceOf(rs.sliceFrom(pairs.items)).array(3), copy$array_u8)), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); - } - rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const _142: rs.ArraySlice = rs.rawArraySliceOf(rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), 1)).array(2); + const slice9 = rs.arraySliceAt(_142, 1); + const _147: rs.u8 = slice9.data[slice9.start]; + const slice10 = rs.arraySliceAt(_142, 0); + const slice11 = rs.arraySliceAt(_142, 0); + slice11.data[slice11.start + 1] = slice10.data[slice10.start + 1] ^ _147; + rs.arraySliceSwap(_142, 0, 1, undefined); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rs.arraySliceToArray(rs.rawArraySliceOf(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)).array(3), rs.byteSliceToArray), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + } + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); const part2 = bytes.length; rs.rawByteSliceOf(rs.byteSliceRange(rs.byteVecSlice(bytes), part2)); rs.byteVecPush(out, rs.byteSliceFrom(Uint8Array.of()).length & 0xff); diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index 0a99ac3b7..1c32cbc48 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -712,7 +712,7 @@ 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.Slice, rs.u8]> = rs.iterZip(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), rs.iterSlice(rs.byteSliceView(data)), [false, false]); + const iter6: rs.Iter<[rs.Slice, rs.u8]> = rs.iterZip(rs.arraySliceIter(rs.arraySliceFrom(grid, rs.sliceFrom)), rs.iterSlice(rs.byteSliceView(data)), [false, false]); l18: while (true) { const _133: [rs.Slice, rs.u8] | rs.Done = iter6.next(); if (_133 === rs.DONE) { @@ -735,7 +735,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.iterLend(rs.iterSlice(grid), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); + const iter10: rs.Iter = rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(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/separated/expected/core/option.ts b/ts/fixtures/lang/separated/expected/core/option.ts index 550101f69..79b138986 100644 --- a/ts/fixtures/lang/separated/expected/core/option.ts +++ b/ts/fixtures/lang/separated/expected/core/option.ts @@ -11,7 +11,7 @@ export function map$0k3subg(self: rs.Slice | undefined, _: (a0: rs.Sl return sumTexts(self); } -export function map$1fgo7n1(self: rs.Slice | undefined, _: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { +export function map$10ynzkb(self: rs.ArraySlice | undefined, _: (a0: rs.ArraySlice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } @@ -46,7 +46,7 @@ export function mapOr$1jad7d1(self: rs.Slice | undefined, default_: r return sumTexts(self); } -export function mapOr$1bxom2b(self: rs.Slice | undefined, default_: rs.u8, _: (a0: rs.Slice) => rs.u8): rs.u8 { +export function mapOr$08f08k5(self: rs.ArraySlice | undefined, default_: rs.u8, _: (a0: rs.ArraySlice) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/separated/expected/separated.ts b/ts/fixtures/lang/separated/expected/separated.ts index 0d7631729..b4f885333 100644 --- a/ts/fixtures/lang/separated/expected/separated.ts +++ b/ts/fixtures/lang/separated/expected/separated.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { map$0k3subg as option_map$0k3subg, map$1fgo7n1 as option_map$1fgo7n1, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1jad7d1 as option_mapOr$1jad7d1, mapOr$1bxom2b as option_mapOr$1bxom2b, mapOr$1khlwl8 as option_mapOr$1khlwl8, mapOr$0r061yq as option_mapOr$0r061yq, mapOr$0ckb6jj as option_mapOr$0ckb6jj, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; +import { map$0k3subg as option_map$0k3subg, map$10ynzkb as option_map$10ynzkb, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1jad7d1 as option_mapOr$1jad7d1, mapOr$08f08k5 as option_mapOr$08f08k5, mapOr$1khlwl8 as option_mapOr$1khlwl8, mapOr$0r061yq as option_mapOr$0r061yq, mapOr$0ckb6jj as option_mapOr$0ckb6jj, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; import * as Below from "./separated.Below.ts"; import * as Pair from "./separated.Pair.ts"; @@ -47,8 +47,8 @@ export function sumTexts(part: rs.Slice): rs.u8 { }); } -export function sumTwos(part: rs.Slice): rs.u8 { - return rs.iterFold(rs.iterLend(rs.iterSlice(rs.sliceItems(part)), rs.byteSliceFrom), part.length & 0xff, (acc: rs.u8, t: rs.ByteSlice): rs.u8 => { +export function sumTwos(part: rs.ArraySlice): rs.u8 { + return rs.iterFold(rs.arraySliceIter(part), part.length & 0xff, (acc: rs.u8, t: rs.ByteSlice): rs.u8 => { return rs.u8WrappingMul(acc, 31) ^ rs.u8WrappingAdd(t.data[t.start], t.data[t.start + 1]); }); } @@ -143,12 +143,12 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi let _635!: rs.Slice | undefined; let _668!: rs.i32; let p12!: rs.Slice | undefined; - let _751!: rs.Slice | undefined; + let _751!: rs.ArraySlice | undefined; let _784!: rs.i32; - let p14!: rs.Slice | undefined; - let _862!: rs.Slice | undefined; + let p14!: rs.ArraySlice | undefined; + let _862!: rs.ArraySlice | undefined; let _895!: rs.i32; - let p16!: rs.Slice | undefined; + let p16!: rs.ArraySlice | undefined; let _971!: rs.ByteSlice | undefined; let _1002!: rs.i32; let p18!: rs.ByteSlice | undefined; @@ -571,7 +571,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back7: boolean = _740; - const it15: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f) => (held11) => f(rs.byteSliceFrom(held11)))); + const it15: rs.Iter> = rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos); hint(it15.sizeHint(), out); flush(log, out); while (true) { @@ -591,7 +591,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it16: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f2) => (held12) => f2(rs.byteSliceFrom(held12)))); + const it16: rs.Iter> = rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos); let iterStart8: rs.i32 = 0; const iterEnd8: rs.i32 = 12; while ((_784 = iterStart8++) < iterEnd8) { @@ -600,19 +600,19 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else { p14 = rs.iterToOption(it16.nextBack()); } - rs.byteVecPush(out, option_mapOr$1bxom2b(p14, 252, sumTwos)); + rs.byteVecPush(out, option_mapOr$08f08k5(p14, 252, sumTwos)); hint(it16.sizeHint(), out); flush(log, out); } - rs.iterExtendBytes(out, rs.iterOption(option_map$1fgo7n1(rs.iterNth(rs.sliceRsplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f3) => (held13) => f3(rs.byteSliceFrom(held13)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$10ynzkb(rs.iterNth(rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos), 1), sumTwos)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$1fgo7n1(rs.iterNthBack(rs.sliceRsplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f4) => (held14) => f4(rs.byteSliceFrom(held14)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$10ynzkb(rs.iterNthBack(rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos), 1), sumTwos)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$1fgo7n1(rs.iterLast(rs.sliceRsplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f5) => (held15) => f5(rs.byteSliceFrom(held15))))), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$10ynzkb(rs.iterLast(rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos)), sumTwos)), undefined, true); flush(log, out); - rs.byteVecPush(out, rs.iterCount(rs.sliceRsplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f6) => (held16) => f6(rs.byteSliceFrom(held16))))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos)) & 0xff); flush(log, out); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceRsplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f7) => (held17) => f7(rs.byteSliceFrom(held17))))), 1), sumTwos), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos)), 1), sumTwos), "next"); flush(log, out); const iter17: rs.Iter = rs.iterSlice([false, true]); l140: while (true) { @@ -621,7 +621,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back8: boolean = _851; - const it17: rs.Iter> = rs.sliceSplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f8) => (held18) => f8(rs.byteSliceFrom(held18)))); + const it17: rs.Iter> = rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos); hint(it17.sizeHint(), out); flush(log, out); while (true) { @@ -641,7 +641,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it18: rs.Iter> = rs.sliceSplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f9) => (held19) => f9(rs.byteSliceFrom(held19)))); + const it18: rs.Iter> = rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos); let iterStart9: rs.i32 = 0; const iterEnd9: rs.i32 = 12; while ((_895 = iterStart9++) < iterEnd9) { @@ -650,19 +650,19 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else { p16 = rs.iterToOption(it18.nextBack()); } - rs.byteVecPush(out, option_mapOr$1bxom2b(p16, 252, sumTwos)); + rs.byteVecPush(out, option_mapOr$08f08k5(p16, 252, sumTwos)); hint(it18.sizeHint(), out); flush(log, out); } - rs.iterExtendBytes(out, rs.iterOption(option_map$1fgo7n1(rs.iterNth(rs.sliceSplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f10) => (held20) => f10(rs.byteSliceFrom(held20)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$10ynzkb(rs.iterNth(rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos), 1), sumTwos)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$1fgo7n1(rs.iterNthBack(rs.sliceSplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f11) => (held21) => f11(rs.byteSliceFrom(held21)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$10ynzkb(rs.iterNthBack(rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos), 1), sumTwos)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$1fgo7n1(rs.iterLast(rs.sliceSplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f12) => (held22) => f12(rs.byteSliceFrom(held22))))), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$10ynzkb(rs.iterLast(rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos)), sumTwos)), undefined, true); flush(log, out); - rs.byteVecPush(out, rs.iterCount(rs.sliceSplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f13) => (held23) => f13(rs.byteSliceFrom(held23))))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos)) & 0xff); flush(log, out); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceSplit(rs.sliceFrom(twos.items), rs.lending(testTwos, (f14) => (held24) => f14(rs.byteSliceFrom(held24))))), 1), sumTwos), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos)), 1), sumTwos), "next"); flush(log, out); } else if (_35 === 2) { const iter19: rs.Iter = rs.iterSlice([false, true]); diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index c256f882c..d949f7f7f 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -1015,10 +1015,10 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(c, 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 part5 = ends$iters_slice_Iter_array2_u8(rs.arraySliceIter(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom)), front, back); 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])]).v); - const part6 = ends$iters_slice_IterMut_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), back, front); + const part6 = ends$iters_slice_IterMut_array2_u8(rs.arraySliceIter(rs.arraySliceFrom(arrays.items, rs.byteSliceFrom)), back, front); put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part6, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["IterMut"])]).v); const _174: rs.Iter = rs.iterSlice([]); const _176: rs.Iter = rs.byteVecIntoIter(new rs.ByteVec()); @@ -1873,12 +1873,12 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { }), front, back); const args147 = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), ["Iter"]), "it")]; put(out, rs.fmtFormat([args147[0], "|", rs.fmtSpec({ alternate: true }, args147[0])]).v); - 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 => { + const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(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); + }), undefined, 2, true).items, rs.byteSliceFrom)), rs.byteSliceToArray), front, back); 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")]).v); const part12 = ends$adaptors_iter_Enumerate_slice_Iter_u8(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(bytes))), front, back); const args149 = [(f: rs.Formatter) => rs.fmtEnumerate(part12, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index 810fdb373..3f435cd2b 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -168,7 +168,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { } Runs.push$u8(runs, _38); } - const _44: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(rs.sliceFrom((runs.pairs as rs.Vec).items)), rs.byteSliceFrom); + const _44: rs.ByteSlice | undefined = rs.arraySliceFirst(rs.arraySliceFrom((runs.pairs as rs.Vec).items, rs.byteSliceFrom)); if (_44 !== undefined) { fill$u8(_44, n); } @@ -214,7 +214,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { } Runs.push$u16(runs2, _154); } - const _160: rs.Slice | undefined = rs.optionMap(rs.sliceFirst(rs.sliceFrom((runs2.pairs as rs.Vec).items)), rs.sliceFrom); + const _160: rs.Slice | undefined = rs.arraySliceFirst(rs.arraySliceFrom((runs2.pairs as rs.Vec).items, rs.sliceFrom)); if (_160 !== undefined) { fill$u16(_160, n2); } diff --git a/ts/fixtures/lang/shares/expected/shares.ts b/ts/fixtures/lang/shares/expected/shares.ts index 828b6b9a4..da39311ee 100644 --- a/ts/fixtures/lang/shares/expected/shares.ts +++ b/ts/fixtures/lang/shares/expected/shares.ts @@ -446,20 +446,20 @@ export function copies(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } pairs(shared.value, out); pairs(fromRef.value, out); - const quads: rs.Arc> = new rs.Arc(rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data2, 2), (c: rs.ByteSlice): Uint8Array => { + const quads: rs.Arc> = new rs.Arc(rs.arraySliceFrom(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data2, 2), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); const _3: rs.u8 = c.data[c.start]; rs.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); - }), undefined, 2, true).items)); - let copy: rs.Arc> = rs.arcClone(quads); - const _79: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(rs.arcMakeMut(rs.place(() => copy, (value2) => copy = value2), (a02: rs.Slice): rs.Slice => { - return rs.sliceFrom(rs.sliceItems(a02).map(copy$array_u8)); - }, rs.drop)), rs.byteSliceFrom); + }), undefined, 2, true).items, rs.byteSliceFrom)); + let copy: rs.Arc> = rs.arcClone(quads); + const _79: rs.ByteSlice | undefined = rs.arraySliceFirst(rs.arcMakeMut(rs.place(() => copy, (value2) => copy = value2), (a02: rs.ArraySlice): rs.ArraySlice => { + return rs.arraySliceFrom(rs.arraySliceItems(a02).map(copy$array_u8), rs.byteSliceFrom); + }, rs.drop)); if (_79 !== undefined) { _79.data[_79.start] = 119; } - const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(rs.sliceItems(quads.value)), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(rs.sliceItems(copy.value)), rs.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.arraySliceIter(quads.value), rs.arraySliceIter(copy.value)); while (true) { const _95: rs.ByteSlice | rs.Done = iter2.next(); if (_95 === rs.DONE) { diff --git a/ts/fixtures/lang/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index d42d39d65..abc12b842 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -1,10 +1,19 @@ // Generated by rust2-ts. Do not edit. import * as rs from "../rs.ts"; +import { copy$array_u16 } from "../lib.ts"; import { digest, digestWords } from "../slices.ts"; import type * as Item from "../slices.Item.ts"; import * as Noisy from "../slices.Noisy.ts"; import type * as Pair from "../slices.Pair.ts"; +import type * as Probe from "../slices.Probe.ts"; + +export function isSomeAnd$1s2tplg(self: Probe.Probe | undefined, f: (a0: Probe.Probe) => boolean): boolean { + if (self === undefined) { + return false; + } + return f(self); +} export function isSomeAnd$1ouf3e6(self: [rs.ByteSlice, rs.ByteSlice] | undefined, f: (a0: [rs.ByteSlice, rs.ByteSlice]) => boolean): boolean { if (self === undefined) { @@ -13,11 +22,41 @@ export function isSomeAnd$1ouf3e6(self: [rs.ByteSlice, rs.ByteSlice] | undefined return f(self); } -export function map$1sh08h7(self: rs.u16[] | undefined, f: (a0: rs.u16[]) => rs.u8): rs.u8 | undefined { +export function unwrapOr$1la41a6(self: Uint8Array | undefined, default_: Uint8Array): Uint8Array { + if (self === undefined) { + return default_; + } + return self; +} + +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return self; +} + +export function unwrapOrDefault$1n9qa5p(self: rs.u16[] | undefined): rs.u16[] { + if (self === undefined) { + return Array.from({ length: 2 }, (): rs.u16 => { + return 0; + }); + } + return self; +} + +export function unwrapOrDefault$0h81s8g(self: Uint8Array | undefined): Uint8Array { + if (self === undefined) { + return rs.bytes(2); + } + return self; +} + +export function map$13tab2s(self: rs.u16[] | undefined, f: (a0: rs.u16[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } - return f(self); + return f(copy$array_u16(self)); } export function map$0duedp1(self: rs.Slice | undefined, f: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { @@ -76,6 +115,13 @@ export function mapOr$135q041(self: Noisy.Noisy | undefined, default_: rs.u8, f: return f(self); } +export function or$0as8tia(self: rs.ByteSlice | undefined, optb: rs.ByteSlice | undefined): rs.ByteSlice | undefined { + if (self === undefined) { + return optb; + } + return self; +} + export function zip$0wdt346(self: rs.ByteSlice | undefined, other: rs.ByteSlice | undefined): [rs.ByteSlice, rs.ByteSlice] | undefined { let _0!: [rs.ByteSlice, rs.ByteSlice] | undefined; b0: { diff --git a/ts/fixtures/lang/slices/expected/lib.ts b/ts/fixtures/lang/slices/expected/lib.ts index e4771ad4e..abd0a5bb5 100644 --- a/ts/fixtures/lang/slices/expected/lib.ts +++ b/ts/fixtures/lang/slices/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { parts, chunked, subslices, drains, ranges, edits, arrays, arraysMut } from "./slices.ts"; +import { parts, chunked, subslices, drains, ranges, edits, arrays, arraysMut, arrayForms, arrayIdentity, arraySources } from "./slices.ts"; import type * as Noisy from "./slices.Noisy.ts"; import type * as Pair from "./slices.Pair.ts"; @@ -33,6 +33,13 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } +export function copy$mem_MaybeUninit_array_u8(v: Uint8Array): Uint8Array { + if (v === undefined) { + return v; + } + return v.slice(); +} + export function copy$slices_Pair(v: Pair.Pair): Pair.Pair { return { a: v.a, b: v.b }; } @@ -46,7 +53,7 @@ export function drop$tuple2_Vec_slices_Noisy_Vec_u8(_1: [rs.Vec, rs * their count, so a case added at the end moves no other. */ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { - return rs.vecFrom([["slices::parts", parts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::drains", drains as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::chunked", chunked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::ranges", ranges as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::edits", edits as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::arrays", arrays as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::arrays_mut", arraysMut 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([["slices::parts", parts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::drains", drains as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::chunked", chunked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::ranges", ranges as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::edits", edits as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::arrays", arrays as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::arrays_mut", arraysMut as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::array_forms", arrayForms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::array_identity", arrayIdentity as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::array_sources", arraySources 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/slices/expected/slices.Probe.ts b/ts/fixtures/lang/slices/expected/slices.Probe.ts new file mode 100644 index 000000000..eb37bf1b9 --- /dev/null +++ b/ts/fixtures/lang/slices/expected/slices.Probe.ts @@ -0,0 +1,23 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; +import { isSomeAnd$1s2tplg } from "./core/option.ts"; +import { LOG } from "./slices.ts"; + +/** What logs, as it is cloned, whether it is the one its `home` points at. */ +export interface Probe { + tag: rs.u8; + home: rs.Cell; +} + +export function clone$Clone(self: Probe): Probe { + const home: boolean = isSomeAnd$1s2tplg(self.home.v, (home2: Probe): boolean => { + return home2 === self; + }); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, self.tag ^ (home ? 1 : 0)); + }); + return { tag: self.tag, home: self.home }; +} + +//# sourceMappingURL=slices.Probe.ts.map diff --git a/ts/fixtures/lang/slices/expected/slices.View.ts b/ts/fixtures/lang/slices/expected/slices.View.ts new file mode 100644 index 000000000..ab14d9c1b --- /dev/null +++ b/ts/fixtures/lang/slices/expected/slices.View.ts @@ -0,0 +1,21 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; +import { copy$Option_array2_u16, copy$Option_array2_u8 } from "./lib.ts"; + +/** A generic struct's slice, instanced with arrays. */ +export interface View { + view: rs.SliceOf; +} + +/** Its last element, if any. */ +export function last$array2_u16(self: View): rs.u16[] | undefined { + return copy$Option_array2_u16(rs.optionMap(rs.arraySliceLast(self.view as rs.ArraySlice>), rs.sliceItems)); +} + +/** Its last element, if any. */ +export function last$array2_u8(self: View): Uint8Array | undefined { + return copy$Option_array2_u8(rs.optionMap(rs.arraySliceLast(self.view as rs.ArraySlice), rs.byteSliceView)); +} + +//# sourceMappingURL=slices.View.ts.map diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index ba4a04179..4b89d5fc8 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -1,12 +1,14 @@ // Generated by rust2-ts. Do not edit. 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$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 { 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$mem_MaybeUninit_array_u8, copy$slices_Pair, drop$tuple2_Vec_slices_Noisy_Vec_u8 } from "./lib.ts"; +import { isSomeAnd$1ouf3e6, unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1n9qa5p as option_unwrapOrDefault$1n9qa5p, unwrapOrDefault$0h81s8g as option_unwrapOrDefault$0h81s8g, map$13tab2s as option_map$13tab2s, 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, or$0as8tia as option_or$0as8tia, 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"; import * as Pair from "./slices.Pair.ts"; +import * as Probe from "./slices.Probe.ts"; +import * as View from "./slices.View.ts"; export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LOG$init, false); @@ -2070,7 +2072,7 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** How many runs of `N` `data` holds, by `as_chunks`, which panics at none. */ export function runs$0(data: rs.ByteSlice): rs.u8 { - return rs.byteSliceAsChunks(data, 0)[0].length & 0xff; + return rs.sliceAsChunks(data, 0)[0].length & 0xff; } /** @@ -2094,85 +2096,86 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 1, true); const _13: rs.u8 = rs.u8Rem(kind, 4); if (_13 === 0) { - const _17: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunks(data, 2); - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_17[0])), rs.byteSliceFrom), (c3: rs.ByteSlice): rs.u8 => { + const _17: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(data, 2); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_17[0]), (c3: rs.ByteSlice): rs.u8 => { return digest(c3); }), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_17[0].length & 0xff, digest(_17[1]))), undefined, true); - const _28: [rs.ByteSlice, rs.Slice] = rs.byteSliceAsRchunks(data, 3); - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_28[1])), rs.byteSliceFrom), (c4: rs.ByteSlice): rs.u8 => { + const _28: [rs.ByteSlice, rs.ArraySlice] = rs.sliceAsRchunks(data, 3); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_28[1]), (c4: rs.ByteSlice): rs.u8 => { return c4.data[c4.start] ^ c4.data[c4.start + 2]; }), 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.iterLend(rs.iterSlice(rs.sliceItems(_39[0])), rs.sliceFrom), (c5: rs.Slice): rs.u8 => { + const _39: [rs.ArraySlice>, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(words.items), 3); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_39[0]), (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.iterLend(rs.iterSlice(rs.sliceItems(_52[1])), rs.sliceFrom), (_211: rs.Slice): rs.u8 => { + const _52: [rs.Slice, rs.ArraySlice>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 1); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_52[1]), (_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.iterLend(rs.iterSlice(rs.sliceItems(_63[0])), rs.sliceFrom), (c6: rs.Slice): rs.u8 => { + const _63: [rs.ArraySlice>, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(items.items), 3); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_63[0]), (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.iterLend(rs.iterSlice(rs.sliceItems(_80[1])), rs.sliceFrom), (c7: rs.Slice): rs.u8 => { + const _80: [rs.Slice, rs.ArraySlice>] = rs.sliceAsRchunks(rs.sliceFrom(items.items), 2); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_80[1]), (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) { - const _97: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunks(rs.byteSliceRange(data, 0, 0), 4); + const _97: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteSliceRange(data, 0, 0), 4); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_97[0].length & 0xff, _97[1].length & 0xff)), undefined, true); - const _108: [rs.Slice, rs.Slice] = rs.sliceAsRchunks(rs.sliceRange(rs.sliceFrom(items.items), 0, 0), 2); + const _108: [rs.Slice, rs.ArraySlice>] = rs.sliceAsRchunks(rs.sliceRange(rs.sliceFrom(items.items), 0, 0), 2); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_108[1].length & 0xff, _108[0].length & 0xff)), undefined, true); const start: rs.usize = rs.usizeDiv(data.length, 3); - const _123: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunks(rs.byteSliceRange(data, start), 3); - const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(_123[0])), rs.byteSliceFrom); + const _123: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteSliceRange(data, start), 3); + const iter: rs.Iter = rs.arraySliceIter(_123[0]); while (true) { const _128: rs.ByteSlice | rs.Done = iter.next(); if (_128 === rs.DONE) { break; } - const _134: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunks(_128, 2); + const _134: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(_128, 2); const _138: rs.u8 = _134[0].length & 0xff; rs.idx(_134[0], 0); - const _141: rs.u8 = _134[0].data[_134[0].start][1]; + const slice3 = rs.arraySliceAt(_134[0], 0); + const _141: rs.u8 = slice3.data[slice3.start + 1]; rs.idx(_134[1], 0); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_138, _141 ^ _134[1].data[_134[1].start])), undefined, true); } 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$0duedp1(rs.optionMap(rs.sliceLast(_155[1]), rs.sliceFrom), (c: rs.Slice): rs.u8 => { + const _155: [rs.Slice, rs.ArraySlice>] = rs.sliceAsRchunks(rs.sliceRange(rs.sliceFrom(words.items), start), 2); + rs.iterExtendBytes(out, rs.iterOption(option_map$0duedp1(rs.arraySliceLast(_155[1]), (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); - const _169: [rs.ByteSlice, rs.Slice] = rs.byteSliceAsRchunks(rs.byteSliceRange(rs.byteVecSlice(bytes), 1), 2); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([isSomeAnd$1ouf3e6(zip$0wdt346(rs.optionMap(rs.sliceFirst(_165[0]), rs.byteSliceFrom), rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, 2)), (_27: [rs.ByteSlice, rs.ByteSlice]): boolean => { + const _165: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 2); + const _169: [rs.ByteSlice, rs.ArraySlice] = rs.sliceAsRchunks(rs.byteSliceRange(rs.byteVecSlice(bytes), 1), 2); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([isSomeAnd$1ouf3e6(zip$0wdt346(rs.arraySliceFirst(_165[0]), rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, 2)), (_27: [rs.ByteSlice, rs.ByteSlice]): boolean => { return rs.byteSliceSame(_27[0], _27[1]); - }), isSomeAnd$1ouf3e6(zip$0wdt346(rs.optionMap(rs.sliceFirst(_165[0]), rs.byteSliceFrom), rs.optionMap(rs.sliceFirst(rs.byteSliceAsChunks(rs.byteVecSlice(bytes), 2)[0]), rs.byteSliceFrom)), (_29: [rs.ByteSlice, rs.ByteSlice]): boolean => { + }), isSomeAnd$1ouf3e6(zip$0wdt346(rs.arraySliceFirst(_165[0]), rs.arraySliceFirst(rs.sliceAsChunks(rs.byteVecSlice(bytes), 2)[0])), (_29: [rs.ByteSlice, rs.ByteSlice]): boolean => { return rs.byteSliceSame(_29[0], _29[1]); - }), isSomeAnd$1ouf3e6(zip$0wdt346(rs.optionMap(rs.sliceLast(_169[1]), rs.byteSliceFrom), rs.optionMap(rs.sliceLast(_165[0]), rs.byteSliceFrom)), (_210: [rs.ByteSlice, rs.ByteSlice]): boolean => { + }), isSomeAnd$1ouf3e6(zip$0wdt346(rs.arraySliceLast(_169[1]), rs.arraySliceLast(_165[0])), (_210: [rs.ByteSlice, rs.ByteSlice]): boolean => { return rs.byteSliceSame(_210[0], _210[1]); })], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const kept: Uint8Array | undefined = copy$Option_array2_u8(rs.optionMap(rs.optionMap(rs.sliceFirst(_165[0]), rs.byteSliceFrom), rs.byteSliceView)); + const kept: Uint8Array | undefined = copy$Option_array2_u8(rs.optionMap(rs.arraySliceFirst(_165[0]), rs.byteSliceView)); const _195: rs.Place | undefined = rs.sliceFirstMut(rs.byteVecSlice(bytes)); if (_195 !== undefined) { _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.optionMap(rs.optionMap(rs.sliceFirst(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0]), rs.sliceFrom), rs.sliceItems)); + const kept2: rs.u16[] | undefined = copy$Option_array2_u16(rs.optionMap(rs.arraySliceFirst(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0]), rs.sliceItems)); const _208: rs.Place | undefined = rs.sliceFirstMut(rs.sliceFrom(words.items)); if (_208 !== undefined) { _208.v = _208.v ^ 65535; } - rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(kept2, (c2: rs.u16[]): rs.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$13tab2s(kept2, (c2: rs.u16[]): rs.u8 => { return digestWords(rs.sliceFrom(c2)); })), undefined, true); } else if (_13 === 2) { @@ -2220,7 +2223,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** How many runs of `N` `data` holds, by `as_chunks_mut`, which panics at none. */ export function runsMut$0(data: rs.ByteSlice): rs.u8 { - return rs.byteSliceAsChunksMut(data, 0)[0].length & 0xff; + return rs.sliceAsChunks(data, 0)[0].length & 0xff; } /** @@ -2244,8 +2247,8 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi }), undefined, 1, true); const _12: rs.u8 = rs.u8Rem(kind, 5); if (_12 === 0) { - const _16: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 3); - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(_16[0])), rs.byteSliceFrom)); + const _16: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 3); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.arraySliceIter(_16[0])); while (true) { const _23: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_23 === rs.DONE) { @@ -2255,7 +2258,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const swapped: Uint8Array = Uint8Array.of(_23[1].data[_23[1].start + 2], _23[1].data[_23[1].start + 1]); rs.byteSliceCopyFromSlice(rs.byteSliceRange(_23[1], 1), rs.byteSliceFrom(swapped)); } - const iter2: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterZip(rs.iterRev(rs.iterLend(rs.iterSlice(rs.sliceItems(_16[0])), rs.byteSliceFrom)), rs.iterSlice(rs.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterZip(rs.iterRev(rs.arraySliceIter(_16[0])), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { const _48: [rs.ByteSlice, rs.u8] | rs.Done = iter2.next(); if (_48 === rs.DONE) { @@ -2264,7 +2267,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _53: rs.u8 = rs.u8WrappingAdd(_48[0].data[_48[0].start + 2], _48[1]); _48[0].data[_48[0].start + 2] = _53; } - const odd: rs.Peekable = rs.iterPeekable(rs.iterFilter(rs.iterLend(rs.iterSlice(rs.sliceItems(_16[0])), rs.byteSliceFrom), (c33: rs.ByteSlice): boolean => { + const odd: rs.Peekable = rs.iterPeekable(rs.iterFilter(rs.arraySliceIter(_16[0]), (c33: rs.ByteSlice): boolean => { const _719: rs.ByteSlice = c33; return (_719.data[_719.start] & 1) !== 0; })); @@ -2283,8 +2286,8 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi _71.data[_71.start] = ~_71.data[_71.start] & 0xff; } 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.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.sliceItems(_83[1])), rs.sliceFrom)); + const _83: [rs.Slice, rs.ArraySlice>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 2); + const iter4: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.arraySliceIter(_83[1])); while (true) { const _90: [rs.usize, rs.Slice] | rs.Done = iter4.next(); if (_90 === rs.DONE) { @@ -2296,7 +2299,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } rs.sliceFill(_83[0], 1, undefined); const part7 = rs.usizeDiv(data.length, 3); - const iter5: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceItems(rs.byteSliceAsChunksMut(rs.byteSliceRange(rs.byteVecSlice(bytes), part7), 2)[0])), rs.byteSliceFrom); + const iter5: rs.Iter = rs.arraySliceIter(rs.sliceAsChunks(rs.byteSliceRange(rs.byteVecSlice(bytes), part7), 2)[0]); while (true) { const _110: rs.ByteSlice | rs.Done = iter5.next(); if (_110 === rs.DONE) { @@ -2304,8 +2307,8 @@ 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.optionMap(rs.optionMap(rs.sliceFirst(rs.sliceAsChunksMut(rs.sliceFrom(words.items), 2)[0]), rs.sliceFrom), rs.sliceItems)); + const kept: Uint8Array | undefined = copy$Option_array2_u8(rs.optionMap(rs.arraySliceFirst(rs.sliceAsChunks(rs.byteVecSlice(bytes), 2)[0]), rs.byteSliceView)); + const keptWords: rs.u16[] | undefined = copy$Option_array2_u16(rs.optionMap(rs.arraySliceFirst(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0]), 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); @@ -2313,353 +2316,380 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi return (w2 ^ (w2 >> 8)) & 0xff; }), undefined, true); } else if (_12 === 1) { - const _142: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2); + const _142: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 2); if (_142[0].length >= 2) { - const first: rs.ByteSlice = rs.byteSliceFrom(_142[0].data[_142[0].start]); - const last: rs.ByteSlice = rs.byteSliceFrom(_142[0].data[_142[0].start + (_142[0].length - 1)]); - const _152: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(first), rs.byteSliceToArray(last)]; - const first2: Uint8Array = copy$array_u8(_152[0]); - const last2: Uint8Array = copy$array_u8(_152[1]); - rs.sliceSwap(_142[0], 0, rs.usizeSub(_142[0].length, 1)); - rs.sliceReverse(_142[0]); + const _152: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(rs.arraySliceAt(_142[0], 0)), rs.byteSliceToArray(rs.arraySliceAt(_142[0], _142[0].length - 1))]; + const first: Uint8Array = copy$array_u8(_152[0]); + const last: Uint8Array = copy$array_u8(_152[1]); + rs.arraySliceSwap(_142[0], 0, rs.usizeSub(_142[0].length, 1), undefined); + rs.arraySliceBy(_142[0], (arrays48) => rs.sliceReverse(arrays48)); const n: rs.usize = _142[0].length; - rs.sliceReverse(rs.sliceRange(_142[0], 1)); - rs.sliceRotateLeft(_142[0], 1); - rs.sliceRotateRight(_142[0], rs.usizeDiv(n, 2)); + rs.arraySliceBy(rs.arraySliceRange(_142[0], 1), (arrays49) => rs.sliceReverse(arrays49)); + rs.arraySliceBy(_142[0], (arrays50) => rs.sliceRotateLeft(arrays50, 1)); + const _168: rs.usize = rs.usizeDiv(n, 2); + rs.arraySliceBy(_142[0], (arrays51) => rs.sliceRotateRight(arrays51, _168)); const _171: rs.usize = rs.usizeSub(n, 1); rs.idx(_142[0], _171); - const kept2: Uint8Array = copy$array_u8(_142[0].data[_142[0].start + _171]); + const kept2: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_142[0], _171)); const _177: { end: rs.usize } = { end: rs.usizeSub(n, 1) }; - rs.sliceCopyWithin(_142[0], 0, _177.end, 1, copy$array_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([copy$array_u8(first2), copy$array_u8(last2), copy$array_u8(kept2)]), rs.byteSliceFrom), (c28: rs.ByteSlice): rs.u8 => { + rs.arraySliceCopyWithin(_142[0], 0, _177.end, 1, copy$array_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom([copy$array_u8(first), copy$array_u8(last), copy$array_u8(kept2)], rs.byteSliceFrom)), (c28: rs.ByteSlice): rs.u8 => { return digest(c28); }), undefined, true); - rs.sliceSort(_142[0], rs.cmpLt(rs.cmpBytes), 2, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_142[0])), rs.byteSliceFrom), (c29: rs.ByteSlice): rs.u8 => { + rs.arraySliceBy(_142[0], (arrays52) => rs.sliceSort(arrays52, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_142[0]), (c29: rs.ByteSlice): rs.u8 => { return digest(c29); }), undefined, true); const f12 = (c30: rs.ByteSlice): rs.u8 => { return c30.data[c30.start + 1]; }; - 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); + rs.arraySliceBy(_142[0], (arrays53) => rs.sliceSort(arrays53, rs.keyLt((held12) => f12(rs.byteSliceFrom(held12)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 2, true)); + rs.arraySliceBy(_142[0], (arrays54) => rs.sliceSortUnstable(arrays54, rs.cmpLt(rs.cmpBytes), 2, true, true)); const f13 = (c31: rs.ByteSlice): rs.u8 => { return c31.data[c31.start]; }; - 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.arraySliceBy(_142[0], (arrays55) => rs.sliceSortByCachedKey(arrays55, (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.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(_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 swapped8 = rs.byteSliceToArray(_198); - _198.data.set(rs.byteSliceToArray(_203), _198.start); - _203.data.set(swapped8, _203.start); + const slice79 = rs.arraySliceAt(_196[0], 0); + const slice80 = rs.arraySliceAt(_196[1], _204); + const swapped8 = rs.byteSliceToArray(slice79); + slice79.data.set(rs.byteSliceToArray(slice80), slice79.start); + slice80.data.set(swapped8, slice80.start); rs.idx(_142[0], 0); - const _210: rs.ByteSlice = rs.byteSliceFrom(_142[0].data[_142[0].start]); - const old13 = rs.byteSliceToArray(_210); - _210.data.set(Uint8Array.of(7, 8), _210.start); + const slice81 = rs.arraySliceAt(_142[0], 0); + const old13 = rs.byteSliceToArray(slice81); + slice81.data.set(Uint8Array.of(7, 8), slice81.start); const old: Uint8Array = old13; const _216: rs.usize = rs.usizeSub(n, 1); rs.idx(_142[0], _216); - _142[0].data[_142[0].start + _216] = copy$array_u8(old); + const slice82 = rs.arraySliceAt(_142[0], _216); + slice82.data.set(copy$array_u8(old), slice82.start); rs.idx(_142[0], 1); - const kept3: Uint8Array = copy$array_u8(_142[0].data[_142[0].start + 1]); + const kept3: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_142[0], 1)); rs.idx(_142[0], 0); - const _226: Uint8Array = copy$array_u8(_142[0].data[_142[0].start]); + const _226: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_142[0], 0)); rs.idx(_142[0], 1); - _142[0].data[_142[0].start + 1] = _226; + const slice83 = rs.arraySliceAt(_142[0], 1); + slice83.data.set(_226, slice83.start); rs.idx(_142[0], 0); - _142[0].data[_142[0].start] = copy$array_u8(kept3); - const _239: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(_142[0]), rs.byteSliceFrom); + const slice84 = rs.arraySliceAt(_142[0], 0); + slice84.data.set(copy$array_u8(kept3), slice84.start); + const _239: rs.ByteSlice | undefined = rs.arraySliceLast(_142[0]); if (_239 !== undefined) { _239.data.set(Uint8Array.of(9, 10), _239.start); } - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_142[0])), rs.byteSliceFrom), (c32: rs.ByteSlice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_142[0]), (c32: rs.ByteSlice): rs.u8 => { return digest(c32); }), undefined, true); - rs.sliceFill(rs.sliceRange(_142[0], rs.usizeDiv(n, 2)), Uint8Array.of(9, 10), copy$array_u8); + const _247: rs.ArraySlice = rs.arraySliceRange(_142[0], rs.usizeDiv(n, 2)); + const _251: Uint8Array = Uint8Array.of(9, 10); + rs.arraySliceBy(_247, (arrays56) => rs.sliceFill(arrays56, _251, copy$array_u8)); } } else if (_12 === 2) { - const _253: [rs.Slice, rs.Slice] = rs.sliceAsRchunksMut(rs.sliceFrom(words.items), 2); + const _253: [rs.Slice, rs.ArraySlice>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 2); if (_253[1].length >= 2) { - 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 _263: [rs.u16[], rs.u16[]] = [rs.sliceToArray(rs.arraySliceAt(_253[1], 0)), rs.sliceToArray(rs.arraySliceAt(_253[1], _253[1].length - 1))]; + const first2: rs.u16[] = copy$array_u16(_263[0]); + const last2: rs.u16[] = copy$array_u16(_263[1]); + rs.arraySliceSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1), undefined); + rs.arraySliceBy(_253[1], (arrays3) => rs.sliceReverse(arrays3)); const n2: rs.usize = _253[1].length; - rs.sliceReverse(rs.sliceRange(_253[1], 1)); - rs.sliceRotateLeft(_253[1], 1); - rs.sliceRotateRight(_253[1], rs.usizeDiv(n2, 2)); + rs.arraySliceBy(rs.arraySliceRange(_253[1], 1), (arrays4) => rs.sliceReverse(arrays4)); + rs.arraySliceBy(_253[1], (arrays5) => rs.sliceRotateLeft(arrays5, 1)); + const _279: rs.usize = rs.usizeDiv(n2, 2); + rs.arraySliceBy(_253[1], (arrays6) => rs.sliceRotateRight(arrays6, _279)); const _282: rs.usize = rs.usizeSub(n2, 1); rs.idx(_253[1], _282); - const kept4: rs.u16[] = copy$array_u16(_253[1].data[_253[1].start + _282]); + const kept4: rs.u16[] = rs.sliceToArray(rs.arraySliceAt(_253[1], _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.iterLend(rs.iterSlice([first4, last4, kept4]), rs.sliceFrom), (c3: rs.Slice): rs.u8 => { + rs.arraySliceCopyWithin(_253[1], 0, _288.end, 1, copy$array_u16); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom([copy$array_u16(first2), copy$array_u16(last2), copy$array_u16(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.iterLend(rs.iterSlice(rs.sliceItems(_253[1])), rs.sliceFrom), (c4: rs.Slice): rs.u8 => { + rs.arraySliceBy(_253[1], (arrays7) => rs.sliceSort(arrays7, rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_253[1]), (c4: rs.Slice): rs.u8 => { return digestWords(c4); }), undefined, 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.arraySliceBy(_253[1], (arrays8) => rs.sliceSort(arrays8, rs.keyLt((held2) => f2(rs.sliceFrom(held2)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true)); + rs.arraySliceBy(_253[1], (arrays9) => rs.sliceSortUnstable(arrays9, rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, 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.arraySliceBy(_253[1], (arrays10) => rs.sliceSortByCachedKey(arrays10, (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.ArraySlice>, rs.ArraySlice>] = rs.arraySliceSplitAt(_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); - const _314: rs.Slice = rs.sliceFrom(_307[1].data[_307[1].start + _315]); - rs.sliceSet(_314, rs.replaceIn(rs.sliceView(_309), rs.sliceToArray(_314))); + const slice10 = rs.arraySliceAt(_307[0], 0); + const slice11 = rs.arraySliceAt(_307[1], _315); + rs.sliceSet(slice11, rs.replaceIn(rs.sliceView(slice10), rs.sliceToArray(slice11))); rs.idx(_253[1], 0); - const old2: rs.u16[] = rs.replaceIn(rs.sliceView(rs.sliceFrom(_253[1].data[_253[1].start])), [7, 8]); + const old2: rs.u16[] = rs.replaceIn(rs.sliceView(rs.arraySliceAt(_253[1], 0)), [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); + rs.sliceSet(rs.arraySliceAt(_253[1], _327), copy$array_u16(old2)); rs.idx(_253[1], 1); - const kept5: rs.u16[] = copy$array_u16(_253[1].data[_253[1].start + 1]); + const kept5: rs.u16[] = rs.sliceToArray(rs.arraySliceAt(_253[1], 1)); rs.idx(_253[1], 0); - const _337: rs.u16[] = copy$array_u16(_253[1].data[_253[1].start]); + const _337: rs.u16[] = rs.sliceToArray(rs.arraySliceAt(_253[1], 0)); rs.idx(_253[1], 1); - _253[1].data[_253[1].start + 1] = _337; + rs.sliceSet(rs.arraySliceAt(_253[1], 1), _337); rs.idx(_253[1], 0); - _253[1].data[_253[1].start] = copy$array_u16(kept5); - const _350: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_253[1]), rs.sliceFrom); + rs.sliceSet(rs.arraySliceAt(_253[1], 0), copy$array_u16(kept5)); + const _350: rs.Slice | undefined = rs.arraySliceLast(_253[1]); if (_350 !== undefined) { rs.sliceSet(_350, [9, 10]); } - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_253[1])), rs.sliceFrom), (c7: rs.Slice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_253[1]), (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 _358: rs.ArraySlice> = rs.arraySliceRange(_253[1], rs.usizeDiv(n2, 2)); + const _362: rs.u16[] = [9, 10]; + rs.arraySliceBy(_358, (arrays11) => rs.sliceFill(arrays11, _362, copy$array_u16)); } - const _364: [rs.ByteSlice, rs.Slice] = rs.byteSliceAsRchunksMut(rs.byteVecSlice(bytes), 4); + const _364: [rs.ByteSlice, rs.ArraySlice] = rs.sliceAsRchunks(rs.byteVecSlice(bytes), 4); if (_364[1].length >= 2) { - 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 _374: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(rs.arraySliceAt(_364[1], 0)), rs.byteSliceToArray(rs.arraySliceAt(_364[1], _364[1].length - 1))]; + const first3: Uint8Array = copy$array_u8(_374[0]); + const last3: Uint8Array = copy$array_u8(_374[1]); + rs.arraySliceSwap(_364[1], 0, rs.usizeSub(_364[1].length, 1), undefined); + rs.arraySliceBy(_364[1], (arrays12) => rs.sliceReverse(arrays12)); const n3: rs.usize = _364[1].length; - rs.sliceReverse(rs.sliceRange(_364[1], 1)); - rs.sliceRotateLeft(_364[1], 1); - rs.sliceRotateRight(_364[1], rs.usizeDiv(n3, 2)); + rs.arraySliceBy(rs.arraySliceRange(_364[1], 1), (arrays13) => rs.sliceReverse(arrays13)); + rs.arraySliceBy(_364[1], (arrays14) => rs.sliceRotateLeft(arrays14, 1)); + const _390: rs.usize = rs.usizeDiv(n3, 2); + rs.arraySliceBy(_364[1], (arrays15) => rs.sliceRotateRight(arrays15, _390)); const _393: rs.usize = rs.usizeSub(n3, 1); rs.idx(_364[1], _393); - const kept6: Uint8Array = copy$array_u8(_364[1].data[_364[1].start + _393]); + const kept6: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_364[1], _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(first6), copy$array_u8(last6), copy$array_u8(kept6)]), rs.byteSliceFrom), (c8: rs.ByteSlice): rs.u8 => { + rs.arraySliceCopyWithin(_364[1], 0, _399.end, 1, copy$array_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom([copy$array_u8(first3), copy$array_u8(last3), 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 => { + rs.arraySliceBy(_364[1], (arrays16) => rs.sliceSort(arrays16, rs.cmpLt(rs.cmpBytes), 4, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_364[1]), (c9: rs.ByteSlice): rs.u8 => { return digest(c9); }), undefined, true); const f4 = (c10: rs.ByteSlice): rs.u8 => { return c10.data[c10.start + 1]; }; - 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); + rs.arraySliceBy(_364[1], (arrays17) => rs.sliceSort(arrays17, rs.keyLt((held4) => f4(rs.byteSliceFrom(held4)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true)); + rs.arraySliceBy(_364[1], (arrays18) => rs.sliceSortUnstable(arrays18, rs.cmpLt(rs.cmpBytes), 4, true, true)); const f5 = (c11: rs.ByteSlice): rs.u8 => { return c11.data[c11.start]; }; - 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.arraySliceBy(_364[1], (arrays19) => rs.sliceSortByCachedKey(arrays19, (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.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(_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 swapped4 = rs.byteSliceToArray(_420); - _420.data.set(rs.byteSliceToArray(_425), _420.start); - _425.data.set(swapped4, _425.start); + const slice19 = rs.arraySliceAt(_418[0], 0); + const slice20 = rs.arraySliceAt(_418[1], _426); + const swapped4 = rs.byteSliceToArray(slice19); + slice19.data.set(rs.byteSliceToArray(slice20), slice19.start); + slice20.data.set(swapped4, slice20.start); rs.idx(_364[1], 0); - const _432: rs.ByteSlice = rs.byteSliceFrom(_364[1].data[_364[1].start]); - const old9 = rs.byteSliceToArray(_432); - _432.data.set(Uint8Array.of(1, 2, 3, 4), _432.start); + const slice21 = rs.arraySliceAt(_364[1], 0); + const old9 = rs.byteSliceToArray(slice21); + slice21.data.set(Uint8Array.of(1, 2, 3, 4), slice21.start); const old3: Uint8Array = old9; const _438: rs.usize = rs.usizeSub(n3, 1); rs.idx(_364[1], _438); - _364[1].data[_364[1].start + _438] = copy$array_u8(old3); + const slice22 = rs.arraySliceAt(_364[1], _438); + slice22.data.set(copy$array_u8(old3), slice22.start); rs.idx(_364[1], 1); - const kept7: Uint8Array = copy$array_u8(_364[1].data[_364[1].start + 1]); + const kept7: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_364[1], 1)); rs.idx(_364[1], 0); - const _448: Uint8Array = copy$array_u8(_364[1].data[_364[1].start]); + const _448: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_364[1], 0)); rs.idx(_364[1], 1); - _364[1].data[_364[1].start + 1] = _448; + const slice23 = rs.arraySliceAt(_364[1], 1); + slice23.data.set(_448, slice23.start); rs.idx(_364[1], 0); - _364[1].data[_364[1].start] = copy$array_u8(kept7); - const _461: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(_364[1]), rs.byteSliceFrom); + const slice24 = rs.arraySliceAt(_364[1], 0); + slice24.data.set(copy$array_u8(kept7), slice24.start); + const _461: rs.ByteSlice | undefined = rs.arraySliceLast(_364[1]); if (_461 !== undefined) { _461.data.set(rs.bytes(4).fill(5), _461.start); } - rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(rs.sliceItems(_364[1])), rs.byteSliceFrom), (c12: rs.ByteSlice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_364[1]), (c12: rs.ByteSlice): rs.u8 => { return digest(c12); }), undefined, true); - rs.sliceFill(rs.sliceRange(_364[1], rs.usizeDiv(n3, 2)), rs.bytes(4).fill(5), copy$array_u8); + const _469: rs.ArraySlice = rs.arraySliceRange(_364[1], rs.usizeDiv(n3, 2)); + const _473: Uint8Array = rs.bytes(4).fill(5); + rs.arraySliceBy(_469, (arrays20) => rs.sliceFill(arrays20, _473, copy$array_u8)); } - const _479: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0], 2); + const _479: [rs.ArraySlice>, rs.ArraySlice] = rs.sliceAsChunks(rs.sliceAsChunks(rs.byteVecSlice(bytes), 2)[0], 2); if (_479[0].length >= 2) { - 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 _487: [Uint8Array[], Uint8Array[]] = [rs.arraySliceToArray(rs.arraySliceAt(_479[0], 0), rs.byteSliceToArray), rs.arraySliceToArray(rs.arraySliceAt(_479[0], _479[0].length - 1), rs.byteSliceToArray)]; + const first4: Uint8Array[] = copy$array_array2_u8(_487[0]); + const last4: Uint8Array[] = copy$array_array2_u8(_487[1]); + rs.arraySliceSwap(_479[0], 0, rs.usizeSub(_479[0].length, 1), undefined); + rs.arraySliceBy(_479[0], (arrays21) => rs.sliceReverse(arrays21)); const n4: rs.usize = _479[0].length; - rs.sliceReverse(rs.sliceRange(_479[0], 1)); - rs.sliceRotateLeft(_479[0], 1); - rs.sliceRotateRight(_479[0], rs.usizeDiv(n4, 2)); + rs.arraySliceBy(rs.arraySliceRange(_479[0], 1), (arrays22) => rs.sliceReverse(arrays22)); + rs.arraySliceBy(_479[0], (arrays23) => rs.sliceRotateLeft(arrays23, 1)); + const _503: rs.usize = rs.usizeDiv(n4, 2); + rs.arraySliceBy(_479[0], (arrays24) => rs.sliceRotateRight(arrays24, _503)); const _506: rs.usize = rs.usizeSub(n4, 1); rs.idx(_479[0], _506); - const kept8: Uint8Array[] = copy$array_array2_u8(_479[0].data[_479[0].start + _506]); + const kept8: Uint8Array[] = rs.arraySliceToArray(rs.arraySliceAt(_479[0], _506), rs.byteSliceToArray); 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.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]; + rs.arraySliceCopyWithin(_479[0], 0, _512.end, 1, copy$array_array2_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom([copy$array_array2_u8(first4), copy$array_array2_u8(last4), copy$array_array2_u8(kept8)], rs.arraySliceOf(rs.byteSliceFrom))), (c13: rs.ArraySlice): rs.u8 => { + const slice28 = rs.arraySliceAt(c13, 0); + const _342: rs.u8 = slice28.data[slice28.start]; + const slice29 = rs.arraySliceAt(c13, 1); + return _342 ^ slice29.data[slice29.start + 1]; }), undefined, true); - rs.sliceSort(_479[0], rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true); - 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]; + rs.arraySliceBy(_479[0], (arrays25) => rs.sliceSort(arrays25, rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_479[0]), (c14: rs.ArraySlice): rs.u8 => { + const slice30 = rs.arraySliceAt(c14, 0); + const _346: rs.u8 = slice30.data[slice30.start]; + const slice31 = rs.arraySliceAt(c14, 1); + return _346 ^ slice31.data[slice31.start + 1]; }), undefined, true); - const f6 = (c15: rs.Slice): Uint8Array => { - return copy$array_u8(c15.data[c15.start + 1]); + const f6 = (c15: rs.ArraySlice): Uint8Array => { + return rs.byteSliceToArray(rs.arraySliceAt(c15, 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); - const f7 = (c16: rs.Slice): Uint8Array => { - return copy$array_u8(c16.data[c16.start]); + rs.arraySliceBy(_479[0], (arrays26) => rs.sliceSort(arrays26, rs.keyLt((held6) => f6(rs.arraySliceOf(rs.byteSliceFrom)(held6)), rs.cmpLt(rs.cmpReverse(rs.cmpBytes))), 4, true)); + rs.arraySliceBy(_479[0], (arrays27) => rs.sliceSortUnstable(arrays27, rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true, true)); + const f7 = (c16: rs.ArraySlice): Uint8Array => { + return rs.byteSliceToArray(rs.arraySliceAt(c16, 0)); }; - 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.arraySliceBy(_479[0], (arrays28) => rs.sliceSortByCachedKey(arrays28, (held7) => f7(rs.arraySliceOf(rs.byteSliceFrom)(held7)), rs.cmpLt(rs.cmpTuple<[Uint8Array, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpBytes), rs.cmp])), 8, true, true)); + const _531: [rs.ArraySlice>, rs.ArraySlice>] = rs.arraySliceSplitAt(_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); - 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)); + const slice32 = rs.arraySliceAt(_531[0], 0); + const slice33 = rs.arraySliceAt(_531[1], _539); + rs.arraySliceSet(slice33, rs.arraySliceReplace(slice32, rs.arraySliceToArray(slice33, rs.byteSliceToArray))); rs.idx(_479[0], 0); - 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 old4: Uint8Array[] = rs.arraySliceReplace(rs.arraySliceAt(_479[0], 0), _550); 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); + rs.arraySliceSet(rs.arraySliceAt(_479[0], _553), copy$array_array2_u8(old4)); rs.idx(_479[0], 1); - const kept9: Uint8Array[] = copy$array_array2_u8(_479[0].data[_479[0].start + 1]); + const kept9: Uint8Array[] = rs.arraySliceToArray(rs.arraySliceAt(_479[0], 1), rs.byteSliceToArray); rs.idx(_479[0], 0); - const _563: Uint8Array[] = copy$array_array2_u8(_479[0].data[_479[0].start]); + const _563: Uint8Array[] = rs.arraySliceToArray(rs.arraySliceAt(_479[0], 0), rs.byteSliceToArray); rs.idx(_479[0], 1); - _479[0].data[_479[0].start + 1] = _563; + rs.arraySliceSet(rs.arraySliceAt(_479[0], 1), _563); rs.idx(_479[0], 0); - _479[0].data[_479[0].start] = copy$array_array2_u8(kept9); - const _576: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_479[0]), rs.sliceFrom); + rs.arraySliceSet(rs.arraySliceAt(_479[0], 0), copy$array_array2_u8(kept9)); + const _576: rs.ArraySlice | undefined = rs.arraySliceLast(_479[0]); if (_576 !== undefined) { - rs.sliceSet(_576, [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]); + rs.arraySliceSet(_576, [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]); } - 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]; + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_479[0]), (c17: rs.ArraySlice): rs.u8 => { + const slice38 = rs.arraySliceAt(c17, 0); + const _353: rs.u8 = slice38.data[slice38.start]; + const slice39 = rs.arraySliceAt(c17, 1); + return _353 ^ slice39.data[slice39.start + 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 _586: rs.ArraySlice> = rs.arraySliceRange(_479[0], rs.usizeDiv(n4, 2)); + const _590: Uint8Array[] = [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]; + rs.arraySliceBy(_586, (arrays29) => rs.sliceFill(arrays29, _590, 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 _600: [rs.ArraySlice>>, rs.ArraySlice>] = rs.sliceAsChunks(rs.sliceAsChunks(rs.sliceAsChunks(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 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 _615: [Uint8Array[][], Uint8Array[][]] = [rs.arraySliceToArray(rs.arraySliceAt(_600[0], 0), (s) => rs.arraySliceToArray(s, rs.byteSliceToArray)), rs.arraySliceToArray(rs.arraySliceAt(_600[0], _600[0].length - 1), (s) => rs.arraySliceToArray(s, rs.byteSliceToArray))]; + const first5: Uint8Array[][] = copy$array_array2_array2_u8(_615[0]); + const last5: Uint8Array[][] = copy$array_array2_array2_u8(_615[1]); + rs.arraySliceSwap(_600[0], 0, rs.usizeSub(_600[0].length, 1), undefined); + rs.arraySliceBy(_600[0], (arrays30) => rs.sliceReverse(arrays30)); const n5: rs.usize = _600[0].length; - rs.sliceReverse(rs.sliceRange(_600[0], 1)); - rs.sliceRotateLeft(_600[0], 1); - rs.sliceRotateRight(_600[0], rs.usizeDiv(n5, 2)); + rs.arraySliceBy(rs.arraySliceRange(_600[0], 1), (arrays31) => rs.sliceReverse(arrays31)); + rs.arraySliceBy(_600[0], (arrays32) => rs.sliceRotateLeft(arrays32, 1)); + const _631: rs.usize = rs.usizeDiv(n5, 2); + rs.arraySliceBy(_600[0], (arrays33) => rs.sliceRotateRight(arrays33, _631)); const _634: rs.usize = rs.usizeSub(n5, 1); rs.idx(_600[0], _634); - const kept10: Uint8Array[][] = copy$array_array2_array2_u8(_600[0].data[_600[0].start + _634]); + const kept10: Uint8Array[][] = rs.arraySliceToArray(rs.arraySliceAt(_600[0], _634), (s) => rs.arraySliceToArray(s, rs.byteSliceToArray)); 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.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]; + rs.arraySliceCopyWithin(_600[0], 0, _640.end, 1, copy$array_array2_array2_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom([copy$array_array2_array2_u8(first5), copy$array_array2_array2_u8(last5), copy$array_array2_array2_u8(kept10)], rs.arraySliceOf(rs.arraySliceOf(rs.byteSliceFrom)))), (c18: rs.ArraySlice>): rs.u8 => { + const slice44 = rs.arraySliceAt(rs.arraySliceAt(c18, 0), 0); + const _356: rs.u8 = slice44.data[slice44.start]; + const slice46 = rs.arraySliceAt(rs.arraySliceAt(c18, 1), 1); + return _356 ^ slice46.data[slice46.start + 1]; }), undefined, true); - rs.sliceSort(_600[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true); - 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]; + rs.arraySliceBy(_600[0], (arrays34) => rs.sliceSort(arrays34, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_600[0]), (c19: rs.ArraySlice>): rs.u8 => { + const slice48 = rs.arraySliceAt(rs.arraySliceAt(c19, 0), 0); + const _357: rs.u8 = slice48.data[slice48.start]; + const slice50 = rs.arraySliceAt(rs.arraySliceAt(c19, 1), 1); + return _357 ^ slice50.data[slice50.start + 1]; }), undefined, true); - const f8 = (c20: rs.Slice): Uint8Array[] => { - return copy$array_array2_u8(c20.data[c20.start + 1]); + const f8 = (c20: rs.ArraySlice>): Uint8Array[] => { + return rs.arraySliceToArray(rs.arraySliceAt(c20, 1), rs.byteSliceToArray); }; - 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); - const f9 = (c21: rs.Slice): Uint8Array[] => { - return copy$array_array2_u8(c21.data[c21.start]); + rs.arraySliceBy(_600[0], (arrays35) => rs.sliceSort(arrays35, rs.keyLt((held8) => f8(rs.arraySliceOf(rs.arraySliceOf(rs.byteSliceFrom))(held8)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)))), 8, true)); + rs.arraySliceBy(_600[0], (arrays36) => rs.sliceSortUnstable(arrays36, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true, true)); + const f9 = (c21: rs.ArraySlice>): Uint8Array[] => { + return rs.arraySliceToArray(rs.arraySliceAt(c21, 0), rs.byteSliceToArray); }; - 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.arraySliceBy(_600[0], (arrays37) => rs.sliceSortByCachedKey(arrays37, (held9) => f9(rs.arraySliceOf(rs.arraySliceOf(rs.byteSliceFrom))(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.ArraySlice>>, rs.ArraySlice>>] = rs.arraySliceSplitAt(_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); - 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)); + const slice51 = rs.arraySliceAt(_659[0], 0); + const slice52 = rs.arraySliceAt(_659[1], _667); + rs.arraySliceSet(slice52, rs.arraySliceReplace(slice51, rs.arraySliceToArray(slice52, (s) => rs.arraySliceToArray(s, rs.byteSliceToArray)))); rs.idx(_600[0], 0); - const old5: Uint8Array[][] = rs.replaceIn(rs.sliceView(rs.sliceFrom(_600[0].data[_600[0].start])), copy$array_array2_array2_u8(one), 2); + const old5: Uint8Array[][] = rs.arraySliceReplace(rs.arraySliceAt(_600[0], 0), copy$array_array2_array2_u8(one)); 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); + rs.arraySliceSet(rs.arraySliceAt(_600[0], _678), copy$array_array2_array2_u8(old5)); rs.idx(_600[0], 1); - const kept11: Uint8Array[][] = copy$array_array2_array2_u8(_600[0].data[_600[0].start + 1]); + const kept11: Uint8Array[][] = rs.arraySliceToArray(rs.arraySliceAt(_600[0], 1), (s) => rs.arraySliceToArray(s, rs.byteSliceToArray)); rs.idx(_600[0], 0); - const _688: Uint8Array[][] = copy$array_array2_array2_u8(_600[0].data[_600[0].start]); + const _688: Uint8Array[][] = rs.arraySliceToArray(rs.arraySliceAt(_600[0], 0), (s) => rs.arraySliceToArray(s, rs.byteSliceToArray)); rs.idx(_600[0], 1); - _600[0].data[_600[0].start + 1] = _688; + rs.arraySliceSet(rs.arraySliceAt(_600[0], 1), _688); rs.idx(_600[0], 0); - _600[0].data[_600[0].start] = copy$array_array2_array2_u8(kept11); - const _701: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_600[0]), rs.sliceFrom); + rs.arraySliceSet(rs.arraySliceAt(_600[0], 0), copy$array_array2_array2_u8(kept11)); + const _701: rs.ArraySlice> | undefined = rs.arraySliceLast(_600[0]); 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); })); - rs.sliceSet(_701, Array.from({ length: 2 }, (): Uint8Array[] => { + rs.arraySliceSet(_701, Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array2_u8(item); })); } - 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]; + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_600[0]), (c22: rs.ArraySlice>): rs.u8 => { + const slice58 = rs.arraySliceAt(rs.arraySliceAt(c22, 0), 0); + const _367: rs.u8 = slice58.data[slice58.start]; + const slice60 = rs.arraySliceAt(rs.arraySliceAt(c22, 1), 1); + return _367 ^ slice60.data[slice60.start + 1]; }), undefined, true); - const _711: rs.Slice = rs.sliceRange(_600[0], rs.usizeDiv(n5, 2)); + const _711: rs.ArraySlice>> = rs.arraySliceRange(_600[0], rs.usizeDiv(n5, 2)); const _717: Uint8Array = rs.bytes(2).fill(9); const item2 = copy$array_array2_u8(Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_717); })); - rs.sliceFill(_711, Array.from({ length: 2 }, (): Uint8Array[] => { + const _715: Uint8Array[][] = Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array2_u8(item2); - }), copy$array_array2_array2_u8); + }); + rs.arraySliceBy(_711, (arrays38) => rs.sliceFill(arrays38, _715, copy$array_array2_array2_u8)); } const backing: rs.Vec = rs.vecFrom(words.items.slice()); const refs: rs.Vec> = rs.iterToVec(rs.sliceChunks(rs.sliceFrom(backing.items), 1), undefined, 8, true); - const _729: [rs.Slice[][]>, rs.Slice[]>] = rs.sliceAsChunksMut(rs.sliceAsChunksMut(rs.sliceFrom(refs.items), 2)[0], 2); + const _729: [rs.ArraySlice>>>, rs.ArraySlice>>] = rs.sliceAsChunks(rs.sliceAsChunks(rs.sliceFrom(refs.items), 2)[0], 2); if (_729[0].length >= 2) { - rs.sliceSwap(_729[0], 0, 1); + rs.arraySliceSwap(_729[0], 0, 1, undefined); } const iter6: rs.Iter<[rs.usize, rs.Place>]> = rs.iterEnumerate(rs.iterSliceMut(rs.sliceFrom(refs.items))); while (true) { @@ -2677,103 +2707,114 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const w: rs.u16 = _24; return (w ^ (w >> 8)) & 0xff; }), undefined, true); - const _760: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.sliceAsChunksMut(rs.sliceFrom(words.items), 2)[0], 2); + const _760: [rs.ArraySlice>>, rs.ArraySlice>] = rs.sliceAsChunks(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0], 2); if (_760[0].length >= 2) { - 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 _768: [rs.u16[][], rs.u16[][]] = [rs.arraySliceToArray(rs.arraySliceAt(_760[0], 0), rs.sliceToArray), rs.arraySliceToArray(rs.arraySliceAt(_760[0], _760[0].length - 1), rs.sliceToArray)]; + const first6: rs.u16[][] = copy$array_array2_u16(_768[0]); + const last6: rs.u16[][] = copy$array_array2_u16(_768[1]); + rs.arraySliceSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1), undefined); + rs.arraySliceBy(_760[0], (arrays39) => rs.sliceReverse(arrays39)); const n6: rs.usize = _760[0].length; - rs.sliceReverse(rs.sliceRange(_760[0], 1)); - rs.sliceRotateLeft(_760[0], 1); - rs.sliceRotateRight(_760[0], rs.usizeDiv(n6, 2)); + rs.arraySliceBy(rs.arraySliceRange(_760[0], 1), (arrays40) => rs.sliceReverse(arrays40)); + rs.arraySliceBy(_760[0], (arrays41) => rs.sliceRotateLeft(arrays41, 1)); + const _784: rs.usize = rs.usizeDiv(n6, 2); + rs.arraySliceBy(_760[0], (arrays42) => rs.sliceRotateRight(arrays42, _784)); const _787: rs.usize = rs.usizeSub(n6, 1); rs.idx(_760[0], _787); - const kept12: rs.u16[][] = copy$array_array2_u16(_760[0].data[_760[0].start + _787]); + const kept12: rs.u16[][] = rs.arraySliceToArray(rs.arraySliceAt(_760[0], _787), rs.sliceToArray); 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.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; + rs.arraySliceCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom([copy$array_array2_u16(first6), copy$array_array2_u16(last6), copy$array_array2_u16(kept12)], rs.arraySliceOf(rs.sliceFrom))), (c23: rs.ArraySlice>): rs.u8 => { + const slice64 = rs.arraySliceAt(c23, 0); + const _415: rs.u16 = slice64.data[slice64.start]; + const slice65 = rs.arraySliceAt(c23, 1); + return (_415 ^ slice65.data[slice65.start + 1]) & 0xff; }), undefined, true); - rs.sliceSort(_760[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true); - 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; + rs.arraySliceBy(_760[0], (arrays43) => rs.sliceSort(arrays43, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_760[0]), (c24: rs.ArraySlice>): rs.u8 => { + const slice66 = rs.arraySliceAt(c24, 0); + const _416: rs.u16 = slice66.data[slice66.start]; + const slice67 = rs.arraySliceAt(c24, 1); + return (_416 ^ slice67.data[slice67.start + 1]) & 0xff; }), undefined, true); - const f10 = (c25: rs.Slice): rs.u16[] => { - return copy$array_u16(c25.data[c25.start + 1]); + const f10 = (c25: rs.ArraySlice>): rs.u16[] => { + return rs.sliceToArray(rs.arraySliceAt(c25, 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); - const f11 = (c26: rs.Slice): rs.u16[] => { - return copy$array_u16(c26.data[c26.start]); + rs.arraySliceBy(_760[0], (arrays44) => rs.sliceSort(arrays44, rs.keyLt((held10) => f10(rs.arraySliceOf(rs.sliceFrom)(held10)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmp)))), 8, true)); + rs.arraySliceBy(_760[0], (arrays45) => rs.sliceSortUnstable(arrays45, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true, true)); + const f11 = (c26: rs.ArraySlice>): rs.u16[] => { + return rs.sliceToArray(rs.arraySliceAt(c26, 0)); }; - 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.arraySliceBy(_760[0], (arrays46) => rs.sliceSortByCachedKey(arrays46, (held11) => f11(rs.arraySliceOf(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.ArraySlice>>, rs.ArraySlice>>] = rs.arraySliceSplitAt(_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); - 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)); + const slice68 = rs.arraySliceAt(_812[0], 0); + const slice69 = rs.arraySliceAt(_812[1], _820); + rs.arraySliceSet(slice69, rs.arraySliceReplace(slice68, rs.arraySliceToArray(slice69, rs.sliceToArray))); rs.idx(_760[0], 0); - 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 old6: rs.u16[][] = rs.arraySliceReplace(rs.arraySliceAt(_760[0], 0), _831); 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); + rs.arraySliceSet(rs.arraySliceAt(_760[0], _834), copy$array_array2_u16(old6)); rs.idx(_760[0], 1); - const kept13: rs.u16[][] = copy$array_array2_u16(_760[0].data[_760[0].start + 1]); + const kept13: rs.u16[][] = rs.arraySliceToArray(rs.arraySliceAt(_760[0], 1), rs.sliceToArray); rs.idx(_760[0], 0); - const _844: rs.u16[][] = copy$array_array2_u16(_760[0].data[_760[0].start]); + const _844: rs.u16[][] = rs.arraySliceToArray(rs.arraySliceAt(_760[0], 0), rs.sliceToArray); rs.idx(_760[0], 1); - _760[0].data[_760[0].start + 1] = _844; + rs.arraySliceSet(rs.arraySliceAt(_760[0], 1), _844); rs.idx(_760[0], 0); - _760[0].data[_760[0].start] = copy$array_array2_u16(kept13); - const _857: rs.Slice | undefined = rs.optionMap(rs.sliceLast(_760[0]), rs.sliceFrom); + rs.arraySliceSet(rs.arraySliceAt(_760[0], 0), copy$array_array2_u16(kept13)); + const _857: rs.ArraySlice> | undefined = rs.arraySliceLast(_760[0]); if (_857 !== undefined) { - rs.sliceSet(_857, [[5, 6], [7, 8]]); + rs.arraySliceSet(_857, [[5, 6], [7, 8]]); } - 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; + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_760[0]), (c27: rs.ArraySlice>): rs.u8 => { + const slice74 = rs.arraySliceAt(c27, 0); + const _417: rs.u16 = slice74.data[slice74.start]; + const slice75 = rs.arraySliceAt(c27, 1); + return (_417 ^ slice75.data[slice75.start + 1]) & 0xff; }), undefined, true); - rs.sliceFill(rs.sliceRange(_760[0], rs.usizeDiv(n6, 2)), [[5, 6], [7, 8]], copy$array_array2_u16); + const _867: rs.ArraySlice>> = rs.arraySliceRange(_760[0], rs.usizeDiv(n6, 2)); + const _871: rs.u16[][] = [[5, 6], [7, 8]]; + rs.arraySliceBy(_867, (arrays47) => rs.sliceFill(arrays47, _871, copy$array_array2_u16)); } } else if (_12 === 3) { - const _875: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.sliceFrom(items.items), 2); + const _875: [rs.ArraySlice>, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(items.items), 2); if (_875[0].length >= 2) { rs.idx(_875[0], 0); - 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); + const first7: Item.Item[] = rs.replaceIn(rs.sliceView(rs.arraySliceAt(_875[0], 0)), [new Item.Item(65), new Item.Item(66)], 1); flush(out); - rs.sliceSwap(_875[0], 0, 1); - rs.sliceReverse(_875[0]); + rs.arraySliceSwap(_875[0], 0, 1, rs.objectCopy); + rs.arraySliceBy(_875[0], (arrays) => rs.sliceReverse(arrays), rs.objectCopy); 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.arraySliceBy(_875[0], (arrays2) => rs.sliceSort(arrays2, rs.keyLt((held) => f(rs.sliceFrom(held)), rs.lt), 2, true), rs.objectCopy); rs.idx(_875[0], 1); - rs.dropAll(_875[0].data[_875[0].start + 1]); - _875[0].data[_875[0].start + 1] = first13; + rs.dropAll(rs.arraySliceAt(_875[0], 1)); + rs.sliceSet(rs.arraySliceAt(_875[0], 1), first7); flush(out); rs.idx(_875[0], 0); - _875[0].data[_875[0].start][1][Symbol.dispose](); - _875[0].data[_875[0].start][1] = new Item.Item(67); + const slice4 = rs.arraySliceAt(_875[0], 0); + slice4.data[slice4.start + 1][Symbol.dispose](); + const slice5 = rs.arraySliceAt(_875[0], 0); + slice5.data[slice5.start + 1] = new Item.Item(67); flush(out); - const _909: [rs.Slice, rs.Slice] = rs.sliceSplitAt(_875[0], 1); + const _909: [rs.ArraySlice>, rs.ArraySlice>] = rs.arraySliceSplitAt(_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); - 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 => { + const slice6 = rs.arraySliceAt(_909[0], 0); + const slice7 = rs.arraySliceAt(_909[1], 0); + rs.sliceSet(slice7, rs.replaceIn(rs.sliceView(slice6), rs.sliceToArray(slice7), 1)); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_875[0]), (c2: rs.Slice): rs.u8 => { return _11(c2); }), undefined, true); } } else { - const _929: [rs.Slice, rs.ByteSlice] = rs.byteSliceAsChunksMut(rs.byteSliceRange(rs.byteVecSlice(bytes), 0, 0), 4); + const _929: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteSliceRange(rs.byteVecSlice(bytes), 0, 0), 4); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_929[0].length & 0xff, _929[1].length & 0xff)), undefined, true); rs.byteVecPush(out, runsMut$0(rs.byteVecSlice(bytes))); } @@ -2789,4 +2830,356 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi flush(out); } +/** Puts each run's bytes. */ +export function putRuns$2(runs: rs.ArraySlice, out: rs.ByteVec): void { + rs.byteVecPush(out, runs.length & 0xff); + const iter: rs.Iter = rs.arraySliceIter(runs); + while (true) { + const _8: rs.ByteSlice | rs.Done = iter.next(); + if (_8 === rs.DONE) { + break; + } + rs.byteVecExtendFromSlice(out, _8); + } +} + +/** Slices of arrays in each form they take, each read after. */ +export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let a!: rs.Slice>; + const byte: (a0: rs.usize) => rs.u8 = (at: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, at), at & 0xff); + }; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _33: rs.u8 = c.data[c.start]; + rs.idx(c, 1); + return Uint8Array.of(_33, c.data[c.start + 1]); + }), undefined, 2, true); + const _8: rs.u8 = rs.u8Rem(kind, 8); + if (_8 === 0) { + const cell: rs.Cell = new rs.Cell(byte(0)); + const other: rs.Cell = new rs.Cell(byte(1)); + let r: rs.Cell = cell; + a = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); + const copy: rs.Cell[] = rs.sliceToArray(a); + const runs: rs.ArraySlice>> = rs.arraySliceOne(a, 1); + const _25: rs.Cell[][] = [[other]]; + const _24: rs.Cell[][] = rs.arraySliceReplace(runs, _25); + const _30: rs.u8 = byte(2); + rs.cellSet(cell, _30); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(copy[0].v, _24[0][0].v, r.v)), undefined, true); + const refs: rs.Cell[][] = [[cell], [other]]; + rs.arraySliceSwap(rs.arraySliceFrom(refs, rs.sliceFrom), 0, 1, undefined); + const _51: rs.u8 = byte(3); + rs.cellSet(other, _51); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(refs[0][0].v, refs[1][0].v)), undefined, true); + } else if (_8 === 1) { + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p4: rs.ByteSlice): rs.String[] => { + const arg = p4.data[p4.start]; + const _310: rs.String = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0); + const arg2 = p4.data[p4.start + 1]; + return [_310, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg2, f), 0)]; + }), undefined, 24, true); + const part = rs.min(words.items.length, 1); + const cloned: rs.Vec = rs.vecFrom(rs.arraySliceItems(rs.arraySliceRange(rs.arraySliceFrom(words.items, rs.sliceFrom), part)).map((a: rs.String[]) => a.map((a0: rs.String): rs.String => { + return rs.stringClone(a0); + }))); + rs.byteVecPush(out, cloned.items.length & 0xff); + const iter: rs.Iter> = rs.iterLend(rs.iterSlice(cloned.items), rs.sliceFrom); + while (true) { + const _85: rs.Slice | rs.Done = iter.next(); + if (_85 === rs.DONE) { + break; + } + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(_85.data[_85.start].v), rs.strBytes(_85.data[_85.start + 1].v)), undefined, true); + } + const boxed: rs.ArraySlice = rs.arraySliceFrom(rs.vecFrom(pairs.items.map(copy$array_u8)).items, rs.byteSliceFrom); + putRuns$2(rs.arraySliceFrom(rs.arraySliceItems(boxed).map(copy$array_u8), rs.byteSliceFrom), out); + putRuns$2(rs.arraySliceFrom(rs.vecFrom(rs.arraySliceItems(boxed)).items, rs.byteSliceFrom), out); + } else if (_8 === 2) { + putRuns$2(rs.arraySliceFrom([Uint8Array.of(1, 2), Uint8Array.of(3, 4)], rs.byteSliceFrom), out); + putRuns$2(rs.arraySliceFrom([], rs.byteSliceFrom), out); + putRuns$2(rs.optionAsArraySlice(copy$Option_array2_u8(rs.optionMap(rs.arraySliceFirst(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceView)), rs.byteSliceFrom), out); + putRuns$2(rs.optionAsArraySlice(undefined, rs.byteSliceFrom), out); + } else if (_8 === 3) { + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOrDefault$0h81s8g(View.last$array2_u8({ view: rs.arraySliceFrom(pairs.items, rs.byteSliceFrom) }))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(option_unwrapOrDefault$1n9qa5p(View.last$array2_u16({ view: rs.arraySliceFrom(rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p3: rs.ByteSlice): rs.u16[] => { + return [p3.data[p3.start] as rs.u16, p3.data[p3.start + 1] as rs.u16]; + }), undefined, 4, true).items, rs.sliceFrom) })), (w: rs.u16): rs.u8 => { + return w & 0xff; + })), undefined, true); + } else if (_8 === 4) { + rs.iterExtendBytes(out, rs.iterSlice(copy$mem_MaybeUninit_array_u8(rs.sliceToArray(rs.sliceFrom([Uint8Array.of(byte(0), byte(1))]), copy$mem_MaybeUninit_array_u8)[0])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceToArray(rs.byteSliceFrom(rs.sliceToArray(rs.sliceFrom([Uint8Array.of(byte(2), byte(3))]), copy$array_u8)[0]))), undefined, true); + } else if (_8 === 5) { + const borrowed: rs.Cow> = new rs.Borrowed(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)); + putRuns$2(rs.cowArraySlice(borrowed, rs.byteSliceFrom), out); + let owned: rs.Cow> = rs.cowClone(borrowed, copy$array_u8); + const owned2 = rs.cowIntoOwned(owned, copy$array_u8); + owned = owned2; + const _183: rs.ByteSlice | undefined = rs.arraySliceFirst(rs.arraySliceFrom(owned2.items, rs.byteSliceFrom)); + if (_183 !== undefined) { + _183.data[_183.start] = _183.data[_183.start] ^ 255; + } + putRuns$2(rs.cowArraySlice(owned, rs.byteSliceFrom), out); + putRuns$2(rs.cowArraySlice(borrowed, rs.byteSliceFrom), out); + putRuns$2(rs.arraySliceFrom(rs.cowIntoOwned(borrowed, copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.cowArraySlice(rs.vecFrom(pairs.items.map(copy$array_u8)), rs.byteSliceFrom), out); + } else if (_8 === 6) { + const some2: Uint8Array | undefined = copy$Option_array2_u8(copy$Option_array2_u8(rs.optionMap(rs.arraySliceFirst(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceView))); + const _211: rs.ByteSlice | undefined = rs.arraySliceFirst(some2 === undefined ? rs.arraySliceFrom([], rs.byteSliceFrom) : rs.arraySliceFrom([some2], rs.byteSliceFrom)); + if (_211 !== undefined) { + _211.data[_211.start + 1] = _211.data[_211.start + 1] ^ 90; + } + putRuns$2(rs.optionAsArraySlice(some2, rs.byteSliceFrom), out); + const _227 = undefined as Uint8Array | undefined; + rs.byteVecPush(out, (_227 === undefined ? rs.arraySliceFrom([], rs.byteSliceFrom) : rs.arraySliceFrom([_227], rs.byteSliceFrom)).length & 0xff); + putRuns$2(rs.cowArraySlice(new rs.Borrowed(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceFrom), out); + const wrapped2: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (_2: rs.ByteSlice): Uint8Array => { + return copy$array_u8(rs.byteSliceToArray(_2)); + }), undefined, 2, true); + putRuns$2(rs.arraySliceOfSlice(rs.sliceFrom(wrapped2.items), rs.byteSliceFrom), out); + const _242: rs.ByteSlice | undefined = rs.arraySliceLast(rs.arraySliceOfSlice(rs.sliceFrom(wrapped2.items), rs.byteSliceFrom)); + if (_242 !== undefined) { + const _248: rs.u8 = rs.u8WrappingAdd(_242.data[_242.start], 1); + _242.data[_242.start] = _248; + } + putRuns$2(rs.arraySliceOfSlice(rs.sliceFrom(wrapped2.items), rs.byteSliceFrom), out); + const boxed2: rs.Slice = rs.sliceNewUninit(pairs.items.length, 2, (): Uint8Array => { + return (new Uint8Array(2) as unknown) as Uint8Array; + }); + const iter2: rs.Iter<[Uint8Array, rs.ByteSlice]> = rs.iterZip(rs.iterSlice(rs.sliceItems(boxed2)), rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), [false, false]); + while (true) { + const _267: [Uint8Array, rs.ByteSlice] | rs.Done = iter2.next(); + if (_267 === rs.DONE) { + break; + } + const uninit = _267[0]; + rs.ptrWrite(uninit, copy$array_u8(rs.byteSliceToArray(_267[1]))); + rs.byteSliceFrom(uninit); + } + putRuns$2(rs.arraySliceOfSlice(boxed2, rs.byteSliceFrom), out); + const half: rs.usize = rs.usizeDiv(pairs.items.length, 2); + putRuns$2(rs.arraySliceFrom(rs.slicesJoin(rs.sliceFrom([rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), half)]), 2, undefined, rs.arraySliceAsSlice, copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.arraySliceFrom(rs.slicesJoin(rs.sliceFrom([new rs.Borrowed(rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), 0, half)), rs.vecFrom(rs.arraySliceItems(rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), half)).map(copy$array_u8))]), 2, undefined, (c) => rs.arraySliceAsSlice(rs.cowArraySlice(c, rs.byteSliceFrom)), copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.arraySliceFrom(rs.slicesJoin(rs.sliceFrom([rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.arraySliceAsSlice(rs.arraySliceOne(rs.byteSliceFrom(Uint8Array.of(238, 255)), 2)), rs.arraySliceAsSlice, copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.arraySliceFrom(rs.slicesJoin(rs.sliceFrom([rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.arraySliceRange(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.arraySliceAsSlice(rs.arraySliceFrom([Uint8Array.of(221, 204), Uint8Array.of(187, 170)], rs.byteSliceFrom)), rs.arraySliceAsSlice, copy$array_u8).items, rs.byteSliceFrom), out); + } else { + let item: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(byte(0))); + const runs2: rs.ArraySlice> = rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => item, (value) => item = value)), 1); + rs.idx(runs2, 0); + const _354: rs.ByteVec[] = [rs.byteVecFrom(Uint8Array.of(byte(1), byte(2)))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.replaceIn(rs.sliceView(rs.arraySliceAt(runs2, 0)), _354, 1)[0])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => item, (value2) => item = value2)), 1), rs.objectCopy), [[rs.byteVecFrom(Uint8Array.of(byte(3)))]])[0][0])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(item)), undefined, true); + } +} + +/** Whether a callback std lends each row of `rows` gets that row itself, by `ptr::eq`. */ +export function lentRows$2(rows: rs.ArraySlice, out: rs.ByteVec): void { + const iter: rs.Iter = rs.arraySliceIter(rows); + while (true) { + const _5: rs.ByteSlice | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + let lent: boolean = false; + const _11: (a0: rs.ByteSlice) => rs.Ordering = (row: rs.ByteSlice): rs.Ordering => { + const _32: boolean = rs.byteSliceSame(row, _5); + lent = lent || _32; + return rs.cmpBytes(row, _5); + }; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceBinarySearchBy(rs.arraySliceAsSlice(rows), (held) => _11(rs.byteSliceFrom(held))).ok ? 1 : 0, lent ? 1 : 0)), undefined, true); + } +} + +/** The same as [`lent_rows`], for rows of words and of arrays. */ +export function lentWords(rows: rs.ArraySlice>, nested: rs.ArraySlice>, out: rs.ByteVec): void { + const iter: rs.Iter> = rs.arraySliceIter(rows); + while (true) { + const _6: rs.Slice | rs.Done = iter.next(); + if (_6 === rs.DONE) { + break; + } + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.arraySliceIter(rows), (row: rs.Slice): boolean => { + return rs.sliceSame(row, _6); + })) & 0xff); + const _19: (a0: rs.Slice) => boolean = (row2: rs.Slice): boolean => { + if (!rs.sliceSame(row2, _6)) { + return rs.cmpSlice(rs.cmp)(row2, _6) === -1; + } + return false; + }; + rs.byteVecPush(out, rs.slicePartitionPoint(rs.arraySliceAsSlice(rows), (held) => _19(rs.sliceFrom(held))) & 0xff); + let lent: boolean = false; + const _22: (a0: rs.Slice) => rs.Ordering = (row3: rs.Slice): rs.Ordering => { + const _33: boolean = rs.sliceSame(row3, _6); + lent = lent || _33; + return rs.cmpSlice(rs.cmp)(row3, _6); + }; + rs.sliceBinarySearchBy(rs.arraySliceAsSlice(rows), (held2) => _22(rs.sliceFrom(held2))); + rs.byteVecPush(out, lent ? 1 : 0); + } + const iter2: rs.Iter> = rs.arraySliceIter(nested); + while (true) { + const _29: rs.ArraySlice | rs.Done = iter2.next(); + if (_29 === rs.DONE) { + break; + } + let lent2: boolean = false; + const _35: (a0: rs.ArraySlice) => rs.Ordering = (row4: rs.ArraySlice): rs.Ordering => { + const _36: boolean = rs.arraySliceSame(row4, _29); + lent2 = lent2 || _36; + return rs.cmpSlice(rs.cmpBytes)(row4, _29); + }; + rs.sliceBinarySearchBy(rs.arraySliceAsSlice(nested), (held3) => _35(rs.arraySliceOf(rs.byteSliceFrom)(held3))); + rs.byteVecPush(out, lent2 ? 1 : 0); + } +} + +/** + * Rows of slices of arrays as std reads them: lent to a callback as themselves, and a + * `join`'s separator cloned where it is. + */ +export function arrayIdentity(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const rows: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _3: rs.u8 = c.data[c.start]; + rs.idx(c, 1); + return Uint8Array.of(_3, c.data[c.start + 1]); + }), undefined, 2, true); + rs.arraySliceBy(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), (arrays) => rs.sliceSort(arrays, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.vecDedupBy(rows, rs.eqBytes); + if (rs.u8Rem(kind, 2) === 0) { + lentRows$2(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); + const part3 = rs.usizeDiv(rows.items.length, 2); + lentRows$2(rs.arraySliceRange(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), part3), out); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (r2: rs.ByteSlice): rs.u16[] => { + return [r2.data[r2.start] as rs.u16, r2.data[r2.start + 1] as rs.u16]; + }), undefined, 4, true); + const nested: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceWindows(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), 2), (w: rs.ArraySlice): Uint8Array[] => { + rs.idx(w, 0); + const _310: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(w, 0)); + rs.idx(w, 1); + return [_310, rs.byteSliceToArray(rs.arraySliceAt(w, 1))]; + }), undefined, 4, true); + const part4 = rs.min(words.items.length, 1); + const _36: rs.ArraySlice> = rs.arraySliceRange(rs.arraySliceFrom(words.items, rs.sliceFrom), part4); + const part5 = rs.usizeDiv(nested.items.length, 2); + lentWords(_36, rs.arraySliceRange(rs.arraySliceFrom(nested.items, rs.arraySliceOf(rs.byteSliceFrom)), part5), out); + } else { + const away: rs.Cell = new rs.Cell(undefined as Probe.Probe | undefined); + const probes: (a0: rs.usize) => rs.Vec = (at: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceRange(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), at)), (r: rs.ByteSlice): Probe.Probe[] => { + return [{ tag: r.data[r.start] & 254, home: away }]; + }), undefined, 8, true); + }; + const _57: rs.Vec = probes(0); + const _56: [rs.Vec, rs.Vec] = [_57, probes(rs.usizeDiv(rows.items.length, 2))]; + const a: rs.Vec = _57; + const b: rs.Vec = _56[1]; + const home: rs.Cell = new rs.Cell(undefined as Probe.Probe | undefined); + const sep: Probe.Probe[] = [{ tag: 238, home }]; + rs.cellSet(home, sep[0]); + const _82: rs.ArraySlice> = rs.arraySliceFrom(a.items, rs.sliceFrom); + const _84: rs.ArraySlice> = rs.arraySliceFrom(b.items, rs.sliceFrom); + const part2 = rs.min(1, a.items.length); + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rs.slicesJoin(rs.sliceFrom([_82, _84, rs.arraySliceRange(rs.arraySliceFrom(a.items, rs.sliceFrom), 0, part2)]), 8, rs.arraySliceAsSlice(rs.arraySliceOne(rs.sliceFrom(sep), 1)), rs.arraySliceAsSlice, (a: Probe.Probe[]) => a.map(Probe.clone$Clone)).items, rs.sliceFrom)), (_2: rs.Slice): rs.u8 => { + return _2.data[_2.start].tag; + }), undefined, true); + flush(out); + } +} + +/** Slices of arrays std's collections and pointers hand out, each read and written after. */ +export function arraySources(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const rows: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _3: rs.u8 = c.data[c.start]; + rs.idx(c, 1); + return Uint8Array.of(_3, c.data[c.start + 1]); + }), undefined, 2, true); + const _7: rs.u8 = rs.u8Rem(kind, 5); + if (_7 === 0) { + const q: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true), 2) as rs.VecDeque; + const _14: rs.ByteSlice | undefined = rs.arraySliceFirst(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)); + if (_14 !== undefined) { + rs.dequePushFront(q, copy$array_u8(rs.byteSliceToArray(_14))); + rs.dequeRotate(q, rs.usizeDiv(q.n, 2)); + } + const _29: [rs.ArraySlice, rs.ArraySlice] = rs.dequeArraySlices(q, rs.byteSliceFrom); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_29[0].length & 0xff, _29[1].length & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterChain(rs.iterOption(rs.arraySliceFirst(_29[0])), rs.iterOption(rs.arraySliceLast(_29[1]))), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const _45: [rs.ArraySlice, rs.ArraySlice] = rs.dequeArraySlices(q, rs.byteSliceFrom); + const _47: rs.ByteSlice | undefined = option_or$0as8tia(rs.arraySliceLast(_45[0]), rs.arraySliceFirst(_45[1])); + if (_47 !== undefined) { + _47.data[_47.start] = _47.data[_47.start] ^ 51; + } + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.dequeArrayMakeContiguous(q, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const _60: rs.ByteSlice | undefined = rs.arraySliceFirst(rs.dequeArrayMakeContiguous(q, rs.byteSliceFrom)); + if (_60 !== undefined) { + _60.data[_60.start + 1] = _60.data[_60.start + 1] ^ 68; + } + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.dequeIter(q), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const words: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), (r: rs.ByteSlice): rs.u16[] => { + return [r.data[r.start] as rs.u16, r.data[r.start + 1] as rs.u16]; + }), undefined, 4, true), 4) as rs.VecDeque; + rs.dequeRotate(words, rs.usizeDiv(words.n, 3), true); + const _84: [rs.ArraySlice>, rs.ArraySlice>] = rs.dequeArraySlices(words, rs.sliceFrom); + rs.iterExtendBytes(out, rs.iterMap(rs.iterFlatten(rs.iterChain(rs.arraySliceIter(_84[0]), rs.arraySliceIter(_84[1])), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2), (_2: rs.u16): rs.u8 => { + return _2 & 0xff; + }), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterFlatten(rs.arraySliceIter(rs.dequeArrayMakeContiguous(words, rs.sliceFrom)), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2), (_22: rs.u16): rs.u8 => { + return _22 & 0xff; + }), undefined, true); + } else if (_7 === 1) { + const raw: rs.RawArraySlice = rs.rawArraySliceOf(rs.arraySliceFrom(rs.vecFrom(rows.items.map(copy$array_u8)).items, rs.byteSliceFrom)); + rs.byteVecPush(out, raw.deref().length & 0xff); + const _106: rs.ByteSlice | undefined = rs.arraySliceFirst(raw.deref()); + if (_106 !== undefined) { + _106.data[_106.start] = _106.data[_106.start] ^ 85; + } + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(raw.deref()), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const owned: rs.Vec = rs.vecFrom(rows.items.map(copy$array_u8)); + const _122: rs.ByteSlice | undefined = rs.arraySliceLast(rs.rawArraySliceOf(rs.arraySliceFrom(owned.items, rs.byteSliceFrom)).deref()); + if (_122 !== undefined) { + _122.data[_122.start + 1] = _122.data[_122.start + 1] ^ 102; + } + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(owned.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + } else if (_7 === 2) { + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceFrom(rs.heapFrom(rs.iterToVec(rs.iterCopied(rs.arraySliceIter(rs.arraySliceFrom(rows.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const shared: rs.Arc> = new rs.Arc(rs.arraySliceFrom(rs.vecFrom(rows.items.map(copy$array_u8)).items, rs.byteSliceFrom)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterRev(rs.arraySliceIter(shared.value)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + shared[Symbol.dispose](); + } else if (_7 === 3) { + const row: (a0: rs.usize) => Uint8Array = (at: rs.usize): Uint8Array => { + return option_unwrapOr$1la41a6(copy$Option_array2_u8(rs.optionMap(rs.arraySliceGet(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), at), rs.byteSliceView)), rs.bytes(2).fill(at & 0xff)); + }; + const grid: Uint8Array[] = [row(0), row(1), row(2)]; + const wrapped: Uint8Array[] = rs.arraySliceItems(rs.arraySliceFrom([Uint8Array.of(grid[2][1], grid[0][0]), Uint8Array.of(grid[1][0], grid[2][0]), Uint8Array.of(grid[0][1], grid[1][1]), copy$array_u8(grid[2])], rs.byteSliceFrom)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(rs.arraySliceOf(rs.byteSliceFrom)(wrapped)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const cow: rs.Cow> = new rs.Borrowed(rs.arraySliceRange(rs.arraySliceFrom(grid, rs.byteSliceFrom), 1)); + if (cow instanceof rs.Borrowed) { + const _217: rs.u8 = (cow as rs.Borrowed>).slice.length & 0xff; + rs.idx((cow as rs.Borrowed>).slice, 0); + const slice2 = rs.arraySliceAt((cow as rs.Borrowed>).slice, 0); + const _219: rs.u8 = slice2.data[slice2.start]; + const _226: rs.usize = rs.usizeSub((cow as rs.Borrowed>).slice.length, 1); + rs.idx((cow as rs.Borrowed>).slice, _226); + const slice4 = rs.arraySliceAt((cow as rs.Borrowed>).slice, _226); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_217, _219, slice4.data[slice4.start + 1])), undefined, true); + } else { + rs.byteVecPush(out, (cow as rs.Vec).items.length & 0xff); + } + } else { + const leaked: rs.ArraySlice = rs.arraySliceFrom(rs.vecFrom(rows.items.map(copy$array_u8)).items, rs.byteSliceFrom); + const _240: rs.ByteSlice | undefined = rs.arraySliceFirst(leaked); + if (_240 !== undefined) { + const _243: rs.u8 = rs.u8WrappingAdd(_240.data[_240.start], 1); + _240.data[_240.start] = _243; + } + rs.iterExtendBytes(out, rs.iterFlatten(rs.arraySliceIter(leaked), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + } +} + //# sourceMappingURL=slices.ts.map diff --git a/ts/fixtures/lang/slices/src/lib.rs b/ts/fixtures/lang/slices/src/lib.rs index 7d9309df2..f59a820eb 100644 --- a/ts/fixtures/lang/slices/src/lib.rs +++ b/ts/fixtures/lang/slices/src/lib.rs @@ -24,5 +24,8 @@ fn cases() -> Vec<(&'static str, Case)> { ("slices::edits", slices::edits), ("slices::arrays", slices::arrays), ("slices::arrays_mut", slices::arrays_mut), + ("slices::array_forms", slices::array_forms), + ("slices::array_identity", slices::array_identity), + ("slices::array_sources", slices::array_sources), ] } diff --git a/ts/fixtures/lang/slices/src/slices.rs b/ts/fixtures/lang/slices/src/slices.rs index df4d7ccdd..9ad2481c6 100644 --- a/ts/fixtures/lang/slices/src/slices.rs +++ b/ts/fixtures/lang/slices/src/slices.rs @@ -5,7 +5,9 @@ //! that log when they drop; and a slice's parts by each kind of range and by fixed size, //! with what is written through a mutable one landing in the slice; a slice's edits in //! place, of values that log as they are cloned and drop; and a slice's runs as arrays, -//! and a `Vec` cloned from a slice. +//! and a `Vec` cloned from a slice; and slices of arrays in each form they take: constants, +//! defaults, an `Option`'s, a `Cow`'s, a generic struct's, clones, and runs of references +//! and of wrapped arrays. use std::cell::RefCell; @@ -1302,3 +1304,343 @@ pub fn arrays_mut(kind: u8, data: &[u8], out: &mut Vec) { drop(items); flush(out); } + +/// Arrays of two bytes a constant holds. +const PAIRS: &[[u8; 2]] = &[[1, 2], [3, 4]]; + +/// A generic struct's slice, instanced with arrays. +struct View<'a, T> { + view: &'a [T], +} + +impl View<'_, T> { + /// Its last element, if any. + fn last(&self) -> Option { + self.view.last().copied() + } +} + +/// Puts each run's bytes. +fn put_runs(runs: &[[u8; N]], out: &mut Vec) { + out.push(runs.len() as u8); + for run in runs { + out.extend_from_slice(run); + } +} + +/// Slices of arrays in each form they take, each read after. +pub fn array_forms(kind: u8, data: &[u8], out: &mut Vec) { + let byte = |at: usize| data.get(at).copied().unwrap_or(at as u8); + let pairs: Vec<[u8; 2]> = data.chunks_exact(2).map(|c| [c[0], c[1]]).collect(); + match kind % 8 { + // A reference copied out of an array of one, or out of runs of them, still points at + // the cell it did. + 0 => { + let cell = std::cell::Cell::new(byte(0)); + let other = std::cell::Cell::new(byte(1)); + let mut r = &cell; + let a = std::array::from_mut(&mut r); + let copy = *a; + let runs = std::array::from_mut(a); + let [[old]] = std::mem::replace(runs, [[&other]]); + cell.set(byte(2)); + out.extend([copy[0].get(), old.get(), r.get()]); + let mut refs = [[&cell], [&other]]; + refs.swap(0, 1); + other.set(byte(3)); + out.extend([refs[0][0].get(), refs[1][0].get()]); + } + // Clones of slices of arrays, of values a clone copies and of others. + 1 => { + let words: Vec<[String; 2]> = pairs.iter().map(|p| [p[0].to_string(), p[1].to_string()]).collect(); + let cloned = words[words.len().min(1)..].to_vec(); + out.push(cloned.len() as u8); + for [a, b] in &cloned { + out.extend(a.bytes().chain(b.bytes())); + } + let boxed: Box<[[u8; 2]]> = pairs.clone().into_boxed_slice(); + let copy = boxed.clone(); + put_runs(©, out); + put_runs(&boxed.into_vec(), out); + } + // A constant's, a default, and an `Option`'s. + 2 => { + put_runs(PAIRS, out); + let empty: &[[u8; 2]] = Default::default(); + put_runs(empty, out); + let some = pairs.first().copied(); + put_runs(some.as_slice(), out); + put_runs(None::<[u8; 2]>.as_slice(), out); + } + // A generic struct's slice, of byte arrays and of others. + 3 => { + let bytes = View { view: &pairs[..] }; + out.extend(bytes.last().unwrap_or_default()); + let words: Vec<[u16; 2]> = pairs.iter().map(|p| [p[0].into(), p[1].into()]).collect(); + let words = View { view: &words[..] }; + out.extend(words.last().unwrap_or_default().map(|w| w as u8)); + } + // Arrays of wrapped arrays, which are elements of their own, copied through a borrow. + 4 => { + let wrapped = [std::mem::MaybeUninit::new([byte(0), byte(1)])]; + let r = &wrapped; + let copy = *r; + // SAFETY: the one element is initialized. + out.extend(unsafe { copy[0].assume_init() }); + let kept = [std::mem::ManuallyDrop::new([byte(2), byte(3)])]; + let r = &kept; + let copy = *r; + out.extend(*copy[0]); + } + // A `Cow`'s, borrowed and owned. + 5 => { + let borrowed: std::borrow::Cow<[[u8; 2]]> = std::borrow::Cow::Borrowed(&pairs[..]); + put_runs(&borrowed, out); + let mut owned = borrowed.clone(); + if let Some(first) = owned.to_mut().first_mut() { + first[0] ^= 0xff; + } + put_runs(&owned, out); + put_runs(&borrowed, out); + put_runs(&borrowed.into_owned(), out); + let from: std::borrow::Cow<[[u8; 2]]> = pairs.clone().into(); + put_runs(&from, out); + } + // An `Option`'s array written through its slice, a borrowed `Vec`'s `Cow`, initialized + // `MaybeUninit`s of arrays, shared, mutable, and boxed, and slices of arrays joined. + 6 => { + let mut some = pairs.first().copied(); + if let Some(run) = some.as_mut_slice().first_mut() { + run[1] ^= 0x5a; + } + put_runs(some.as_slice(), out); + out.push(None::<[u8; 2]>.as_mut_slice().len() as u8); + let cow: std::borrow::Cow<'_, [[u8; 2]]> = std::borrow::Cow::from(&pairs); + put_runs(&cow, out); + let mut wrapped: Vec> = + pairs.iter().map(|&p| std::mem::MaybeUninit::new(p)).collect(); + // SAFETY: every element is initialized. + put_runs(unsafe { wrapped.assume_init_ref() }, out); + // SAFETY: every element is initialized. + if let Some(run) = unsafe { wrapped.assume_init_mut() }.last_mut() { + run[0] = run[0].wrapping_add(1); + } + // SAFETY: every element is initialized. + put_runs(unsafe { wrapped.assume_init_ref() }, out); + let mut boxed = Box::<[[u8; 2]]>::new_uninit_slice(pairs.len()); + for (slot, &p) in boxed.iter_mut().zip(&pairs) { + slot.write(p); + } + // SAFETY: every element is written. + put_runs(&unsafe { boxed.assume_init() }, out); + let half = pairs.len() / 2; + let joined = [&pairs[..half], &pairs[half..]].concat(); + put_runs(&joined, out); + let cows = [ + std::borrow::Cow::Borrowed(&pairs[..half]), + std::borrow::Cow::Owned(pairs[half..].to_vec()), + ]; + put_runs(&cows.concat(), out); + put_runs(&[&pairs[..half], &pairs[half..]].join(&[0xee_u8, 0xff]), out); + put_runs( + &[&pairs[..half], &pairs[half..]].join(&[[0xdd_u8, 0xcc], [0xbb, 0xaa]][..]), + out, + ); + } + // `mem::replace` and `Cell` of a run whose elements a write lands in. + _ => { + let mut item = vec![byte(0)]; + let a = std::array::from_mut(&mut item); + let runs = std::slice::from_mut(a); + let [old] = std::mem::replace(&mut runs[0], [vec![byte(1), byte(2)]]); + out.extend(&old); + let [[old]] = std::cell::Cell::from_mut(std::array::from_mut(std::array::from_mut(&mut item))) + .replace([[vec![byte(3)]]]); + out.extend(&old); + out.extend(&item); + } + } +} + +/// What logs, as it is cloned, whether it is the one its `home` points at. +struct Probe<'a> { + tag: u8, + home: &'a std::cell::Cell>>, +} + +impl Clone for Probe<'_> { + fn clone(&self) -> Self { + let home = self.home.get().is_some_and(|home| std::ptr::eq(home, self)); + LOG.with_borrow_mut(|log| log.push(self.tag ^ home as u8)); + Probe { + tag: self.tag, + home: self.home, + } + } +} + +/// Whether a callback std lends each row of `rows` gets that row itself, by `ptr::eq`. +fn lent_rows(rows: &[[u8; N]], out: &mut Vec) { + for target in rows { + let mut lent = false; + let found = rows.binary_search_by(|row| { + lent |= std::ptr::eq(row, target); + row.cmp(target) + }); + out.extend([found.is_ok() as u8, lent as u8]); + } +} + +/// The same as [`lent_rows`], for rows of words and of arrays. +fn lent_words(rows: &[[u16; 2]], nested: &[[[u8; 2]; 2]], out: &mut Vec) { + for target in rows { + out.push(rows.iter().filter(|row| std::ptr::eq(*row, target)).count() as u8); + out.push(rows.partition_point(|row| !std::ptr::eq(row, target) && row < target) as u8); + let mut lent = false; + let _ = rows.binary_search_by(|row| { + lent |= std::ptr::eq(row, target); + row.cmp(target) + }); + out.push(lent as u8); + } + for target in nested { + let mut lent = false; + let _ = nested.binary_search_by(|row| { + lent |= std::ptr::eq(row, target); + row.cmp(target) + }); + out.push(lent as u8); + } +} + +/// Rows of slices of arrays as std reads them: lent to a callback as themselves, and a +/// `join`'s separator cloned where it is. +pub fn array_identity(kind: u8, data: &[u8], out: &mut Vec) { + let mut rows: Vec<[u8; 2]> = data.chunks_exact(2).map(|c| [c[0], c[1]]).collect(); + rows.sort(); + rows.dedup(); + match kind % 2 { + // A callback's `ptr::eq` on a row std lends, of all the rows and of part of them. + 0 => { + lent_rows(&rows, out); + lent_rows(&rows[rows.len() / 2..], out); + let words: Vec<[u16; 2]> = rows.iter().map(|r| [r[0].into(), r[1].into()]).collect(); + let nested: Vec<[[u8; 2]; 2]> = rows.windows(2).map(|w| [w[0], w[1]]).collect(); + lent_words(&words[words.len().min(1)..], &nested[nested.len() / 2..], out); + } + // `join`'s separator, an array, cloned by each element's `Clone` where it is. + _ => { + let away = std::cell::Cell::new(None); + let probes = |at: usize| -> Vec<[Probe; 1]> { + rows[at..] + .iter() + .map(|r| { + [Probe { + tag: r[0] & 0xfe, + home: &away, + }] + }) + .collect() + }; + let (a, b) = (probes(0), probes(rows.len() / 2)); + let home = std::cell::Cell::new(None); + let sep = [Probe { tag: 0xee, home: &home }]; + home.set(Some(&sep[0])); + let joined = [&a[..], &b[..], &a[..1.min(a.len())]].join(&sep); + out.extend(joined.iter().map(|[p]| p.tag)); + flush(out); + } + } +} + +/// Slices of arrays std's collections and pointers hand out, each read and written after. +pub fn array_sources(kind: u8, data: &[u8], out: &mut Vec) { + let rows: Vec<[u8; 2]> = data.chunks_exact(2).map(|c| [c[0], c[1]]).collect(); + match kind % 5 { + // A deque's, shared, mutable, and made contiguous, of bytes and of words. + 0 => { + let mut q: std::collections::VecDeque<[u8; 2]> = rows.iter().copied().collect(); + if let Some(&first) = rows.first() { + q.push_front(first); + q.rotate_left(q.len() / 2); + } + let (a, b) = q.as_slices(); + out.extend([a.len() as u8, b.len() as u8]); + out.extend(a.first().into_iter().chain(b.last()).flatten()); + let (a, b) = q.as_mut_slices(); + if let Some(row) = a.last_mut().or(b.first_mut()) { + row[0] ^= 0x33; + } + out.extend(q.make_contiguous().iter().flatten()); + if let Some(row) = q.make_contiguous().first_mut() { + row[1] ^= 0x44; + } + out.extend(q.iter().flatten()); + let mut words: std::collections::VecDeque<[u16; 2]> = + rows.iter().map(|r| [r[0].into(), r[1].into()]).collect(); + words.rotate_right(words.len() / 3); + let (a, b) = words.as_slices(); + out.extend(a.iter().chain(b).flatten().map(|&w| w as u8)); + out.extend(words.make_contiguous().iter().flatten().map(|&w| w as u8)); + } + // A box's, through a raw pointer and back, and written through it. + 1 => { + let boxed: Box<[[u8; 2]]> = rows.clone().into_boxed_slice(); + let raw = Box::into_raw(boxed); + // SAFETY: `raw` is the box's, which nothing else holds. + let shared = unsafe { &*raw }; + out.push(shared.len() as u8); + // SAFETY: `raw` is the box's, which nothing else holds. + if let Some(row) = unsafe { (*raw).first_mut() } { + row[0] ^= 0x55; + } + // SAFETY: `raw` came from `Box::into_raw`. + let back = unsafe { Box::from_raw(raw) }; + out.extend(back.iter().flatten()); + let mut owned = rows.clone(); + let p: *mut [[u8; 2]] = &mut owned[..]; + // SAFETY: `p` points at `owned`, which nothing else borrows. + if let Some(row) = unsafe { (*p).last_mut() } { + row[1] ^= 0x66; + } + out.extend(owned.iter().flatten()); + } + // A heap's and a shared box's. + 2 => { + let heap: std::collections::BinaryHeap<[u8; 2]> = rows.iter().copied().collect(); + out.extend(heap.as_slice().iter().flatten()); + let shared: std::rc::Rc<[[u8; 2]]> = rows.clone().into(); + out.extend(shared.iter().rev().flatten()); + } + // A reborrow of a `MaybeUninit` of an array of arrays through a raw pointer, and a + // borrowed `Cow`'s, matched. + 3 => { + let row = |at: usize| rows.get(at).copied().unwrap_or([at as u8; 2]); + let grid = [row(0), row(1), row(2)]; + let pairs = [ + [grid[2][1], grid[0][0]], + [grid[1][0], grid[2][0]], + [grid[0][1], grid[1][1]], + grid[2], + ]; + let p = (&pairs as *const [[u8; 2]; 4]).cast::>(); + // SAFETY: `p` points at `pairs`, which is initialized and outlives the borrow. + let wrapped = unsafe { &*p }; + // SAFETY: as above. + out.extend(unsafe { wrapped.assume_init_ref() }.iter().flatten()); + let cow: std::borrow::Cow<'_, [[u8; 2]]> = std::borrow::Cow::Borrowed(&grid[1..]); + match cow { + std::borrow::Cow::Borrowed(rows) => out.extend([rows.len() as u8, rows[0][0], rows[rows.len() - 1][1]]), + std::borrow::Cow::Owned(rows) => out.push(rows.len() as u8), + } + } + // A leaked `Vec`'s, written through. + _ => { + let leaked: &mut [[u8; 2]] = rows.clone().leak(); + if let Some(row) = leaked.first_mut() { + row[0] = row[0].wrapping_add(1); + } + out.extend(leaked.iter().flatten()); + } + } +} diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index e1f77d1f2..d2a17dca8 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -219,9 +219,9 @@ 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 `Slice` of a `[T; N]`'s elements, a `ByteSlice` - * of a `[u8; N]`'s. + * of a `[u8; N]`'s, and the `ArraySlice` of a `[[T; N]; M]`'s. */ -export type Ptr = T | Place | ByteSlice | (T extends readonly (infer E)[] ? Slice : never); +export type Ptr = T | Place | ByteSlice | (T extends readonly (infer E)[] ? Slice | ArraySlice : never); /** A generic union whose layout only an instance decides: its slots, each read cast to its part's type. */ export type Slots = { [slot: string]: unknown }; @@ -229,14 +229,14 @@ export type Slots = { [slot: string]: unknown }; /** A generic type's `[T; N]`: the array, or the `Uint8Array` of a `[u8; N]`. */ export type ArrayOf = T[] | Uint8Array; -/** A generic type's `[T]`, as behind a reference: the `Slice`, or the `ByteSlice` of a `[u8]`. */ -export type SliceOf = Slice | ByteSlice; +/** A generic type's `[T]`, as behind a reference: the `Slice`, the `ByteSlice` of a `[u8]`, or the `ArraySlice` of a `[[T; N]]`. */ +export type SliceOf = Slice | ByteSlice | ArraySlice; /** A generic type's `Vec`: the `Vec`, or the `ByteVec` of a `Vec`. */ export type VecOf = Vec | ByteVec; -/** A generic type's `Cow<[T]>`: the `Cow`, or the `ByteCow` of a `Cow<[u8]>`. */ -export type CowOf = Cow | ByteCow; +/** A generic type's `Cow<[T]>`: the `Cow`, the `ByteCow` of a `Cow<[u8]>`, or the `Cow` of a `Cow<[[T; N]]>`'s arrays. */ +export type CowOf = Cow | ByteCow | Cow>; /** * The pointer to element `index` of `s`, a `[T; N]` or a `Vec`'s storage. A null or @@ -551,6 +551,42 @@ export function rawSliceOf(s: Slice): RawSlice { return new RawSlice(sliceAsPtr(s), s.length); } +/** + * A raw pointer to a slice of arrays, `*const [[T; N]]` or `*mut [[T; N]]`: the array slice + * it points at, which a read through it gives back where it is, and never null. + */ +export class RawArraySlice { + readonly slice: ArraySlice; + + constructor(slice: ArraySlice) { + this.slice = slice; + } + + /** Where it points, which is never `NULL`. */ + get ptr(): ArraySlice { + return this.slice; + } + + get length(): number { + return this.slice.length; + } + + /** The array slice it points at, read through it. */ + deref(): ArraySlice { + return this.slice; + } + + /** `p as *const [[T; N]; n]`: its first `n` arrays, read through only where Rust reads, as `RawSlice`'s `array` casts. */ + array(n: number): ArraySlice { + return arraySlicePart(this.slice, 0, n); + } +} + +/** The raw pointer to `r`, a slice of arrays. */ +export function rawArraySliceOf(r: ArraySlice): RawArraySlice { + return new RawArraySlice(r); +} + /** The raw pointer to the bytes of `s`. */ export function rawByteSliceOf(s: ByteSlice): RawSlice { return new RawSlice(byteSliceAsPtr(s), s.length); @@ -600,14 +636,11 @@ 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, as are runs a - * view of runs holds. + * a write may land in, as a `sliceIn`'s, which a view of one copies too. */ 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; @@ -774,11 +807,11 @@ export function sliceItems(s: Slice): T[] { } /** Elements in a row, as a slice reads them: the JS array of a `[T; N]`, a `Slice`, or a `Vec`. */ -export type Elements = ArrayLike | Slice | Vec; +export type Elements = ArrayLike | Slice | Vec | ArraySlice; -/** The array `s`'s elements are in: a slice's storage, a `Vec`'s items, or the array itself. */ +/** The array `s`'s elements are in: a slice's storage, a `Vec`'s items, an array slice's arrays as `arraySliceItems` reads them, or the array itself. */ export function sliceData(s: Elements): ArrayLike { - return s instanceof Slice ? s.data : s instanceof Vec ? s.items : s; + return s instanceof Slice ? s.data : s instanceof Vec ? s.items : s instanceof ArraySlice ? (arraySliceItems(s) as unknown as ArrayLike) : s; } /** Where `s`'s elements start in `sliceData(s)`. */ @@ -808,7 +841,7 @@ export function sliceSet(s: Slice, items: ArrayLike): void { /** * 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. + * element of the same array, through any `arrayView` of part of it, or both null. */ export function sliceSame(a: Slice, b: Slice): boolean { if (!(a instanceof Slice && b instanceof Slice)) return a === b; @@ -848,10 +881,10 @@ export function slicePart(s: Slice, start: number, end: number = s.length) /** * Elements `start` to `end` of `s` as a JS array whose every element is `s`'s, read and - * written where it is, as a JS array has no views of its own: a `[T; N]` that a slice of - * them lends where `as_chunks_mut` makes one of a flat slice. Its own array, holes of the - * same length, answers for the rest, such as `length` and the methods. A view of a view - * reads the array beneath both. + * written where it is, as a JS array has no views of its own: the `[T; N]` a `&mut` to part + * of an array lends where what takes it writes a JS array. Its own array, holes of the same + * length, answers for the rest, such as `length` and the methods. A view of a view reads + * the array beneath both. */ function arrayView(s: T[], start: number, end: number): T[] { const outer = (s as { [VIEW]?: View })[VIEW]; @@ -875,6 +908,11 @@ export function optionAsSlice(o: T, none?: None): Slice { return sliceFrom(o === none ? [] : [o]); } +/** `optionAsSlice` of an array, which is never `undefined`: the arrays of it alone, lent by `of`, or of none. */ +export function optionAsArraySlice(o: LentArray | undefined, of: (array: LentArray) => S): ArraySlice { + return arraySliceFrom, S>(o === undefined ? [] : [o], of); +} + /** `optionAsSlice` of a byte. */ export function byteOptionAsSlice(o: number | undefined): ByteSlice { return byteSliceFrom(o === undefined ? new Uint8Array(0) : Uint8Array.of(o)); @@ -963,12 +1001,6 @@ class View implements ProxyHandler { this.s[i] = value; } - /** Holds a copy of what it views from now on, as a read of the array it views copied it. */ - detach(): void { - this.s = Array.from({ length: this.length }, (_, i) => this.item(this.start + i)); - this.start = 0; - } - /** Where in `s` the element `key` names is, or -1 if it names none. */ at(key: string | symbol): number { if (typeof key !== "string") return -1; @@ -1005,140 +1037,274 @@ class View implements ProxyHandler { } /** - * `as_chunks_mut`'s slice of arrays: element `i` the view of run `i` of `n` elements of `flat` - * from `offset`, made the first time it is read and kept in `views`. A whole write of a run - * copies into it, and the view a read took of it first detaches to a copy of what it held, - * as Rust's read copied the array. + * `op` of the elements of `s`, which it reads before writes that may overwrite them, as a + * JS array: the storage itself where `s` is all of it, or else a copy, written back after. + */ +export function byValue(s: SliceLike, op: (items: T[]) => void): void { + if (s.start === 0 && s.length === s.data.length) return op(s.data as T[]); + const items = new Array(s.length); + for (let i = 0; i < s.length; i++) items[i] = s.data[s.start + i]; + op(items); + for (let i = 0; i < items.length; i++) s.data[s.start + i] = items[i]; +} + +/** `reverse`: the elements in place, back to front. */ +export function sliceReverse(s: Slice): void { + byValue(s, (items) => items.reverse()); +} + +// Slices of arrays: `ArraySlice`. + +/** What a `&[T; N]` is, as a slice of arrays lends each of its arrays: a slice of its elements, of its bytes, or of its own arrays. */ +export type ArrayRef = Slice | ByteSlice | ArraySlice; + +/** The `[T; N]` a `&[T; N]`, `S`, lends: its elements' array, its bytes, or its own arrays. */ +export type LentArray = S extends ByteSlice ? Uint8Array : S extends Slice ? T[] : S extends ArraySlice ? LentArray[] : never; + +/** + * A `&[[T; N]]`, `&mut [[T; N]]`, or `Box<[[T; N]]>`: `length` arrays from `start`, each lent + * as `S`, the slice a `&[T; N]` is, so an array is read and written where the slice holds it. + * The arrays are each a `[T; N]`'s own array, `items[i]`, as a `Vec<[T; N]>` or a + * `[[T; N]; M]` holds them, which `of` lends, or else `n` elements each of `flat`, as + * `as_chunks` splits a slice. */ -class Runs extends View { - flat: T[]; - offset: number; +export class ArraySlice { + readonly items: readonly unknown[] | undefined; + readonly of: ((array: never) => S) | undefined; + readonly flat: S | undefined; readonly n: number; + readonly start: number; + readonly length: number; - constructor(flat: T[], at: number, n: number, views: T[][], start: number, length: number) { - super(views, start, length); + constructor(items: readonly unknown[] | undefined, of: ((array: never) => S) | undefined, flat: S | undefined, n: number, start: number, length: number) { + this.items = items; + this.of = of; this.flat = flat; - this.offset = at; this.n = n; + this.start = start; + this.length = length; } +} - override part(start: number, length: number): Runs { - return new Runs(this.flat, this.offset, this.n, this.s as T[][], this.start + start, length); - } +/** + * All of `items`, the arrays of a `[[T; N]; M]` or a `Vec<[T; N]>`, as arrays, each lent by + * `of`. An array slice of none takes its type from where they go, as `[]` says nothing of it. + */ +export function arraySliceFrom(items: readonly [], of: (array: NoInfer>) => S): ArraySlice; +export function arraySliceFrom(items: readonly A[], of: (array: A) => S): ArraySlice; +export function arraySliceFrom(items: readonly A[], of: (array: A) => S): ArraySlice { + return new ArraySlice(items, of, undefined, 0, 0, items.length); +} - override item(i: number): T[] { - const from = this.offset + i * this.n; - return ((this.s as (T[] | undefined)[])[i] ??= arrayView(this.flat, from, from + this.n)); - } +/** The arrays of `s`, a slice of arrays, each lent by `of` where `s` holds it, as `assume_init_ref` of a slice of `MaybeUninit`s of them has it. */ +export function arraySliceOfSlice(s: Slice, of: (array: A) => S): ArraySlice { + return new ArraySlice(s.data, of, undefined, 0, s.start, s.length); +} - override put(i: number, value: T[]): void { - const views = this.s as (T[] | undefined)[]; - const held = views[i]; - if (held !== undefined) { - (held as { [VIEW]?: View })[VIEW]!.detach(); - views[i] = undefined; - } - const from = this.offset + i * this.n; - for (let k = 0; k < this.n; k++) this.flat[from + k] = value[k]; - } +/** `arraySliceFrom` of `of`, as a function of the arrays, as a `[[T; N]; M]` is lent: one function for each `of`. */ +export function arraySliceOf(of: (array: A) => S): (items: readonly A[]) => ArraySlice { + let f = LENT.get(of) as ((items: readonly A[]) => ArraySlice) | undefined; + if (f === undefined) LENT.set(of, (f = (items: readonly A[]) => arraySliceFrom(items, of))); + return f; +} - override detach(): void { - const from = this.offset + this.start * this.n; - const runs = isRuns(this.flat); - this.flat = Array.from({ length: this.length * this.n }, (_, k) => (runs ? copyRun(this.flat[from + k]) : this.flat[from + k])); - this.offset = -this.start * this.n; - this.s = []; - } +/** `arraySliceOf`'s functions, by the `of` each lends with. */ +const LENT = /* @__PURE__ */ new Map(); + +/** Run `i` of `r`, in bounds, lent where `r` holds it. */ +export function arraySliceAt(r: ArraySlice, i: number): S { + const k = r.start + i; + if (r.items !== undefined) return (r.of as (array: unknown) => S)(r.items[k]); + return arrayRefPart(r.flat as S, k * r.n, r.n); } -/** Whether `s` is runs, or a view of them, whose elements are views of their runs. */ -function isRuns(s: object): boolean { - const view = (s as { [VIEW]?: unknown })[VIEW]; - return view instanceof Runs || view instanceof ByteRuns; +/** `length` elements of `s` from `start`: a slice of the same storage, of the same class. */ +function arrayRefPart(s: S, start: number, length: number): S { + if (s instanceof ByteSlice) return new ByteSlice(s.data, s.start + start, length) as S; + if (s instanceof Slice) return new Slice(s.data, s.start + start, length) as S; + const r = s as ArraySlice; + return new ArraySlice(r.items, r.of, r.flat, r.n, r.start + start, length) as S; +} + +/** Arrays `start` to `end` of `r`, in bounds already. */ +export function arraySlicePart(r: ArraySlice, start: number, end: number = r.length): ArraySlice { + return arrayRefPart(r, start, end - start); +} + +/** `&r[start..end]` and `&mut r[start..end]`, with `end` defaulting to the length. */ +export function arraySliceRange(r: ArraySlice, start: number, end: number = r.length, at?: Location): ArraySlice { + rangeCheck(r.length, start, end, at); + return arrayRefPart(r, start, end - start); +} + +/** Each array of `r`, lent where `r` holds it, as `each_ref` and `each_mut` of a `[[T; N]; M]` lend them. */ +export function arraySliceEach(r: ArraySlice): S[] { + const out = new Array(r.length); + for (let i = 0; i < r.length; i++) out[i] = arraySliceAt(r, i); + return out; +} + +/** `slice::from_mut` or `array::from_mut` of a `&mut [T; n]`, which is `s`: the arrays of it alone. */ +export function arraySliceOne(s: S, n: number): ArraySlice { + return new ArraySlice(undefined, undefined, s, n, 0, 1); +} + +/** `*r` of a `&[[T; N]; M]`: each array copied by `copy`, an array of its own. */ +export function arraySliceToArray(r: ArraySlice, copy: (run: S) => A): A[] { + const out = new Array(r.length); + for (let i = 0; i < r.length; i++) out[i] = copy(arraySliceAt(r, i)); + return out; +} + +/** `*r = items` of a `&mut [[T; N]; M]`: each array written where `r` holds it. */ +export function arraySliceSet(r: ArraySlice, items: ArrayLike>): void { + for (let i = 0; i < r.length; i++) arrayRefSet(arraySliceAt(r, i), items[i]); } /** - * `x`, a run read out of runs, as a value of its own, since a write through the runs - * would change it: a copy of its elements, and of each run it holds as runs at any depth, - * but not of what its elements point at. + * What an array's element is copied by, as a copy of the arrays reads it: a `Copy` value JS + * holds as an object, and one a write lands in, as a `sliceIn`'s does, which a write of the + * arrays back would change. */ -function copyRun(x: T): T { - if (x instanceof Uint8Array) return x.slice() as T; - const run = x as unknown as unknown[]; - return (isRuns(run) ? Array.from(run, copyRun) : Array.from(run)) as T; +export type ElemCopy = (value: never) => unknown; + +/** `mem::replace` of what a `&mut [[T; N]; M]`, `r`, points at: its arrays as arrays of their own, each element copied by `copy`, then `items` written where `r` holds them. */ +export function arraySliceReplace(r: ArraySlice, items: ArrayLike>, copy?: ElemCopy): LentArray[] { + const old = arraySliceCopy(r, copy); + arraySliceSet(r, items); + return old; +} + +/** A whole write of `value`, a `[T; N]`, into the array `s`: its elements moved into where `s` holds them. */ +function arrayRefSet(s: ArrayRef, value: unknown): void { + if (s instanceof ByteSlice) s.data.set(value as Uint8Array, s.start); + else if (s instanceof Slice) sliceSet(s, value as unknown[]); + else arraySliceSet(s, value as ArrayLike); } /** - * `as_chunks_mut` of bytes' slice of arrays: element `i` a `Uint8Array` view of run `i` of - * `n` bytes of `data` from `offset`, made the first time it is read and kept in `views`, and a - * whole write of a run copied into it. A `Uint8Array` can't detach as `Runs`' views do, so - * a read of one by value copies it, as `byValue` has the runtime's own reads do. + * The array `s` as a `[T; N]` of its own: a copy of its elements, and of the arrays it holds at + * any depth, but not of the objects its elements are, which a write of it moves, unless + * `copy` copies them. */ -class ByteRuns extends View { - data: Uint8Array; - offset: number; - readonly n: number; +function arrayRefCopy(s: S, copy?: ElemCopy): LentArray { + if (s instanceof ByteSlice) return byteSliceToArray(s) as LentArray; + if (s instanceof Slice) return sliceToArray(s, copy as ((value: unknown) => unknown) | undefined) as LentArray; + return arraySliceCopy(s as ArraySlice, copy) as LentArray; +} - constructor(data: Uint8Array, at: number, n: number, views: Uint8Array[], start: number, length: number) { - super(views, start, length); - this.data = data; - this.offset = at; - this.n = n; - } +/** The arrays of `r` as arrays of their own, as `arrayRefCopy` copies each. */ +export function arraySliceCopy(r: ArraySlice, copy?: ElemCopy): LentArray[] { + return arraySliceToArray(r, (s) => arrayRefCopy(s, copy)); +} - override part(start: number, length: number): ByteRuns { - return new ByteRuns(this.data, this.offset, this.n, this.s as Uint8Array[], this.start + start, length); - } +/** + * Whether pointers to `[[T; N]; M]`s, `a` and `b`, point at the same place: the same array of + * the same arrays, or of the same storage, or both null. + */ +export function arraySliceSame(a: ArraySlice, b: ArraySlice): boolean { + if (!(a instanceof ArraySlice && b instanceof ArraySlice)) return a === b; + if (a.items !== undefined || b.items !== undefined) return a.items === b.items && a.start === b.start; + return arrayRefSame(arrayRefPart(a.flat!, a.start * a.n, 0), arrayRefPart(b.flat!, b.start * b.n, 0)); +} - override item(i: number): Uint8Array { - const from = this.offset + i * this.n; - return ((this.s as (Uint8Array | undefined)[])[i] ??= this.data.subarray(from, from + this.n)); - } +/** Whether `a` and `b`, slices a pointer to a `[T; N]` is, point at the same place. */ +function arrayRefSame(a: ArrayRef, b: ArrayRef): boolean { + if (a instanceof ByteSlice) return b instanceof ByteSlice && byteSliceSame(a, b); + if (a instanceof Slice) return b instanceof Slice && sliceSame(a, b); + return b instanceof ArraySlice && arraySliceSame(a, b); +} - override put(i: number, value: Uint8Array): void { - this.data.set(value, this.offset + i * this.n); - } +/** + * The arrays of `r` as a JS array of arrays, for what only reads them: the arrays themselves + * where each array is one, so a callback's `ptr::eq` sees the array it was lent, or else copies + * of the arrays `as_chunks` split from one flat slice, which have no array of their own. + */ +export function arraySliceItems(r: ArraySlice): LentArray[] { + if (r.items === undefined) return arraySliceCopy(r); + if (r.start === 0 && r.length === r.items.length) return r.items as LentArray[]; + return r.items.slice(r.start, r.start + r.length) as LentArray[]; +} - override detach(): void { - const from = this.offset + this.start * this.n; - this.data = this.data.slice(from, from + this.length * this.n); - this.offset = -this.start * this.n; - this.s = []; - } +/** `last_chunk` of an array slice, shared or mutable: the last `n`, or `undefined` if fewer. */ +export function arraySliceLastChunk(r: ArraySlice, n: number): ArraySlice | undefined { + return n > r.length ? undefined : arrayRefPart(r, r.length - n, n); +} +/** `split_last_chunk` of an array slice, shared or mutable: the rest and the last `n`, or `undefined` if fewer. */ +export function arraySliceSplitLastChunk(r: ArraySlice, n: number): [ArraySlice, ArraySlice] | undefined { + return n > r.length ? undefined : [arrayRefPart(r, 0, r.length - n), arrayRefPart(r, r.length - n, n)]; +} + +/** The arrays of `r` as a slice of arrays, as `arraySliceItems` reads them: a slice of the arrays where each array is one. */ +export function arraySliceAsSlice(r: ArraySlice): Slice> { + if (r.items !== undefined) return new Slice(r.items as LentArray[], r.start, r.length); + return sliceFrom(arraySliceCopy(r)); } /** - * `op` of the elements of `s`, which it reads before writes that may overwrite them, as a - * JS array: the storage itself where `s` is all of it, or else a copy, written back after. - * A run `s` holds as `ByteRuns`' view is copied too, as a write through `s` would change - * it under `op`. + * `op` of the arrays of `r` as a slice of arrays of their own, each a copy, its elements by `copy`, which `op` may + * reorder, overwrite, and copy, each then written back where `r` holds it, as Rust moves + * their elements; written back even if `op` panics, which leaves what it moved so far. */ -export function byValue(s: SliceLike, op: (items: T[]) => void): void { - const runs = byteRuns(s.data); - if (!runs && s.start === 0 && s.length === s.data.length) return op(s.data as T[]); - const items = new Array(s.length); - for (let i = 0; i < s.length; i++) { - const x = s.data[s.start + i]; - items[i] = runs ? ((x as Uint8Array).slice() as T) : x; +export function arraySliceBy(r: ArraySlice, op: (s: Slice>) => R, copy?: ElemCopy): R { + const items = arraySliceCopy(r, copy); + try { + return op(sliceFrom(items)); + } finally { + arraySliceSet(r, items); } - op(items); - for (let i = 0; i < items.length; i++) s.data[s.start + i] = items[i]; } -/** `reverse`: the elements in place, back to front. */ -export function sliceReverse(s: Slice): void { - byValue(s, (items) => items.reverse()); +/** `swap` of an array slice, each element copied out by `copy`, panicking on either index past the end, `a` first, as std's indexing does. */ +export function arraySliceSwap(r: ArraySlice, a: number, b: number, copy: ElemCopy | undefined, at?: Location): void { + const x = arraySliceAt(r, idx(r, a, at)); + const y = arraySliceAt(r, idx(r, b, at)); + const kept = arrayRefCopy(x, copy); + arrayRefSet(x, arrayRefCopy(y, copy)); + arrayRefSet(y, kept); +} + +/** `first` and `first_mut` of an array slice: the first array, or `undefined` if empty. */ +export function arraySliceFirst(r: ArraySlice): S | undefined { + return r.length === 0 ? undefined : arraySliceAt(r, 0); +} + +/** `last` and `last_mut` of an array slice: the last array, or `undefined` if empty. */ +export function arraySliceLast(r: ArraySlice): S | undefined { + return r.length === 0 ? undefined : arraySliceAt(r, r.length - 1); +} + +/** `get` and `get_mut` of an array slice: the array at `index`, or `undefined` past the end. */ +export function arraySliceGet(r: ArraySlice, index: number): S | undefined { + return index < r.length ? arraySliceAt(r, index) : undefined; +} + +/** `get` of `start..end` of an array slice, shared or mutable: the part, or `undefined` unless it is within them. */ +export function arraySliceGetRange(r: ArraySlice, start: number, end: number = r.length): ArraySlice | undefined { + return start <= end && end <= r.length ? arrayRefPart(r, start, end - start) : undefined; +} + +/** `split_first` and `split_first_mut` of an array slice: the first and the rest, or `undefined` if empty. */ +export function arraySliceSplitFirst(r: ArraySlice): [S, ArraySlice] | undefined { + return r.length === 0 ? undefined : [arraySliceAt(r, 0), arrayRefPart(r, 1, r.length - 1)]; +} + +/** `split_last` and `split_last_mut` of an array slice: the last and the rest, or `undefined` if empty. */ +export function arraySliceSplitLast(r: ArraySlice): [S, ArraySlice] | undefined { + const n = r.length - 1; + return n < 0 ? undefined : [arraySliceAt(r, n), arrayRefPart(r, 0, n)]; } -/** `x`, an element of `data` read before a write that may overwrite it: a copy if `data` holds `ByteRuns`' views. */ -function held(data: T[], x: T): T { - return byteRuns(data) ? ((x as Uint8Array).slice() as T) : x; +/** `split_at` and `split_at_mut` of an array slice, panicking past the length. */ +export function arraySliceSplitAt(r: ArraySlice, n: number, at?: Location): [ArraySlice, ArraySlice] { + if (n > r.length) panic("mid > len", at); + return [arrayRefPart(r, 0, n), arrayRefPart(r, n, r.length - n)]; } -/** Whether `s` holds `ByteRuns`' views. */ -function byteRuns(s: object): boolean { - return (s as { [VIEW]?: unknown })[VIEW] instanceof ByteRuns; +/** `split_at_checked` and `split_at_mut_checked` of an array slice: the halves, or `undefined` past the length. */ +export function arraySliceSplitAtChecked(r: ArraySlice, n: number): [ArraySlice, ArraySlice] | undefined { + return n > r.length ? undefined : [arrayRefPart(r, 0, n), arrayRefPart(r, n, r.length - n)]; } /** `get` of `start..end`, shared or mutable: the part, or `undefined` unless it is within the slice. */ @@ -1156,46 +1322,20 @@ export function sliceSplitLastChunk(s: Slice, n: number): [Slice, Slice 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); - 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) => 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. + * `as_chunks` and `as_chunks_mut` of a slice of any element: each array of `n` elements from + * the front, lent where `s` holds it, and the rest, panicking at a size of 0. */ -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. */ -export function sliceAsChunksMut(s: Slice, n: number, at?: Location): [Slice, Slice] { +export function sliceAsChunks(s: S, n: number, at?: Location): [ArraySlice, S] { const count = chunkCount(s.length, n, at); - return [runsOf(s.data, s.start, n, count), slicePart(s, count * n)]; + return [new ArraySlice(undefined, undefined, s, n, 0, count), arrayRefPart(s, count * n, s.length - count * n)]; } -/** `as_rchunks_mut`: the rest, and each run of `n` elements up to the back as an array, written where the slice holds it, panicking at a size of 0. */ -export function sliceAsRchunksMut(s: Slice, n: number, at?: Location): [Slice, Slice] { +/** `as_rchunks` and `as_rchunks_mut` of a slice of any element: the rest, and each array of `n` elements up to the back, as `sliceAsChunks` lends them. */ +export function sliceAsRchunks(s: S, n: number, at?: Location): [S, ArraySlice] { const count = chunkCount(s.length, n, at); const rest = s.length - count * n; - return [slicePart(s, 0, rest), runsOf(s.data, s.start + rest, n, count)]; -} - -/** `count` runs of `n` elements of `s` from `at`, as `Runs` lends them. */ -function runsOf(s: T[], at: number, n: number, count: number): Slice { - return sliceFrom(new Proxy(new Array(count), new Runs(s, at, n, [], 0, count))); + return [arrayRefPart(s, 0, rest), new ArraySlice(undefined, undefined, arrayRefPart(s, rest, count * n), n, 0, count)]; } /** How many runs of `n` elements fit in `length`, panicking at a size of 0, as `as_chunks` does. */ @@ -1204,12 +1344,6 @@ function chunkCount(length: number, n: number, at?: Location): number { return Math.floor(length / n); } -/** `count` runs of `n` elements, each made from its bounds. */ -function runs(count: number, n: number, run: (start: number, end: number) => R): R[] { - const out = new Array(count); - for (let i = 0; i < count; i++) out[i] = run(i * n, i * n + n); - return out; -} /** `split_first`: the first element and the rest, or `undefined` if empty. */ export function sliceSplitFirst(s: Slice): [T, Slice] | undefined { @@ -1365,7 +1499,7 @@ export function slicePartitionPoint(s: SliceLike, pred: (item: T) => boole /** `swap`, panicking on either index past the end, `a` first, as std's indexing does. */ export function sliceSwap(s: Slice, a: number, b: number, at?: Location): void { const d = s.data; - const x = held(d, d[s.start + idx(s, a, at)]); + const x = d[s.start + idx(s, a, at)]; d[s.start + a] = d[s.start + idx(s, b, at)]; d[s.start + b] = x; } @@ -1448,10 +1582,17 @@ export function sliceCopyWithin(s: Slice, start: number, end: number, dest copyWithinCheck(s.length, start, end, dest, at); // Each read, and copied, before any write, which may land in what one views. const d = s.data; - const items = Array.from({ length: end - start }, (_, i) => held(d, d[s.start + start + i])); + const items = Array.from({ length: end - start }, (_, i) => d[s.start + start + i]); for (let i = 0; i < items.length; i++) d[s.start + dest + i] = copy === undefined ? items[i] : copy(items[i]); } +/** `copy_within` of an array slice: `r[start..end]` copied to index `dest`, each array read, and copied by `copy` if given, before any is written, panicking out of bounds. */ +export function arraySliceCopyWithin(r: ArraySlice, start: number, end: number, dest: number, copy?: (value: LentArray) => LentArray, at?: Location): void { + copyWithinCheck(r.length, start, end, dest, at); + const items = Array.from({ length: end - start }, (_, i) => arrayRefCopy(arraySliceAt(r, start + i))); + for (let i = 0; i < items.length; i++) arrayRefSet(arraySliceAt(r, dest + i), copy === undefined ? items[i] : copy(items[i])); +} + /** `copy_within`'s checks of `start..end` and `dest` in `length` elements. */ function copyWithinCheck(length: number, start: number, end: number, dest: number, at?: Location): void { // `slice::range` checks the end first, then `range` reports the rest. @@ -1516,6 +1657,22 @@ export function boxSliceCloneFrom(dst: Slice, src: Slice, clone?: (valu return sliceFrom(items); } +/** + * `Clone::clone_from` of a `Box<[[T; N]]>`, the arrays `dst`: itself, by `clone_from_slice`, + * where the lengths match, or else the arrays `of` makes of a clone of `src`'s arrays, as + * `boxSliceCloneFrom` makes it. + */ +export function arraySliceBoxCloneFrom(dst: ArraySlice, src: ArraySlice, of: (array: LentArray) => S, clone?: (value: LentArray) => LentArray, drop?: (item: LentArray) => void, over?: CloneFrom>, at?: Location): ArraySlice { + if (dst.length !== src.length) return arraySliceFrom(boxSliceCloneFrom(arraySliceAsSlice(dst), arraySliceAsSlice(src), clone, drop, over, at).data, of); + arraySliceBy(dst, (d) => sliceCloneFromSlice(d, arraySliceAsSlice(src), clone, drop, over, at)); + return dst; +} + +/** `arraySliceBoxCloneFrom` as a `CloneFrom`. */ +export function arraySliceBoxCloneFromFn(of: (array: LentArray) => S, clone?: (value: LentArray) => LentArray, drop?: (item: LentArray) => void, over?: CloneFrom>, at?: Location): CloneFrom> { + return (old, src) => arraySliceBoxCloneFrom(old, src, of, clone, drop, over, at); +} + /** `boxSliceCloneFrom` as a `CloneFrom`. */ export function boxSliceCloneFromFn(clone?: (value: T) => T, drop?: (item: T) => void, over?: CloneFrom, at?: Location): CloneFrom> { return (old, src) => boxSliceCloneFrom(old, src, clone, drop, over, at); @@ -2000,38 +2157,6 @@ export function byteSliceSplitAtChecked(s: ByteSlice, n: number): [ByteSlice, By return [new ByteSlice(s.data, s.start, n), new ByteSlice(s.data, s.start + n, s.length - n)]; } -/** `as_chunks` of bytes: views of each run of `n` from the front, and the rest, panicking at a size of 0. */ -export function byteSliceAsChunks(s: ByteSlice, n: number, at?: Location): [Slice, ByteSlice] { - const count = chunkCount(s.length, n, at); - const from = s.start; - return [sliceFrom(runs(count, n, (start, end) => s.data.subarray(from + start, from + end))), new ByteSlice(s.data, from + count * n, s.length - count * n)]; -} - -/** `as_rchunks` of bytes: the rest, and views of each run of `n` up to the back, panicking at a size of 0. */ -export function byteSliceAsRchunks(s: ByteSlice, n: number, at?: Location): [ByteSlice, Slice] { - const count = chunkCount(s.length, n, at); - const from = s.start + s.length - count * n; - return [new ByteSlice(s.data, s.start, s.length - count * n), sliceFrom(runs(count, n, (start, end) => s.data.subarray(from + start, from + end)))]; -} - -/** `as_chunks_mut` of bytes: each run of `n` from the front as an array, written where the slice holds it, and the rest, panicking at a size of 0. */ -export function byteSliceAsChunksMut(s: ByteSlice, n: number, at?: Location): [Slice, ByteSlice] { - const count = chunkCount(s.length, n, at); - return [byteRunsOf(s.data, s.start, n, count), new ByteSlice(s.data, s.start + count * n, s.length - count * n)]; -} - -/** `as_rchunks_mut` of bytes: the rest, and each run of `n` up to the back as an array, written where the slice holds it, panicking at a size of 0. */ -export function byteSliceAsRchunksMut(s: ByteSlice, n: number, at?: Location): [ByteSlice, Slice] { - const count = chunkCount(s.length, n, at); - const rest = s.length - count * n; - return [new ByteSlice(s.data, s.start, rest), byteRunsOf(s.data, s.start + rest, n, count)]; -} - -/** `count` runs of `n` bytes of `data` from `at`, as `ByteRuns` lends them. */ -function byteRunsOf(data: Uint8Array, at: number, n: number, count: number): Slice { - return sliceFrom(new Proxy(new Array(count), new ByteRuns(data, at, n, [], 0, count))); -} - /** `first`: the first byte, or `undefined` if empty. */ export function byteSliceFirst(s: ByteSlice): number | undefined { return s.length === 0 ? undefined : s.data[s.start]; @@ -2772,8 +2897,8 @@ export class Borrowed { } } -/** `Cow<[T]>`: the `Vec` it owns, or the slice it borrows. */ -export type Cow = Vec | Borrowed>; +/** `Cow<[T]>`: the `Vec` it owns, or the slice it borrows, `S`: `ArraySlice` of arrays. */ +export type Cow | ArraySlice = Slice> = Vec | Borrowed; /** `Cow<[u8]>`: the `Vec` it owns, or the bytes it borrows. */ export type ByteCow = ByteVec | ByteSlice; /** `Cow`: the `String` it owns, or the `str` it borrows. */ @@ -2784,6 +2909,11 @@ export function cowSlice(c: Cow): Slice { return c instanceof Borrowed ? c.slice : sliceFrom(c.items); } +/** `Deref` of a `Cow<[[T; N]]>`: its arrays, each of an owned one lent by `of`. */ +export function cowArraySlice(c: Cow, ArraySlice>, of: (array: LentArray) => S): ArraySlice { + return c instanceof Borrowed ? c.slice : arraySliceFrom(c.items, of); +} + /** `Deref` of a `Cow<[u8]>`: its bytes. */ export function byteCowSlice(c: ByteCow): ByteSlice { return c instanceof ByteVec ? byteVecSlice(c) : c; @@ -2792,9 +2922,11 @@ export function byteCowSlice(c: ByteCow): ByteSlice { /** * `Cow::into_owned` of a `Cow<[T]>`: its `Vec`, or a clone of what it borrows, each item by `clone` if given, with room for exactly them, as `to_vec` makes it. */ -export function cowIntoOwned(c: Cow, clone?: (item: T) => T): Vec { +export function cowIntoOwned | ArraySlice = Slice>(c: Cow, clone?: (item: T) => T): Vec { if (!(c instanceof Borrowed)) return c; - return vecFrom(clone === undefined ? sliceToArray(c.slice) : sliceItems(c.slice).map(clone)); + const s = c.slice; + if (s instanceof ArraySlice) return vecFrom((clone === undefined ? arraySliceCopy(s) : arraySliceItems(s).map(clone as (item: unknown) => unknown)) as T[]); + return vecFrom(clone === undefined ? sliceToArray(s as Slice) : sliceItems(s as Slice).map(clone)); } /** `Cow::into_owned` of a `Cow<[u8]>`. */ @@ -2806,7 +2938,7 @@ export function byteCowIntoOwned(c: ByteCow): ByteVec { * `Clone` of a `Cow<[T]>`: a borrow of the same slice, or a clone of its `Vec` with room * for exactly its items, as `to_vec` makes it. */ -export function cowClone(c: Cow, clone?: (item: T) => T): Cow { +export function cowClone | ArraySlice = Slice>(c: Cow, clone?: (item: T) => T): Cow { if (c instanceof Borrowed) return new Borrowed(c.slice); return vecFrom(clone === undefined ? c.items.slice() : c.items.map(clone)); } @@ -2820,7 +2952,7 @@ export function byteCowClone(c: ByteCow): ByteCow { * `clone_from` of a `Cow<[T]>`, of `size`-byte items: an owned one's `Vec`, of an owned * one's, as `vecCloneFrom` clones into it, and else `src`'s clone, made before `c` drops. */ -export function cowCloneFrom(c: Cow, src: Cow, size: number, clone?: (value: T) => T, drop?: (item: T) => void, over?: CloneFrom): Cow { +export function cowCloneFrom | ArraySlice = Slice>(c: Cow, src: Cow, size: number, clone?: (value: T) => T, drop?: (item: T) => void, over?: CloneFrom): Cow { if (!(c instanceof Borrowed || src instanceof Borrowed)) return vecCloneFrom(c, src.items, size, clone, drop, over); const item = cowClone(src, clone); cowDrop(c, drop); @@ -2828,7 +2960,7 @@ export function cowCloneFrom(c: Cow, src: Cow, size: number, clone?: (v } /** `cowCloneFrom` as a `CloneFrom`. */ -export function cowCloneFromFn(size: number, clone?: (value: T) => T, drop?: (item: T) => void, over?: CloneFrom): CloneFrom> { +export function cowCloneFromFn | ArraySlice = Slice>(size: number, clone?: (value: T) => T, drop?: (item: T) => void, over?: CloneFrom): CloneFrom> { return (old, src) => cowCloneFrom(old, src, size, clone, drop, over); } @@ -2843,7 +2975,7 @@ export function byteCowCloneFromFn(): CloneFrom { } /** Drop a `Cow<[T]>`: the items it owns, by `f` if given. */ -export function cowDrop(c: Cow, f?: (item: T) => void): void { +export function cowDrop | ArraySlice = Slice>(c: Cow, f?: (item: T) => void): void { if (!(c instanceof Borrowed)) dropAll(c.items, f); } diff --git a/ts/runtime/rs/collections.ts b/ts/runtime/rs/collections.ts index f7b226f8f..79cfe34fe 100644 --- a/ts/runtime/rs/collections.ts +++ b/ts/runtime/rs/collections.ts @@ -15,7 +15,7 @@ // A function that may drop a key, value, or item std's would, rather than return or keep // it, takes what drops each that does, as `k`, `v`, or `f`, and drops it where std's does. -import { Borrowed, ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, type Room, roomPast, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; +import { type ArrayRef, ArraySlice, arraySliceOfSlice, Borrowed, ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, type Room, roomPast, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; import type { HashKey, Hashing } from "./hash.ts"; import { type Limbs, lt, type u64, type usize } from "./int.ts"; @@ -355,6 +355,10 @@ function seqItems(s: Seq): [number, (i: number) => T] { if (s instanceof Slice) return [s.length, (i) => s.data[s.start + i]]; if (s instanceof ByteVec) return [s.length, (i) => s.data[i] as T]; if (s instanceof Vec) return [s.items.length, (i) => s.items[i] as T]; + if (s instanceof ArraySlice) { + const items = sliceData(s) as ArrayLike; + return [items.length, (i) => items[i]]; + } if (!("length" in s)) return [s.n, (i) => s.b[phys(s, i)] as T]; return [s.length, (i) => s[i] as T]; } @@ -3717,6 +3721,11 @@ export function dequeMakeContiguous(q: VecDeque): Slice { return new Slice(q.b as T[], q.h, q.n); } +/** `make_contiguous` of arrays: the deque's own arrays, each lent by `of`. */ +export function dequeArrayMakeContiguous(q: VecDeque, of: (array: A) => S): ArraySlice { + return arraySliceOfSlice(dequeMakeContiguous(q), of); +} + /** `make_contiguous` of bytes, viewing the deque's. */ export function dequeByteMakeContiguous(q: VecDeque): ByteSlice { const h = contiguous(q); @@ -3904,6 +3913,12 @@ export function dequeAsSlices(q: VecDeque): [Slice, Slice] { return [new Slice(q.b as T[], phys(q, 0), n), new Slice(q.b as T[], 0, q.n - n)]; } +/** `as_slices` and `as_mut_slices` of arrays: the deque's own arrays, each lent by `of`. */ +export function dequeArraySlices(q: VecDeque, of: (array: A) => S): [ArraySlice, ArraySlice] { + const [a, b] = dequeAsSlices(q); + return [arraySliceOfSlice(a, of), arraySliceOfSlice(b, of)]; +} + /** `as_slices` and `as_mut_slices` of bytes, which view the deque's. */ export function dequeByteSlices(q: VecDeque): [ByteSlice, ByteSlice] { const n = firstEnd(q, 0, q.n); diff --git a/ts/runtime/rs/hash.ts b/ts/runtime/rs/hash.ts index c5018c119..5124a6754 100644 --- a/ts/runtime/rs/hash.ts +++ b/ts/runtime/rs/hash.ts @@ -5,7 +5,7 @@ // A hash collection hashes a key that is a JS object with a faster hasher of its own, // whose values nothing sees, as std keys a map's hasher at random. -import { ByteSlice, type ByteVec, type Elements, type None, Slice, sliceData, sliceItems, sliceLength, sliceStart, Vec } from "../rs.ts"; +import { ByteSlice, type ByteVec, type Elements, type None, Slice, sliceData, sliceItems, sliceLength, sliceStart } from "../rs.ts"; import { type i8, type i16, @@ -711,7 +711,7 @@ export function hashSlice(hash: (value: T, s: Hasher) => void): (items: Eleme export function hashInts(size: 1 | 2 | 4 | 8 | 16): (items: Elements, s: Hasher) => void { return (items, s) => { s.prefix(sliceLength(items)); - s.ints(items instanceof Slice ? sliceItems(items) : items instanceof Vec ? items.items : items, size); + s.ints(items instanceof Slice ? sliceItems(items) : sliceData(items), size); }; } diff --git a/ts/runtime/rs/iter.ts b/ts/runtime/rs/iter.ts index a687c45f3..d2e29a2d8 100644 --- a/ts/runtime/rs/iter.ts +++ b/ts/runtime/rs/iter.ts @@ -22,7 +22,7 @@ // `owned` functions follow it, dispatching on the kind, so a bundle that never drops an // item carries none of it. -import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, capReserve, type Debug, Err, type Fmt, type FmtResult, type Formatter, fmtBool, fmtDebugStructFields, fmtDebugTupleFields, fmtOption, type None, Ok, type Place, panic, place, type RangeBound, type Result, sliceItems, slicePart, type Slice, type SliceLike, Vec, vecCapacity, vecExtendFromSlice, vecFrom, vecHold, vecMax, vecWithCapacity } from "../rs.ts"; +import { ByteSlice, ByteVec, type ArrayRef, type ArraySlice, arraySliceItems, arraySliceAt, arraySlicePart, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, capReserve, type Debug, Err, type Fmt, type FmtResult, type Formatter, fmtBool, fmtDebugStructFields, fmtDebugTupleFields, fmtOption, type None, Ok, type Place, panic, place, type RangeBound, type Result, sliceItems, slicePart, type Slice, type SliceLike, Vec, vecCapacity, vecExtendFromSlice, vecFrom, vecHold, vecMax, vecWithCapacity } from "../rs.ts"; import { AtIndex, BTreeIter, HashIter, type Ordering } from "./collections.ts"; import { type Hasher, hash8 } from "./hash.ts"; import { charStep, intToBig, type Limbs, type Step, usizeDebug, lt as wideLt } from "./int.ts"; @@ -475,6 +475,31 @@ export function sliceRsplitn(s: Slice, n: number, f: (item: T) => boolean) return new SplitIter(s, s.data, s.start, slicePart, f, true, false, n); } +/** `slice::split` and `split_mut` of an array slice: the parts between the arrays `f` is true of, each lent where the slice holds it. */ +export function arraySliceSplit(r: ArraySlice, f: (run: S) => boolean): Iter> { + return new SplitIter(r, (i: number) => arraySliceAt(r, i), 0, arraySlicePart, f, false, false); +} + +/** `slice::rsplit` and `rsplit_mut` of an array slice. */ +export function arraySliceRsplit(r: ArraySlice, f: (run: S) => boolean): Iter> { + return new SplitIter(r, (i: number) => arraySliceAt(r, i), 0, arraySlicePart, f, true, false); +} + +/** `slice::split_inclusive` and `split_inclusive_mut` of an array slice. */ +export function arraySliceSplitInclusive(r: ArraySlice, f: (run: S) => boolean): Iter> { + return new SplitIter(r, (i: number) => arraySliceAt(r, i), 0, arraySlicePart, f, false, true); +} + +/** `slice::splitn` and `splitn_mut` of an array slice. */ +export function arraySliceSplitn(r: ArraySlice, n: number, f: (run: S) => boolean): Iter> { + return new SplitIter(r, (i: number) => arraySliceAt(r, i), 0, arraySlicePart, f, false, false, n); +} + +/** `slice::rsplitn` and `rsplitn_mut` of an array slice. */ +export function arraySliceRsplitn(r: ArraySlice, n: number, f: (run: S) => boolean): Iter> { + return new SplitIter(r, (i: number) => arraySliceAt(r, i), 0, arraySlicePart, f, true, false, n); +} + /** `slice::split` and `split_mut` of bytes, whose parts are views already. */ export function byteSliceSplit(s: ByteSlice, f: (byte: number) => boolean): Iter { return new SplitIter(s, s.data, s.start, byteSlicePart, f, false, false); @@ -516,6 +541,37 @@ function byteSlicePart(s: ByteSlice, start: number, end: number): ByteSlice { return new ByteSlice(s.data, s.start + start, end - start); } +/** `slice::iter` and `iter_mut` of an array slice: each array, lent where the slice holds it. */ +export function arraySliceIter(r: ArraySlice): Iter { + return new ArraySliceIter(r); +} + +/** `slice::windows` of an array slice. */ +export function arraySliceWindows(r: ArraySlice, size: number, at?: Location): Iter> { + if (size === 0) panic("window size must be non-zero", at, true); + return new PartsIter(r, r.length, size, 1, Math.max(r.length - size + 1, 0), false, arraySlicePart); +} + +/** `slice::chunks` and `chunks_mut` of an array slice. */ +export function arraySliceChunks(r: ArraySlice, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, false, false, arraySlicePart, at); +} + +/** `slice::chunks_exact` and `chunks_exact_mut` of an array slice. */ +export function arraySliceChunksExact(r: ArraySlice, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, true, false, arraySlicePart, at); +} + +/** `slice::rchunks` and `rchunks_mut` of an array slice. */ +export function arraySliceRchunks(r: ArraySlice, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, false, true, arraySlicePart, at); +} + +/** `slice::rchunks_exact` and `rchunks_exact_mut` of an array slice. */ +export function arraySliceRchunksExact(r: ArraySlice, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, true, true, arraySlicePart, at); +} + /** `Option::iter`, and with what drops its item, `option::IntoIter`. */ export function iterOption(o: T | undefined, drop?: Drop): Iter; export function iterOption(o: T | None, drop: Drop | undefined, none: None): Iter; @@ -1992,6 +2048,58 @@ class SliceIter extends Iter implements Disposable { } } +/** The arrays of a slice of arrays, from both ends, each lent where the slice holds it. */ +class ArraySliceIter extends Iter { + private readonly r: ArraySlice; + front = 0; + back: number; + + constructor(r: ArraySlice) { + super(); + this.r = r; + this.back = r.length; + } + + next(): S | Done { + return this.front < this.back ? arraySliceAt(this.r, this.front++) : DONE; + } + + override nextBack(): S | Done { + return this.front < this.back ? arraySliceAt(this.r, --this.back) : DONE; + } + + override len(): number { + return this.back - this.front; + } + + override sizeHint(): SizeHint { + return exactHint(this.len()); + } + + override remaining(): Iterable { + return arraySliceItems(arraySlicePart(this.r, this.front, this.back)); + } + + override clone(): Iter { + const it = new ArraySliceIter(this.r); + it.front = this.front; + it.back = this.back; + return it; + } + + override advanceBy(n: number): number { + const step = Math.min(n, this.back - this.front); + this.front += step; + return n - step; + } + + override advanceBackBy(n: number): number { + const step = Math.min(n, this.back - this.front); + this.back -= step; + return n - step; + } +} + /** The places of a slice's elements, from both ends. */ class SliceMutIter extends Iter> { private readonly s: { [i: number]: T; length: number }; @@ -2156,7 +2264,8 @@ class PartsIter extends Iter { */ class SplitIter extends Iter implements Disposable { readonly #s: S; - readonly #items: ArrayLike; + /** The items, from `#offset`, or what reads item `i`, as an array slice lends each array only once read. */ + readonly #items: ArrayLike | ((i: number) => T); readonly #offset: number; readonly #part: (s: S, start: number, end: number) => S; readonly #f: (item: T) => boolean; @@ -2172,7 +2281,7 @@ class SplitIter extends Iter implements Disposable { #finished: boolean; #dropped = false; - constructor(s: S, items: ArrayLike, offset: number, part: (s: S, start: number, end: number) => S, f: (item: T) => boolean, rev: boolean, inclusive: boolean, count?: number) { + constructor(s: S, items: ArrayLike | ((i: number) => T), offset: number, part: (s: S, start: number, end: number) => S, f: (item: T) => boolean, rev: boolean, inclusive: boolean, count?: number) { super(); this.#s = s; this.#items = items; @@ -2187,6 +2296,12 @@ class SplitIter extends Iter implements Disposable { this.#finished = inclusive && this.#end === 0; } + /** Item `i` of what is split. */ + #at(i: number): T { + const items = this.#items; + return typeof items === "function" ? items(i) : items[this.#offset + i]; + } + override clone(h?: Clones): Iter { const it = new SplitIter(this.#s, this.#items, this.#offset, this.#part, cloned(this.#f, h?.f), this.#rev, this.#inclusive, this.#count); it.#start = this.#start; @@ -2247,7 +2362,7 @@ class SplitIter extends Iter implements Disposable { if (this.#finished) return DONE; const start = this.#start; let i = start; - while (i < this.#end && !this.#f(this.#items[this.#offset + i])) i++; + while (i < this.#end && !this.#f(this.#at(i))) i++; if (this.#inclusive) { const end = Math.min(i + 1, this.#end); if (end === this.#end) this.#finished = true; @@ -2264,7 +2379,7 @@ class SplitIter extends Iter implements Disposable { const end = this.#end; // The last element ends an inclusive part whether it is a separator or not. let i = this.#inclusive ? Math.max(end - 1, this.#start) : end; - while (i > this.#start && !this.#f(this.#items[this.#offset + i - 1])) i--; + while (i > this.#start && !this.#f(this.#at(i - 1))) i--; if (this.#inclusive) { if (i === this.#start) this.#finished = true; this.#end = i; diff --git a/ts/runtime/rs/task.ts b/ts/runtime/rs/task.ts index 9a14842ed..e168edf2c 100644 --- a/ts/runtime/rs/task.ts +++ b/ts/runtime/rs/task.ts @@ -4,7 +4,7 @@ // A value whose drop JS can observe has `[Symbol.dispose]`, which runs its `Drop` impl // and drops its fields. `None` is `undefined`, which drops as nothing. -import { Abort, arrayAssign, type ByteSlice, type CloneFrom, cloneOver, type Debug, type DebugStruct, debugStructField, debugStructFinish, debugStructFinishNonExhaustive, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtBool, fmtDebugStruct, fmtDebugTuple, fmtDebugTupleFields, fmtPad, fmtStr, type None, NULL, objectCopy, OK, Ok, Panic, panic, type Place, place, ptrErase, ptrHome, ptrNowhere, ptrWrite, type Result, Slice, stringAsBytes, type Vec } from "../rs.ts"; +import { Abort, arrayAssign, type ByteSlice, type ArrayRef, type LentArray, type ElemCopy, ArraySlice, arraySliceItems, arraySliceCopy, arraySliceSet, type CloneFrom, cloneOver, type Debug, type DebugStruct, debugStructField, debugStructFinish, debugStructFinishNonExhaustive, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtBool, fmtDebugStruct, fmtDebugTuple, fmtDebugTupleFields, fmtPad, fmtStr, type None, NULL, objectCopy, OK, Ok, Panic, panic, type Place, place, ptrErase, ptrHome, ptrNowhere, ptrWrite, type Result, Slice, stringAsBytes, type Vec } from "../rs.ts"; import type { Hasher } from "./hash.ts"; import type { Location } from "./location.ts"; @@ -16,8 +16,9 @@ export function drop(value: unknown): void { } /** Drop every element of `values`, an array or a boxed slice, from `from` on, in order, by `f` if it has no `[Symbol.dispose]`. */ -export function dropAll(values: ArrayLike | Slice | undefined, f: (value: T) => void = drop, from = 0): void { +export function dropAll(values: ArrayLike | Slice | ArraySlice | undefined, f: (value: T) => void = drop, from = 0): void { if (values instanceof Slice) dropRange(values.data, f, values.start + from, values.start + values.length); + else if (values instanceof ArraySlice) dropRange(arraySliceItems(values) as unknown as ArrayLike, f, from, values.length); else if (values !== undefined) dropRange(values, f, from, values.length); } @@ -911,6 +912,14 @@ export function cellOfPlace(p: Place): Cell { return p as Cell; } +/** + * `Cell::from_mut` of a `&mut [[T; N]; M]`, which is the arrays `r`: a read is a copy of + * them, each element copied by `copy`, and a write lands where `r` holds them. + */ +export function cellOfArraySlice(r: ArraySlice, copy?: ElemCopy): Cell[]> { + return cellOfPlace(place(() => arraySliceCopy(r, copy), (value) => arraySliceSet(r, value))); +} + /** * `Cell::from_mut` of the object or the bytes a `&mut` is: a read is a copy, as a `Cell` * only moves or copies its value out, and a write lands in place, a JS array's taking diff --git a/ts/src/lower/array_slice.rs b/ts/src/lower/array_slice.rs new file mode 100644 index 000000000..205d33afd --- /dev/null +++ b/ts/src/lower/array_slice.rs @@ -0,0 +1,173 @@ +//! Slices of arrays, which are `rs.ArraySlice`: a `&[[T; N]]` lends each array as the slice a +//! `&[T; N]` is, where the slice holds it, whether its arrays are each an array's own, as a +//! `Vec<[T; N]>` holds them, or parts of one slice, as `as_chunks` splits it. The runtime's +//! `arraySlice` functions map std's methods that lend arrays or parts. Any other method of a +//! slice of arrays reads it as an `rs.Slice` of JS arrays: shared, of its arrays themselves, or +//! of copies of those `as_chunks` split from one slice, which have no array of their own; and +//! mutable, of copies that `rs.arraySliceBy` writes back once it returns, as Rust moves their +//! elements. + +use rustc_middle::ty::{self, Ty, TyCtxt}; + +use super::body::Body; +use super::library::{self, Call}; +use crate::ts::{Expr, Param, Stmt, StmtKind, Type}; + +/// Whether `ty` is a slice or array of arrays, which behind a reference is an `rs.ArraySlice`. +pub fn of_arrays(ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Slice(elem) | ty::Array(elem, _) if elem.is_array()) +} + +/// Whether std's `def_id` of `args` is a method of a slice of arrays the runtime's own +/// functions map, which take and lend the arrays where the slice holds them. +pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: ty::GenericArgsRef<'tcx>) -> bool { + let Some((owner, name)) = library::key(tcx, def_id) else { + return false; + }; + owner == "slice" + && args.types().next().is_some_and(|elem| elem.is_array()) + && matches!( + name.as_str(), + "len" + | "is_empty" + | "first" + | "last" + | "get" + | "first_mut" + | "last_mut" + | "get_mut" + | "split_first" + | "split_last" + | "split_first_mut" + | "split_last_mut" + | "split_at" + | "split_at_mut" + | "split_at_checked" + | "split_at_mut_checked" + | "windows" + | "chunks" + | "chunks_exact" + | "rchunks" + | "rchunks_exact" + | "chunks_mut" + | "chunks_exact_mut" + | "rchunks_mut" + | "rchunks_exact_mut" + | "as_chunks" + | "as_rchunks" + | "as_chunks_mut" + | "as_rchunks_mut" + | "first_chunk" + | "first_chunk_mut" + | "last_chunk" + | "last_chunk_mut" + | "split_first_chunk" + | "split_first_chunk_mut" + | "split_last_chunk" + | "split_last_chunk_mut" + | "swap" + | "iter" + | "iter_mut" + | "split" + | "split_mut" + | "rsplit" + | "rsplit_mut" + | "split_inclusive" + | "split_inclusive_mut" + | "splitn" + | "splitn_mut" + | "rsplitn" + | "rsplitn_mut" + | "to_vec" + ) +} + +/// `args` as std's mapping of `call` reads them, unless [`native`] maps it: each +/// `&[[T; N]]` it reads as a slice given as `rs.arraySliceAsSlice`' copies, and each `&mut` one by +/// name, which [`wrap`] binds to `rs.arraySliceBy`'s copies. A function that returns a borrow, +/// which may be of the copies, is refused. +pub fn give<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> Result { + let tcx = b.t.tcx; + let mut given = Given { args, by: Vec::new() }; + // Only std's own functions and methods; a trait's mapping reads arrays as their type says. + if native(tcx, call.def_id, call.args) || tcx.trait_of_assoc(call.def_id).is_some() { + return Ok(given); + } + let generic = tcx + .fn_sig(call.def_id) + .instantiate_identity() + .skip_norm_wip() + .skip_binder(); + let sig = b.t.sig(call.def_id, call.args); + let mut any = false; + for (i, (&g, &ty)) in std::iter::zip(generic.inputs(), sig.inputs()).enumerate() { + // What std takes by a reference of its own, not a value it holds as it is. + let (ty::Ref(..), ty::Ref(_, inner, mutability)) = (g.kind(), ty.kind()) else { + continue; + }; + // A reference to an array of arrays std takes as a `&T` [`super::lend::give`]s. + if !(inner.is_slice() && of_arrays(*inner)) || i >= given.args.len() { + continue; + } + any = true; + let value = std::mem::replace(&mut given.args[i], Expr::undefined()); + given.args[i] = match mutability { + ty::Mutability::Not => Expr::rs("arraySliceAsSlice", vec![value]), + ty::Mutability::Mut => { + let name = b.fresh("arrays"); + let copy = b.t.elem_copy(*inner, call.span); + given.by.push(By { + name: name.clone(), + value, + copy, + }); + Expr::ident(name) + } + }; + } + if any && generic.output().walk().any(|arg| arg.as_region().is_some()) { + let path = tcx.def_path_str(call.def_id); + return Err(b.err( + call.span, + format!("`{path}` of a slice of arrays, which lends part of it, which is not supported yet"), + )); + } + Ok(given) +} + +/// What [`give`] makes of a call's arguments. +pub struct Given { + /// The arguments std's mapping takes. + pub args: Vec, + /// Each `&mut [[T; N]]` given by name. + pub by: Vec, +} + +/// A `&mut [[T; N]]` [`give`] names in a call's arguments. +pub struct By { + /// Its name in the arguments. + pub name: String, + /// The arrays. + pub value: Expr, + /// What copies an element of the arrays out, as [`super::Translator::elem_copy`] says. + pub copy: Option, +} + +/// `e`, the call std's mapping made of [`Given::args`], a `ty`, after `stmts`, with each +/// name it binds the `rs.arraySliceBy` copies of its arrays. +pub fn wrap(e: Expr, ty: Type, stmts: Vec, by: Vec) -> Expr { + let mut stmts = Some(stmts); + let mut e = e; + for By { name, value, copy } in by.into_iter().rev() { + let param = Param { name, ty: None }; + let f = match stmts.take().filter(|s| !s.is_empty()) { + Some(mut body) => { + body.push(StmtKind::Return(Some(e)).at(None)); + Expr::Arrow(vec![param], ty.clone(), body) + } + None => Expr::Lambda(vec![param], Box::new(e)), + }; + e = Expr::rs("arraySliceBy", [vec![value, f], copy.into_iter().collect()].concat()); + } + e +} diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 197a0e188..5a1b759e0 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -242,7 +242,7 @@ pub fn call<'tcx>( && (key.is_array() || b.t.std_of(key) == Some(Std::Vec)) && let Some(at) = args.get_mut(1) { - *at = Expr::rs("sliceItems", vec![std::mem::replace(at, Expr::undefined())]); + *at = super::library::items_of(std::mem::replace(at, Expr::undefined()), *elem); } // Elements of any form, an array, a slice, or a `Vec`, hash and compare alike, so each // finds the others. A reference key finds what it points at by that value's own impls, @@ -1850,6 +1850,10 @@ fn deque<'tcx>( (_, "rotate_left") => Expr::rs("dequeRotate", values), (_, "rotate_right") => Expr::rs("dequeRotate", flagged(values, true, false)), (_, "make_contiguous") if super::byte(item) => Expr::rs("dequeByteMakeContiguous", values), + (_, "make_contiguous") if item.is_array() => { + values.push(super::array_fn(item, "From")); + Expr::rs("dequeArrayMakeContiguous", values) + } (_, "make_contiguous") => Expr::rs("dequeMakeContiguous", values), (_, "binary_search") => { values.push(cmp_fn(b, item, false, span)); @@ -1884,8 +1888,12 @@ fn deque<'tcx>( ranged.after(Expr::rs(f, values)) } // Each a copy of its part of the buffer, or with `_mut`, a view that writes into it; - // bytes are views either way. + // bytes and arrays are views either way. (_, "as_slices" | "as_mut_slices") if super::byte(item) => Expr::rs("dequeByteSlices", values), + (_, "as_slices" | "as_mut_slices") if item.is_array() => { + values.push(super::array_fn(item, "From")); + Expr::rs("dequeArraySlices", values) + } (_, "as_slices" | "as_mut_slices") => Expr::rs("dequeAsSlices", values), (_, "drain") => { let ranged = bounds(b, call, values.pop()?); @@ -2086,6 +2094,7 @@ fn heap<'tcx>( .call(vec![values.pop()?.member("items")]), ], ), + (_, "as_slice") if item.is_array() => super::slice_items_from(values.pop()?.member("items"), item), (_, "as_slice") => values.pop()?.member("items"), (_, "clear") => Expr::rs("heapClear", values), (_, "drain") => { diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index e9744dbd3..17d590ccf 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -74,10 +74,10 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(items)], ), - _ => Expr::rs("sliceFrom", vec![Expr::Array(items)]), + _ => super::slice_items_from(Expr::Array(items), *elem), } } - _ if inner.is_array() => super::array_fn(*inner, "From").call(vec![self.value(*inner, valtree, span)]), + _ if inner.is_array() => super::array_slice(*inner, 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 2bd85b9a3..1d4924d77 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -152,11 +152,30 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if super::byte(elem) { return Expr::rs("byteSliceToArray", vec![s]); } + // An array slice of arrays, as a slice holds them, but not of a wrapper's, which is an element. + if elem.is_array() { + let copy = self.array_copy_fn(elem, span); + return Expr::rs("arraySliceToArray", vec![s, copy]); + } let mut values = vec![s]; values.extend(self.changes(elem).then(|| self.shim(elem, span)).flatten()); Expr::rs("sliceToArray", values) } + /// What copies an element of the arrays of `ty`, an array or slice of arrays, as arrays + /// copied out and written back read it: a `Copy` value's copy where it is an object, and + /// `rs.objectCopy` of an object a write lands in, which a write of the arrays back changes. + pub fn elem_copy(&mut self, ty: Ty<'tcx>, span: Span) -> Option { + let mut elem = self.uninit_inner(ty); + while let ty::Array(inner, _) | ty::Slice(inner) = elem.kind() { + elem = *inner; + } + match self.changes(elem) { + true => self.shim(elem, span), + false => self.write_in(elem).map(|_| Expr::Rs("objectCopy".into())), + } + } + /// 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) { diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 577f8368a..08137630c 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -830,6 +830,10 @@ fn peeled_into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, ty.ref_mutability() == Some(ty::Mutability::Mut) && b.t.needs_place(elem) }; match ty.peel_refs().kind() { + // Each array, where a slice of arrays holds it. + ty::Slice(elem) | ty::Array(elem, _) if ty.is_ref() && elem.is_array() => { + Some(Expr::rs("arraySliceIter", vec![value])) + } ty::Slice(elem) | ty::Array(elem, _) if places(b, *elem) => { Some(Expr::rs("iterSliceMut", vec![library::slice_of(value, ty)])) } @@ -1036,6 +1040,7 @@ pub fn call<'tcx>( ("slice", "iter_mut") if b.t.needs_place(targ(0)?) => { return Some(Expr::rs("iterSliceMut", args)); } + ("slice", "iter" | "iter_mut") if targ(0)?.is_array() => return Some(Expr::rs("arraySliceIter", args)), ("slice", "iter" | "iter_mut") => { let s = args.pop()?; let s = library::elements(s, Ty::new_slice(tcx, targ(0)?)); @@ -1385,7 +1390,7 @@ pub fn call<'tcx>( name: name.into(), ty: None, }; - let slice = super::array_fn(expected, "From").call(vec![Expr::ident("b")]); + let slice = super::array_slice(expected, Expr::ident("b")); let call = eq.call(vec![Expr::ident("a"), slice]); Expr::Lambda(vec![param("a"), param("b")], Box::new(call)) } diff --git a/ts/src/lower/lend.rs b/ts/src/lower/lend.rs index fb9f68fe8..01f0593d7 100644 --- a/ts/src/lower/lend.rs +++ b/ts/src/lower/lend.rs @@ -56,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_array) { + if t.translated(def_id, args) || !args.types().any(owns_array) || super::array_slice::native(tcx, def_id, args) { return Plan::Untouched; } let self_ty = args.types().next(); @@ -405,6 +405,17 @@ fn cross_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, w if let ty::Ref(_, inner, mutability) = ty.kind() && let ty::Array(elem, _) = inner.kind() { + // An array slice, each array lent as its own `From` lends it, and given as copies, which a `&` reads. + if elem.is_array() { + return match (way, mutability) { + (Way::Lent, _) => super::array_fn(*inner, "From"), + (Way::Given, ty::Mutability::Not) => Expr::Rs("arraySliceItems".into()), + (Way::Given, ty::Mutability::Mut) => b.err( + span, + format!("giving std a `{ty}` to write through as an array, which is not supported yet"), + ), + }; + } return Expr::Rs( match (way, super::byte(*elem), mutability) { (Way::Lent, true, _) => "byteSliceFrom", diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 306620653..b877768ae 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -635,6 +635,7 @@ pub fn cow_deref(cow: Expr, borrowed: Ty<'_>) -> Expr { match borrowed.kind() { ty::Str => Expr::rs("strCowStr", vec![cow]), _ if cow_bytes(borrowed) => Expr::rs("byteCowSlice", vec![cow]), + ty::Slice(elem) if elem.is_array() => Expr::rs("cowArraySlice", vec![cow, super::array_fn(*elem, "From")]), _ => Expr::rs("cowSlice", vec![cow]), } } @@ -1486,7 +1487,18 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec *value = super::lend::lend_closure(b, f, &closure.params, holds, call.span, out); } } - let mut e = mapping(b, call, owner.clone(), name.clone(), discarded, args, out)?; + let given = match super::array_slice::give(b, call, args) { + Ok(given) => given, + Err(e) => return Some(e), + }; + let mut stmts = Vec::new(); + let mut e = mapping(b, call, owner.clone(), name.clone(), discarded, given.args, &mut stmts)?; + if given.by.is_empty() { + out.extend(stmts); + } else { + let ty = b.t.ty(b.t.sig(call.def_id, call.args).output(), call.span); + e = super::array_slice::wrap(e, ty, stmts, given.by); + } if let Some((generic, ty)) = lent.and_then(|lent| lent.output) { e = super::lend::lend(b, generic, ty, e, call.span); } @@ -1937,6 +1949,11 @@ fn mapping<'tcx>( ("Option", "as_ref" | "as_mut") => args.pop()?, // The payload, if any, as a slice of one, as `slice::from_ref` makes it. ("Option", "as_slice") if byte(targ(gargs, 0)) => Expr::rs("byteOptionAsSlice", args), + // Of an array, the arrays of the one it holds, if any. + ("Option", "as_slice") if targ(gargs, 0).is_array() => { + args.push(super::array_fn(targ(gargs, 0), "From")); + Expr::rs("optionAsArraySlice", args) + } ("Option", "as_slice") => { args.extend(b.t.none_arg(targ(gargs, 0))); Expr::rs("optionAsSlice", args) @@ -2106,11 +2123,7 @@ fn mapping<'tcx>( ("slice", "split_first" | "split_at" | "split_at_checked" | "first" | "get") if name != "get" || Int::of(targ(gargs, 1)).is_some() => { - let of = match byte(targ(gargs, 0)) { - true => "byteSlice", - false => "slice", - }; - rt2(args, of, &super::camel(&name)) + rt2(args, slice_of_elem(targ(gargs, 0)), &super::camel(&name)) } // An element JS copies is lent as its place, and an object as itself. ("slice", "first_mut" | "last_mut" | "get_mut") if name != "get_mut" || Int::of(targ(gargs, 1)).is_some() => { @@ -2120,21 +2133,25 @@ fn mapping<'tcx>( true => name.as_str(), false => name.strip_suffix("_mut")?, }; - rt2(values, "slice", &super::camel(name)) + let of = match elem.is_array() { + true => "arraySlice", + false => "slice", + }; + rt2(values, of, &super::camel(name)) } ("slice", "windows" | "chunks" | "chunks_exact" | "rchunks" | "rchunks_exact") => { rt2(args, slice_of_elem(targ(gargs, 0)), &super::camel(&name)) } - // Each run of `N` as an array: shared, a copy, which a shared borrow can't tell from - // the slice's own elements, and mutable, the runtime's view of where the slice holds it. + // An array slice of `N`-element arrays lent where the slice holds them, shared or mutable alike, of any slice. ("slice", "as_chunks" | "as_rchunks" | "as_chunks_mut" | "as_rchunks_mut") => { let n = gargs.consts().next()?.try_to_target_usize(tcx)?; let mut values = args; values.push(Expr::lit(n.to_string())); - match byte(targ(gargs, 0)) { - true => rt2(values, "byteSlice", &super::camel(&name)), - false => rt2(values, "slice", &super::camel(&name)), - } + rt2( + values, + "slice", + &super::camel(name.strip_suffix("_mut").unwrap_or(&name)), + ) } // A part is a slice of the same storage, shared or mutable alike. ("slice", "chunks_mut" | "chunks_exact_mut" | "rchunks_mut" | "rchunks_exact_mut") => rt2( @@ -2168,6 +2185,7 @@ fn mapping<'tcx>( // The element is lent as `first_mut` lends it. ("slice", "split_first_mut" | "split_last_mut") => match byte(targ(gargs, 0)) { true => rt2(args, "byteSlice", &super::camel(&name)), + false if targ(gargs, 0).is_array() => rt2(args, "arraySlice", &super::camel(name.strip_suffix("_mut")?)), false => { let mut values = args; values.push(Expr::lit(b.t.needs_place(targ(gargs, 0)).to_string())); @@ -2213,7 +2231,7 @@ fn mapping<'tcx>( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![value])], ), - false => Expr::rs("sliceFrom", vec![Expr::Array(vec![value])]), + false => super::slice_items_from(Expr::Array(vec![value]), targ(gargs, 0)), } } // A slice or a `str` as itself. @@ -2222,10 +2240,7 @@ fn mapping<'tcx>( ("AsRef", "as_ref") | ("AsMut", "as_mut") | ("Borrow", "borrow") | ("BorrowMut", "borrow_mut") if targ(gargs, 0).is_array() && targ(gargs, 1).is_slice() => { - slice_of( - args.pop()?, - Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, targ(gargs, 0)), - ) + args.pop()? } // A `Vec` as its slice, as `as_slice` has it, or as itself. ("AsRef", "as_ref") | ("AsMut", "as_mut") | ("Borrow", "borrow") | ("BorrowMut", "borrow_mut") @@ -2316,6 +2331,11 @@ fn mapping<'tcx>( values.push(super::collections::clone_fn(b, elem, span)); Expr::rs("sliceWriteCloneOfSlice", values) } + // Of arrays, the arrays of the same arrays, which a slice of their `MaybeUninit`s holds. + ("slice", "assume_init_ref" | "assume_init_mut") if targ(gargs, 0).is_array() => Expr::rs( + "arraySliceOfSlice", + vec![args.pop()?, super::array_fn(targ(gargs, 0), "From")], + ), ("slice", "assume_init_ref" | "assume_init_mut") => args.pop()?, ("slice", "clone_from_slice") => { let mut values = args; @@ -2328,10 +2348,13 @@ fn mapping<'tcx>( Expr::rs("byteSliceEq", args) } ("slice", "to_vec") => slice_to_vec(b, args.pop()?, targ(gargs, 0), span), - ("slice", "last" | "swap") => match byte(targ(gargs, 0)) { - true => rt2(args, "byteSlice", &super::camel(&name)), - false => rt2(args, "slice", &super::camel(&name)), - }, + // A swap of arrays copies each out, as a write of it back reads it. + ("slice", "swap") if targ(gargs, 0).is_array() => { + let mut values = args; + values.push(b.t.elem_copy(targ(gargs, 0), span).unwrap_or_else(Expr::undefined)); + Expr::rs("arraySliceSwap", values) + } + ("slice", "last" | "swap") => rt2(args, slice_of_elem(targ(gargs, 0)), &super::camel(&name)), ("slice", "reverse") => match byte(targ(gargs, 0)) { true => Expr::rs("byteSliceView", args).method("reverse", Vec::new()), false => Expr::rs("sliceReverse", args), @@ -2478,7 +2501,13 @@ fn mapping<'tcx>( .boxed_ty() .is_some_and(|t| t.is_slice()) => { - args.pop()? + match targ(gargs, 0).is_array() { + true => Expr::rs( + "arraySliceOfSlice", + vec![args.pop()?, super::array_fn(targ(gargs, 0), "From")], + ), + false => args.pop()?, + } } // `vec![x; n]`: `n - 1` clones of `x`, then `x` itself, which the caller gives as its // own, as it does whatever std keeps, or `x` dropped where `n` is 0. @@ -3135,6 +3164,9 @@ fn mapping<'tcx>( if name == "each_mut" && b.t.needs_place(elem) { return Some(Expr::rs("slicePlaces", vec![s])); } + if elem.is_array() { + return Some(Expr::rs("arraySliceEach", vec![s])); + } let a = match byte(elem) { true => Expr::rs("byteSliceView", vec![s]), false => slice_items(s), @@ -3368,8 +3400,22 @@ pub(super) fn box_slice_clone_from<'tcx>( if byte(elem) { return Expr::rs("byteBoxSliceCloneFrom", vec![slot, source]); } + let (name, fns) = box_slice_clone_from_fns(b, elem, span); + Expr::rs(name, [vec![slot, source], fns].concat()) +} + +/// The runtime's `clone_from` of a `Box<[elem]>` of other than bytes, and what it takes +/// after the box it writes over and its source: of arrays, the arrays' own, which makes arrays +/// of a clone by `array_fn`'s `From`. +fn box_slice_clone_from_fns<'tcx>(b: &mut Body<'_, '_, 'tcx>, elem: Ty<'tcx>, span: Span) -> (&'static str, Vec) { let fns = clone_from_fns(b, elem, span); - Expr::rs("boxSliceCloneFrom", [vec![slot, source], fns].concat()) + match elem.is_array() { + true => ( + "arraySliceBoxCloneFrom", + [vec![super::array_fn(elem, "From")], fns].concat(), + ), + false => ("boxSliceCloneFrom", fns), + } } /// What `clone_from` of `source` leaves over `old`, a `ty` whose `clone_from` is std's own @@ -3414,7 +3460,7 @@ fn std_clone_from<'tcx>( return Ok(("arrayCloneFrom", clone_from_fns(b, *elem, span))); } if let Some(elem) = box_slice(b.t.tcx, own) { - return Ok(("boxSliceCloneFrom", clone_from_fns(b, elem, span))); + return Ok(box_slice_clone_from_fns(b, elem, span)); } let refused = |b: &mut Body<'_, '_, 'tcx>| { b.err( @@ -3572,20 +3618,46 @@ fn slices_join<'tcx>( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![sep])], ), + // An array separator is the array slice of it alone, whose elements the join clones as + // they are, so each `Clone` reads the separator's own. + (true, false) if let ty::Array(_, len) = elem.kind() => { + let n = len.try_to_target_usize(b.t.tcx).unwrap_or(0); + let one = Expr::rs("arraySliceOne", vec![sep, Expr::lit(n.to_string())]); + Expr::rs("arraySliceAsSlice", vec![one]) + } (true, false) => Expr::rs("sliceFrom", vec![Expr::Array(vec![sep])]), + // An array slice, as the slice of its arrays. + (false, false) if join && elem.is_array() => Expr::rs("arraySliceAsSlice", vec![sep]), (false, _) => sep, }; let items = args.pop()?; // What reads an item as its slice, unless it is one. + let rs = |f: &str| Some(Expr::Rs(f.into())); let slice = match item.kind() { - ty::Array(..) => Some(if bytes { "byteSliceFrom" } else { "sliceFrom" }), + ty::Array(..) => rs(if bytes { "byteSliceFrom" } else { "sliceFrom" }), + // An array slice, as a slice of its arrays. + ty::Ref(_, s, _) if super::array_slice::of_arrays(*s) => rs("arraySliceAsSlice"), ty::Ref(_, s, _) if s.is_slice() => None, - _ if b.t.std_of(item) == Some(Std::Vec) => Some(if bytes { "byteVecSlice" } else { "vecSlice" }), - _ if cow_slice(b.t.tcx, item).is_some() => Some(if bytes { "byteCowSlice" } else { "cowSlice" }), + _ if b.t.std_of(item) == Some(Std::Vec) => rs(if bytes { "byteVecSlice" } else { "vecSlice" }), + _ if let Some(elem) = cow_slice(b.t.tcx, item) + && elem.is_array() => + { + let runs = cow_deref(Expr::ident("c"), Ty::new_slice(b.t.tcx, elem)); + let param = crate::ts::Param { + name: "c".into(), + ty: None, + }; + Some(Expr::Lambda( + vec![param], + Box::new(Expr::rs("arraySliceAsSlice", vec![runs])), + )) + } + _ if cow_slice(b.t.tcx, item).is_some() => rs(if bytes { "byteCowSlice" } else { "cowSlice" }), + _ if box_slice(b.t.tcx, item).is_some_and(|elem| elem.is_array()) => rs("arraySliceAsSlice"), _ if box_slice(b.t.tcx, item).is_some() => None, _ => return None, }; - let slice = slice.map_or_else(Expr::undefined, |f| Expr::Rs(f.into())); + let slice = slice.unwrap_or_else(Expr::undefined); if bytes { return Some(Expr::rs("byteSlicesJoin", trimmed(vec![items, sep, slice]))); } @@ -3626,8 +3698,9 @@ pub(super) fn slice_to_vec<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: /// them if each element's clone is itself, or else each element cloned. fn items_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, span: Span) -> Expr { match super::collections::clone_fn(b, elem, span) { + Expr::Lit(l) if l == "undefined" && elem.is_array() => Expr::rs("arraySliceCopy", vec![slice]), Expr::Lit(l) if l == "undefined" => Expr::rs("sliceToArray", vec![slice]), - clone => slice_items(slice).method("map", vec![clone]), + clone => items_of(slice, elem).method("map", vec![clone]), } } @@ -3654,7 +3727,7 @@ fn slice_boxed<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, sp "byteSliceFrom", vec![Expr::rs("byteSliceToArray", vec![slice])], )), - _ => Some(Expr::rs("sliceFrom", vec![items_clone(b, slice, elem, span)])), + _ => Some(super::slice_items_from(items_clone(b, slice, elem, span), elem)), } } @@ -3668,16 +3741,13 @@ pub(super) fn vec_boxed(v: Expr, elem: Ty<'_>) -> Expr { fn boxed_vec(boxed: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { _ if byte(elem) => Expr::rs("byteSliceToByteVec", vec![boxed]), - _ => Expr::rs("vecFrom", vec![slice_items(boxed)]), + _ => Expr::rs("vecFrom", vec![items_of(boxed, elem)]), } } /// The `Box<[elem]>` that `From<[elem; N]>` moves `array` into: its elements. fn array_boxed(array: Expr, elem: Ty<'_>) -> Expr { - match elem.kind() { - _ if byte(elem) => Expr::rs("byteSliceFrom", vec![array]), - _ => Expr::rs("sliceFrom", vec![array]), - } + super::slice_items_from(array, elem) } /// The operator a binary operator trait, `Add` or another, applies. @@ -4097,11 +4167,13 @@ pub fn primitive(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Char) || super::float::is(ty) } -/// The prefix of the runtime's functions of a slice of `elem`: `byteSlice` of bytes. +/// The prefix of the runtime's functions of a slice of `elem`: `byteSlice` of bytes, and +/// `arraySlice` of arrays. fn slice_of_elem(elem: Ty<'_>) -> &'static str { - match byte(elem) { - true => "byteSlice", - false => "slice", + match elem.kind() { + _ if byte(elem) => "byteSlice", + ty::Array(..) => "arraySlice", + _ => "slice", } } @@ -4110,7 +4182,7 @@ fn slice_of_elem(elem: Ty<'_>) -> &'static str { pub fn vec_view(v: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { _ if byte(elem) => Expr::rs("byteVecSlice", vec![v]), - _ => Expr::rs("sliceFrom", vec![v.member("items")]), + _ => super::slice_items_from(v.member("items"), elem), } } @@ -4136,6 +4208,8 @@ pub fn vec_new(bytes: bool) -> Expr { pub fn elements(v: Expr, ty: Ty<'_>) -> Expr { match ty.peel_refs().kind() { ty::Slice(elem) if byte(*elem) => Expr::rs("byteSliceView", vec![v]), + // The arrays of a slice of arrays, as `rs.arraySliceItems` reads them. + ty::Slice(elem) | ty::Array(elem, _) if elem.is_array() && (ty.is_ref() || ty.is_slice()) => items_of(v, *elem), 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), @@ -4153,6 +4227,15 @@ pub fn slice_items(s: Expr) -> Expr { array_of(s, "sliceItems") } +/// The elements of `s`, a slice of `elem`s, as [`slice_items`] reads them: of arrays, the +/// arrays of its arrays, as `rs.arraySliceItems` reads them. +pub fn items_of(s: Expr, elem: Ty<'_>) -> Expr { + match elem.is_array() { + true => array_of(s, "arraySliceItems"), + false => slice_items(s), + } +} + /// 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 { @@ -4165,6 +4248,10 @@ fn array_of(s: Expr, read: &str) -> Expr { Expr::Call(f, mut args) if matches!(&*f, Expr::Rs(n) if n == "sliceFrom") && args.len() == 1 => { args.pop().unwrap() } + // All of the arrays of a slice of arrays, which only a read takes as they are. + Expr::Call(f, mut args) if matches!(&*f, Expr::Rs(n) if n == "arraySliceFrom") && read == "arraySliceItems" => { + args.swap_remove(0) + } s => Expr::rs(read, vec![s]), } } @@ -4182,14 +4269,14 @@ pub fn slice_from(items: Expr) -> Expr { } } -/// The slice of a slice, array, or `Vec`, a `ty`: an `rs.ByteSlice` of bytes, and an -/// `rs.Slice` of other values, which the runtime's slice functions read and write. +/// The slice of a slice, array, or `Vec`, a `ty`: an `rs.ByteSlice` of bytes, an `rs.ArraySlice` +/// of arrays, and an `rs.Slice` of other values, which the runtime's slice functions read +/// and write. pub fn slice_of(v: Expr, ty: Ty<'_>) -> Expr { match ty.peel_refs().kind() { ty::Slice(_) => 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::Array(elem, _) => super::slice_items_from(v, *elem), ty::Adt(_, args) => vec_view(v, args.type_at(0)), _ => v, } @@ -4252,7 +4339,7 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span, "byteSliceFrom", vec![Expr::New(Box::new(Expr::ident("Uint8Array")), vec![Expr::lit("0")])], ), - ty::Slice(_) => Expr::rs("sliceFrom", vec![Expr::Array(Vec::new())]), + ty::Slice(elem) => super::slice_items_from(Expr::Array(Vec::new()), *elem), ty::Str => Expr::Str(String::new()), _ => return None, }, diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 4da8a6602..c8ed36ec5 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -655,6 +655,19 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // 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); + // Of an array of arrays, the arrays' arrays, as `rs.arraySliceBy` writes them back. + if elem.is_array() { + let name = self.b.fresh("arrays"); + let source = Expr::rs("arraySliceAsSlice", vec![source]); + let e = Expr::rs( + "sliceCloneFromSlice", + [vec![Expr::ident(name.clone()), source], fns].concat(), + ); + let copy = self.b.t.elem_copy(ty, span); + let by = crate::lower::array_slice::By { name, value: to, copy }; + let e = crate::lower::array_slice::wrap(e, ts::Type::Builtin("void"), Vec::new(), vec![by]); + return done(e, true); + } return done(Expr::rs("sliceCloneFromSlice", [vec![to, source], fns].concat()), true); } done(library::clone_from(self.b, to, source, ty, span), true) @@ -999,6 +1012,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { return done(target, true); }; let none = target.clone().binary("===", self.b.t.none(inner)); + // Of an array, the arrays of it alone, which a write lands in, or of none. + if inner.is_array() { + let of = crate::lower::array_fn(inner, "From"); + let runs = |items: Vec| Expr::rs("arraySliceFrom", vec![Expr::Array(items), of.clone()]); + let e = Expr::Cond(Box::new(none), Box::new(runs(Vec::new())), Box::new(runs(vec![target]))); + return done(e, true); + } let some = if self.b.t.needs_place(inner) { Expr::rs("sliceOfPlace", vec![self.make_place(payload, target, span, out)]) } else if self.b.t.write_in(inner).is_some() { @@ -1129,6 +1149,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let mut values = vec![s, start, end, dest]; let f = match elem.kind() { _ if crate::lower::byte(elem) => "byteSliceCopyWithin", + ty::Array(..) => { + values.extend(self.b.t.copy_fn(elem, span)); + "arraySliceCopyWithin" + } _ => { values.extend(self.b.t.copy_fn(elem, span)); "sliceCopyWithin" @@ -1385,6 +1409,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(borrowed) } + /// The slice `place`, an array a reference points at, is, whose copy `read` + /// [`Self::borrowed_place`] made of it. + fn borrowed_slice(&mut self, read: Expr, place: Place<'tcx>, span: Span, out: &mut Vec) -> Expr { + match copied_slice(&read) { + Some(slice) => slice, + None => self.place_expr(place, span, out), + } + } + /// `slice::from_mut`, `array::from_mut`, or with `cell`, `Cell::from_mut` of `op`, a /// `&mut` to a `ty`: of the `rs.Place` it is or of the place it names, or else in place /// of the bytes or the object it is, which a cell reads a copy of, as a `Cell` only @@ -1408,6 +1441,22 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { false => ("sliceOfPlace", "sliceIn"), }; let of = |made: Expr| Expr::rs(of_place, vec![made]); + // A `&mut [T; N]` is the slice it views: a slice of it is the array slice of that one, and a + // cell of an array of arrays reads a copy of the arrays it views and writes into them. + if let ty::Array(elem, len) = ty.kind() + && (!cell || elem.is_array()) + { + let slice = self.operand(op, span, out); + if cell { + let copy = self.b.t.elem_copy(ty, span); + return Some(Expr::rs( + "cellOfArraySlice", + [vec![slice], copy.into_iter().collect()].concat(), + )); + } + let n = len.try_to_target_usize(tcx).unwrap_or(0); + return Some(Expr::rs("arraySliceOne", vec![slice, Expr::lit(n.to_string())])); + } if !cell && crate::lower::byte(ty) { return Some(self.err( span, @@ -1658,7 +1707,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { 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))); + return Some(Some(( + crate::lower::array_slice(self.b.t.uninit_inner(payload_ty), read), + true, + ))); } if let Some(local) = dest.as_local() && self.defs[local] == 1 @@ -1744,16 +1796,28 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // 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 { + let old = match array { + // An array slice, each array copied out and written where the slice holds it. + Some(p) if crate::lower::array_slice::of_arrays(self.b.t.uninit_inner(ty)) => { + let slice = self.borrowed_slice(place.0, p, span, out); + let copy = self.b.t.elem_copy(ty, span); + Expr::rs( + "arraySliceReplace", + [vec![slice, value], copy.into_iter().collect()].concat(), + ) + } Some(p) => { - let slice = self.place_expr(p, span, out); - Expr::rs("sliceView", vec![slice]) + let slice = self.borrowed_slice(place.0, p, span, out); + let mut made = vec![Expr::rs("sliceView", vec![slice]), value]; + made.extend(self.copy_depth(ty)); + Expr::rs("replaceIn", made) + } + None => { + let mut made = vec![place.0, value]; + made.extend(self.copy_depth(ty)); + Expr::rs("replaceIn", made) } - 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 { out.push(StmtKind::Expr(old).at(None)); return Expr::undefined(); @@ -1810,6 +1874,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { return None; } + // An array of a slice of arrays, which is the slice of its elements, in no slot. + if self.in_array(target) { + return None; + } let mut read = read; while let Expr::Located(_, inner) = read { read = inner; @@ -1838,6 +1906,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// Set what a `&mut` borrows to `value`. fn set_borrowed(&mut self, (read, place): &Borrowed<'tcx>, value: Expr, span: Span, out: &mut Vec) { match place { + // Into the slice `read` copies, which `borrowed_place` named. + Some(place) + if self.in_array(*place) + && let Some(slice) = copied_slice(read) => + { + let stmt = self.store_in_slice(*place, slice, value, span); + out.push(stmt); + } Some(place) => out.extend(self.store(*place, value, span)), None => self.assign_to(read.clone(), value, None, out), } @@ -1921,13 +1997,20 @@ 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 of a slice of arrays is the slice of its elements already. + ty::Slice(_) | ty::Array(..) if elem_ty.is_array() => { + return Some(Some((Expr::rs("arraySliceAt", vec![base, checked]), true))); + } // 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 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))); + return Some(Some(( + crate::lower::array_slice(self.b.t.uninit_inner(elem_ty), place), + true, + ))); } // The reference reads and writes the element where it is. if let Some(local) = dest.as_local() @@ -1984,6 +2067,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let range = match (bytes, get) { (true, false) => "byteSliceRange", (true, true) => "byteSliceGetRange", + _ if elem_ty.is_array() && !get => "arraySliceRange", + _ if elem_ty.is_array() => "arraySliceGetRange", (false, false) => "sliceRange", (false, true) => "sliceGetRange", }; @@ -2203,3 +2288,13 @@ fn locate(e: &mut Expr, arguments: &mut Vec<(Expr, ts::Loc)>) { _ => {} } } + +/// The slice `read`, a copy of an array `borrowed_place` made, reads, if it is one. +fn copied_slice(read: &Expr) -> Option { + match read { + Expr::Call(f, args) if matches!(&**f, Expr::Rs(n) if matches!(n.as_str(), "byteSliceToArray" | "sliceToArray" | "arraySliceToArray")) => { + args.first().cloned() + } + _ => None, + } +} diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 7de8a4a69..e0917d952 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -250,7 +250,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { e = match in_slice { true => { let base = self.slice_path(e, out); - slice_at(base, i) + self.slice_elem(base, i, ty) } false => e.index(i), }; @@ -269,7 +269,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { true => super::scalar::sub(slice_member(base.clone(), "length"), Expr::lit(offset.to_string())), }; e = match in_slice { - true => slice_at(base, i), + true => self.slice_elem(base, i, ty), false => base.index(i), }; } @@ -281,7 +281,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } if let ty::Slice(elem_ty) = ty.kind() => { let base = self.slice_path(e, out); // A range of parts, which the pattern that took it checked the length for. - if let Some([data, start, length]) = made_slice(&base) { + if elem_ty.is_array() { + let end = base.clone().member("length").binary("-", Expr::lit(to.to_string())); + e = Expr::rs("arraySlicePart", vec![base, Expr::lit(from.to_string()), end]); + } else if let Some([data, start, length]) = made_slice(&base) { let len = super::scalar::sub(length.clone(), Expr::lit((from + to).to_string())); let start = super::scalar::add(start.clone(), Expr::lit(from.to_string())); e = Expr::New( @@ -311,6 +314,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let base = self.slice_path(e, out); e = match made_slice(&base) { + _ if elem.is_array() => Expr::rs( + "arraySlicePart", + vec![base, Expr::lit(from.to_string()), Expr::lit(end.to_string())], + ), // In bounds of the array's. Some([data, start, _]) => Expr::New( Box::new(Expr::Rs(slice_class(elem).into())), @@ -346,16 +353,28 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { | ProjectionElem::UnwrapUnsafeBinder(_) | ProjectionElem::PhantomDeref => {} } + let next = pty.projection_ty(tcx, elem); in_slice = match elem { ProjectionElem::Deref => self.array_behind(place.local, read, ty), ProjectionElem::Subslice { .. } => in_slice, + // An array of a slice of arrays is the slice of its elements. + ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => in_slice && next.ty.is_array(), _ => false, }; - pty = pty.projection_ty(tcx, elem); + pty = next; } e } + /// Element `i` of `base`, the slice a place of `ty`, a `[T]` or a `[T; N]`, is: an + /// An `rs.ArraySlice`'s array, lent as the slice of its elements, of arrays. + fn slice_elem(&self, base: Expr, i: Expr, ty: Ty<'tcx>) -> Expr { + match ty.kind() { + ty::Slice(elem) | ty::Array(elem, _) if elem.is_array() => Expr::rs("arraySliceAt", vec![base, i]), + _ => slice_at(base, i), + } + } + /// The parts of field `field` of union `adt` that `rest`, the projections after it, /// go down to, how many of them that takes, and the type they make: one slot, or the /// parts of an aggregate kept in several. @@ -416,6 +435,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { in_array = match elem { ProjectionElem::Deref => self.array_behind(place.local, at, ty), ProjectionElem::Subslice { .. } => in_array || ty.is_slice(), + ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => { + (in_array || ty.is_slice()) && matches!(ty.kind(), ty::Slice(e) | ty::Array(e, _) if e.is_array()) + } _ => false, }; } @@ -487,6 +509,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let base = self.place_expr(base.to_place(self.tcx), span, out); let end = self.subslice_end(&base, ty, to, from_end); let from = Expr::lit(from.to_string()); + // Of arrays, the arrays of an array slice of them all. + if let ty::Array(elem, _) = ty.kind() + && elem.is_array() + { + let all = crate::lower::slice_items_from(base, *elem); + return Some(Expr::rs("arraySlicePart", vec![all, from, end])); + } let length = super::scalar::sub(end, from.clone()); Some(Expr::New(Box::new(Expr::Rs("Slice".into())), vec![base, from, length])) } @@ -659,15 +688,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(Std::Cow) if let Some(borrowed) = crate::lower::library::cow_borrowed(tcx, ty) => { let bytes = crate::lower::library::cow_slice(tcx, ty).is_some_and(crate::lower::byte); let owned = variant.is_some_and(|v| v.index() == 1); - // What an `rs.Borrowed` holds, and what it owns: an `rs.Slice` and an - // `rs.Vec`, or text and an `rs.String`. + // What an `rs.Borrowed` holds, and what it owns: an `rs.Slice`, or for + // arrays an `rs.ArraySlice`, and an `rs.Vec`, or text and an `rs.String`. let (held, owns) = match borrowed.kind() { ty::Slice(elem) => { - let elem = self.b.t.ty(*elem, span); - ( - crate::ts::Type::Rs("Slice", vec![elem.clone()]), - crate::ts::Type::Rs("Vec", vec![elem]), - ) + let held = match elem.is_array() { + true => self.b.t.slice_ty(*elem, span), + false => crate::ts::Type::Rs("Slice", vec![self.b.t.ty(*elem, span)]), + }; + (held, crate::ts::Type::Rs("Vec", vec![self.b.t.ty(*elem, span)])) } _ => ( crate::ts::Type::Builtin("string"), @@ -773,6 +802,23 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { !self.mutated[place.local] && place.projection.iter().all(|e| !matches!(e, ProjectionElem::Deref)) } + /// The statement that copies `value` into `target`, the slice an array `place` a + /// reference points at is, named as [`Self::slice_path`] names it. + pub(super) fn store_in_slice(&mut self, place: Place<'tcx>, target: Expr, value: Expr, span: Span) -> Stmt { + let e = match self.in_bytes(place) { + true => target + .clone() + .member("data") + .member("set") + .call(vec![value, target.member("start")]), + false => { + let ty = self.b.t.uninit_inner(place.ty(&self.mir.local_decls, self.tcx).ty); + crate::lower::array_fn(ty, "Set").call(vec![target, value]) + } + }; + StmtKind::Expr(e).at(self.b.t.loc(span)) + } + /// The statements that assign `value` to `place`, which has projections. pub(super) fn store(&mut self, place: Place<'tcx>, value: Expr, span: Span) -> Vec { let (place, value) = self.rebuilt(place, value, span); @@ -803,15 +849,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.in_array(place) { let target = self.place_expr(place, span, &mut out); let target = self.slice_path(target, &mut out); - 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))); + out.push(self.store_in_slice(place, target, value, span)); return out; } // `*r = v` replaces the object `r` points at in place, which other references and diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 2fc4f3291..35708529b 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -61,9 +61,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // 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 (pointee.is_array(), self.in_array(*place)) { - (true, false) => self.b.t.array_rs(pointee, "From").call(vec![value]), + (true, false) => crate::lower::array_slice(self.b.t.uninit_inner(pointee), value), (false, true) if self.in_bytes(*place) => Expr::rs("byteSliceView", vec![value]), - (false, true) => crate::lower::library::slice_items(value), + (false, true) => match self.b.t.uninit_inner(pointee).kind() { + ty::Array(elem, _) => crate::lower::library::items_of(value, *elem), + _ => crate::lower::library::slice_items(value), + }, _ => value, } } @@ -96,9 +99,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } _ => { let value = self.place_expr(*place, span, out); - match crate::lower::pointer::slice_of_bytes(pointee) { - true => Expr::rs("rawByteSliceOf", vec![value]), - false => Expr::rs("rawSliceOf", vec![value]), + match pointee { + _ if crate::lower::pointer::slice_of_bytes(pointee) => { + Expr::rs("rawByteSliceOf", vec![value]) + } + _ if crate::lower::pointer::slice_of_arrays(pointee) => { + Expr::rs("rawArraySliceOf", vec![value]) + } + _ => Expr::rs("rawSliceOf", vec![value]), } } }, @@ -110,7 +118,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let value = self.place_expr(*place, span, out); match self.in_array(*place) { true => value, - false => self.b.t.array_rs(pointee, "From").call(vec![value]), + false => crate::lower::array_slice(self.b.t.uninit_inner(pointee), value), } } // `&raw mut *p` is `p`. A pointer to `()` is an identity, which only another @@ -440,11 +448,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // 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() => { + Some(pointee) if let ty::Slice(elem) = pointee.kind() => { let value = self.operand(op, span, out); match crate::lower::array_ref(from) { Some(_) => value, - None => Expr::rs("sliceFrom", vec![value]), + None => crate::lower::slice_items_from(value, *elem), } } _ => self.err(span, format!("a coercion to `{to}`")), @@ -529,7 +537,7 @@ 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 pointee.is_array() && object.is_slice() { - crate::lower::array_fn(pointee, "From").call(vec![value]) + crate::lower::array_slice(pointee, 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() { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 413c14bc1..7777c21e3 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -8,6 +8,7 @@ mod alloc; mod bind; pub use bind::check_module; +pub mod array_slice; mod body; mod caller; mod collections; @@ -1492,6 +1493,18 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { false } + /// The TypeScript type of a slice of `elem`s, as behind a reference, which a + /// reference to a `[elem; N]` is too: an `rs.ByteSlice` of bytes, an `rs.ArraySlice` of + /// arrays, lending each as this of its own elements, and else an `rs.Slice`. + pub fn slice_ty(&mut self, elem: Ty<'tcx>, span: Span) -> Type { + match elem.kind() { + _ if byte(elem) => Type::Rs("ByteSlice", vec![]), + _ if self.open_elem(elem) => Type::Rs("SliceOf", vec![self.ty(elem, span)]), + ty::Array(inner, _) => Type::Rs("ArraySlice", vec![self.slice_ty(*inner, span)]), + _ => Type::Rs("Slice", vec![self.ty(elem, span)]), + } + } + /// The TypeScript type of a Rust type. pub fn ty(&mut self, ty: Ty<'tcx>, span: Span) -> Type { let tcx = self.tcx; @@ -1509,22 +1522,14 @@ 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 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(..) if let Some(elem) = array_ref(ty) => self.slice_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)]), ty::Array(elem, _) => match byte(*elem) { true => Type::Builtin("Uint8Array"), false => Type::Array(Box::new(self.ty(*elem, span))), }, - ty::Slice(elem) => match byte(*elem) { - true => Type::Rs("ByteSlice", vec![]), - false => Type::Rs("Slice", vec![self.ty(*elem, span)]), - }, + ty::Slice(elem) => self.slice_ty(*elem, span), ty::Param(param) => Type::Param(param.name.to_string()), ty::FnDef(def_id, args) => { let sig = self.sig(*def_id, args.skip_binder()); @@ -1689,6 +1694,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { match elem.kind() { _ if self.open_elem(elem) => Type::Rs("CowOf", vec![self.ty(elem, span)]), _ if byte(elem) => Type::Rs("ByteCow", vec![]), + // Of arrays, borrowing their arrays. + ty::Array(..) => Type::Rs("Cow", vec![self.ty(elem, span), self.slice_ty(elem, span)]), _ => Type::Rs("Cow", vec![self.ty(elem, span)]), } } @@ -2334,15 +2341,38 @@ pub fn bytes_ref(ty: Ty<'_>) -> bool { } /// The runtime's function `name` of the slice a reference to `ty`, a `[T; N]`, is: -/// `byteSlice{name}` of bytes, and else `slice{name}`. +/// `byteSlice{name}` of bytes, `arraySlice{name}` of arrays, and else `slice{name}`. `From` +/// of arrays, which lends each by its own `From`, is `rs.arraySliceOf` of that. pub fn array_fn(ty: Ty<'_>, name: &str) -> ts::Expr { - let prefix = match byte_array(ty) { - true => "byteSlice", - false => "slice", + let prefix = match ty.kind() { + _ if byte_array(ty) => "byteSlice", + ty::Array(elem, _) if elem.is_array() => match name { + "From" => return ts::Expr::rs("arraySliceOf", vec![array_fn(*elem, "From")]), + _ => "arraySlice", + }, + _ => "slice", }; ts::Expr::Rs(format!("{prefix}{name}")) } +/// `value`, the JS array of a `ty`, a `[T; N]`, as the slice a reference to it is. +pub fn array_slice(ty: Ty<'_>, value: ts::Expr) -> ts::Expr { + match ty.kind() { + ty::Array(elem, _) => slice_items_from(value, *elem), + _ => unreachable!("an array's slice"), + } +} + +/// `items`, a JS array of `elem`s, or their `Uint8Array`, as the slice of all of them: an +/// `rs.ByteSlice`, an `rs.ArraySlice` of arrays, lending each by its own slice, or an `rs.Slice`. +pub fn slice_items_from(items: ts::Expr, elem: Ty<'_>) -> ts::Expr { + match elem.kind() { + _ if byte(elem) => ts::Expr::rs("byteSliceFrom", vec![items]), + ty::Array(..) => ts::Expr::rs("arraySliceFrom", vec![items, array_fn(elem, "From")]), + _ => library::slice_from(items), + } +} + /// 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. diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index dc6ef7636..f21628d76 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -49,7 +49,7 @@ pub enum Pointee { /// 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. + /// a read through it makes the slice of; of a `[[T; N]]`, an `rs.RawArraySlice`. Slice, } @@ -86,8 +86,8 @@ 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}`. + /// `[T; N]` through any `MaybeUninit`s, is: `byteSlice{name}` of bytes, `arraySlice{name}` + /// of arrays, and else `slice{name}`. pub fn array_rs(&self, ty: Ty<'tcx>, name: &str) -> Expr { super::array_fn(self.uninit_inner(ty), name) } @@ -180,11 +180,13 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Pointee::Place => Type::Rs("Place", vec![self.ty(pointee, span)]), Pointee::Object => self.ty(pointee, span), 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)]), + ty::Array(elem, _) => self.slice_ty(*elem, span), _ => unreachable!("an array's pointee"), }, Pointee::Slice => match self.uninit_inner(pointee).kind() { + ty::Slice(elem) if let ty::Array(inner, _) = elem.kind() => { + Type::Rs("RawArraySlice", vec![self.slice_ty(*inner, span)]) + } ty::Slice(elem) => Type::Rs("RawSlice", vec![self.ty(*elem, span)]), _ => unreachable!("a slice's pointee"), }, @@ -502,19 +504,25 @@ pub fn call<'tcx>( // 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_pointer = |b: &Body<'_, '_, 'tcx>, e: Expr| match b.t.uninit_inner(pointee()).kind() { + ty::Array(elem, _) => super::slice_items_from(e, *elem), + _ => 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), + // The arrays of an array of arrays have no JS array to write through. + let to_reference = |b: &mut Body<'_, '_, 'tcx>, e: Expr| match b.t.uninit_inner(pointee()) { + ty if super::byte_array(ty) => Expr::rs("byteSliceView", vec![e]), + ty if super::array_slice::of_arrays(ty) => b.err( + span, + format!("a reference to `{ty}` from a raw pointer, which is not supported yet"), + ), + _ => 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) { - true => Expr::rs("rawByteSliceOf", vec![s]), - false => Expr::rs("rawSliceOf", vec![s]), + let raw_of = |ty: Ty<'tcx>, s: Expr| match ty { + _ if slice_of_bytes(ty) => Expr::rs("rawByteSliceOf", vec![s]), + _ if slice_of_arrays(ty) => Expr::rs("rawArraySliceOf", vec![s]), + _ => Expr::rs("rawSliceOf", vec![s]), }; let deref = |ty: Ty<'tcx>, p: Expr, shared: bool| match slice_of_bytes(ty) { true => p.member("derefBytes").call(vec![Expr::lit(shared.to_string())]), @@ -1160,6 +1168,12 @@ pub fn slice_of_bytes(ty: Ty<'_>) -> bool { } } +/// Whether `ty`, a raw pointer's pointee, is a slice of arrays, which an +/// `rs.RawArraySlice` points at. +pub fn slice_of_arrays(ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Slice(elem) if elem.is_array()) +} + /// Whether pointers `x` and `y` to `ty` point at the same place: the same object or /// bytes, or null both. pub fn compare<'tcx>(b: &mut Body<'_, '_, 'tcx>, x: Expr, y: Expr, ty: Ty<'tcx>, span: Span) -> Expr {