From d1695bf4c6bdc3cc33b802815b602021d2a05e94 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 13:28:31 -0800 Subject: [PATCH 01/12] chore(quest): claim quest/m3/ts-slice-object.md Quest-Claim: f7589f7b711c512c From 4fd1b02ff6023852ec870f3bd0ed2c146e349dcd Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 16:35:50 -0800 Subject: [PATCH 02/12] wip(ts): slice runs, checkpoint of the interrupted iterate session Co-Authored-By: Claude Opus 5.5 --- quest/m3/README.md | 3 +- quest/m3/ts-byte-slice-place.md | 28 + quest/m3/ts-iter-mut-places.md | 2 +- quest/m3/ts-runtime-throws.md | 12 + quest/m3/ts-slice-object.md | 60 +- quest/m3/ts-string-capacity.md | 2 +- ts/README.md | 25 +- ts/fixtures/codec/expected/bench.ts | 4 +- ts/fixtures/lang/arrays/expected/arrays.ts | 297 +++--- ts/fixtures/lang/boxes/expected/boxes.ts | 10 +- .../lang/capacity/expected/capacity.ts | 14 +- ts/fixtures/lang/chunks/expected/chunks.ts | 8 +- ts/fixtures/lang/clones/expected/clones.ts | 55 +- ts/fixtures/lang/clones/expected/lib.ts | 2 +- .../lang/collections/expected/collections.ts | 10 +- .../lang/conversions/expected/conversions.ts | 870 +++++++++--------- .../lang/defaults/expected/defaults.ts | 6 +- ts/fixtures/lang/edits/expected/edits.ts | 14 +- ts/fixtures/lang/hints/expected/hints.ts | 4 +- ts/fixtures/lang/holds/expected/holds.ts | 2 +- ts/fixtures/lang/iters/expected/iters.ts | 8 +- ts/fixtures/lang/joins/expected/joins.ts | 42 +- ts/fixtures/lang/keys/expected/keys.ts | 106 +-- ts/fixtures/lang/lengths/expected/lengths.ts | 216 +++-- ts/fixtures/lang/orders/expected/orders.ts | 12 +- .../lang/pointers/expected/pointers.ts | 14 +- ts/fixtures/lang/refs/expected/refs.ts | 4 +- .../lang/separated/expected/core/option.ts | 4 +- .../lang/separated/expected/separated.ts | 46 +- ts/fixtures/lang/shapes/expected/fmt.ts | 8 +- ts/fixtures/lang/shapes/expected/generics.ts | 4 +- ts/fixtures/lang/shares/expected/shares.ts | 14 +- ts/fixtures/lang/slices/expected/slices.ts | 608 ++++++------ ts/runtime/rs.ts | 447 +++++---- ts/runtime/rs/collections.ts | 6 +- ts/runtime/rs/hash.ts | 4 +- ts/runtime/rs/iter.ts | 110 ++- ts/runtime/rs/task.ts | 13 +- ts/src/check.rs | 2 +- ts/src/lower/consts.rs | 2 +- ts/src/lower/copy.rs | 4 + ts/src/lower/iter.rs | 5 +- ts/src/lower/lend.rs | 13 +- ts/src/lower/library.rs | 94 +- ts/src/lower/mir/call.rs | 89 +- ts/src/lower/mir/place.rs | 61 +- ts/src/lower/mir/rvalue.rs | 10 +- ts/src/lower/mod.rs | 56 +- ts/src/lower/pointer.rs | 20 +- ts/src/lower/runs.rs | 138 +++ 50 files changed, 2132 insertions(+), 1456 deletions(-) create mode 100644 quest/m3/ts-byte-slice-place.md create mode 100644 ts/src/lower/runs.rs diff --git a/quest/m3/README.md b/quest/m3/README.md index d4be3829d..9827aec0e 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -19,7 +19,7 @@ generic std gap is planned here even when moq never calls it. - [Trait objects' TypeId](/quest/m3/ts-dyn.md) - `Any::type_id` and `TypeId` translate with Rust's equality, order, and hash, so a consumer neither rewrites nor binds them - [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 - [rs.String](/quest/m3/ts-string-capacity.md) - `String`, `Box`, and `&str` are a runtime type holding std's capacity - [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 @@ -27,3 +27,4 @@ generic std gap is planned here even when moq never calls it. - [Buf on a deque of bytes](/quest/m3/ts-vecdeque-buf.md) - `bytes`' `Buf` for a deque of bytes translates - [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 B-tree drops as std's does](/quest/m3/ts-btree-drop-order.md) - keys and values drop node by node, in std's order +- [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 diff --git a/quest/m3/ts-byte-slice-place.md b/quest/m3/ts-byte-slice-place.md new file mode 100644 index 000000000..44b26fadd --- /dev/null +++ b/quest/m3/ts-byte-slice-place.md @@ -0,0 +1,28 @@ +# [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`. + +## Related + +- [rs.String](/quest/m3/ts-string-capacity.md) - another runtime wrapper over storage JS holds differently 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 5991b9505..f53bb3eb0 100644 --- a/quest/m3/ts-runtime-throws.md +++ b/quest/m3/ts-runtime-throws.md @@ -30,6 +30,18 @@ values, ranges stepped without their type, and fmt widths written as a placehold comparisons [#584](https://github.com/moq-dev/rust2/pull/584) refuses at translation are in scope too, through [addresses](/quest/m2/ts-model/addresses.md)' identities. +✅ 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](/quest/m3/ts-string-capacity.md) 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. + 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 72a31a87c..fd132c949 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -1,45 +1,43 @@ -# [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.Runs` 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.runsBy` writes runs 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.Runs`: + +1. How a `&mut [[T; N]]` holds its runs: + - ✅ (a) A runtime type for every slice of arrays, nested or flat, whose element `i` is + the slice of run `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-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.runsReplace` and `rs.cellOfRuns` do for runs. 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. +Public API: the translator's output. ## Related diff --git a/quest/m3/ts-string-capacity.md b/quest/m3/ts-string-capacity.md index 638839636..2745e9990 100644 --- a/quest/m3/ts-string-capacity.md +++ b/quest/m3/ts-string-capacity.md @@ -40,4 +40,4 @@ Public API: the translator's output and what a hand-written caller passes for a ## Related -- [rs.Slice](/quest/m3/ts-slice-object.md) - the other native mapping becoming a wrapper +- [Parts of arrays without arrayView](/quest/m3/ts-slice-object.md) - the other native mapping becoming a wrapper diff --git a/ts/README.md b/ts/README.md index 1ad22f88b..169ed79f9 100644 --- a/ts/README.md +++ b/ts/README.md @@ -104,8 +104,8 @@ crate translation reaches is refused, and so are two versions of one crate it re | `Option` | `T \| undefined`; `T \| rs.None` where `T` can already be `undefined`, as `()` and `Option` can, so `Option<()>` and `Option>` keep `None` apart from each `Some` | | `Result` | `rs.Result`: `{ ok: true, value }` or `{ ok: false, error }`; `rs.OK` or `rs.ERR` where the payload is `undefined`, as in `Ok(())` | | `ControlFlow` | `rs.Result`, `Ok` to continue; what `?` branches on is the value it was applied to, but for a `Poll`'s `Pending` and `Ready(None)`, which continue as `Ok` of themselves | -| tuple, `[T; N]`, `&[T; N]` | an array, 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.Runs` 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.Runs` 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 string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | | `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | @@ -170,14 +170,19 @@ 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.Runs` of the slice each +array is, `rs.Runs>`, `rs.Runs` for bytes, and `rs.Runs` of +`rs.Runs` for arrays of arrays: its element `i` is the slice of run `i`, read and written +where the runs 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.runsFrom(arrays, rs.sliceFrom)`, `rs.byteSliceFrom` +for bytes and `rs.runsOf(rs.sliceFrom)` for arrays of arrays, and reads one as +`rs.runsArray(runs)`, the arrays themselves where the runs are all of them. std's methods +that lend runs or parts of the slice, such as `iter_mut`, `split_at_mut`, `chunks_mut`, +and `swap`, take them where they are; any other, such as `sort` or `rotate_left`, reads +copies of the runs, which a `&mut` one 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 9430b1ac3..3d7272c73 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -531,7 +531,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.runsIter(rs.sliceAsChunks(rs.byteVecSlice(packets), 188)[0])); while (true) { const _21: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_21 === rs.DONE) { @@ -550,7 +550,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.runsIter(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 54a89a3d9..8f8a82c79 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.Runs = rs.runsFrom(grid, rs.byteSliceFrom); + [_97, rs.sliceFrom(named)] as [rs.Runs, rs.Slice]; + const _100: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(_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.Runs = rs.runsFrom(grid, rs.byteSliceFrom); + const _136: rs.Runs = rs.runsFrom(flipped, rs.byteSliceFrom); + const _138: rs.Runs = rs.runsFrom(same2, rs.byteSliceFrom); + [_133, _135, _136, rs.sliceFrom(sums), _138] as [rs.Slice, rs.Runs, rs.Runs, rs.Slice, rs.Runs]; + const _140: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(_135), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const _141: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(_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.runsArray(_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)); @@ -304,7 +304,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { } _49[_51].v = _49[_51].v + String.fromCodePoint(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.runsEach(rs.runsFrom(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.runsEach(rs.runsFrom(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: string): rs.u8 => { return rs.stringLen(w) & 0xff; }); - const rows2: Uint8Array = rs.bytesMap(rs.arrayMap(grid, rs.byteSliceFrom), (row: rs.ByteSlice): rs.u8 => { + const rows2: Uint8Array = rs.bytesMap(rs.runsEach(rs.runsFrom(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.runsEach(rs.runsFrom(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]]))); } } - [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.runsFrom(grid, rs.byteSliceFrom), rs.runsFrom(pairs, rs.sliceFrom)] as [rs.ByteSlice, rs.Slice, rs.Slice, rs.Runs, rs.Runs>]; const arg2 = rs.byteSliceFrom(bytes); const _158: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); const arg3 = rs.sliceFrom(wide); const _159: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.u16Debug); const arg4 = rs.sliceFrom(words); const _160: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg4), f, rs.fmtStr); - const arg5 = rs.sliceFrom(grid); - const _161: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg5), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); - const arg6 = rs.sliceFrom(pairs); - const args6 = [_158, _159, _160, _161, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg6), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug))]; + const arg5 = rs.runsFrom(grid, rs.byteSliceFrom); + const _161: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(arg5), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const arg6 = rs.runsFrom(pairs, rs.sliceFrom); + const args6 = [_158, _159, _160, _161, (f: rs.Formatter) => rs.fmtList(rs.runsArray(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]]))); } @@ -422,15 +422,14 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_46, _48); _46.data[_46.start + _48] = _46.data[_46.start + _48] + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_22 === 3) { - const _59: rs.Slice = rs.sliceFrom(grid); + const _59: rs.Runs = rs.runsFrom(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.runsAt(_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.runsAt(_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.Runs> = rs.runsFrom(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.runsAt(all, _93), rs.sliceFrom([op as rs.u32, ((op as rs.u32) << 20) >>> 0])); + rs.runsSwap(all, 0, 1); } 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.Runs = rs.runsFrom(grid, rs.byteSliceFrom); + const _155: rs.Runs> = rs.runsFrom(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, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.runsArray(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.runsArray(_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]]))); } @@ -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.Runs): void { + const iter: rs.Iter = rs.runsIter(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.Runs): void { + const iter: rs.Iter = rs.runsIter(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.Runs): void { + const iter: rs.Iter = rs.runsIter(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.Runs): void { + const iter: rs.Iter = rs.runsIter(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.Runs): void { + const iter: rs.Iter = rs.runsIter(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.Runs): void { + const iter: rs.Iter = rs.runsIter(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.runsFrom([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.runsFrom([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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$0(out, rs.runsFrom(v.items, rs.byteSliceFrom)); + const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.Runs = rs.runsRange(rs.runsFrom(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.runsItems(_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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(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.runsFrom(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.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0)); + rs.byteVecPush(out, rs.sliceContains(rs.runsItems(_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.Runs = rs.runsFrom([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.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.Runs = rs.runsFrom([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.runsArray(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -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.runsFrom([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.runsFrom([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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$1(out, rs.runsFrom(v.items, rs.byteSliceFrom)); + const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.Runs = rs.runsRange(rs.runsFrom(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.runsItems(_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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(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.runsAt(_87[0], 0); + const slice4 = rs.runsAt(_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.runsFrom(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.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1)); + rs.byteVecPush(out, rs.sliceContains(rs.runsItems(_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.Runs = rs.runsFrom([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.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.Runs = rs.runsFrom([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.runsArray(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -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.runsFrom([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.runsFrom([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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$3(out, rs.runsFrom(v.items, rs.byteSliceFrom)); + const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.Runs = rs.runsRange(rs.runsFrom(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.runsItems(_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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(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.runsAt(_87[0], 0); + const slice4 = rs.runsAt(_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.runsFrom(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.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3)); + rs.byteVecPush(out, rs.sliceContains(rs.runsItems(_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.Runs = rs.runsFrom([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.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.Runs = rs.runsFrom([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.runsArray(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -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.runsFrom([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.runsFrom([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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + put$40(out, rs.runsFrom(v.items, rs.byteSliceFrom)); + const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _75: rs.ByteSlice = rs.byteSliceFrom(a); + const _72: boolean = rs.sliceContains(rs.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); + const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _79: rs.ByteSlice = rs.byteSliceFrom(b); + const _76: boolean = rs.sliceContains(rs.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); + const _81: rs.Runs = rs.runsRange(rs.runsFrom(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.runsItems(_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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(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.runsAt(_87[0], 0); + const slice4 = rs.runsAt(_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.runsFrom(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.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + const _117: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 40)); + rs.byteVecPush(out, rs.sliceContains(rs.runsItems(_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.Runs = rs.runsFrom([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.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); + const _190: rs.Runs = rs.runsFrom([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.runsArray(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -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.runsFrom([copy$array_u8(a), old, copy$array_u8(held.bytes)], rs.byteSliceFrom)); const part = { _0: copy$array_u8(held.bytes) }; const shown: string = rs.fmtFormat([(f: rs.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]); const _41: rs.ByteSlice = rs.byteSliceFrom(held.bytes); const taken2 = rs.byteSliceToArray(_41); _41.data.set(rs.bytes(3), _41.start); - put$3(out, rs.sliceFrom([taken2, copy$array_u8(held.bytes)])); + put$3(out, rs.runsFrom([taken2, copy$array_u8(held.bytes)], rs.byteSliceFrom)); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown)); 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.runsFrom([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.runsFrom([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.runsFrom([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.runsFrom([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.runsFrom(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.Runs => { + return rs.runsFrom(v.items, rs.byteSliceFrom); + }), undefined, 8, true)), (value: rs.Runs) => rs.runsIter(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.runsIter(rs.runsFrom(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.runsOf(rs.byteSliceFrom))), (value: rs.Runs) => rs.runsIter(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.runsFrom(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.Runs => { + return rs.runsFrom(v.items, rs.byteSliceFrom); + }), undefined, 8, true)), (value: rs.Runs) => rs.runsIter(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.runsIter(rs.runsFrom(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.runsOf(rs.byteSliceFrom))), (value: rs.Runs) => rs.runsIter(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.runsFrom(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.Runs => { + return rs.runsFrom(v.items, rs.byteSliceFrom); + }), undefined, 8, true)), (value: rs.Runs) => rs.runsIter(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.runsIter(rs.runsFrom(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.runsOf(rs.byteSliceFrom))), (value: rs.Runs) => rs.runsIter(value), true, 2); while (true) { const _381: rs.ByteSlice | rs.Done = iter21.next(); if (_381 === rs.DONE) { diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index 67f0459c4..087367bd6 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.Runs = rs.runsFrom(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.sliceItems(rs.runsFrom(rs.sliceItems(quads).map(copy$array_u8), rs.byteSliceFrom))); + const _554: rs.ByteSlice | undefined = rs.runsFirst(rs.runsFrom(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.runsIter(quads), rs.runsIter(rs.runsFrom(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 d9a28c9d8..4a0baa653 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.runsItems(rs.runsFrom(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.sliceItems(rs.runsFrom(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.runsArray(rs.runsFrom(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.runsChunksExact(rs.runsFrom(v.items, rs.sliceFrom), 2); while (true) { - const _392: rs.Slice | rs.Done = iter4.next(); + const _392: rs.Runs> | 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.runsAt(_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.runsAt(_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 33392c25d..544d936fb 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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterMap(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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 bddd7d194..b61d2a526 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.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.runsIter(rs.runsFrom(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]; @@ -7746,7 +7746,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _263: Logged.Logged = logged(part10); const part11 = at(3); const grid: Logged.Logged[][] = [_249, [_263, logged(part11)]]; - const copy2: Logged.Logged[][] = grid.map((a: Logged.Logged[]) => a.map(Logged.clone$Clone)); + const copy2: Logged.Logged[][] = rs.sliceItems(rs.runsFrom(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); @@ -7779,7 +7779,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.runsIter(rs.runsFrom(rows.items, rs.sliceFrom)), (a0: rs.Slice): Logged.Logged[] => { return rs.sliceItems(a0).map(Logged.clone$Clone); }); while (true) { @@ -7924,12 +7924,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.Runs> = rs.runsFrom(grid, rs.sliceFrom); + const _248: rs.Runs> = rs.runsFrom(other, rs.sliceFrom); + rs.runsBy(_247, (runs6) => rs.sliceCloneFromSlice(runs6, rs.runsItems(_248), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); flush(log.value, out); const part44 = rs.sliceFrom(grid[1]); _14(part44, out); - 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.Runs> = rs.runsFrom(other, rs.sliceFrom); + rs.runsBy(rs.runsFrom(grid, rs.sliceFrom), (runs7) => rs.sliceCloneFromSlice(runs7, rs.runsItems(_260), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); flush(log.value, out); drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged([grid, other] as [Logged.Logged[][], Logged.Logged[][]]); flush(log.value, out); @@ -7951,23 +7953,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.Runs> = rs.runsFrom(rows.items, rs.sliceFrom); + const _332: rs.Runs> = rs.runsFrom(other2, rs.sliceFrom); + rs.runsBy(_330, (runs2) => rs.sliceCloneFromSlice(runs2, rs.runsItems(_332), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); flush(log.value, out); - rs.sliceFill(rs.sliceRange(rs.sliceFrom(rows.items), 0, 1), other2[1].map(Logged.clone$Clone), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)); + const _338: rs.Runs> = rs.runsRange(rs.runsFrom(rows.items, rs.sliceFrom), 0, 1); + const _341: Logged.Logged[] = other2[1].map(Logged.clone$Clone); + rs.runsBy(_338, (runs3) => rs.sliceFill(runs3, _341, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); flush(log.value, out); - const _349: rs.Slice = rs.sliceFrom(rows.items); + const _349: rs.Runs> = rs.runsFrom(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.runsBy(_349, (runs4) => rs.sliceFill(runs4, _351, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); flush(log.value, out); const part33 = rs.sliceFrom(rows.items[rs.idx(rows.items, 0)]); _14(part33, out); - const _375: rs.Slice = rs.sliceFrom([]); + const _375: rs.Runs> = rs.runsFrom([], 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.runsBy(_375, (runs5) => rs.sliceFill(runs5, _377, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); flush(log.value, out); drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged([rows, other2] as [rs.Vec, Logged.Logged[][]]); flush(log.value, out); @@ -8014,19 +8022,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.Runs> = (from2: rs.usize, n3: rs.usize): rs.Runs> => { + return rs.runsFrom(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.Runs> = ones(8, part12); const part13 = len(12); - const d2: rs.Slice = ones(12, part13); + const d2: rs.Runs> = 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.runsBoxCloneFrom(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.Runs>, rs.Runs>]); flush(log.value, out); } else { const kept: (a0: rs.usize) => Kept.Kept = (i5: rs.usize): Kept.Kept => { @@ -8042,9 +8050,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.Runs> = rs.runsFrom(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.Runs> = rs.runsFrom(_586, rs.sliceFrom); + rs.runsBy(_584, (runs) => rs.sliceCloneFromSlice(runs, rs.runsItems(_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)))); rs.dropAll(_586, drop$array2_clones_Kept); flush(log.value, out); let some: Kept.Kept | undefined = kept(9); @@ -8135,7 +8144,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.runsIter(rs.runsFrom(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 a72fcbbc4..d56589dd7 100644 --- a/ts/fixtures/lang/clones/expected/lib.ts +++ b/ts/fixtures/lang/clones/expected/lib.ts @@ -108,7 +108,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.Runs>, rs.Runs>]): 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 a7e9efab2..78b8e4318 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -3733,7 +3733,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.Runs = rs.runsFrom(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 => { @@ -4710,12 +4710,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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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); @@ -4725,13 +4725,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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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 6059901f0..28ec7cae4 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"; @@ -519,72 +519,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.Runs, 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.runsAt(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.Runs, 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 old2 = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_8, slice2.start); const old: Uint8Array = old2; const _10: Uint8Array = value; rs.idx(s, 0); - s.data[s.start] = _10; + const slice3 = rs.runsAt(s, 0); + slice3.data.set(_10, slice3.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.Runs>, 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.runsAt(s, 0)), _8); const _10: rs.u32[] = value; rs.idx(s, 0); - s.data[s.start] = _10; + rs.sliceSet(rs.runsAt(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.Runs, 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 old2 = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_8, slice2.start); const old: Uint8Array = old2; const _10: Uint8Array = value; rs.idx(s, 0); - s.data[s.start] = _10; + const slice3 = rs.runsAt(s, 0); + slice3.data.set(_10, slice3.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.Runs, 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 old2 = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_8, slice2.start); const old: Uint8Array = old2; const _10: Uint8Array = value; rs.idx(s, 0); - s.data[s.start] = _10; + const slice3 = rs.runsAt(s, 0); + slice3.data.set(_10, slice3.start); return old; } @@ -638,82 +640,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.Runs>, 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.runsAt(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: string[]): string[] { +export function replaceFirst$String(s: rs.Runs>, value: string[]): string[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value); + return rs.replaceIn(rs.sliceView(rs.runsAt(s, 0)), value); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$Vec_u32(s: rs.Slice[]>, value: rs.Vec[]): rs.Vec[] { +export function replaceFirst$Vec_u32(s: rs.Runs>>, 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.runsAt(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.Runs>, 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.runsAt(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.Runs>, 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.Runs>, 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.runsReplace(rs.runsAt(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.Runs>>, 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.runsReplace(rs.runsAt(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.Runs>, 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.runsReplace(rs.runsAt(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.Runs>, 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.runsReplace(rs.runsAt(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.Runs>, 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.runsAt(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.Runs>, 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.runsAt(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.Runs>, 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.runsAt(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.Runs>, 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.runsAt(s, 0)), copy$array_u64(value)); } /** @@ -778,11 +779,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.runsOne(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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_Option_u16(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -851,11 +852,11 @@ export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)))), [make$conversions_Value_String(data, 27)])[0], out); + put$conversions_Value_String(replaceFirst$String(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [make$conversions_Value_String(data, 27)])[0], out); rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))))), 1), [[make$conversions_Value_String(data, 28)]])[0][0], out); + put$conversions_Value_String(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_String(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -913,11 +914,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.runsOne(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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[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); @@ -975,11 +976,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.runsOne(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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[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); @@ -993,37 +994,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.Runs = rs.runsOne(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.Runs = rs.runsFrom(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.runsAt(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.runsAt(t, 1), out); rs.idx(s, 0); - rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + rs.runsOne(rs.runsAt(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.runsAt(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); @@ -1031,21 +1026,22 @@ 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.runsAt(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.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 0), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 0), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[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.runsAt(s, 0); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(rs.byteSliceToArray(_159), slice2.start); rs.idx(s, 0); - put$conversions_Value_array0_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array0_u8(rs.runsAt(s, 0), out); } /** @@ -1055,49 +1051,54 @@ 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.Runs = rs.runsOne(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 swapped = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(rs.byteSliceToArray(_16), slice2.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 slice3 = rs.runsAt(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(slice3), _20.start); + const slice4 = rs.runsAt(s, 0); + slice4.data.set(swapped2, slice4.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.Runs = rs.runsFrom(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 slice5 = rs.runsAt(s, 0); + const slice6 = rs.runsAt(t, 1); + const swapped3 = rs.byteSliceToArray(slice5); + const slice7 = rs.runsAt(s, 0); + slice7.data.set(rs.byteSliceToArray(slice6), slice7.start); + const slice8 = rs.runsAt(t, 1); + slice8.data.set(swapped3, slice8.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 slice9 = rs.runsAt(t, 0); + const slice10 = rs.runsAt(s, 0); + const swapped4 = rs.byteSliceToArray(slice9); + const slice11 = rs.runsAt(t, 0); + slice11.data.set(rs.byteSliceToArray(slice10), slice11.start); + const slice12 = rs.runsAt(s, 0); + slice12.data.set(swapped4, slice12.start); rs.idx(t, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(t.data[t.start]), out); + put$conversions_Value_array1_u8(rs.runsAt(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.runsAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.Runs = rs.runsOne(rs.runsAt(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.runsReplace(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.runsAt(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); @@ -1105,21 +1106,22 @@ 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.runsAt(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.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 1), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 1), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[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 slice13 = rs.runsAt(s, 0); + const slice14 = rs.runsAt(s, 0); + slice14.data.set(rs.byteSliceToArray(_159), slice14.start); rs.idx(s, 0); - put$conversions_Value_array1_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array1_u8(rs.runsAt(s, 0), out); } /** @@ -1129,41 +1131,43 @@ 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.Runs> = rs.runsOne(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.runsAt(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.runsAt(s, 0); + const swapped2 = rs.replaceIn(rs.sliceView(_20), rs.sliceToArray(slice2)); + rs.sliceSet(rs.runsAt(s, 0), swapped2); 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.Runs> = rs.runsFrom(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 slice4 = rs.runsAt(s, 0); + const slice5 = rs.runsAt(t, 1); + const swapped3 = rs.replaceIn(rs.sliceView(slice4), rs.sliceToArray(slice5)); + rs.sliceSet(rs.runsAt(t, 1), swapped3); 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 slice7 = rs.runsAt(t, 0); + const slice8 = rs.runsAt(s, 0); + const swapped4 = rs.replaceIn(rs.sliceView(slice7), rs.sliceToArray(slice8)); + rs.sliceSet(rs.runsAt(s, 0), swapped4); rs.idx(t, 0); - put$conversions_Value_array2_u32(rs.sliceFrom(t.data[t.start]), out); + put$conversions_Value_array2_u32(rs.runsAt(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.runsAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.sliceView(rs.sliceFrom(s.data[s.start]))); + const a: rs.Runs> = rs.runsOne(rs.runsAt(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.runsReplace(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.runsAt(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); @@ -1171,21 +1175,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.runsAt(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.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 2), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 2), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.sliceToArray)), rs.runsSet), [[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.runsAt(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.runsAt(s, 0), out); } /** @@ -1195,49 +1198,54 @@ 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.Runs = rs.runsOne(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 swapped = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(rs.byteSliceToArray(_16), slice2.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 slice3 = rs.runsAt(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(slice3), _20.start); + const slice4 = rs.runsAt(s, 0); + slice4.data.set(swapped2, slice4.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.Runs = rs.runsFrom(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 slice5 = rs.runsAt(s, 0); + const slice6 = rs.runsAt(t, 1); + const swapped3 = rs.byteSliceToArray(slice5); + const slice7 = rs.runsAt(s, 0); + slice7.data.set(rs.byteSliceToArray(slice6), slice7.start); + const slice8 = rs.runsAt(t, 1); + slice8.data.set(swapped3, slice8.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 slice9 = rs.runsAt(t, 0); + const slice10 = rs.runsAt(s, 0); + const swapped4 = rs.byteSliceToArray(slice9); + const slice11 = rs.runsAt(t, 0); + slice11.data.set(rs.byteSliceToArray(slice10), slice11.start); + const slice12 = rs.runsAt(s, 0); + slice12.data.set(swapped4, slice12.start); rs.idx(t, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(t.data[t.start]), out); + put$conversions_Value_array3_u8(rs.runsAt(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.runsAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.Runs = rs.runsOne(rs.runsAt(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.runsReplace(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.runsAt(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); @@ -1245,21 +1253,22 @@ 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.runsAt(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.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 3), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 3), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[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 slice13 = rs.runsAt(s, 0); + const slice14 = rs.runsAt(s, 0); + slice14.data.set(rs.byteSliceToArray(_159), slice14.start); rs.idx(s, 0); - put$conversions_Value_array3_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array3_u8(rs.runsAt(s, 0), out); } /** @@ -1269,49 +1278,54 @@ 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.Runs = rs.runsOne(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 swapped = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(rs.byteSliceToArray(_16), slice2.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 slice3 = rs.runsAt(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(slice3), _20.start); + const slice4 = rs.runsAt(s, 0); + slice4.data.set(swapped2, slice4.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.Runs = rs.runsFrom(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 slice5 = rs.runsAt(s, 0); + const slice6 = rs.runsAt(t, 1); + const swapped3 = rs.byteSliceToArray(slice5); + const slice7 = rs.runsAt(s, 0); + slice7.data.set(rs.byteSliceToArray(slice6), slice7.start); + const slice8 = rs.runsAt(t, 1); + slice8.data.set(swapped3, slice8.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 slice9 = rs.runsAt(t, 0); + const slice10 = rs.runsAt(s, 0); + const swapped4 = rs.byteSliceToArray(slice9); + const slice11 = rs.runsAt(t, 0); + slice11.data.set(rs.byteSliceToArray(slice10), slice11.start); + const slice12 = rs.runsAt(s, 0); + slice12.data.set(swapped4, slice12.start); rs.idx(t, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(t.data[t.start]), out); + put$conversions_Value_array40_u8(rs.runsAt(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.runsAt(t, 1), out); rs.idx(s, 0); - const a: rs.Slice = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s.data[s.start]))); + const a: rs.Runs = rs.runsOne(rs.runsAt(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.runsReplace(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.runsAt(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); @@ -1319,21 +1333,22 @@ 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.runsAt(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.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 40), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 40), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[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 slice13 = rs.runsAt(s, 0); + const slice14 = rs.runsAt(s, 0); + slice14.data.set(rs.byteSliceToArray(_159), slice14.start); rs.idx(s, 0); - put$conversions_Value_array40_u8(rs.byteSliceFrom(s.data[s.start]), out); + put$conversions_Value_array40_u8(rs.runsAt(s, 0), out); } /** @@ -1398,12 +1413,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.runsOne(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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, (s) => rs.sliceToArray(s, copy$conversions_Logged)), rs.runsSet), [[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](); @@ -1468,11 +1483,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.runsOne(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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, (s) => rs.sliceToArray(s, copy$conversions_Named)), rs.runsSet), [[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); @@ -1541,11 +1556,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.runsOne(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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_u32(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -1614,11 +1629,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.runsOne(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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_u64(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -2401,10 +2416,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.Runs = rs.runsFrom([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.runsAt(one, 0)); + put$conversions_Value_array0_u8(rs.runsAt(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); @@ -2420,19 +2435,21 @@ 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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.runsAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.Runs = rs.runsFrom(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.runsAt(_124, 2); + const slice3 = rs.runsAt(_124, 2); + slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2442,26 +2459,28 @@ 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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice4 = rs.runsAt(_165, 0); + slice4.data.set(_163, slice4.start); + const _173: rs.Runs = rs.runsFrom(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 slice5 = rs.runsAt(_173, 1); + const slice6 = rs.runsAt(_173, 1); + slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); 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.runsIter(rs.runsFrom(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) { @@ -2509,10 +2528,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.Runs = rs.runsFrom([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.runsAt(one, 0)); + put$conversions_Value_array1_u8(rs.runsAt(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); @@ -2528,19 +2547,21 @@ 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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.runsAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.Runs = rs.runsFrom(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.runsAt(_124, 2); + const slice3 = rs.runsAt(_124, 2); + slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2550,26 +2571,28 @@ 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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice4 = rs.runsAt(_165, 0); + slice4.data.set(_163, slice4.start); + const _173: rs.Runs = rs.runsFrom(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 slice5 = rs.runsAt(_173, 1); + const slice6 = rs.runsAt(_173, 1); + slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); 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.runsIter(rs.runsFrom(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) { @@ -2616,10 +2639,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.Runs> = rs.runsFrom([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.runsAt(one, 0)); + put$conversions_Value_array2_u32(rs.runsAt(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)); @@ -2635,19 +2658,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.runsFrom(array, rs.sliceFrom).length, rs.runsFrom(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.Runs> = rs.runsFrom(array, rs.sliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + rs.sliceSet(rs.runsAt(_116, 0), _114); + const _124: rs.Runs> = rs.runsFrom(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.runsAt(_124, 2)), rs.sliceToArray(_130)); + const iter: rs.Iter> = rs.runsIter(rs.runsFrom(array, rs.sliceFrom)); while (true) { const _134: rs.Slice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2657,26 +2679,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.runsFrom(list.items, rs.sliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.sliceFrom).length, rs.runsFrom(none.items, rs.sliceFrom).length, rs.runsFrom(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.Runs> = rs.runsFrom(list.items, rs.sliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + rs.sliceSet(rs.runsAt(_165, 0), _163); + const _173: rs.Runs> = rs.runsFrom(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.runsAt(_173, 1)), rs.sliceToArray(_179)); + rs.runsSwap(rs.runsFrom(list.items, rs.sliceFrom), 0, 1); const _184: rs.Vec = list; const _186: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 15)); _184.items.push(_186); const _188: rs.Vec = none; const _190: rs.u32[] = copy$array_u32(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.runsIter(rs.runsFrom(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) { @@ -2723,10 +2744,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.Runs = rs.runsFrom([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.runsAt(one, 0)); + put$conversions_Value_array3_u8(rs.runsAt(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); @@ -2742,19 +2763,21 @@ 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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.runsAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.Runs = rs.runsFrom(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.runsAt(_124, 2); + const slice3 = rs.runsAt(_124, 2); + slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2764,26 +2787,28 @@ 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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice4 = rs.runsAt(_165, 0); + slice4.data.set(_163, slice4.start); + const _173: rs.Runs = rs.runsFrom(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 slice5 = rs.runsAt(_173, 1); + const slice6 = rs.runsAt(_173, 1); + slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); 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.runsIter(rs.runsFrom(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) { @@ -2832,10 +2857,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.Runs = rs.runsFrom([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.runsAt(one, 0)); + put$conversions_Value_array40_u8(rs.runsAt(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); @@ -2851,19 +2876,21 @@ 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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const slice = rs.runsAt(_116, 0); + slice.data.set(_114, slice.start); + const _124: rs.Runs = rs.runsFrom(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.runsAt(_124, 2); + const slice3 = rs.runsAt(_124, 2); + slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); if (_134 === rs.DONE) { @@ -2873,26 +2900,28 @@ 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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const slice4 = rs.runsAt(_165, 0); + slice4.data.set(_163, slice4.start); + const _173: rs.Runs = rs.runsFrom(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 slice5 = rs.runsAt(_173, 1); + const slice6 = rs.runsAt(_173, 1); + slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); 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.runsIter(rs.runsFrom(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) { @@ -3661,15 +3690,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.Runs = rs.runsFrom(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.Runs = rs.runsFrom(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.runsBoxCloneFrom(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.runsIter(into), rs.runsIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3713,15 +3742,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.Runs = rs.runsFrom(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.Runs = rs.runsFrom(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.runsBoxCloneFrom(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.runsIter(into), rs.runsIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3765,15 +3794,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.Runs> = rs.runsFrom(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.Runs> = rs.runsFrom(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.runsBoxCloneFrom(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.runsIter(into), rs.runsIter(whole)); while (true) { const _108: rs.Slice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3817,15 +3846,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.Runs = rs.runsFrom(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.Runs = rs.runsFrom(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.runsBoxCloneFrom(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.runsIter(into), rs.runsIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -3869,15 +3898,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.Runs = rs.runsFrom(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.Runs = rs.runsFrom(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.runsBoxCloneFrom(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.runsIter(into), rs.runsIter(whole)); while (true) { const _108: rs.ByteSlice | rs.Done = iter2.next(); if (_108 === rs.DONE) { @@ -4352,18 +4381,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.Runs = rs.runsOne(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.runsOne(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.runsOne(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.Runs = rs.runsOne(rs.byteSliceFrom(c), 0); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); + const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 0)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4386,21 +4416,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.Runs = rs.runsOne(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 old4 = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_28, slice2.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.runsOne(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.runsOne(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.Runs = rs.runsOne(rs.byteSliceFrom(c), 1); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); + const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 1)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4423,19 +4455,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.Runs> = rs.runsOne(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.runsAt(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.runsOne(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.runsOne(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.Runs> = rs.runsOne(rs.sliceFrom(c), 2); + const _55: rs.u32[] = copy$array_u32(b.slice()); + rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u32)); + const iter: rs.Iter> = rs.runsIter(rs.runsOne(rs.sliceFrom(a), 2)); while (true) { const _61: rs.Slice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4458,21 +4491,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.Runs = rs.runsOne(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 old4 = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_28, slice2.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.runsOne(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.runsOne(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.Runs = rs.runsOne(rs.byteSliceFrom(c), 3); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); + const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 3)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4495,21 +4530,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.Runs = rs.runsOne(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 old4 = rs.byteSliceToArray(rs.runsAt(s, 0)); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_28, slice2.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.runsOne(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.runsOne(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.Runs = rs.runsOne(rs.byteSliceFrom(c), 40); + const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); + rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); + const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 40)); while (true) { const _61: rs.ByteSlice | rs.Done = iter.next(); if (_61 === rs.DONE) { @@ -4923,8 +4960,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 0, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -4932,7 +4969,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.Runs = rs.runsRange(rs.runsFrom(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; @@ -4942,6 +4979,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); @@ -4952,11 +4990,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.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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.runsItems(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -4985,8 +5023,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 1, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -4994,7 +5032,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.Runs = rs.runsRange(rs.runsFrom(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; @@ -5004,6 +5042,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); @@ -5014,11 +5053,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.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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.runsItems(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5047,8 +5086,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.runsBy(rs.runsFrom(v.items, rs.sliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpSlice(rs.cmp)), 8, true)); + const tagged: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -5056,7 +5095,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.Runs> = rs.runsRange(rs.runsFrom(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; @@ -5066,6 +5105,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); @@ -5076,11 +5116,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.runsItems(s), rs.sliceItems(_56), rs.cmpSlice(rs.cmp)), rs.sliceBinarySearchBy(rs.runsItems(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.runsItems(s), (held2) => _65(rs.sliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5109,8 +5149,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 3, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -5118,7 +5158,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.Runs = rs.runsRange(rs.runsFrom(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; @@ -5128,6 +5168,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); @@ -5138,11 +5179,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.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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.runsItems(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5171,8 +5212,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 40, true)); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -5180,7 +5221,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.Runs = rs.runsRange(rs.runsFrom(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; @@ -5190,6 +5231,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); @@ -5200,11 +5242,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.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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.runsItems(s), (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { const _69: rs.Result | rs.Done = iter3.next(); if (_69 === rs.DONE) { @@ -5759,14 +5801,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.runsFrom(array, rs.byteSliceFrom), out); + readAs$array3_u8_ref_ref_slice_array3_u8(rs.runsRange(rs.runsFrom(array, rs.byteSliceFrom), 1), out); + readAs$array3_u8_ref_array3_array3_u8(rs.runsFrom(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.runsFrom(array, rs.byteSliceFrom), make$conversions_Value_array3_u8(data, 18)); + writeAs$array3_u8_mut_array3_array3_u8(rs.runsFrom(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; @@ -5793,8 +5835,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.runsFrom(array, rs.byteSliceFrom), rs.runsFrom(list.items, rs.byteSliceFrom), out).length & 0xff); + const iter: rs.Iter = rs.iterChain(rs.runsIter(rs.runsFrom(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) { @@ -6289,9 +6331,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.Runs = rs.runsFrom(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.runsIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6303,9 +6345,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.Runs = rs.runsFrom(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.runsIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6316,10 +6358,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.Runs, out: rs.ByteVec): void { + const s: rs.Runs = 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.runsIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6331,9 +6373,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.Runs = rs.runsFrom(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.runsIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6344,10 +6386,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.Runs, out: rs.ByteVec): void { + const s: rs.Runs = 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.runsIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6358,10 +6400,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.Runs, out: rs.ByteVec): void { + const s: rs.Runs = 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.runsIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6740,16 +6782,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.runsLast(rs.runsFrom(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.Runs, 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.runsLast(b); if (_3 !== undefined) { _3.data.set(value, _3.start); } @@ -6758,16 +6800,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.runsLast(rs.runsFrom(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.Runs, 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.runsLast(b); if (_3 !== undefined) { _3.data.set(value, _3.start); } @@ -7679,7 +7721,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.Runs, b: rs.Runs, out: rs.ByteVec): rs.Runs { 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 4d6dae998..2b993b97c 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.runsFrom(grid, rs.sliceFrom), rs.byteSliceFrom(bytes)] as [rs.Slice, rs.Runs>, 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.runsFrom(grid, rs.sliceFrom); + const _38: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(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/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 0083f2797..24784ef7e 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -1102,7 +1102,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.runsIter(rs.runsFrom(pairs.items, rs.sliceFrom)), rs.runsIter(rs.runsFrom(moved.items, rs.sliceFrom)))); while (true) { const _309: [rs.usize, rs.Slice] | rs.Done = iter4.next(); if (_309 === rs.DONE) { @@ -1124,7 +1124,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void _325[1] = rs.u16Add(_325[1], 10); } rs.vecAppend(pairs, moved, 4); - const iter6: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); + const iter6: rs.Iter = rs.iterFlatten(rs.runsIter(rs.runsFrom(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) { @@ -1148,7 +1148,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.runsIter(rs.runsFrom(keys.items, rs.byteSliceFrom)), rs.runsIter(rs.runsFrom(rest.items, rs.byteSliceFrom)))), 2); while (true) { const _395: [rs.usize, rs.ByteSlice] | rs.Done = iter8.next(); if (_395 === rs.DONE) { @@ -1161,7 +1161,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.runsIter(rs.runsFrom(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); @@ -1368,7 +1368,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.runsIter(rs.runsFrom(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) { @@ -1718,7 +1718,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]])))), 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.runsIter(rs.runsFrom(pairs.items, rs.sliceFrom))); while (true) { const _372: [rs.usize, rs.Slice] | rs.Done = iter5.next(); if (_372 === rs.DONE) { @@ -1731,7 +1731,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.runsIter(rs.runsFrom(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 34b0774f0..9f7d73c32 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.runsIter(rs.runsFrom(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..894c9a0ee 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.runsIter(rs.runsFrom(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 a6b5eeba6..b30db06a5 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -136,12 +136,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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.runsIter(rs.runsFrom(copies.items, rs.byteSliceFrom))); while (true) { const _187: rs.ByteSlice | rs.Done = iter4.next(); if (_187 === rs.DONE) { @@ -1001,10 +1001,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.runsIter(rs.runsFrom(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 6279d10b2..41719d1bd 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.runsItems(rs.runsFrom([hashA, hashB], rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([hashA, hashB], rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([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.runsItems(rs.runsFrom(quads.items, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(quads.items, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(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.runsItems(rs.runsFrom(zeros.items, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(zeros.items, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(zeros.items, rs.byteSliceFrom)), seps, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([], rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([], 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.runsItems(rs.runsFrom(pairs.items, rs.sliceFrom)), 2, undefined, rs.sliceFrom), out); + wides(rs.slicesJoin(rs.runsItems(rs.runsFrom(pairs.items, rs.sliceFrom)), 2, rs.sliceFrom([sep2]), rs.sliceFrom), out); + const _231: rs.Runs> = rs.runsFrom(pairs.items, rs.sliceFrom); + const _233: rs.Slice = rs.sliceFrom(wideSeps.items); + wides(rs.slicesJoin(rs.runsItems(_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.runsItems(rs.runsFrom(zeros2.items, rs.sliceFrom)), 2, undefined, rs.sliceFrom), out); + wides(rs.slicesJoin(rs.runsItems(rs.runsFrom(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.runsItems(rs.runsFrom(pairs2, rs.sliceFrom)), 8, undefined, rs.sliceFrom, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(rs.runsItems(rs.runsFrom(pairs2, rs.sliceFrom)), 8, rs.sliceFrom([sep3]), rs.sliceFrom, Logged.clone$Clone), log.value, out); + const _383: rs.Runs> = rs.runsFrom(pairs2, rs.sliceFrom); + const _385: rs.Slice = rs.sliceFrom(seps2.items); + ids(rs.slicesJoin(rs.runsItems(_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 720a57a3f..e6413f0fc 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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(members.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, 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.runsBy(rs.runsFrom(values.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, 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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(members.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 0, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsFirst(rs.runsFrom(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.runsBy(rs.runsFrom(values.items, rs.byteSliceFrom), (runs2) => rs.sliceSort(runs2, rs.cmpLt(rs.cmpBytes), 0, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(members.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsFirst(rs.runsFrom(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.runsBy(rs.runsFrom(values.items, rs.byteSliceFrom), (runs2) => rs.sliceSort(runs2, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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..0720e8f1b 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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_0(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_0(data, rs.runsFrom(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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_1(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_1(data, rs.runsFrom(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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_17(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_17(data, rs.runsFrom(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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + recloned$u32_3(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); + swapped$u32_3(data, rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.Runs, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(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.Runs, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(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.Runs, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(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.Runs, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(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.Runs>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(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.Runs>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(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.Runs>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(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.Runs>, out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(0, 1)); + rs.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _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.runsIter(rs.runsFrom(_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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(17, 1)); + rs.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _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.runsIter(rs.runsFrom(_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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(1, 1)); + rs.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _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.runsIter(rs.runsFrom(_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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + const _110: rs.usize = rs.usizeRem(byte as rs.usize, rs.max(3, 1)); + rs.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _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.runsIter(rs.runsFrom(_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.Runs>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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.Runs>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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.Runs>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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.Runs>, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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.Runs, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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.Runs, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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.Runs, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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.Runs, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(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.runsFirst(_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.runsAt(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.runsIter(rs.runsFrom(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 61cbd61a7..38511b8cc 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -519,13 +519,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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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) { @@ -534,15 +534,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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(arrays.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index 0c7318344..f8ee4e21a 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.runsToArray(rs.runsFrom(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)); }), ["", "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.runsLast(rs.runsFrom(v.items, rs.sliceFrom))); const _20: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); _20.data[_20.start] = _20.data[_20.start] + "y"; const _24: rs.u8 = rs.sliceSame(first, rs.sliceFrom(v.items[rs.idx(v.items, 0)])) ? 1 : 0; @@ -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.runsFirst(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.runsLast(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.runsIter(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.runsIter(rs.runsFrom(pairs.items, rs.sliceFrom)).next())), rs.optionUnwrap(rs.runsFirst(rs.runsFrom(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.runsLast(rs.runsFrom(nested, rs.sliceFrom))), rs.optionUnwrap(rs.iterNth(rs.runsIter(rs.runsFrom(nested, rs.sliceFrom)), 1))) ? 1 : 0; rs.byteVecPush(o, _296); un[Symbol.dispose](); held[Symbol.dispose](); diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index 9b3e3bde0..c06269d6c 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -715,7 +715,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.runsIter(rs.runsFrom(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) { @@ -738,7 +738,7 @@ export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { for (const _168 of pairs.items) { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_168[0], option_unwrapOr$1fr498u(_168[1], 238)))); } - const iter10: rs.Iter = rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.sliceFrom), (value: rs.Slice) => rs.iterSlice(rs.sliceItems(value)), true, 2); + const iter10: rs.Iter = rs.iterFlatten(rs.runsIter(rs.runsFrom(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 505b0482a..66e245bae 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$13p7ywa(self: rs.Slice | undefined, _: (a0: rs.Slice return sumTexts(self); } -export function map$1fgo7n1(self: rs.Slice | undefined, _: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { +export function map$1w7gh4m(self: rs.Runs | undefined, _: (a0: rs.Runs) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } @@ -46,7 +46,7 @@ export function mapOr$1dcbyoa(self: rs.Slice | undefined, default_: rs.u return sumTexts(self); } -export function mapOr$1bxom2b(self: rs.Slice | undefined, default_: rs.u8, _: (a0: rs.Slice) => rs.u8): rs.u8 { +export function mapOr$1kivo4d(self: rs.Runs | undefined, default_: rs.u8, _: (a0: rs.Runs) => 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 43146b0a5..86baba947 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$13p7ywa as option_map$13p7ywa, 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$1dcbyoa as option_mapOr$1dcbyoa, 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$13p7ywa as option_map$13p7ywa, map$1w7gh4m as option_map$1w7gh4m, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1dcbyoa as option_mapOr$1dcbyoa, mapOr$1kivo4d as option_mapOr$1kivo4d, 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.Runs): rs.u8 { + return rs.iterFold(rs.runsIter(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.Runs | undefined; let _784!: rs.i32; - let p14!: rs.Slice | undefined; - let _862!: rs.Slice | undefined; + let p14!: rs.Runs | undefined; + let _862!: rs.Runs | undefined; let _895!: rs.i32; - let p16!: rs.Slice | undefined; + let p16!: rs.Runs | undefined; let _971!: rs.ByteSlice | undefined; let _1002!: rs.i32; let p18!: rs.ByteSlice | undefined; @@ -572,7 +572,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.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); hint(it15.sizeHint(), out); flush(log, out); while (true) { @@ -592,7 +592,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.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); let iterStart8: rs.i32 = 0; const iterEnd8: rs.i32 = 12; while ((_784 = iterStart8++) < iterEnd8) { @@ -601,19 +601,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$1kivo4d(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$1w7gh4m(rs.iterNth(rs.runsRsplit(rs.runsFrom(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$1w7gh4m(rs.iterNthBack(rs.runsRsplit(rs.runsFrom(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$1w7gh4m(rs.iterLast(rs.runsRsplit(rs.runsFrom(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.runsRsplit(rs.runsFrom(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.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos)), 1), sumTwos), "next"); flush(log, out); const iter17: rs.Iter = rs.iterSlice([false, true]); l140: while (true) { @@ -622,7 +622,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.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); hint(it17.sizeHint(), out); flush(log, out); while (true) { @@ -642,7 +642,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.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); let iterStart9: rs.i32 = 0; const iterEnd9: rs.i32 = 12; while ((_895 = iterStart9++) < iterEnd9) { @@ -651,19 +651,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$1kivo4d(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$1w7gh4m(rs.iterNth(rs.runsSplit(rs.runsFrom(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$1w7gh4m(rs.iterNthBack(rs.runsSplit(rs.runsFrom(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$1w7gh4m(rs.iterLast(rs.runsSplit(rs.runsFrom(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.runsSplit(rs.runsFrom(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.runsSplit(rs.runsFrom(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 ca6999aae..87f582eb9 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.runsIter(rs.runsFrom(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])])); - 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.runsIter(rs.runsFrom(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"])])); const _174: rs.Iter = rs.iterSlice([]); const _176: rs.Iter = rs.byteVecIntoIter(new rs.ByteVec()); @@ -1870,12 +1870,12 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 12, true).items)), front, back); const args147 = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.fmtStr, ["Iter"]), "it")]; put(out, rs.fmtFormat([args147[0], "|", rs.fmtSpec({ alternate: true }, args147[0])])); - const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunksExact(data, 2), 3), (c: rs.ByteSlice): Uint8Array => { + const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.runsIter(rs.runsFrom(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")])); 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 e106e8026..f73b9f0ef 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -166,7 +166,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.runsFirst(rs.runsFrom((runs.pairs as rs.Vec).items, rs.byteSliceFrom)); if (_44 !== undefined) { fill$u8(_44, n); } @@ -212,7 +212,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.runsFirst(rs.runsFrom((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 d24b63954..11173f200 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.runsFrom(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.runsFirst(rs.arcMakeMut(rs.place(() => copy, (value2) => copy = value2), (a02: rs.Runs): rs.Runs => { + return rs.runsFrom(rs.sliceItems(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.runsIter(quads.value), rs.runsIter(copy.value)); while (true) { const _95: rs.ByteSlice | rs.Done = iter2.next(); if (_95 === rs.DONE) { diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index aa82e6676..d1fa5cfb2 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2070,7 +2070,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,80 +2094,81 @@ 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.Runs, rs.ByteSlice] = rs.sliceAsChunks(data, 2); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.Runs] = rs.sliceAsRchunks(data, 3); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.Runs>, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(words.items), 3); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 1); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.Runs>, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(items.items), 3); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(items.items), 2); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.Runs, 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.Runs>] = 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.Runs, rs.ByteSlice] = rs.sliceAsChunks(rs.byteSliceRange(data, start), 3); + const iter: rs.Iter = rs.runsIter(_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.Runs, 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.runsAt(_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.Runs>] = rs.sliceAsRchunks(rs.sliceRange(rs.sliceFrom(words.items), start), 2); + rs.iterExtendBytes(out, rs.iterOption(option_map$0duedp1(rs.runsLast(_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.Runs, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 2); + const _169: [rs.ByteSlice, rs.Runs] = rs.sliceAsRchunks(rs.byteSliceRange(rs.byteVecSlice(bytes), 1), 2); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([isSomeAnd$1ouf3e6(zip$0wdt346(rs.runsFirst(_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.runsFirst(_165[0]), rs.runsFirst(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.runsLast(_169[1]), rs.runsLast(_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.runsFirst(_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.runsFirst(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; @@ -2220,7 +2221,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 +2245,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.Runs, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 3); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(_16[0])); while (true) { const _23: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); if (_23 === rs.DONE) { @@ -2255,7 +2256,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.runsIter(_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 +2265,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.runsIter(_16[0]), (c33: rs.ByteSlice): boolean => { const _719: rs.ByteSlice = c33; return (_719.data[_719.start] & 1) !== 0; })); @@ -2283,8 +2284,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.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 2); + const iter4: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(_83[1])); while (true) { const _90: [rs.usize, rs.Slice] | rs.Done = iter4.next(); if (_90 === rs.DONE) { @@ -2296,7 +2297,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.runsIter(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 +2305,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.runsFirst(rs.sliceAsChunks(rs.byteVecSlice(bytes), 2)[0]), rs.byteSliceView)); + const keptWords: rs.u16[] | undefined = copy$Option_array2_u16(rs.optionMap(rs.runsFirst(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 +2314,383 @@ 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.Runs, 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.runsAt(_142[0], 0)), rs.byteSliceToArray(rs.runsAt(_142[0], _142[0].length - 1))]; + const first: Uint8Array = copy$array_u8(_152[0]); + const last: Uint8Array = copy$array_u8(_152[1]); + rs.runsSwap(_142[0], 0, rs.usizeSub(_142[0].length, 1)); + rs.runsBy(_142[0], (runs48) => rs.sliceReverse(runs48)); 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.runsBy(rs.runsRange(_142[0], 1), (runs49) => rs.sliceReverse(runs49)); + rs.runsBy(_142[0], (runs50) => rs.sliceRotateLeft(runs50, 1)); + const _168: rs.usize = rs.usizeDiv(n, 2); + rs.runsBy(_142[0], (runs51) => rs.sliceRotateRight(runs51, _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.runsAt(_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.runsCopyWithin(_142[0], 0, _177.end, 1, copy$array_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([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.runsBy(_142[0], (runs52) => rs.sliceSort(runs52, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.runsBy(_142[0], (runs53) => rs.sliceSort(runs53, rs.keyLt((held12) => f12(rs.byteSliceFrom(held12)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 2, true)); + rs.runsBy(_142[0], (runs54) => rs.sliceSortUnstable(runs54, 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.runsBy(_142[0], (runs55) => rs.sliceSortByCachedKey(runs55, (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.Runs, rs.Runs] = rs.runsSplitAt(_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 slice87 = rs.runsAt(_196[0], 0); + const slice88 = rs.runsAt(_196[1], _204); + const swapped8 = rs.byteSliceToArray(slice87); + const slice89 = rs.runsAt(_196[0], 0); + slice89.data.set(rs.byteSliceToArray(slice88), slice89.start); + const slice90 = rs.runsAt(_196[1], _204); + slice90.data.set(swapped8, slice90.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 old13 = rs.byteSliceToArray(rs.runsAt(_142[0], 0)); + const slice92 = rs.runsAt(_142[0], 0); + slice92.data.set(Uint8Array.of(7, 8), slice92.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 slice93 = rs.runsAt(_142[0], _216); + slice93.data.set(copy$array_u8(old), slice93.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.runsAt(_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.runsAt(_142[0], 0)); rs.idx(_142[0], 1); - _142[0].data[_142[0].start + 1] = _226; + const slice94 = rs.runsAt(_142[0], 1); + slice94.data.set(_226, slice94.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 slice95 = rs.runsAt(_142[0], 0); + slice95.data.set(copy$array_u8(kept3), slice95.start); + const _239: rs.ByteSlice | undefined = rs.runsLast(_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.runsIter(_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.Runs = rs.runsRange(_142[0], rs.usizeDiv(n, 2)); + const _251: Uint8Array = Uint8Array.of(9, 10); + rs.runsBy(_247, (runs56) => rs.sliceFill(runs56, _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.Runs>] = 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.runsAt(_253[1], 0)), rs.sliceToArray(rs.runsAt(_253[1], _253[1].length - 1))]; + const first2: rs.u16[] = _263[0]; + const last2: rs.u16[] = _263[1]; + rs.runsSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1)); + rs.runsBy(_253[1], (runs3) => rs.sliceReverse(runs3)); 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.runsBy(rs.runsRange(_253[1], 1), (runs4) => rs.sliceReverse(runs4)); + rs.runsBy(_253[1], (runs5) => rs.sliceRotateLeft(runs5, 1)); + const _279: rs.usize = rs.usizeDiv(n2, 2); + rs.runsBy(_253[1], (runs6) => rs.sliceRotateRight(runs6, _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.runsAt(_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.runsCopyWithin(_253[1], 0, _288.end, 1, copy$array_u16); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([first2, last2, 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.runsBy(_253[1], (runs7) => rs.sliceSort(runs7, rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.runsBy(_253[1], (runs8) => rs.sliceSort(runs8, rs.keyLt((held2) => f2(rs.sliceFrom(held2)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true)); + rs.runsBy(_253[1], (runs9) => rs.sliceSortUnstable(runs9, 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.runsBy(_253[1], (runs10) => rs.sliceSortByCachedKey(runs10, (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.Runs>, rs.Runs>] = rs.runsSplitAt(_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 slice11 = rs.runsAt(_307[0], 0); + const slice12 = rs.runsAt(_307[1], _315); + const swapped3 = rs.replaceIn(rs.sliceView(slice11), rs.sliceToArray(slice12)); + rs.sliceSet(rs.runsAt(_307[1], _315), swapped3); 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.runsAt(_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.runsAt(_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.runsAt(_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.runsAt(_253[1], 0)); rs.idx(_253[1], 1); - _253[1].data[_253[1].start + 1] = _337; + rs.sliceSet(rs.runsAt(_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.runsAt(_253[1], 0), copy$array_u16(kept5)); + const _350: rs.Slice | undefined = rs.runsLast(_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.runsIter(_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.Runs> = rs.runsRange(_253[1], rs.usizeDiv(n2, 2)); + const _362: rs.u16[] = [9, 10]; + rs.runsBy(_358, (runs11) => rs.sliceFill(runs11, _362, copy$array_u16)); } - const _364: [rs.ByteSlice, rs.Slice] = rs.byteSliceAsRchunksMut(rs.byteVecSlice(bytes), 4); + const _364: [rs.ByteSlice, rs.Runs] = 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.runsAt(_364[1], 0)), rs.byteSliceToArray(rs.runsAt(_364[1], _364[1].length - 1))]; + const first3: Uint8Array = copy$array_u8(_374[0]); + const last3: Uint8Array = copy$array_u8(_374[1]); + rs.runsSwap(_364[1], 0, rs.usizeSub(_364[1].length, 1)); + rs.runsBy(_364[1], (runs12) => rs.sliceReverse(runs12)); 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.runsBy(rs.runsRange(_364[1], 1), (runs13) => rs.sliceReverse(runs13)); + rs.runsBy(_364[1], (runs14) => rs.sliceRotateLeft(runs14, 1)); + const _390: rs.usize = rs.usizeDiv(n3, 2); + rs.runsBy(_364[1], (runs15) => rs.sliceRotateRight(runs15, _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.runsAt(_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.runsCopyWithin(_364[1], 0, _399.end, 1, copy$array_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([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.runsBy(_364[1], (runs16) => rs.sliceSort(runs16, rs.cmpLt(rs.cmpBytes), 4, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.runsBy(_364[1], (runs17) => rs.sliceSort(runs17, rs.keyLt((held4) => f4(rs.byteSliceFrom(held4)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true)); + rs.runsBy(_364[1], (runs18) => rs.sliceSortUnstable(runs18, 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.runsBy(_364[1], (runs19) => rs.sliceSortByCachedKey(runs19, (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.Runs, rs.Runs] = rs.runsSplitAt(_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 slice21 = rs.runsAt(_418[0], 0); + const slice22 = rs.runsAt(_418[1], _426); + const swapped4 = rs.byteSliceToArray(slice21); + const slice23 = rs.runsAt(_418[0], 0); + slice23.data.set(rs.byteSliceToArray(slice22), slice23.start); + const slice24 = rs.runsAt(_418[1], _426); + slice24.data.set(swapped4, slice24.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 old9 = rs.byteSliceToArray(rs.runsAt(_364[1], 0)); + const slice26 = rs.runsAt(_364[1], 0); + slice26.data.set(Uint8Array.of(1, 2, 3, 4), slice26.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 slice27 = rs.runsAt(_364[1], _438); + slice27.data.set(copy$array_u8(old3), slice27.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.runsAt(_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.runsAt(_364[1], 0)); rs.idx(_364[1], 1); - _364[1].data[_364[1].start + 1] = _448; + const slice28 = rs.runsAt(_364[1], 1); + slice28.data.set(_448, slice28.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 slice29 = rs.runsAt(_364[1], 0); + slice29.data.set(copy$array_u8(kept7), slice29.start); + const _461: rs.ByteSlice | undefined = rs.runsLast(_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.runsIter(_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.Runs = rs.runsRange(_364[1], rs.usizeDiv(n3, 2)); + const _473: Uint8Array = rs.bytes(4).fill(5); + rs.runsBy(_469, (runs20) => rs.sliceFill(runs20, _473, copy$array_u8)); } - const _479: [rs.Slice, rs.Slice] = rs.sliceAsChunksMut(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0], 2); + const _479: [rs.Runs>, rs.Runs] = 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.runsToArray(rs.runsAt(_479[0], 0), rs.byteSliceToArray), rs.runsToArray(rs.runsAt(_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.runsSwap(_479[0], 0, rs.usizeSub(_479[0].length, 1)); + rs.runsBy(_479[0], (runs21) => rs.sliceReverse(runs21)); 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.runsBy(rs.runsRange(_479[0], 1), (runs22) => rs.sliceReverse(runs22)); + rs.runsBy(_479[0], (runs23) => rs.sliceRotateLeft(runs23, 1)); + const _503: rs.usize = rs.usizeDiv(n4, 2); + rs.runsBy(_479[0], (runs24) => rs.sliceRotateRight(runs24, _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.runsToArray(rs.runsAt(_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.runsCopyWithin(_479[0], 0, _512.end, 1, copy$array_array2_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_u8(first4), copy$array_array2_u8(last4), copy$array_array2_u8(kept8)], rs.runsOf(rs.byteSliceFrom))), (c13: rs.Runs): rs.u8 => { + const slice33 = rs.runsAt(c13, 0); + const _342: rs.u8 = slice33.data[slice33.start]; + const slice34 = rs.runsAt(c13, 1); + return _342 ^ slice34.data[slice34.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.runsBy(_479[0], (runs25) => rs.sliceSort(runs25, rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_479[0]), (c14: rs.Runs): rs.u8 => { + const slice35 = rs.runsAt(c14, 0); + const _346: rs.u8 = slice35.data[slice35.start]; + const slice36 = rs.runsAt(c14, 1); + return _346 ^ slice36.data[slice36.start + 1]; }), undefined, true); - const f6 = (c15: rs.Slice): Uint8Array => { - return copy$array_u8(c15.data[c15.start + 1]); + const f6 = (c15: rs.Runs): Uint8Array => { + return rs.byteSliceToArray(rs.runsAt(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.runsBy(_479[0], (runs26) => rs.sliceSort(runs26, rs.keyLt((held6) => f6(rs.runsOf(rs.byteSliceFrom)(held6)), rs.cmpLt(rs.cmpReverse(rs.cmpBytes))), 4, true)); + rs.runsBy(_479[0], (runs27) => rs.sliceSortUnstable(runs27, rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true, true)); + const f7 = (c16: rs.Runs): Uint8Array => { + return rs.byteSliceToArray(rs.runsAt(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.runsBy(_479[0], (runs28) => rs.sliceSortByCachedKey(runs28, (held7) => f7(rs.runsOf(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.Runs>, rs.Runs>] = rs.runsSplitAt(_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 swapped5 = rs.runsReplace(rs.runsAt(_531[0], 0), rs.runsToArray(rs.runsAt(_531[1], _539), rs.byteSliceToArray)); + rs.runsSet(rs.runsAt(_531[1], _539), swapped5); 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.runsReplace(rs.runsAt(_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.runsSet(rs.runsAt(_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.runsToArray(rs.runsAt(_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.runsToArray(rs.runsAt(_479[0], 0), rs.byteSliceToArray); rs.idx(_479[0], 1); - _479[0].data[_479[0].start + 1] = _563; + rs.runsSet(rs.runsAt(_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.runsSet(rs.runsAt(_479[0], 0), copy$array_array2_u8(kept9)); + const _576: rs.Runs | undefined = rs.runsLast(_479[0]); if (_576 !== undefined) { - rs.sliceSet(_576, [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]); + rs.runsSet(_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.runsIter(_479[0]), (c17: rs.Runs): rs.u8 => { + const slice44 = rs.runsAt(c17, 0); + const _353: rs.u8 = slice44.data[slice44.start]; + const slice45 = rs.runsAt(c17, 1); + return _353 ^ slice45.data[slice45.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.Runs> = rs.runsRange(_479[0], rs.usizeDiv(n4, 2)); + const _590: Uint8Array[] = [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]; + rs.runsBy(_586, (runs29) => rs.sliceFill(runs29, _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.Runs>>, rs.Runs>] = 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.runsToArray(rs.runsAt(_600[0], 0), (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsToArray(rs.runsAt(_600[0], _600[0].length - 1), (s) => rs.runsToArray(s, rs.byteSliceToArray))]; + const first5: Uint8Array[][] = copy$array_array2_array2_u8(_615[0]); + const last5: Uint8Array[][] = copy$array_array2_array2_u8(_615[1]); + rs.runsSwap(_600[0], 0, rs.usizeSub(_600[0].length, 1)); + rs.runsBy(_600[0], (runs30) => rs.sliceReverse(runs30)); 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.runsBy(rs.runsRange(_600[0], 1), (runs31) => rs.sliceReverse(runs31)); + rs.runsBy(_600[0], (runs32) => rs.sliceRotateLeft(runs32, 1)); + const _631: rs.usize = rs.usizeDiv(n5, 2); + rs.runsBy(_600[0], (runs33) => rs.sliceRotateRight(runs33, _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.runsToArray(rs.runsAt(_600[0], _634), (s) => rs.runsToArray(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.runsCopyWithin(_600[0], 0, _640.end, 1, copy$array_array2_array2_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_array2_u8(first5), copy$array_array2_array2_u8(last5), copy$array_array2_array2_u8(kept10)], rs.runsOf(rs.runsOf(rs.byteSliceFrom)))), (c18: rs.Runs>): rs.u8 => { + const slice50 = rs.runsAt(rs.runsAt(c18, 0), 0); + const _356: rs.u8 = slice50.data[slice50.start]; + const slice52 = rs.runsAt(rs.runsAt(c18, 1), 1); + return _356 ^ slice52.data[slice52.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.runsBy(_600[0], (runs34) => rs.sliceSort(runs34, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_600[0]), (c19: rs.Runs>): rs.u8 => { + const slice54 = rs.runsAt(rs.runsAt(c19, 0), 0); + const _357: rs.u8 = slice54.data[slice54.start]; + const slice56 = rs.runsAt(rs.runsAt(c19, 1), 1); + return _357 ^ slice56.data[slice56.start + 1]; }), undefined, true); - const f8 = (c20: rs.Slice): Uint8Array[] => { - return copy$array_array2_u8(c20.data[c20.start + 1]); + const f8 = (c20: rs.Runs>): Uint8Array[] => { + return rs.runsToArray(rs.runsAt(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.runsBy(_600[0], (runs35) => rs.sliceSort(runs35, rs.keyLt((held8) => f8(rs.runsOf(rs.runsOf(rs.byteSliceFrom))(held8)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)))), 8, true)); + rs.runsBy(_600[0], (runs36) => rs.sliceSortUnstable(runs36, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true, true)); + const f9 = (c21: rs.Runs>): Uint8Array[] => { + return rs.runsToArray(rs.runsAt(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.runsBy(_600[0], (runs37) => rs.sliceSortByCachedKey(runs37, (held9) => f9(rs.runsOf(rs.runsOf(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.Runs>>, rs.Runs>>] = rs.runsSplitAt(_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 swapped6 = rs.runsReplace(rs.runsAt(_659[0], 0), rs.runsToArray(rs.runsAt(_659[1], _667), (s) => rs.runsToArray(s, rs.byteSliceToArray))); + rs.runsSet(rs.runsAt(_659[1], _667), swapped6); 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.runsReplace(rs.runsAt(_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.runsSet(rs.runsAt(_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.runsToArray(rs.runsAt(_600[0], 1), (s) => rs.runsToArray(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.runsToArray(rs.runsAt(_600[0], 0), (s) => rs.runsToArray(s, rs.byteSliceToArray)); rs.idx(_600[0], 1); - _600[0].data[_600[0].start + 1] = _688; + rs.runsSet(rs.runsAt(_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.runsSet(rs.runsAt(_600[0], 0), copy$array_array2_array2_u8(kept11)); + const _701: rs.Runs> | undefined = rs.runsLast(_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.runsSet(_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.runsIter(_600[0]), (c22: rs.Runs>): rs.u8 => { + const slice65 = rs.runsAt(rs.runsAt(c22, 0), 0); + const _367: rs.u8 = slice65.data[slice65.start]; + const slice67 = rs.runsAt(rs.runsAt(c22, 1), 1); + return _367 ^ slice67.data[slice67.start + 1]; }), undefined, true); - const _711: rs.Slice = rs.sliceRange(_600[0], rs.usizeDiv(n5, 2)); + const _711: rs.Runs>> = rs.runsRange(_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.runsBy(_711, (runs38) => rs.sliceFill(runs38, _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.Runs>>>, rs.Runs>>] = rs.sliceAsChunks(rs.sliceAsChunks(rs.sliceFrom(refs.items), 2)[0], 2); if (_729[0].length >= 2) { - rs.sliceSwap(_729[0], 0, 1); + rs.runsSwap(_729[0], 0, 1); } const iter6: rs.Iter<[rs.usize, rs.Place>]> = rs.iterEnumerate(rs.iterSliceMut(rs.sliceFrom(refs.items))); while (true) { @@ -2677,103 +2708,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.Runs>>, rs.Runs>] = 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.runsToArray(rs.runsAt(_760[0], 0), rs.sliceToArray), rs.runsToArray(rs.runsAt(_760[0], _760[0].length - 1), rs.sliceToArray)]; + const first6: rs.u16[][] = _768[0]; + const last6: rs.u16[][] = _768[1]; + rs.runsSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1)); + rs.runsBy(_760[0], (runs39) => rs.sliceReverse(runs39)); 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.runsBy(rs.runsRange(_760[0], 1), (runs40) => rs.sliceReverse(runs40)); + rs.runsBy(_760[0], (runs41) => rs.sliceRotateLeft(runs41, 1)); + const _784: rs.usize = rs.usizeDiv(n6, 2); + rs.runsBy(_760[0], (runs42) => rs.sliceRotateRight(runs42, _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.runsToArray(rs.runsAt(_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.runsCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([first6, last6, kept12], rs.runsOf(rs.sliceFrom))), (c23: rs.Runs>): rs.u8 => { + const slice71 = rs.runsAt(c23, 0); + const _415: rs.u16 = slice71.data[slice71.start]; + const slice72 = rs.runsAt(c23, 1); + return (_415 ^ slice72.data[slice72.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.runsBy(_760[0], (runs43) => rs.sliceSort(runs43, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true)); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_760[0]), (c24: rs.Runs>): rs.u8 => { + const slice73 = rs.runsAt(c24, 0); + const _416: rs.u16 = slice73.data[slice73.start]; + const slice74 = rs.runsAt(c24, 1); + return (_416 ^ slice74.data[slice74.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.Runs>): rs.u16[] => { + return rs.sliceToArray(rs.runsAt(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.runsBy(_760[0], (runs44) => rs.sliceSort(runs44, rs.keyLt((held10) => f10(rs.runsOf(rs.sliceFrom)(held10)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmp)))), 8, true)); + rs.runsBy(_760[0], (runs45) => rs.sliceSortUnstable(runs45, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true, true)); + const f11 = (c26: rs.Runs>): rs.u16[] => { + return rs.sliceToArray(rs.runsAt(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.runsBy(_760[0], (runs46) => rs.sliceSortByCachedKey(runs46, (held11) => f11(rs.runsOf(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.Runs>>, rs.Runs>>] = rs.runsSplitAt(_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 swapped7 = rs.runsReplace(rs.runsAt(_812[0], 0), rs.runsToArray(rs.runsAt(_812[1], _820), rs.sliceToArray)); + rs.runsSet(rs.runsAt(_812[1], _820), swapped7); 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.runsReplace(rs.runsAt(_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.runsSet(rs.runsAt(_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.runsToArray(rs.runsAt(_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.runsToArray(rs.runsAt(_760[0], 0), rs.sliceToArray); rs.idx(_760[0], 1); - _760[0].data[_760[0].start + 1] = _844; + rs.runsSet(rs.runsAt(_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.runsSet(rs.runsAt(_760[0], 0), copy$array_array2_u16(kept13)); + const _857: rs.Runs> | undefined = rs.runsLast(_760[0]); if (_857 !== undefined) { - rs.sliceSet(_857, [[5, 6], [7, 8]]); + rs.runsSet(_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.runsIter(_760[0]), (c27: rs.Runs>): rs.u8 => { + const slice82 = rs.runsAt(c27, 0); + const _417: rs.u16 = slice82.data[slice82.start]; + const slice83 = rs.runsAt(c27, 1); + return (_417 ^ slice83.data[slice83.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.Runs>> = rs.runsRange(_760[0], rs.usizeDiv(n6, 2)); + const _871: rs.u16[][] = [[5, 6], [7, 8]]; + rs.runsBy(_867, (runs47) => rs.sliceFill(runs47, _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.Runs>, 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.runsAt(_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.runsSwap(_875[0], 0, 1); + rs.runsBy(_875[0], (runs) => rs.sliceReverse(runs)); 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.runsBy(_875[0], (runs2) => rs.sliceSort(runs2, rs.keyLt((held) => f(rs.sliceFrom(held)), rs.lt), 2, true)); rs.idx(_875[0], 1); - rs.dropAll(_875[0].data[_875[0].start + 1]); - _875[0].data[_875[0].start + 1] = first13; + rs.dropAll(rs.runsAt(_875[0], 1)); + rs.sliceSet(rs.runsAt(_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.runsAt(_875[0], 0); + slice4.data[slice4.start + 1][Symbol.dispose](); + const slice5 = rs.runsAt(_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.Runs>, rs.Runs>] = rs.runsSplitAt(_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.runsAt(_909[0], 0); + const slice7 = rs.runsAt(_909[1], 0); + const swapped2 = rs.replaceIn(rs.sliceView(slice6), rs.sliceToArray(slice7), 1); + rs.sliceSet(rs.runsAt(_909[1], 0), swapped2); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_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.Runs, 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))); } diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index f4c095417..837aa3ee6 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -548,14 +548,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; @@ -714,16 +711,19 @@ export function sliceFrom(items: T[]): Slice { * The elements of `s` as a JS array, for what only reads one: the storage itself where `s` * is all of it, or else a copy, which nothing can tell from it while the borrow lives. */ -export function sliceItems(s: Slice): T[] { +export function sliceItems(s: Slice): T[]; +export function sliceItems(s: Runs): RunArray[]; +export function sliceItems(s: Slice | Runs): unknown[] { + if (s instanceof Runs) return runsArray(s); return s.start === 0 && s.length === s.data.length ? s.data : s.data.slice(s.start, s.start + s.length); } /** Elements in a row, as a slice reads them: the JS array of a `[T; N]`, a `Slice`, or a `Vec`. */ -export type Elements = ArrayLike | Slice | Vec; +export type Elements = ArrayLike | Slice | Vec | Runs; -/** 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, the arrays of runs as `runsArray` 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 Runs ? (runsArray(s) as unknown as ArrayLike) : s; } /** Where `s`'s elements start in `sliceData(s)`. */ @@ -753,7 +753,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; @@ -793,10 +793,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]; @@ -908,12 +908,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; @@ -950,140 +944,254 @@ 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. */ -class Runs extends View { - flat: T[]; - offset: number; +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: `Runs`. + +/** What a `&[T; N]` is, as a slice of arrays lends each of its runs: a slice of its elements, of its bytes, or of its own runs. */ +export type Run = Slice | ByteSlice | Runs; + +/** The `[T; N]` a run `S` lends: its elements' array, its bytes, or its runs' arrays. */ +export type RunArray = S extends ByteSlice ? Uint8Array : S extends Slice ? T[] : S extends Runs ? RunArray[] : never; + +/** + * A `&[[T; N]]`, `&mut [[T; N]]`, or `Box<[[T; N]]>`: `length` runs from `start`, each lent + * as `S`, the slice a `&[T; N]` is, so a run is read and written where the slice holds it. + * The runs 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. + */ +export class Runs { + 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 runs, each lent by + * `of`. Runs of none take their type from where they go, as `[]` says nothing of it. + */ +export function runsFrom(items: readonly [], of: (array: NoInfer>) => S): Runs; +export function runsFrom(items: readonly A[], of: (array: A) => S): Runs; +export function runsFrom(items: readonly A[], of: (array: A) => S): Runs { + return new Runs(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)); - } +/** `runsFrom` of `of`, as a function of the arrays, as a `[[T; N]; M]` is lent: one function for each `of`. */ +export function runsOf(of: (array: A) => S): (items: readonly A[]) => Runs { + let f = LENT.get(of) as ((items: readonly A[]) => Runs) | undefined; + if (f === undefined) LENT.set(of, (f = (items: readonly A[]) => runsFrom(items, of))); + return f; +} - 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]; - } +/** `runsOf`'s functions, by the `of` each lends with. */ +const LENT = /* @__PURE__ */ new Map(); - 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 = []; - } +/** Run `i` of `r`, in bounds, lent where `r` holds it. */ +export function runsAt(r: Runs, i: number): S { + const k = r.start + i; + if (r.items !== undefined) return (r.of as (array: unknown) => S)(r.items[k]); + return runPart(r.flat as S, k * r.n, r.n); +} + +/** `length` elements of `s` from `start`: a slice of the same storage, of the same class. */ +function runPart(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 Runs; + return new Runs(r.items, r.of, r.flat, r.n, r.start + start, length) as S; +} + +/** Runs `start` to `end` of `r`, in bounds already. */ +export function runsPart(r: Runs, start: number, end: number = r.length): Runs { + return runPart(r, start, end - start); +} + +/** `&r[start..end]` and `&mut r[start..end]`, with `end` defaulting to the length. */ +export function runsRange(r: Runs, start: number, end: number = r.length, at?: Location): Runs { + rangeCheck(r.length, start, end, at); + return runPart(r, start, end - start); +} + +/** Each run of `r`, lent where `r` holds it, as `each_ref` and `each_mut` of a `[[T; N]; M]` lend them. */ +export function runsEach(r: Runs): S[] { + const out = new Array(r.length); + for (let i = 0; i < r.length; i++) out[i] = runsAt(r, i); + return out; +} + +/** `slice::from_mut` or `array::from_mut` of a `&mut [T; n]`, which is `s`: the runs of it alone. */ +export function runsOne(s: S, n: number): Runs { + return new Runs(undefined, undefined, s, n, 0, 1); +} + +/** `*r` of a `&[[T; N]; M]`: each run copied by `copy`, an array of its own. */ +export function runsToArray(r: Runs, copy: (run: S) => A): A[] { + const out = new Array(r.length); + for (let i = 0; i < r.length; i++) out[i] = copy(runsAt(r, i)); + return out; } -/** 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; +/** `*r = items` of a `&mut [[T; N]; M]`: each run written where `r` holds it. */ +export function runsSet(r: Runs, items: ArrayLike>): void { + for (let i = 0; i < r.length; i++) runSet(runsAt(r, i), items[i]); +} + +/** `mem::replace` of what a `&mut [[T; N]; M]`, `r`, points at: its runs as arrays of their own, then `items` written where `r` holds them. */ +export function runsReplace(r: Runs, items: ArrayLike>): RunArray[] { + const old = runsToArray(r, runCopy); + runsSet(r, items); + return old; +} + +/** A whole write of `value`, a `[T; N]`, into the run `s`: its elements moved into where `s` holds them. */ +function runSet(s: Run, 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 runsSet(s, value as ArrayLike); } /** - * `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. + * The run `s` as a `[T; N]` of its own: a copy of its elements, and of the runs it holds at + * any depth, but not of the objects its elements are, which a write of it moves. */ -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; +function runCopy(s: S): RunArray { + if (s instanceof ByteSlice) return byteSliceToArray(s) as RunArray; + if (s instanceof Slice) return sliceToArray(s) as RunArray; + return runsToArray(s as Runs, runCopy) as RunArray; } /** - * `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. + * Whether pointers to `[[T; N]; M]`s, `a` and `b`, point at the same place: the same run of + * the same arrays, or of the same storage, or both null. */ -class ByteRuns extends View { - data: Uint8Array; - offset: number; - readonly n: number; - - 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; - } +export function runsSame(a: Runs, b: Runs): boolean { + if (!(a instanceof Runs && b instanceof Runs)) return a === b; + if (a.items !== undefined || b.items !== undefined) return a.items === b.items && a.start === b.start; + return runSame(runPart(a.flat!, a.start * a.n, 0), runPart(b.flat!, b.start * b.n, 0)); +} - 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 `a` and `b`, slices a pointer to a `[T; N]` is, point at the same place. */ +function runSame(a: Run, b: Run): 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 Runs && runsSame(a, b); +} - 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)); - } +/** + * The runs of `r` as a JS array of arrays, for what only reads them: the arrays themselves + * where `r` is all of them, or else copies, which nothing can tell from them while the + * borrow lives. + */ +export function runsArray(r: Runs): RunArray[] { + if (r.items !== undefined && r.start === 0 && r.length === r.items.length) return r.items as RunArray[]; + return runsToArray(r, runCopy); +} - override put(i: number, value: Uint8Array): void { - this.data.set(value, this.offset + i * this.n); - } +/** `last_chunk` of runs, shared or mutable: the last `n`, or `undefined` if fewer. */ +export function runsLastChunk(r: Runs, n: number): Runs | undefined { + return n > r.length ? undefined : runPart(r, r.length - n, n); +} - 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 = []; - } +/** `split_last_chunk` of runs, shared or mutable: the rest and the last `n`, or `undefined` if fewer. */ +export function runsSplitLastChunk(r: Runs, n: number): [Runs, Runs] | undefined { + return n > r.length ? undefined : [runPart(r, 0, r.length - n), runPart(r, r.length - n, n)]; +} +/** The runs of `r` as a slice of arrays, as `runsArray` reads them. */ +export function runsItems(r: Runs): Slice> { + return sliceFrom(runsArray(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 runs of `r` as a slice of arrays of their own, each a 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 runsBy(r: Runs, op: (s: Slice>) => R): R { + const items = runsToArray(r, runCopy); + try { + return op(sliceFrom(items)); + } finally { + runsSet(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 runs, panicking on either index past the end, `a` first, as std's indexing does. */ +export function runsSwap(r: Runs, a: number, b: number, at?: Location): void { + const x = runsAt(r, idx(r, a, at)); + const y = runsAt(r, idx(r, b, at)); + const kept = runCopy(x); + runSet(x, runCopy(y)); + runSet(y, kept); } -/** `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; +/** `first` and `first_mut` of runs: the first run, or `undefined` if empty. */ +export function runsFirst(r: Runs): S | undefined { + return r.length === 0 ? undefined : runsAt(r, 0); } -/** Whether `s` holds `ByteRuns`' views. */ -function byteRuns(s: object): boolean { - return (s as { [VIEW]?: unknown })[VIEW] instanceof ByteRuns; +/** `last` and `last_mut` of runs: the last run, or `undefined` if empty. */ +export function runsLast(r: Runs): S | undefined { + return r.length === 0 ? undefined : runsAt(r, r.length - 1); +} + +/** `get` and `get_mut` of runs: the run at `index`, or `undefined` past the end. */ +export function runsGet(r: Runs, index: number): S | undefined { + return index < r.length ? runsAt(r, index) : undefined; +} + +/** `get` of `start..end` of runs, shared or mutable: the part, or `undefined` unless it is within them. */ +export function runsGetRange(r: Runs, start: number, end: number = r.length): Runs | undefined { + return start <= end && end <= r.length ? runPart(r, start, end - start) : undefined; +} + +/** `split_first` and `split_first_mut` of runs: the first and the rest, or `undefined` if empty. */ +export function runsSplitFirst(r: Runs): [S, Runs] | undefined { + return r.length === 0 ? undefined : [runsAt(r, 0), runPart(r, 1, r.length - 1)]; +} + +/** `split_last` and `split_last_mut` of runs: the last and the rest, or `undefined` if empty. */ +export function runsSplitLast(r: Runs): [S, Runs] | undefined { + const n = r.length - 1; + return n < 0 ? undefined : [runsAt(r, n), runPart(r, 0, n)]; +} + +/** `split_at` and `split_at_mut` of runs, panicking past the length. */ +export function runsSplitAt(r: Runs, n: number, at?: Location): [Runs, Runs] { + if (n > r.length) panic("mid > len", at); + return [runPart(r, 0, n), runPart(r, n, r.length - n)]; +} + +/** `split_at_checked` and `split_at_mut_checked` of runs: the halves, or `undefined` past the length. */ +export function runsSplitAtChecked(r: Runs, n: number): [Runs, Runs] | undefined { + return n > r.length ? undefined : [runPart(r, 0, n), runPart(r, n, r.length - n)]; } /** `get` of `start..end`, shared or mutable: the part, or `undefined` unless it is within the slice. */ @@ -1101,46 +1209,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 run 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): [Runs, S] { const count = chunkCount(s.length, n, at); - return [runsOf(s.data, s.start, n, count), slicePart(s, count * n)]; + return [new Runs(undefined, undefined, s, n, 0, count), runPart(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 run of `n` elements up to the back, as `sliceAsChunks` lends them. */ +export function sliceAsRchunks(s: S, n: number, at?: Location): [S, Runs] { 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 [runPart(s, 0, rest), new Runs(undefined, undefined, runPart(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. */ @@ -1149,12 +1231,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 { @@ -1310,7 +1386,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; } @@ -1393,10 +1469,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 runs: `r[start..end]` copied to index `dest`, each run read, and copied by `copy` if given, before any is written, panicking out of bounds. */ +export function runsCopyWithin(r: Runs, start: number, end: number, dest: number, copy?: (value: RunArray) => RunArray, at?: Location): void { + copyWithinCheck(r.length, start, end, dest, at); + const items = Array.from({ length: end - start }, (_, i) => runCopy(runsAt(r, start + i))); + for (let i = 0; i < items.length; i++) runSet(runsAt(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. @@ -1441,6 +1524,22 @@ export function boxSliceCloneFrom(dst: Slice, src: Slice, clone?: (valu return sliceFrom(items); } +/** + * `Clone::clone_from` of a `Box<[[T; N]]>`, the runs `dst`: itself, by `clone_from_slice`, + * where the lengths match, or else the runs `of` makes of a clone of `src`'s arrays, as + * `boxSliceCloneFrom` makes it. + */ +export function runsBoxCloneFrom(dst: Runs, src: Runs, of: (array: RunArray) => S, clone?: (value: RunArray) => RunArray, drop?: (item: RunArray) => void, over?: CloneFrom>, at?: Location): Runs { + if (dst.length !== src.length) return runsFrom(boxSliceCloneFrom(runsItems(dst), runsItems(src), clone, drop, over, at).data, of); + runsBy(dst, (d) => sliceCloneFromSlice(d, runsItems(src), clone, drop, over, at)); + return dst; +} + +/** `runsBoxCloneFrom` as a `CloneFrom`. */ +export function runsBoxCloneFromFn(of: (array: RunArray) => S, clone?: (value: RunArray) => RunArray, drop?: (item: RunArray) => void, over?: CloneFrom>, at?: Location): CloneFrom> { + return (old, src) => runsBoxCloneFrom(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); @@ -1905,38 +2004,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]; diff --git a/ts/runtime/rs/collections.ts b/ts/runtime/rs/collections.ts index 93b77cf1d..a071c44fb 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 { 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, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; +import { ByteSlice, ByteVec, Runs, 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, 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 { Hashing } from "./hash.ts"; import { type Limbs, lt, type u64, type usize } from "./int.ts"; @@ -335,6 +335,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 Runs) { + 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]; } diff --git a/ts/runtime/rs/hash.ts b/ts/runtime/rs/hash.ts index 5762270f8..d3c156b30 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, @@ -710,7 +710,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 3cb3e55b0..1fd3f5c00 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 Run, type Runs, runsArray, runsAt, runsEach, runsPart, 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 runs: the parts between the runs `f` is true of, each lent where the slice holds it. */ +export function runsSplit(r: Runs, f: (run: S) => boolean): Iter> { + return new SplitIter(r, runsEach(r), 0, runsPart, f, false, false); +} + +/** `slice::rsplit` and `rsplit_mut` of runs. */ +export function runsRsplit(r: Runs, f: (run: S) => boolean): Iter> { + return new SplitIter(r, runsEach(r), 0, runsPart, f, true, false); +} + +/** `slice::split_inclusive` and `split_inclusive_mut` of runs. */ +export function runsSplitInclusive(r: Runs, f: (run: S) => boolean): Iter> { + return new SplitIter(r, runsEach(r), 0, runsPart, f, false, true); +} + +/** `slice::splitn` and `splitn_mut` of runs. */ +export function runsSplitn(r: Runs, n: number, f: (run: S) => boolean): Iter> { + return new SplitIter(r, runsEach(r), 0, runsPart, f, false, false, n); +} + +/** `slice::rsplitn` and `rsplitn_mut` of runs. */ +export function runsRsplitn(r: Runs, n: number, f: (run: S) => boolean): Iter> { + return new SplitIter(r, runsEach(r), 0, runsPart, 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 runs: each run, lent where the slice holds it. */ +export function runsIter(r: Runs): Iter { + return new RunsIter(r); +} + +/** `slice::windows` of runs. */ +export function runsWindows(r: Runs, 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, runsPart); +} + +/** `slice::chunks` and `chunks_mut` of runs. */ +export function runsChunks(r: Runs, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, false, false, runsPart, at); +} + +/** `slice::chunks_exact` and `chunks_exact_mut` of runs. */ +export function runsChunksExact(r: Runs, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, true, false, runsPart, at); +} + +/** `slice::rchunks` and `rchunks_mut` of runs. */ +export function runsRchunks(r: Runs, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, false, true, runsPart, at); +} + +/** `slice::rchunks_exact` and `rchunks_exact_mut` of runs. */ +export function runsRchunksExact(r: Runs, size: number, at?: Location): Iter> { + return chunks(r, r.length, size, true, true, runsPart, 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 runs of a slice of arrays, from both ends, each lent where the slice holds it. */ +class RunsIter extends Iter { + private readonly r: Runs; + front = 0; + back: number; + + constructor(r: Runs) { + super(); + this.r = r; + this.back = r.length; + } + + next(): S | Done { + return this.front < this.back ? runsAt(this.r, this.front++) : DONE; + } + + override nextBack(): S | Done { + return this.front < this.back ? runsAt(this.r, --this.back) : DONE; + } + + override len(): number { + return this.back - this.front; + } + + override sizeHint(): SizeHint { + return exactHint(this.len()); + } + + override remaining(): Iterable { + return runsArray(runsPart(this.r, this.front, this.back - this.front)); + } + + override clone(): Iter { + const it = new RunsIter(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 }; diff --git a/ts/runtime/rs/task.ts b/ts/runtime/rs/task.ts index 26db5ac64..249299638 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 Run, Runs, runsArray, 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 | Runs | 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 Runs) dropRange(runsArray(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 runs `r`: a read is `copy`'s of + * them, and a write `set`s them. + */ +export function cellOfRuns(r: Runs, copy: (r: Runs) => A, set: (r: Runs, value: A) => void): Cell { + return cellOfPlace(place(() => copy(r), (value) => set(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/check.rs b/ts/src/check.rs index defee1c0a..5415ee4bf 100644 --- a/ts/src/check.rs +++ b/ts/src/check.rs @@ -186,7 +186,7 @@ pub fn typecheck(tcx: TyCtxt<'_>, program: &Program, out: &Path, written: &[(Pat None => _ = tcx.dcx().err(format!("rust2-ts: {msg}")), } } - _ = crate::program::clean(out); + // DEBUGKEEP _ = crate::program::clean(out); } /// The span where `loc` is. diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index e9744dbd3..19e28f1fe 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -77,7 +77,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { _ => Expr::rs("sliceFrom", vec![Expr::Array(items)]), } } - _ if 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 92ca19873..468aee162 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -152,6 +152,10 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if super::byte(elem) { return Expr::rs("byteSliceToArray", vec![s]); } + if self.uninit_inner(elem).is_array() { + let copy = self.array_copy_fn(elem, span); + return Expr::rs("runsToArray", vec![s, copy]); + } let mut values = vec![s]; values.extend(self.changes(elem).then(|| self.shim(elem, span)).flatten()); Expr::rs("sliceToArray", values) diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 15d260fc4..203e14225 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -828,6 +828,8 @@ 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 run, where a slice of arrays holds it. + ty::Slice(elem) | ty::Array(elem, _) if ty.is_ref() && elem.is_array() => Some(Expr::rs("runsIter", vec![value])), ty::Slice(elem) | ty::Array(elem, _) if places(b, *elem) => { Some(Expr::rs("iterSliceMut", vec![library::slice_of(value, ty)])) } @@ -1034,6 +1036,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("runsIter", args)), ("slice", "iter" | "iter_mut") => { let s = args.pop()?; let s = library::elements(s, Ty::new_slice(tcx, targ(0)?)); @@ -1375,7 +1378,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..fe178634c 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::runs::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() { + // Runs, lent each 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("runsArray".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 a6f9a1f03..4005527ba 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1472,7 +1472,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::runs::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::runs::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); } @@ -2085,11 +2096,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() => { @@ -2099,21 +2106,21 @@ 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 => "runs", + 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. + // Runs of `N` 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( @@ -2147,6 +2154,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, "runs", &super::camel(name.strip_suffix("_mut")?)), false => { let mut values = args; values.push(Expr::lit(b.t.needs_place(targ(gargs, 0)).to_string())); @@ -2192,7 +2200,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. @@ -2201,10 +2209,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") @@ -2297,10 +2302,7 @@ 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)), - }, + ("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), @@ -3038,6 +3040,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("runsEach", vec![s])); + } let a = match byte(elem) { true => Expr::rs("byteSliceView", vec![s]), false => slice_items(s), @@ -3249,8 +3254,19 @@ 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 runs' own, which makes runs +/// 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 => ("runsBoxCloneFrom", [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 @@ -3295,7 +3311,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( @@ -3526,7 +3542,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)), } } @@ -3546,10 +3562,7 @@ fn boxed_vec(boxed: Expr, elem: Ty<'_>) -> Expr { /// 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. @@ -3956,11 +3969,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 +/// `runs` 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(..) => "runs", + _ => "slice", } } @@ -3969,7 +3984,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), } } @@ -3995,6 +4010,10 @@ 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]), + // Copies of the runs of a slice of arrays, which a read can't tell from them. + ty::Slice(elem) | ty::Array(elem, _) if elem.is_array() && (ty.is_ref() || ty.is_slice()) => { + Expr::rs("runsArray", vec![v]) + } ty::Slice(_) => slice_items(v), _ if super::bytes_ref(ty) => Expr::rs("byteSliceView", vec![v]), _ if super::array_ref(ty).is_some() => slice_items(v), @@ -4024,6 +4043,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 == "runsFrom") && read == "sliceItems" => { + args.swap_remove(0) + } s => Expr::rs(read, vec![s]), } } @@ -4049,7 +4072,8 @@ pub fn slice_of(v: Expr, ty: Ty<'_>) -> Expr { _ if super::array_ref(ty).is_some() => v, ty::Array(elem, _) if byte(*elem) => Expr::rs("byteSliceFrom", vec![v]), ty::Array(..) => Expr::rs("sliceFrom", vec![v]), - ty::Adt(_, args) => vec_view(v, args.type_at(0)), + ty::Adt(_, args) if byte(args.type_at(0)) => Expr::rs("byteVecSlice", vec![v]), + ty::Adt(..) => Expr::rs("sliceFrom", vec![v.member("items")]), _ => v, } } diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index b32ff4e28..9fdbe8d7e 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -655,6 +655,14 @@ 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 runs' arrays, as `rs.runsBy` writes them back. + if elem.is_array() { + let name = self.b.fresh("runs"); + let source = Expr::rs("runsItems", vec![source]); + let e = Expr::rs("sliceCloneFromSlice", [vec![Expr::ident(name.clone()), source], fns].concat()); + let e = crate::lower::runs::wrap(e, ts::Type::Builtin("void"), Vec::new(), vec![(name, to)]); + 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) @@ -1131,6 +1139,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)); + "runsCopyWithin" + } _ => { values.extend(self.b.t.copy_fn(elem, span)); "sliceCopyWithin" @@ -1387,6 +1399,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 @@ -1410,6 +1431,20 @@ 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 runs of that one, and a + // cell of an array of arrays reads a copy of the runs 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.array_copy_fn(ty, span); + let set = crate::lower::array_fn(ty, "Set"); + return Some(Expr::rs("cellOfRuns", vec![slice, copy, set])); + } + let n = len.try_to_target_usize(tcx).unwrap_or(0); + return Some(Expr::rs("runsOne", vec![slice, Expr::lit(n.to_string())])); + } if !cell && crate::lower::byte(ty) { return Some(self.err( span, @@ -1661,7 +1696,7 @@ 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 @@ -1747,16 +1782,24 @@ 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 { + // Runs, each copied out and written where the slice holds it. + Some(p) if crate::lower::runs::of_arrays(self.b.t.uninit_inner(ty)) => { + let slice = self.borrowed_slice(place.0, p, span, out); + Expr::rs("runsReplace", vec![slice, value]) + } 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(); @@ -1813,6 +1856,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { return None; } + // A run 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; @@ -1841,6 +1888,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), } @@ -1918,13 +1973,17 @@ 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), + // A run 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("runsAt", 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() @@ -1981,6 +2040,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 => "runsRange", + _ if elem_ty.is_array() => "runsGetRange", (false, false) => "sliceRange", (false, true) => "sliceGetRange", }; @@ -2200,3 +2261,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" | "runsToArray")) => { + args.first().cloned() + } + _ => None, + } +} diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index f93619b65..b914efaa2 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("runsPart", 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( + "runsPart", + 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,32 @@ 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, + // A run of a slice of arrays is the slice of its elements. + ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => { + in_slice && self.b.t.uninit_inner(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 + /// `rs.Runs`' run, 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 self.b.t.uninit_inner(*elem).is_array() => { + Expr::rs("runsAt", 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. @@ -415,6 +438,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 self.b.t.uninit_inner(*e).is_array()) + } _ => false, }; } @@ -769,6 +795,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); @@ -799,15 +842,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 6d127f34b..4b4517e78 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -61,7 +61,7 @@ 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), _ => value, @@ -110,7 +110,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 +440,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 +529,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 e110030e1..743368dfe 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -24,6 +24,7 @@ mod mir; pub(crate) mod names; mod num; pub mod pointer; +pub mod runs; mod stock; mod task; mod time; @@ -1512,6 +1513,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.Runs` 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("Runs", 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; @@ -1529,22 +1542,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()); @@ -2288,15 +2293,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, `runs{name}` of arrays, and else `slice{name}`. `From` +/// of arrays, which lends each by its own `From`, is `rs.runsOf` 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("runsOf", vec![array_fn(*elem, "From")]), + _ => "runs", + }, + _ => "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.Runs` 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("runsFrom", 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 087e48216..b901066b0 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -180,8 +180,7 @@ 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() { @@ -501,13 +500,18 @@ 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 runs 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::runs::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. diff --git a/ts/src/lower/runs.rs b/ts/src/lower/runs.rs new file mode 100644 index 000000000..875eab055 --- /dev/null +++ b/ts/src/lower/runs.rs @@ -0,0 +1,138 @@ +//! Slices of arrays, which are `rs.Runs`: a `&[[T; N]]` lends each run as the slice a +//! `&[T; N]` is, where the slice holds it, whether its runs 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 +//! `runs` functions map std's methods that lend runs or parts. Any other method of a slice +//! of arrays reads it as an `rs.Slice` of JS arrays: shared, of its arrays or copies of its +//! runs, which a shared borrow can't tell from them, and mutable, of copies that +//! `rs.runsBy` 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.Runs`. +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 runs 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" + ) +} + +/// `args` as std's mapping of `call` reads them, unless [`native`] maps it: each +/// `&[[T; N]]` it reads as a slice given as `rs.runsItems`' copies, and each `&mut` one by +/// name, which [`wrap`] binds to `rs.runsBy`'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 a slice's own methods; a trait's mapping reads runs as their type says. + if native(tcx, call.def_id, call.args) || library::key(tcx, call.def_id).is_none_or(|(owner, _)| owner != "slice") { + 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("runsItems", vec![value]), + ty::Mutability::Mut => { + let name = b.fresh("runs"); + given.by.push((name.clone(), value)); + 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]]`'s name in `args`, and its value. + pub by: Vec<(String, Expr)>, +} + +/// `e`, the call std's mapping made of [`Given::args`], a `ty`, after `stmts`, with each +/// name it binds the `rs.runsBy` copies of its runs. +pub fn wrap(e: Expr, ty: Type, stmts: Vec, by: Vec<(String, Expr)>) -> Expr { + let mut stmts = Some(stmts); + let mut e = e; + for (name, value) 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("runsBy", vec![value, f]); + } + e +} From fbc9480574bc10e4f566765110b3e09b310d9c20 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 16:38:35 -0800 Subject: [PATCH 03/12] fix(ts): restore cleaning the typecheck output Co-Authored-By: Claude Opus 5.5 --- ts/src/check.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/src/check.rs b/ts/src/check.rs index 5415ee4bf..defee1c0a 100644 --- a/ts/src/check.rs +++ b/ts/src/check.rs @@ -186,7 +186,7 @@ pub fn typecheck(tcx: TyCtxt<'_>, program: &Program, out: &Path, written: &[(Pat None => _ = tcx.dcx().err(format!("rust2-ts: {msg}")), } } - // DEBUGKEEP _ = crate::program::clean(out); + _ = crate::program::clean(out); } /// The span where `loc` is. From 5f9230f6eef79224e74e296e1262d80082d39b76 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 16:41:04 -0800 Subject: [PATCH 04/12] style(ts): format Co-Authored-By: Claude Opus 5.5 --- ts/src/lower/iter.rs | 4 ++- ts/src/lower/library.rs | 6 +++- ts/src/lower/mir/call.rs | 15 ++++++++-- ts/src/lower/mir/place.rs | 3 +- ts/src/lower/runs.rs | 62 +++++++++++++++++++++++++-------------- 5 files changed, 62 insertions(+), 28 deletions(-) diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index e9ed96000..b7db3f795 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -831,7 +831,9 @@ fn peeled_into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, }; match ty.peel_refs().kind() { // Each run, where a slice of arrays holds it. - ty::Slice(elem) | ty::Array(elem, _) if ty.is_ref() && elem.is_array() => Some(Expr::rs("runsIter", vec![value])), + ty::Slice(elem) | ty::Array(elem, _) if ty.is_ref() && elem.is_array() => { + Some(Expr::rs("runsIter", vec![value])) + } ty::Slice(elem) | ty::Array(elem, _) if places(b, *elem) => { Some(Expr::rs("iterSliceMut", vec![library::slice_of(value, ty)])) } diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 3c1d88202..d55bf6a3b 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -2120,7 +2120,11 @@ fn mapping<'tcx>( let n = gargs.consts().next()?.try_to_target_usize(tcx)?; let mut values = args; values.push(Expr::lit(n.to_string())); - rt2(values, "slice", &super::camel(name.strip_suffix("_mut").unwrap_or(&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( diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 9fdbe8d7e..69d72d968 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -659,7 +659,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if elem.is_array() { let name = self.b.fresh("runs"); let source = Expr::rs("runsItems", vec![source]); - let e = Expr::rs("sliceCloneFromSlice", [vec![Expr::ident(name.clone()), source], fns].concat()); + let e = Expr::rs( + "sliceCloneFromSlice", + [vec![Expr::ident(name.clone()), source], fns].concat(), + ); let e = crate::lower::runs::wrap(e, ts::Type::Builtin("void"), Vec::new(), vec![(name, to)]); return done(e, true); } @@ -1696,7 +1699,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((crate::lower::array_slice(self.b.t.uninit_inner(payload_ty), 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 @@ -1983,7 +1989,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; // A reference to an array is a slice of it. if elem_ty.is_array() { - return Some(Some((crate::lower::array_slice(self.b.t.uninit_inner(elem_ty), 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() diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index b914efaa2..1706d1cf2 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -439,7 +439,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { 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 self.b.t.uninit_inner(*e).is_array()) + (in_array || ty.is_slice()) + && matches!(ty.kind(), ty::Slice(e) | ty::Array(e, _) if self.b.t.uninit_inner(*e).is_array()) } _ => false, }; diff --git a/ts/src/lower/runs.rs b/ts/src/lower/runs.rs index 875eab055..ad1b8811b 100644 --- a/ts/src/lower/runs.rs +++ b/ts/src/lower/runs.rs @@ -29,37 +29,54 @@ pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: t name.as_str(), "len" | "is_empty" - | "first" | "last" - | "get" | "first_mut" - | "last_mut" | "get_mut" + | "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" + | "split_at_mut" | "split_at_checked" | "split_at_mut_checked" - | "windows" | "chunks" + | "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" + | "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" + | "swap" + | "iter" | "iter_mut" - | "split" | "split_mut" - | "rsplit" | "rsplit_mut" + | "split" + | "split_mut" + | "rsplit" + | "rsplit_mut" | "split_inclusive" | "split_inclusive_mut" - | "splitn" | "splitn_mut" - | "rsplitn" | "rsplitn_mut" + | "splitn" + | "splitn_mut" + | "rsplitn" + | "rsplitn_mut" ) } @@ -69,15 +86,16 @@ pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: t /// 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(), - }; + let mut given = Given { args, by: Vec::new() }; // Only a slice's own methods; a trait's mapping reads runs as their type says. if native(tcx, call.def_id, call.args) || library::key(tcx, call.def_id).is_none_or(|(owner, _)| owner != "slice") { return Ok(given); } - let generic = tcx.fn_sig(call.def_id).instantiate_identity().skip_norm_wip().skip_binder(); + 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() { From 2901fb98a7dec38d01c663acf39d66fac64fadb0 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 17:47:48 -0800 Subject: [PATCH 05/12] fix(ts): runs read their remaining arrays, copy objects a write lands in, and pass as slices to std's other functions Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/boxes/expected/boxes.ts | 2 +- .../lang/capacity/expected/capacity.ts | 2 +- ts/fixtures/lang/clones/expected/clones.ts | 2 +- .../lang/conversions/expected/conversions.ts | 242 ++++++++---------- ts/fixtures/lang/shares/expected/shares.ts | 2 +- ts/fixtures/lang/slices/expected/slices.ts | 157 ++++++------ ts/runtime/rs.ts | 12 +- ts/runtime/rs/iter.ts | 2 +- ts/src/lower/collections.rs | 2 +- ts/src/lower/library.rs | 19 +- ts/src/lower/runs.rs | 4 +- 11 files changed, 210 insertions(+), 236 deletions(-) diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index 087367bd6..de9879505 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -367,7 +367,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); }), undefined, 2, true).items, rs.byteSliceFrom); - const quadsV: rs.Vec = rs.vecFrom(rs.sliceItems(rs.runsFrom(rs.sliceItems(quads).map(copy$array_u8), rs.byteSliceFrom))); + const quadsV: rs.Vec = rs.vecFrom(rs.runsArray(rs.runsFrom(rs.runsArray(quads).map(copy$array_u8), rs.byteSliceFrom))); const _554: rs.ByteSlice | undefined = rs.runsFirst(rs.runsFrom(quadsV.items, rs.byteSliceFrom)); if (_554 !== undefined) { _554.data[_554.start] = 119; diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 4a0baa653..1ca836876 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -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(rs.sliceItems(rs.runsFrom(v.items, rs.sliceFrom))); + v = rs.vecFrom(rs.runsArray(rs.runsFrom(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 => { diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index b61d2a526..f9630e70c 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -7746,7 +7746,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _263: Logged.Logged = logged(part10); const part11 = at(3); const grid: Logged.Logged[][] = [_249, [_263, logged(part11)]]; - const copy2: Logged.Logged[][] = rs.sliceItems(rs.runsFrom(grid, rs.sliceFrom)).map((a: Logged.Logged[]) => a.map(Logged.clone$Clone)); + const copy2: Logged.Logged[][] = rs.runsArray(rs.runsFrom(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); diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index 28ec7cae4..e15672c72 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -535,14 +535,14 @@ export function writeFirst$array1_u8(s: rs.Runs, value: Uint8Array value = copy$array_u8(value); rs.idx(s, 0); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const old2 = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(_8, slice2.start); + const slice = rs.runsAt(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); - const slice3 = rs.runsAt(s, 0); - slice3.data.set(_10, slice3.start); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_10, slice2.start); return old; } @@ -563,14 +563,14 @@ export function writeFirst$array3_u8(s: rs.Runs, value: Uint8Array value = copy$array_u8(value); rs.idx(s, 0); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const old2 = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(_8, slice2.start); + const slice = rs.runsAt(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); - const slice3 = rs.runsAt(s, 0); - slice3.data.set(_10, slice3.start); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_10, slice2.start); return old; } @@ -579,14 +579,14 @@ export function writeFirst$array40_u8(s: rs.Runs, value: Uint8Arra value = copy$array_u8(value); rs.idx(s, 0); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const old2 = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(_8, slice2.start); + const slice = rs.runsAt(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); - const slice3 = rs.runsAt(s, 0); - slice3.data.set(_10, slice3.start); + const slice2 = rs.runsAt(s, 0); + slice2.data.set(_10, slice2.start); return old; } @@ -1038,8 +1038,7 @@ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); const slice = rs.runsAt(s, 0); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(rs.byteSliceToArray(_159), slice2.start); + slice.data.set(rs.byteSliceToArray(_159), slice.start); rs.idx(s, 0); put$conversions_Value_array0_u8(rs.runsAt(s, 0), out); } @@ -1056,38 +1055,33 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r const other: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 19)); rs.idx(s, 0); const _16: rs.ByteSlice = rs.byteSliceFrom(other); - const swapped = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(rs.byteSliceToArray(_16), slice2.start); + const slice = rs.runsAt(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 slice3 = rs.runsAt(s, 0); + const slice2 = rs.runsAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); - _20.data.set(rs.byteSliceToArray(slice3), _20.start); - const slice4 = rs.runsAt(s, 0); - slice4.data.set(swapped2, slice4.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.Runs = rs.runsFrom(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); rs.idx(t, 1); - const slice5 = rs.runsAt(s, 0); - const slice6 = rs.runsAt(t, 1); - const swapped3 = rs.byteSliceToArray(slice5); - const slice7 = rs.runsAt(s, 0); - slice7.data.set(rs.byteSliceToArray(slice6), slice7.start); - const slice8 = rs.runsAt(t, 1); - slice8.data.set(swapped3, slice8.start); + const slice3 = rs.runsAt(s, 0); + const slice4 = rs.runsAt(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); rs.idx(s, 0); - const slice9 = rs.runsAt(t, 0); - const slice10 = rs.runsAt(s, 0); - const swapped4 = rs.byteSliceToArray(slice9); - const slice11 = rs.runsAt(t, 0); - slice11.data.set(rs.byteSliceToArray(slice10), slice11.start); - const slice12 = rs.runsAt(s, 0); - slice12.data.set(swapped4, slice12.start); + const slice5 = rs.runsAt(t, 0); + const slice6 = rs.runsAt(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.runsAt(t, 0), out); rs.idx(t, 1); @@ -1117,9 +1111,8 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 1), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[copy$array_u8(make$conversions_Value_array1_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); - const slice13 = rs.runsAt(s, 0); - const slice14 = rs.runsAt(s, 0); - slice14.data.set(rs.byteSliceToArray(_159), slice14.start); + const slice7 = rs.runsAt(s, 0); + slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); put$conversions_Value_array1_u8(rs.runsAt(s, 0), out); } @@ -1141,22 +1134,19 @@ export function lentParam$array2_u32(to: rs.Slice, data: rs.ByteSlice, o const _20: rs.Slice = rs.sliceFrom(other); rs.idx(s, 0); const slice2 = rs.runsAt(s, 0); - const swapped2 = rs.replaceIn(rs.sliceView(_20), rs.sliceToArray(slice2)); - rs.sliceSet(rs.runsAt(s, 0), swapped2); + rs.sliceSet(slice2, rs.replaceIn(rs.sliceView(_20), rs.sliceToArray(slice2))); put$conversions_Value_array2_u32(rs.sliceFrom(other), out); const t: rs.Runs> = rs.runsFrom(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); rs.idx(t, 1); - const slice4 = rs.runsAt(s, 0); - const slice5 = rs.runsAt(t, 1); - const swapped3 = rs.replaceIn(rs.sliceView(slice4), rs.sliceToArray(slice5)); - rs.sliceSet(rs.runsAt(t, 1), swapped3); + const slice3 = rs.runsAt(s, 0); + const slice4 = rs.runsAt(t, 1); + rs.sliceSet(slice4, rs.replaceIn(rs.sliceView(slice3), rs.sliceToArray(slice4))); rs.idx(t, 0); rs.idx(s, 0); - const slice7 = rs.runsAt(t, 0); - const slice8 = rs.runsAt(s, 0); - const swapped4 = rs.replaceIn(rs.sliceView(slice7), rs.sliceToArray(slice8)); - rs.sliceSet(rs.runsAt(s, 0), swapped4); + const slice5 = rs.runsAt(t, 0); + const slice6 = rs.runsAt(s, 0); + rs.sliceSet(slice6, rs.replaceIn(rs.sliceView(slice5), rs.sliceToArray(slice6))); rs.idx(t, 0); put$conversions_Value_array2_u32(rs.runsAt(t, 0), out); rs.idx(t, 1); @@ -1203,38 +1193,33 @@ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r const other: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 19)); rs.idx(s, 0); const _16: rs.ByteSlice = rs.byteSliceFrom(other); - const swapped = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(rs.byteSliceToArray(_16), slice2.start); + const slice = rs.runsAt(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 slice3 = rs.runsAt(s, 0); + const slice2 = rs.runsAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); - _20.data.set(rs.byteSliceToArray(slice3), _20.start); - const slice4 = rs.runsAt(s, 0); - slice4.data.set(swapped2, slice4.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.Runs = rs.runsFrom(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); rs.idx(t, 1); - const slice5 = rs.runsAt(s, 0); - const slice6 = rs.runsAt(t, 1); - const swapped3 = rs.byteSliceToArray(slice5); - const slice7 = rs.runsAt(s, 0); - slice7.data.set(rs.byteSliceToArray(slice6), slice7.start); - const slice8 = rs.runsAt(t, 1); - slice8.data.set(swapped3, slice8.start); + const slice3 = rs.runsAt(s, 0); + const slice4 = rs.runsAt(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); rs.idx(s, 0); - const slice9 = rs.runsAt(t, 0); - const slice10 = rs.runsAt(s, 0); - const swapped4 = rs.byteSliceToArray(slice9); - const slice11 = rs.runsAt(t, 0); - slice11.data.set(rs.byteSliceToArray(slice10), slice11.start); - const slice12 = rs.runsAt(s, 0); - slice12.data.set(swapped4, slice12.start); + const slice5 = rs.runsAt(t, 0); + const slice6 = rs.runsAt(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.runsAt(t, 0), out); rs.idx(t, 1); @@ -1264,9 +1249,8 @@ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 3), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[copy$array_u8(make$conversions_Value_array3_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); - const slice13 = rs.runsAt(s, 0); - const slice14 = rs.runsAt(s, 0); - slice14.data.set(rs.byteSliceToArray(_159), slice14.start); + const slice7 = rs.runsAt(s, 0); + slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); put$conversions_Value_array3_u8(rs.runsAt(s, 0), out); } @@ -1283,38 +1267,33 @@ export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: const other: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 19)); rs.idx(s, 0); const _16: rs.ByteSlice = rs.byteSliceFrom(other); - const swapped = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(rs.byteSliceToArray(_16), slice2.start); + const slice = rs.runsAt(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 slice3 = rs.runsAt(s, 0); + const slice2 = rs.runsAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); - _20.data.set(rs.byteSliceToArray(slice3), _20.start); - const slice4 = rs.runsAt(s, 0); - slice4.data.set(swapped2, slice4.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.Runs = rs.runsFrom(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); rs.idx(t, 1); - const slice5 = rs.runsAt(s, 0); - const slice6 = rs.runsAt(t, 1); - const swapped3 = rs.byteSliceToArray(slice5); - const slice7 = rs.runsAt(s, 0); - slice7.data.set(rs.byteSliceToArray(slice6), slice7.start); - const slice8 = rs.runsAt(t, 1); - slice8.data.set(swapped3, slice8.start); + const slice3 = rs.runsAt(s, 0); + const slice4 = rs.runsAt(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); rs.idx(s, 0); - const slice9 = rs.runsAt(t, 0); - const slice10 = rs.runsAt(s, 0); - const swapped4 = rs.byteSliceToArray(slice9); - const slice11 = rs.runsAt(t, 0); - slice11.data.set(rs.byteSliceToArray(slice10), slice11.start); - const slice12 = rs.runsAt(s, 0); - slice12.data.set(swapped4, slice12.start); + const slice5 = rs.runsAt(t, 0); + const slice6 = rs.runsAt(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.runsAt(t, 0), out); rs.idx(t, 1); @@ -1344,9 +1323,8 @@ export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 40), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[copy$array_u8(make$conversions_Value_array40_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); - const slice13 = rs.runsAt(s, 0); - const slice14 = rs.runsAt(s, 0); - slice14.data.set(rs.byteSliceToArray(_159), slice14.start); + const slice7 = rs.runsAt(s, 0); + slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); put$conversions_Value_array40_u8(rs.runsAt(s, 0), out); } @@ -2447,8 +2425,7 @@ export function converted$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); const slice2 = rs.runsAt(_124, 2); - const slice3 = rs.runsAt(_124, 2); - slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); @@ -2465,14 +2442,13 @@ export function converted$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice4 = rs.runsAt(_165, 0); - slice4.data.set(_163, slice4.start); + const slice3 = rs.runsAt(_165, 0); + slice3.data.set(_163, slice3.start); const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice5 = rs.runsAt(_173, 1); - const slice6 = rs.runsAt(_173, 1); - slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + const slice4 = rs.runsAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 15)); @@ -2559,8 +2535,7 @@ export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); const slice2 = rs.runsAt(_124, 2); - const slice3 = rs.runsAt(_124, 2); - slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); @@ -2577,14 +2552,13 @@ export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice4 = rs.runsAt(_165, 0); - slice4.data.set(_163, slice4.start); + const slice3 = rs.runsAt(_165, 0); + slice3.data.set(_163, slice3.start); const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice5 = rs.runsAt(_173, 1); - const slice6 = rs.runsAt(_173, 1); - slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + const slice4 = rs.runsAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 15)); @@ -2775,8 +2749,7 @@ export function converted$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); const slice2 = rs.runsAt(_124, 2); - const slice3 = rs.runsAt(_124, 2); - slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); @@ -2793,14 +2766,13 @@ export function converted$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice4 = rs.runsAt(_165, 0); - slice4.data.set(_163, slice4.start); + const slice3 = rs.runsAt(_165, 0); + slice3.data.set(_163, slice3.start); const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice5 = rs.runsAt(_173, 1); - const slice6 = rs.runsAt(_173, 1); - slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + const slice4 = rs.runsAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 15)); @@ -2888,8 +2860,7 @@ export function converted$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); const slice2 = rs.runsAt(_124, 2); - const slice3 = rs.runsAt(_124, 2); - slice3.data.set(rs.byteSliceToArray(_130), slice3.start); + slice2.data.set(rs.byteSliceToArray(_130), slice2.start); const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); while (true) { const _134: rs.ByteSlice | rs.Done = iter.next(); @@ -2906,14 +2877,13 @@ export function converted$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice4 = rs.runsAt(_165, 0); - slice4.data.set(_163, slice4.start); + const slice3 = rs.runsAt(_165, 0); + slice3.data.set(_163, slice3.start); const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice5 = rs.runsAt(_173, 1); - const slice6 = rs.runsAt(_173, 1); - slice6.data.set(rs.byteSliceToArray(_179), slice6.start); + const slice4 = rs.runsAt(_173, 1); + slice4.data.set(rs.byteSliceToArray(_179), slice4.start); rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 15)); @@ -4420,9 +4390,9 @@ export function lentOne$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 5)); - const old4 = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(_28, slice2.start); + const slice = rs.runsAt(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.runsOne(rs.byteSliceFrom(held.value), 1), make$conversions_Value_array1_u8(data, 7))), out); @@ -4495,9 +4465,9 @@ export function lentOne$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 5)); - const old4 = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(_28, slice2.start); + const slice = rs.runsAt(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.runsOne(rs.byteSliceFrom(held.value), 3), make$conversions_Value_array3_u8(data, 7))), out); @@ -4534,9 +4504,9 @@ export function lentOne$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 5)); - const old4 = rs.byteSliceToArray(rs.runsAt(s, 0)); - const slice2 = rs.runsAt(s, 0); - slice2.data.set(_28, slice2.start); + const slice = rs.runsAt(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.runsOne(rs.byteSliceFrom(held.value), 40), make$conversions_Value_array40_u8(data, 7))), out); diff --git a/ts/fixtures/lang/shares/expected/shares.ts b/ts/fixtures/lang/shares/expected/shares.ts index 11173f200..4e9046f84 100644 --- a/ts/fixtures/lang/shares/expected/shares.ts +++ b/ts/fixtures/lang/shares/expected/shares.ts @@ -454,7 +454,7 @@ export function copies(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true).items, rs.byteSliceFrom)); let copy: rs.Arc> = rs.arcClone(quads); const _79: rs.ByteSlice | undefined = rs.runsFirst(rs.arcMakeMut(rs.place(() => copy, (value2) => copy = value2), (a02: rs.Runs): rs.Runs => { - return rs.runsFrom(rs.sliceItems(a02).map(copy$array_u8), rs.byteSliceFrom); + return rs.runsFrom(rs.runsArray(a02).map(copy$array_u8), rs.byteSliceFrom); }, rs.drop)); if (_79 !== undefined) { _79.data[_79.start] = 119; diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index d1fa5cfb2..20621b5be 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2351,32 +2351,30 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_196[0], 0); const _204: rs.usize = rs.usizeSub(n, 2); rs.idx(_196[1], _204); - const slice87 = rs.runsAt(_196[0], 0); - const slice88 = rs.runsAt(_196[1], _204); - const swapped8 = rs.byteSliceToArray(slice87); - const slice89 = rs.runsAt(_196[0], 0); - slice89.data.set(rs.byteSliceToArray(slice88), slice89.start); - const slice90 = rs.runsAt(_196[1], _204); - slice90.data.set(swapped8, slice90.start); + const slice79 = rs.runsAt(_196[0], 0); + const slice80 = rs.runsAt(_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 old13 = rs.byteSliceToArray(rs.runsAt(_142[0], 0)); - const slice92 = rs.runsAt(_142[0], 0); - slice92.data.set(Uint8Array.of(7, 8), slice92.start); + const slice81 = rs.runsAt(_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); - const slice93 = rs.runsAt(_142[0], _216); - slice93.data.set(copy$array_u8(old), slice93.start); + const slice82 = rs.runsAt(_142[0], _216); + slice82.data.set(copy$array_u8(old), slice82.start); rs.idx(_142[0], 1); const kept3: Uint8Array = rs.byteSliceToArray(rs.runsAt(_142[0], 1)); rs.idx(_142[0], 0); const _226: Uint8Array = rs.byteSliceToArray(rs.runsAt(_142[0], 0)); rs.idx(_142[0], 1); - const slice94 = rs.runsAt(_142[0], 1); - slice94.data.set(_226, slice94.start); + const slice83 = rs.runsAt(_142[0], 1); + slice83.data.set(_226, slice83.start); rs.idx(_142[0], 0); - const slice95 = rs.runsAt(_142[0], 0); - slice95.data.set(copy$array_u8(kept3), slice95.start); + const slice84 = rs.runsAt(_142[0], 0); + slice84.data.set(copy$array_u8(kept3), slice84.start); const _239: rs.ByteSlice | undefined = rs.runsLast(_142[0]); if (_239 !== undefined) { _239.data.set(Uint8Array.of(9, 10), _239.start); @@ -2426,10 +2424,9 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_307[0], 0); const _315: rs.usize = rs.usizeSub(n2, 2); rs.idx(_307[1], _315); - const slice11 = rs.runsAt(_307[0], 0); - const slice12 = rs.runsAt(_307[1], _315); - const swapped3 = rs.replaceIn(rs.sliceView(slice11), rs.sliceToArray(slice12)); - rs.sliceSet(rs.runsAt(_307[1], _315), swapped3); + const slice10 = rs.runsAt(_307[0], 0); + const slice11 = rs.runsAt(_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.runsAt(_253[1], 0)), [7, 8]); const _327: rs.usize = rs.usizeSub(n2, 1); @@ -2491,32 +2488,30 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_418[0], 0); const _426: rs.usize = rs.usizeSub(n3, 2); rs.idx(_418[1], _426); - const slice21 = rs.runsAt(_418[0], 0); - const slice22 = rs.runsAt(_418[1], _426); - const swapped4 = rs.byteSliceToArray(slice21); - const slice23 = rs.runsAt(_418[0], 0); - slice23.data.set(rs.byteSliceToArray(slice22), slice23.start); - const slice24 = rs.runsAt(_418[1], _426); - slice24.data.set(swapped4, slice24.start); + const slice19 = rs.runsAt(_418[0], 0); + const slice20 = rs.runsAt(_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 old9 = rs.byteSliceToArray(rs.runsAt(_364[1], 0)); - const slice26 = rs.runsAt(_364[1], 0); - slice26.data.set(Uint8Array.of(1, 2, 3, 4), slice26.start); + const slice21 = rs.runsAt(_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); - const slice27 = rs.runsAt(_364[1], _438); - slice27.data.set(copy$array_u8(old3), slice27.start); + const slice22 = rs.runsAt(_364[1], _438); + slice22.data.set(copy$array_u8(old3), slice22.start); rs.idx(_364[1], 1); const kept7: Uint8Array = rs.byteSliceToArray(rs.runsAt(_364[1], 1)); rs.idx(_364[1], 0); const _448: Uint8Array = rs.byteSliceToArray(rs.runsAt(_364[1], 0)); rs.idx(_364[1], 1); - const slice28 = rs.runsAt(_364[1], 1); - slice28.data.set(_448, slice28.start); + const slice23 = rs.runsAt(_364[1], 1); + slice23.data.set(_448, slice23.start); rs.idx(_364[1], 0); - const slice29 = rs.runsAt(_364[1], 0); - slice29.data.set(copy$array_u8(kept7), slice29.start); + const slice24 = rs.runsAt(_364[1], 0); + slice24.data.set(copy$array_u8(kept7), slice24.start); const _461: rs.ByteSlice | undefined = rs.runsLast(_364[1]); if (_461 !== undefined) { _461.data.set(rs.bytes(4).fill(5), _461.start); @@ -2546,17 +2541,17 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _512: { end: rs.usize } = { end: rs.usizeSub(n4, 1) }; rs.runsCopyWithin(_479[0], 0, _512.end, 1, copy$array_array2_u8); rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_u8(first4), copy$array_array2_u8(last4), copy$array_array2_u8(kept8)], rs.runsOf(rs.byteSliceFrom))), (c13: rs.Runs): rs.u8 => { - const slice33 = rs.runsAt(c13, 0); - const _342: rs.u8 = slice33.data[slice33.start]; - const slice34 = rs.runsAt(c13, 1); - return _342 ^ slice34.data[slice34.start + 1]; + const slice28 = rs.runsAt(c13, 0); + const _342: rs.u8 = slice28.data[slice28.start]; + const slice29 = rs.runsAt(c13, 1); + return _342 ^ slice29.data[slice29.start + 1]; }), undefined, true); rs.runsBy(_479[0], (runs25) => rs.sliceSort(runs25, rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true)); rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_479[0]), (c14: rs.Runs): rs.u8 => { - const slice35 = rs.runsAt(c14, 0); - const _346: rs.u8 = slice35.data[slice35.start]; - const slice36 = rs.runsAt(c14, 1); - return _346 ^ slice36.data[slice36.start + 1]; + const slice30 = rs.runsAt(c14, 0); + const _346: rs.u8 = slice30.data[slice30.start]; + const slice31 = rs.runsAt(c14, 1); + return _346 ^ slice31.data[slice31.start + 1]; }), undefined, true); const f6 = (c15: rs.Runs): Uint8Array => { return rs.byteSliceToArray(rs.runsAt(c15, 1)); @@ -2571,8 +2566,9 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_531[0], 0); const _539: rs.usize = rs.usizeSub(n4, 2); rs.idx(_531[1], _539); - const swapped5 = rs.runsReplace(rs.runsAt(_531[0], 0), rs.runsToArray(rs.runsAt(_531[1], _539), rs.byteSliceToArray)); - rs.runsSet(rs.runsAt(_531[1], _539), swapped5); + const slice32 = rs.runsAt(_531[0], 0); + const slice33 = rs.runsAt(_531[1], _539); + rs.runsSet(slice33, rs.runsReplace(slice32, rs.runsToArray(slice33, rs.byteSliceToArray))); rs.idx(_479[0], 0); const _550: Uint8Array[] = [Uint8Array.of(1, 2), Uint8Array.of(3, 4)]; const old4: Uint8Array[] = rs.runsReplace(rs.runsAt(_479[0], 0), _550); @@ -2592,10 +2588,10 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.runsSet(_576, [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]); } rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_479[0]), (c17: rs.Runs): rs.u8 => { - const slice44 = rs.runsAt(c17, 0); - const _353: rs.u8 = slice44.data[slice44.start]; - const slice45 = rs.runsAt(c17, 1); - return _353 ^ slice45.data[slice45.start + 1]; + const slice38 = rs.runsAt(c17, 0); + const _353: rs.u8 = slice38.data[slice38.start]; + const slice39 = rs.runsAt(c17, 1); + return _353 ^ slice39.data[slice39.start + 1]; }), undefined, true); const _586: rs.Runs> = rs.runsRange(_479[0], rs.usizeDiv(n4, 2)); const _590: Uint8Array[] = [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]; @@ -2620,17 +2616,17 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _640: { end: rs.usize } = { end: rs.usizeSub(n5, 1) }; rs.runsCopyWithin(_600[0], 0, _640.end, 1, copy$array_array2_array2_u8); rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_array2_u8(first5), copy$array_array2_array2_u8(last5), copy$array_array2_array2_u8(kept10)], rs.runsOf(rs.runsOf(rs.byteSliceFrom)))), (c18: rs.Runs>): rs.u8 => { - const slice50 = rs.runsAt(rs.runsAt(c18, 0), 0); - const _356: rs.u8 = slice50.data[slice50.start]; - const slice52 = rs.runsAt(rs.runsAt(c18, 1), 1); - return _356 ^ slice52.data[slice52.start + 1]; + const slice44 = rs.runsAt(rs.runsAt(c18, 0), 0); + const _356: rs.u8 = slice44.data[slice44.start]; + const slice46 = rs.runsAt(rs.runsAt(c18, 1), 1); + return _356 ^ slice46.data[slice46.start + 1]; }), undefined, true); rs.runsBy(_600[0], (runs34) => rs.sliceSort(runs34, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true)); rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_600[0]), (c19: rs.Runs>): rs.u8 => { - const slice54 = rs.runsAt(rs.runsAt(c19, 0), 0); - const _357: rs.u8 = slice54.data[slice54.start]; - const slice56 = rs.runsAt(rs.runsAt(c19, 1), 1); - return _357 ^ slice56.data[slice56.start + 1]; + const slice48 = rs.runsAt(rs.runsAt(c19, 0), 0); + const _357: rs.u8 = slice48.data[slice48.start]; + const slice50 = rs.runsAt(rs.runsAt(c19, 1), 1); + return _357 ^ slice50.data[slice50.start + 1]; }), undefined, true); const f8 = (c20: rs.Runs>): Uint8Array[] => { return rs.runsToArray(rs.runsAt(c20, 1), rs.byteSliceToArray); @@ -2645,8 +2641,9 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_659[0], 0); const _667: rs.usize = rs.usizeSub(n5, 2); rs.idx(_659[1], _667); - const swapped6 = rs.runsReplace(rs.runsAt(_659[0], 0), rs.runsToArray(rs.runsAt(_659[1], _667), (s) => rs.runsToArray(s, rs.byteSliceToArray))); - rs.runsSet(rs.runsAt(_659[1], _667), swapped6); + const slice51 = rs.runsAt(_659[0], 0); + const slice52 = rs.runsAt(_659[1], _667); + rs.runsSet(slice52, rs.runsReplace(slice51, rs.runsToArray(slice52, (s) => rs.runsToArray(s, rs.byteSliceToArray)))); rs.idx(_600[0], 0); const old5: Uint8Array[][] = rs.runsReplace(rs.runsAt(_600[0], 0), copy$array_array2_array2_u8(one)); const _678: rs.usize = rs.usizeSub(n5, 1); @@ -2671,10 +2668,10 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi })); } rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_600[0]), (c22: rs.Runs>): rs.u8 => { - const slice65 = rs.runsAt(rs.runsAt(c22, 0), 0); - const _367: rs.u8 = slice65.data[slice65.start]; - const slice67 = rs.runsAt(rs.runsAt(c22, 1), 1); - return _367 ^ slice67.data[slice67.start + 1]; + const slice58 = rs.runsAt(rs.runsAt(c22, 0), 0); + const _367: rs.u8 = slice58.data[slice58.start]; + const slice60 = rs.runsAt(rs.runsAt(c22, 1), 1); + return _367 ^ slice60.data[slice60.start + 1]; }), undefined, true); const _711: rs.Runs>> = rs.runsRange(_600[0], rs.usizeDiv(n5, 2)); const _717: Uint8Array = rs.bytes(2).fill(9); @@ -2726,17 +2723,17 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _793: { end: rs.usize } = { end: rs.usizeSub(n6, 1) }; rs.runsCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([first6, last6, kept12], rs.runsOf(rs.sliceFrom))), (c23: rs.Runs>): rs.u8 => { - const slice71 = rs.runsAt(c23, 0); - const _415: rs.u16 = slice71.data[slice71.start]; - const slice72 = rs.runsAt(c23, 1); - return (_415 ^ slice72.data[slice72.start + 1]) & 0xff; + const slice64 = rs.runsAt(c23, 0); + const _415: rs.u16 = slice64.data[slice64.start]; + const slice65 = rs.runsAt(c23, 1); + return (_415 ^ slice65.data[slice65.start + 1]) & 0xff; }), undefined, true); rs.runsBy(_760[0], (runs43) => rs.sliceSort(runs43, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true)); rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_760[0]), (c24: rs.Runs>): rs.u8 => { - const slice73 = rs.runsAt(c24, 0); - const _416: rs.u16 = slice73.data[slice73.start]; - const slice74 = rs.runsAt(c24, 1); - return (_416 ^ slice74.data[slice74.start + 1]) & 0xff; + const slice66 = rs.runsAt(c24, 0); + const _416: rs.u16 = slice66.data[slice66.start]; + const slice67 = rs.runsAt(c24, 1); + return (_416 ^ slice67.data[slice67.start + 1]) & 0xff; }), undefined, true); const f10 = (c25: rs.Runs>): rs.u16[] => { return rs.sliceToArray(rs.runsAt(c25, 1)); @@ -2751,8 +2748,9 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_812[0], 0); const _820: rs.usize = rs.usizeSub(n6, 2); rs.idx(_812[1], _820); - const swapped7 = rs.runsReplace(rs.runsAt(_812[0], 0), rs.runsToArray(rs.runsAt(_812[1], _820), rs.sliceToArray)); - rs.runsSet(rs.runsAt(_812[1], _820), swapped7); + const slice68 = rs.runsAt(_812[0], 0); + const slice69 = rs.runsAt(_812[1], _820); + rs.runsSet(slice69, rs.runsReplace(slice68, rs.runsToArray(slice69, rs.sliceToArray))); rs.idx(_760[0], 0); const _831: rs.u16[][] = [[1, 2], [3, 4]]; const old6: rs.u16[][] = rs.runsReplace(rs.runsAt(_760[0], 0), _831); @@ -2772,10 +2770,10 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.runsSet(_857, [[5, 6], [7, 8]]); } rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_760[0]), (c27: rs.Runs>): rs.u8 => { - const slice82 = rs.runsAt(c27, 0); - const _417: rs.u16 = slice82.data[slice82.start]; - const slice83 = rs.runsAt(c27, 1); - return (_417 ^ slice83.data[slice83.start + 1]) & 0xff; + const slice74 = rs.runsAt(c27, 0); + const _417: rs.u16 = slice74.data[slice74.start]; + const slice75 = rs.runsAt(c27, 1); + return (_417 ^ slice75.data[slice75.start + 1]) & 0xff; }), undefined, true); const _867: rs.Runs>> = rs.runsRange(_760[0], rs.usizeDiv(n6, 2)); const _871: rs.u16[][] = [[5, 6], [7, 8]]; @@ -2808,8 +2806,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_909[1], 0); const slice6 = rs.runsAt(_909[0], 0); const slice7 = rs.runsAt(_909[1], 0); - const swapped2 = rs.replaceIn(rs.sliceView(slice6), rs.sliceToArray(slice7), 1); - rs.sliceSet(rs.runsAt(_909[1], 0), swapped2); + rs.sliceSet(slice7, rs.replaceIn(rs.sliceView(slice6), rs.sliceToArray(slice7), 1)); rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_875[0]), (c2: rs.Slice): rs.u8 => { return _11(c2); }), undefined, true); diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index ca7c02644..32fe6fe34 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -711,10 +711,7 @@ export function sliceFrom(items: T[]): Slice { * The elements of `s` as a JS array, for what only reads one: the storage itself where `s` * is all of it, or else a copy, which nothing can tell from it while the borrow lives. */ -export function sliceItems(s: Slice): T[]; -export function sliceItems(s: Runs): RunArray[]; -export function sliceItems(s: Slice | Runs): unknown[] { - if (s instanceof Runs) return runsArray(s); +export function sliceItems(s: Slice): T[] { return s.start === 0 && s.length === s.data.length ? s.data : s.data.slice(s.start, s.start + s.length); } @@ -738,10 +735,12 @@ export function sliceLength(s: Elements): number { /** * A copy of the elements of `s`, as an array of its own, as `to_vec` of what JS copies makes - * one, and `*r` of a `&[T; N]` with each element made a value of its own by `copy`. + * one, and `*r` of a `&[T; N]` with each element made a value of its own by `copy`, or, of + * objects a write lands in, as a `sliceIn`'s, by `objectCopy`, as a later write would change them. */ export function sliceToArray(s: Slice, copy?: (value: T) => T): T[] { const items = s.data.slice(s.start, s.start + s.length); + copy ??= writesIn(s.data) ? (value) => (typeof value === "object" && value !== null ? objectCopy(value) : value) : undefined; if (copy) for (let i = 0; i < items.length; i++) items[i] = copy(items[i]); return items; } @@ -1079,7 +1078,8 @@ function runSet(s: Run, value: unknown): void { /** * The run `s` as a `[T; N]` of its own: a copy of its elements, and of the runs it holds at - * any depth, but not of the objects its elements are, which a write of it moves. + * any depth, but not of the objects its elements are, which a write of it moves, unless a + * write lands in them, as `sliceToArray` copies them. */ function runCopy(s: S): RunArray { if (s instanceof ByteSlice) return byteSliceToArray(s) as RunArray; diff --git a/ts/runtime/rs/iter.ts b/ts/runtime/rs/iter.ts index 1fd3f5c00..294be0f95 100644 --- a/ts/runtime/rs/iter.ts +++ b/ts/runtime/rs/iter.ts @@ -2077,7 +2077,7 @@ class RunsIter extends Iter { } override remaining(): Iterable { - return runsArray(runsPart(this.r, this.front, this.back - this.front)); + return runsArray(runsPart(this.r, this.front, this.back)); } override clone(): Iter { diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index b70094fdb..d91725d98 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -236,7 +236,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, diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index d55bf6a3b..2e4d2af3c 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -3557,7 +3557,7 @@ pub(super) fn slice_to_vec<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: 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" => Expr::rs("sliceToArray", vec![slice]), - clone => slice_items(slice).method("map", vec![clone]), + clone => items_of(slice, elem).method("map", vec![clone]), } } @@ -3598,7 +3598,7 @@ 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)]), } } @@ -4053,9 +4053,7 @@ pub fn elements(v: Expr, ty: Ty<'_>) -> Expr { match ty.peel_refs().kind() { ty::Slice(elem) if byte(*elem) => Expr::rs("byteSliceView", vec![v]), // Copies of the runs of a slice of arrays, which a read can't tell from them. - ty::Slice(elem) | ty::Array(elem, _) if elem.is_array() && (ty.is_ref() || ty.is_slice()) => { - Expr::rs("runsArray", vec![v]) - } + 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), @@ -4073,6 +4071,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 runs, as `rs.runsArray` reads them. +pub fn items_of(s: Expr, elem: Ty<'_>) -> Expr { + match elem.is_array() { + true => array_of(s, "runsArray"), + 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 { @@ -4086,7 +4093,7 @@ fn array_of(s: Expr, read: &str) -> Expr { 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 == "runsFrom") && read == "sliceItems" => { + Expr::Call(f, mut args) if matches!(&*f, Expr::Rs(n) if n == "runsFrom") && read == "runsArray" => { args.swap_remove(0) } s => Expr::rs(read, vec![s]), diff --git a/ts/src/lower/runs.rs b/ts/src/lower/runs.rs index ad1b8811b..6e65d406d 100644 --- a/ts/src/lower/runs.rs +++ b/ts/src/lower/runs.rs @@ -87,8 +87,8 @@ pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: t 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 a slice's own methods; a trait's mapping reads runs as their type says. - if native(tcx, call.def_id, call.args) || library::key(tcx, call.def_id).is_none_or(|(owner, _)| owner != "slice") { + // Only std's own functions and methods; a trait's mapping reads runs 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 From db7651768744098352f0975a9ba0795b4a5b2571 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 19:00:24 -0800 Subject: [PATCH 06/12] fix(ts): runs in every form a slice of arrays takes, copied out by their elements' type Constants, defaults, Option::as_slice, a Cow's borrow, and the erased SliceOf and Ptr are runs too; to_vec reads runs as they are; a wrapped array is an element, not runs; and runs copied out and written back copy an element only as its type says: a Copy object's copy, or objectCopy of one a write lands in, never a reference. Co-Authored-By: Claude Opus 5.5 --- ts/README.md | 2 +- ts/fixtures/lang/arrays/expected/arrays.ts | 2 +- ts/fixtures/lang/clones/expected/clones.ts | 16 +-- ts/fixtures/lang/clones/expected/lib.ts | 12 +- .../lang/conversions/expected/conversions.ts | 46 +++---- .../lang/slices/expected/core/option.ts | 23 ++++ ts/fixtures/lang/slices/expected/lib.ts | 11 +- .../lang/slices/expected/slices.View.ts | 21 +++ ts/fixtures/lang/slices/expected/slices.ts | 129 ++++++++++++++++-- ts/fixtures/lang/slices/src/lib.rs | 1 + ts/fixtures/lang/slices/src/slices.rs | 120 +++++++++++++++- ts/runtime/rs.ts | 88 +++++++----- ts/runtime/rs/task.ts | 10 +- ts/src/lower/consts.rs | 2 +- ts/src/lower/copy.rs | 17 ++- ts/src/lower/library.rs | 17 ++- ts/src/lower/mir/call.rs | 15 +- ts/src/lower/mir/place.rs | 11 +- ts/src/lower/mod.rs | 2 + ts/src/lower/runs.rs | 28 +++- 20 files changed, 463 insertions(+), 110 deletions(-) create mode 100644 ts/fixtures/lang/slices/expected/slices.View.ts diff --git a/ts/README.md b/ts/README.md index 5ebc322d4..2af9ba6b0 100644 --- a/ts/README.md +++ b/ts/README.md @@ -107,7 +107,7 @@ crate translation reaches is refused, and so are two versions of one crate it re | tuple, `[T; N]`, `&[T; N]` | an array, and `rs.Slice` of all of it for `&[T; N]`, `rs.Runs` 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.Runs` 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 string it owns or an `rs.Borrowed` holding the one it borrows, which `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 runs of a slice of arrays; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | | `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | | `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rs.Slice` of a `[T; N]`'s elements or an `rs.ByteSlice` of a `[u8; N]`'s bytes, which compares by the array or buffer and offset they are at, refused for an array of one, which `array::from_ref`, `from_mut` of a variable, and `Option::as_slice` make of their own, or an `rs.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to other values JS copies, each a place JS makes of its own; `rs.NULL` for null and `rs.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rs.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rs.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rs.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rs` class such as `rs.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | | `MaybeUninit` | `T`: `undefined` until written, `0` for a byte, or an object whose parts kept as objects are there, holding `undefined`, 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 | diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index 8f8a82c79..ab2f4be8f 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -443,7 +443,7 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const _93: rs.usize = rs.usizeRem(i, 2); rs.idx(all, _93); rs.sliceCopyFromSlice(rs.runsAt(all, _93), rs.sliceFrom([op as rs.u32, ((op as rs.u32) << 20) >>> 0])); - rs.runsSwap(all, 0, 1); + rs.runsSwap(all, 0, 1, undefined); } else if (_22 === 5) { rs.sliceReverse(rs.sliceFrom([])); rs.byteSliceFill(rs.byteSliceFrom(Uint8Array.of()), op); diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index f9630e70c..88344a87c 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"; @@ -7926,12 +7926,12 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo flush(log.value, out); const _247: rs.Runs> = rs.runsFrom(grid, rs.sliceFrom); const _248: rs.Runs> = rs.runsFrom(other, rs.sliceFrom); - rs.runsBy(_247, (runs6) => rs.sliceCloneFromSlice(runs6, rs.runsItems(_248), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); + rs.runsBy(_247, (runs6) => rs.sliceCloneFromSlice(runs6, rs.runsItems(_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.Runs> = rs.runsFrom(other, rs.sliceFrom); - rs.runsBy(rs.runsFrom(grid, rs.sliceFrom), (runs7) => rs.sliceCloneFromSlice(runs7, rs.runsItems(_260), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); + rs.runsBy(rs.runsFrom(grid, rs.sliceFrom), (runs7) => rs.sliceCloneFromSlice(runs7, rs.runsItems(_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); @@ -7955,18 +7955,18 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo flush(log.value, out); const _330: rs.Runs> = rs.runsFrom(rows.items, rs.sliceFrom); const _332: rs.Runs> = rs.runsFrom(other2, rs.sliceFrom); - rs.runsBy(_330, (runs2) => rs.sliceCloneFromSlice(runs2, rs.runsItems(_332), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); + rs.runsBy(_330, (runs2) => rs.sliceCloneFromSlice(runs2, rs.runsItems(_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); const _338: rs.Runs> = rs.runsRange(rs.runsFrom(rows.items, rs.sliceFrom), 0, 1); const _341: Logged.Logged[] = other2[1].map(Logged.clone$Clone); - rs.runsBy(_338, (runs3) => rs.sliceFill(runs3, _341, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); + rs.runsBy(_338, (runs3) => rs.sliceFill(runs3, _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.Runs> = rs.runsFrom(rows.items, rs.sliceFrom); const part31 = at(8); const _352: Logged.Logged = logged(part31); const part32 = at(9); const _351: Logged.Logged[] = [_352, logged(part32)]; - rs.runsBy(_349, (runs4) => rs.sliceFill(runs4, _351, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); + rs.runsBy(_349, (runs4) => rs.sliceFill(runs4, _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); @@ -7975,7 +7975,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _378: Logged.Logged = logged(part34); const part35 = at(11); const _377: Logged.Logged[] = [_378, logged(part35)]; - rs.runsBy(_375, (runs5) => rs.sliceFill(runs5, _377, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop))); + rs.runsBy(_375, (runs5) => rs.sliceFill(runs5, _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); @@ -8053,7 +8053,7 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const _584: rs.Runs> = rs.runsFrom(grid2, rs.sliceFrom); const _586: Kept.Kept[][] = [[kept(7), kept(8)]]; const _585: rs.Runs> = rs.runsFrom(_586, rs.sliceFrom); - rs.runsBy(_584, (runs) => rs.sliceCloneFromSlice(runs, rs.runsItems(_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)))); + rs.runsBy(_584, (runs) => rs.sliceCloneFromSlice(runs, rs.runsItems(_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); diff --git a/ts/fixtures/lang/clones/expected/lib.ts b/ts/fixtures/lang/clones/expected/lib.ts index d56589dd7..aae621282 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); } diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index e15672c72..3e069719e 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -783,7 +783,7 @@ export function lentParam$Option_u16(to: rs.Place, data: rs. rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_Option_u16(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_Option_u16(data, 28)]])[0][0], out); + put$conversions_Value_Option_u16(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); @@ -856,7 +856,7 @@ export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_String(data, 28)]])[0][0], out); + put$conversions_Value_String(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1)), [[make$conversions_Value_String(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -918,7 +918,7 @@ export function lentParam$Vec_u32(to: rs.Vec, data: rs.ByteSlice, out: r rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_Vec_u32(data, 28)]])[0][0], out); + put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); @@ -980,7 +980,7 @@ export function lentParam$Vec_u8(to: rs.ByteVec, data: rs.ByteSlice, out: rs.Byt rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_Vec_u8(data, 28)]])[0][0], out); + put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); @@ -1030,11 +1030,11 @@ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(s, 0); put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 0), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [copy$array_u8(make$conversions_Value_array0_u8(data, 26))])[0]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsAt(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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 0), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[copy$array_u8(make$conversions_Value_array0_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 0), 1)), [[copy$array_u8(make$conversions_Value_array0_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); const slice = rs.runsAt(s, 0); @@ -1104,11 +1104,11 @@ export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(s, 0); put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 1), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [copy$array_u8(make$conversions_Value_array1_u8(data, 26))])[0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsAt(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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 1), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[copy$array_u8(make$conversions_Value_array1_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 1), 1)), [[copy$array_u8(make$conversions_Value_array1_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); const slice7 = rs.runsAt(s, 0); @@ -1169,11 +1169,11 @@ export function lentParam$array2_u32(to: rs.Slice, data: rs.ByteSlice, o rs.idx(s, 0); put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellIn(rs.sliceView(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 2), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [copy$array_u32(make$conversions_Value_array2_u32(data, 26))])[0]), out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsAt(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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 2), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.sliceToArray)), rs.runsSet), [[copy$array_u32(make$conversions_Value_array2_u32(data, 28))]])[0][0]), out); + put$conversions_Value_array2_u32(rs.sliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 2), 1)), [[copy$array_u32(make$conversions_Value_array2_u32(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.Slice = rs.sliceFrom(other); rs.replaceIn(rs.sliceView(rs.runsAt(s, 0)), rs.sliceToArray(_159)); @@ -1242,11 +1242,11 @@ export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.idx(s, 0); put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 3), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [copy$array_u8(make$conversions_Value_array3_u8(data, 26))])[0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsAt(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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 3), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[copy$array_u8(make$conversions_Value_array3_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 3), 1)), [[copy$array_u8(make$conversions_Value_array3_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); const slice7 = rs.runsAt(s, 0); @@ -1316,11 +1316,11 @@ export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.idx(s, 0); put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 40), (s) => rs.runsToArray(s, rs.byteSliceToArray), rs.runsSet), [copy$array_u8(make$conversions_Value_array40_u8(data, 26))])[0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsAt(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.runsOne(rs.runsOne(rs.runsAt(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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 40), 1), (s) => rs.runsToArray(s, (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsSet), [[copy$array_u8(make$conversions_Value_array40_u8(data, 28))]])[0][0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 40), 1)), [[copy$array_u8(make$conversions_Value_array40_u8(data, 28))]])[0][0]), out); rs.idx(s, 0); const _159: rs.ByteSlice = rs.byteSliceFrom(other); const slice7 = rs.runsAt(s, 0); @@ -1396,7 +1396,7 @@ export function lentParam$conversions_Logged(to: Logged.Logged, data: rs.ByteSli rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - const old3: Logged.Logged = rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, (s) => rs.sliceToArray(s, copy$conversions_Logged)), rs.runsSet), [[Logged.make$conversions_Value(data, 28)]])[0][0]; + const old3: Logged.Logged = rs.cellReplace(rs.cellOfRuns(rs.runsOne(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](); @@ -1465,7 +1465,7 @@ export function lentParam$conversions_Named(to: Named.Named, data: rs.ByteSlice, rs.idx(s, 0); const borrowed7 = s.data; const borrowed8 = s.start; - Named.put$conversions_Value(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), (s) => rs.runsToArray(s, (s) => rs.sliceToArray(s, copy$conversions_Named)), rs.runsSet), [[Named.make$conversions_Value(data, 28)]])[0][0], out); + Named.put$conversions_Value(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); @@ -1538,7 +1538,7 @@ export function lentParam$u32(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_u32(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_u32(data, 28)]])[0][0], out); + put$conversions_Value_u32(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); @@ -1611,7 +1611,7 @@ export function lentParam$u64(to: rs.Place, data: rs.ByteSlice, out: rs. rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_u64(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1), (s) => rs.runsToArray(s, rs.sliceToArray), rs.runsSet), [[make$conversions_Value_u64(data, 28)]])[0][0], out); + put$conversions_Value_u64(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); @@ -2449,7 +2449,7 @@ export function converted$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _179: rs.ByteSlice = rs.byteSliceFrom(c); const slice4 = rs.runsAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); + rs.runsSwap(rs.runsFrom(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); @@ -2559,7 +2559,7 @@ export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _179: rs.ByteSlice = rs.byteSliceFrom(c); const slice4 = rs.runsAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); + rs.runsSwap(rs.runsFrom(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); @@ -2664,7 +2664,7 @@ export function converted$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void rs.idx(_173, 1); const _179: rs.Slice = rs.sliceFrom(c); rs.replaceIn(rs.sliceView(rs.runsAt(_173, 1)), rs.sliceToArray(_179)); - rs.runsSwap(rs.runsFrom(list.items, rs.sliceFrom), 0, 1); + rs.runsSwap(rs.runsFrom(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); @@ -2773,7 +2773,7 @@ export function converted$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _179: rs.ByteSlice = rs.byteSliceFrom(c); const slice4 = rs.runsAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); + rs.runsSwap(rs.runsFrom(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); @@ -2884,7 +2884,7 @@ export function converted$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void const _179: rs.ByteSlice = rs.byteSliceFrom(c); const slice4 = rs.runsAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1); + rs.runsSwap(rs.runsFrom(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); diff --git a/ts/fixtures/lang/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index d42d39d65..5c8ad4e30 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -13,6 +13,29 @@ export function isSomeAnd$1ouf3e6(self: [rs.ByteSlice, rs.ByteSlice] | undefined return f(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$1sh08h7(self: rs.u16[] | undefined, f: (a0: rs.u16[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; diff --git a/ts/fixtures/lang/slices/expected/lib.ts b/ts/fixtures/lang/slices/expected/lib.ts index e4771ad4e..6d3c188c3 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 } 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]]); } //# sourceMappingURL=lib.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..852fd1b2b --- /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.runsLast(self.view as rs.Runs>), rs.sliceItems)); +} + +/** Its last element, if any. */ +export function last$array2_u8(self: View): Uint8Array | undefined { + return copy$Option_array2_u8(rs.optionMap(rs.runsLast(self.view as rs.Runs), 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 20621b5be..52ec8513f 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -1,12 +1,13 @@ // 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$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1n9qa5p as option_unwrapOrDefault$1n9qa5p, unwrapOrDefault$0h81s8g as option_unwrapOrDefault$0h81s8g, map$1sh08h7 as option_map$1sh08h7, map$0duedp1 as option_map$0duedp1, map$0q6fk7x as option_map$0q6fk7x, map$1uud0v7 as option_map$1uud0v7, map$1j0y4j0 as option_map$1j0y4j0, map$0vk4zok as option_map$0vk4zok, map$1aqm6sp as option_map$1aqm6sp, map$04ry0e1 as option_map$04ry0e1, mapOr$135q041 as option_mapOr$135q041, zip$0wdt346, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; import * as Counted from "./slices.Counted.ts"; import * as Item from "./slices.Item.ts"; import * as Noisy from "./slices.Noisy.ts"; import * as Pair from "./slices.Pair.ts"; +import * as View from "./slices.View.ts"; export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LOG$init, false); @@ -2319,7 +2320,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _152: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(rs.runsAt(_142[0], 0)), rs.byteSliceToArray(rs.runsAt(_142[0], _142[0].length - 1))]; const first: Uint8Array = copy$array_u8(_152[0]); const last: Uint8Array = copy$array_u8(_152[1]); - rs.runsSwap(_142[0], 0, rs.usizeSub(_142[0].length, 1)); + rs.runsSwap(_142[0], 0, rs.usizeSub(_142[0].length, 1), undefined); rs.runsBy(_142[0], (runs48) => rs.sliceReverse(runs48)); const n: rs.usize = _142[0].length; rs.runsBy(rs.runsRange(_142[0], 1), (runs49) => rs.sliceReverse(runs49)); @@ -2392,7 +2393,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _263: [rs.u16[], rs.u16[]] = [rs.sliceToArray(rs.runsAt(_253[1], 0)), rs.sliceToArray(rs.runsAt(_253[1], _253[1].length - 1))]; const first2: rs.u16[] = _263[0]; const last2: rs.u16[] = _263[1]; - rs.runsSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1)); + rs.runsSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1), undefined); rs.runsBy(_253[1], (runs3) => rs.sliceReverse(runs3)); const n2: rs.usize = _253[1].length; rs.runsBy(rs.runsRange(_253[1], 1), (runs4) => rs.sliceReverse(runs4)); @@ -2456,7 +2457,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _374: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(rs.runsAt(_364[1], 0)), rs.byteSliceToArray(rs.runsAt(_364[1], _364[1].length - 1))]; const first3: Uint8Array = copy$array_u8(_374[0]); const last3: Uint8Array = copy$array_u8(_374[1]); - rs.runsSwap(_364[1], 0, rs.usizeSub(_364[1].length, 1)); + rs.runsSwap(_364[1], 0, rs.usizeSub(_364[1].length, 1), undefined); rs.runsBy(_364[1], (runs12) => rs.sliceReverse(runs12)); const n3: rs.usize = _364[1].length; rs.runsBy(rs.runsRange(_364[1], 1), (runs13) => rs.sliceReverse(runs13)); @@ -2528,7 +2529,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _487: [Uint8Array[], Uint8Array[]] = [rs.runsToArray(rs.runsAt(_479[0], 0), rs.byteSliceToArray), rs.runsToArray(rs.runsAt(_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.runsSwap(_479[0], 0, rs.usizeSub(_479[0].length, 1)); + rs.runsSwap(_479[0], 0, rs.usizeSub(_479[0].length, 1), undefined); rs.runsBy(_479[0], (runs21) => rs.sliceReverse(runs21)); const n4: rs.usize = _479[0].length; rs.runsBy(rs.runsRange(_479[0], 1), (runs22) => rs.sliceReverse(runs22)); @@ -2603,7 +2604,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _615: [Uint8Array[][], Uint8Array[][]] = [rs.runsToArray(rs.runsAt(_600[0], 0), (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsToArray(rs.runsAt(_600[0], _600[0].length - 1), (s) => rs.runsToArray(s, rs.byteSliceToArray))]; const first5: Uint8Array[][] = copy$array_array2_array2_u8(_615[0]); const last5: Uint8Array[][] = copy$array_array2_array2_u8(_615[1]); - rs.runsSwap(_600[0], 0, rs.usizeSub(_600[0].length, 1)); + rs.runsSwap(_600[0], 0, rs.usizeSub(_600[0].length, 1), undefined); rs.runsBy(_600[0], (runs30) => rs.sliceReverse(runs30)); const n5: rs.usize = _600[0].length; rs.runsBy(rs.runsRange(_600[0], 1), (runs31) => rs.sliceReverse(runs31)); @@ -2687,7 +2688,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const refs: rs.Vec> = rs.iterToVec(rs.sliceChunks(rs.sliceFrom(backing.items), 1), undefined, 8, true); const _729: [rs.Runs>>>, rs.Runs>>] = rs.sliceAsChunks(rs.sliceAsChunks(rs.sliceFrom(refs.items), 2)[0], 2); if (_729[0].length >= 2) { - rs.runsSwap(_729[0], 0, 1); + rs.runsSwap(_729[0], 0, 1, undefined); } const iter6: rs.Iter<[rs.usize, rs.Place>]> = rs.iterEnumerate(rs.iterSliceMut(rs.sliceFrom(refs.items))); while (true) { @@ -2710,7 +2711,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _768: [rs.u16[][], rs.u16[][]] = [rs.runsToArray(rs.runsAt(_760[0], 0), rs.sliceToArray), rs.runsToArray(rs.runsAt(_760[0], _760[0].length - 1), rs.sliceToArray)]; const first6: rs.u16[][] = _768[0]; const last6: rs.u16[][] = _768[1]; - rs.runsSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1)); + rs.runsSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1), undefined); rs.runsBy(_760[0], (runs39) => rs.sliceReverse(runs39)); const n6: rs.usize = _760[0].length; rs.runsBy(rs.runsRange(_760[0], 1), (runs40) => rs.sliceReverse(runs40)); @@ -2785,12 +2786,12 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.idx(_875[0], 0); const first7: Item.Item[] = rs.replaceIn(rs.sliceView(rs.runsAt(_875[0], 0)), [new Item.Item(65), new Item.Item(66)], 1); flush(out); - rs.runsSwap(_875[0], 0, 1); - rs.runsBy(_875[0], (runs) => rs.sliceReverse(runs)); + rs.runsSwap(_875[0], 0, 1, rs.objectCopy); + rs.runsBy(_875[0], (runs) => rs.sliceReverse(runs), rs.objectCopy); const f = (c: rs.Slice): rs.u8 => { return c.data[c.start + 1].tag; }; - rs.runsBy(_875[0], (runs2) => rs.sliceSort(runs2, rs.keyLt((held) => f(rs.sliceFrom(held)), rs.lt), 2, true)); + rs.runsBy(_875[0], (runs2) => rs.sliceSort(runs2, rs.keyLt((held) => f(rs.sliceFrom(held)), rs.lt), 2, true), rs.objectCopy); rs.idx(_875[0], 1); rs.dropAll(rs.runsAt(_875[0], 1)); rs.sliceSet(rs.runsAt(_875[0], 1), first7); @@ -2828,4 +2829,108 @@ 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.Runs, out: rs.ByteVec): void { + rs.byteVecPush(out, runs.length & 0xff); + const iter: rs.Iter = rs.runsIter(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, 7); + 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.Runs>> = rs.runsOne(a, 1); + const _25: rs.Cell[][] = [[other]]; + const _24: rs.Cell[][] = rs.runsReplace(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.runsSwap(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (p2: rs.ByteSlice): string[] => { + const arg = p2.data[p2.start]; + const _310: string = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f)); + const arg2 = p2.data[p2.start + 1]; + return [_310, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg2, f))]; + }), undefined, 24, true); + const part = rs.min(words.items.length, 1); + const cloned: rs.Vec = rs.vecFrom(rs.runsArray(rs.runsRange(rs.runsFrom(words.items, rs.sliceFrom), part)).map((a: string[]) => a.slice())); + 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]), rs.strBytes(_85.data[_85.start + 1])), undefined, true); + } + const boxed: rs.Runs = rs.runsFrom(rs.vecFrom(pairs.items.map(copy$array_u8)).items, rs.byteSliceFrom); + putRuns$2(rs.runsFrom(rs.runsArray(boxed).map(copy$array_u8), rs.byteSliceFrom), out); + putRuns$2(rs.runsFrom(rs.vecFrom(rs.runsArray(boxed)).items, rs.byteSliceFrom), out); + } else if (_8 === 2) { + putRuns$2(rs.runsFrom([Uint8Array.of(1, 2), Uint8Array.of(3, 4)], rs.byteSliceFrom), out); + putRuns$2(rs.runsFrom([], rs.byteSliceFrom), out); + putRuns$2(rs.optionAsRuns(copy$Option_array2_u8(rs.optionMap(rs.runsFirst(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceView)), rs.byteSliceFrom), out); + putRuns$2(rs.optionAsRuns(undefined, rs.byteSliceFrom), out); + } else if (_8 === 3) { + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOrDefault$0h81s8g(View.last$array2_u8({ view: rs.runsFrom(pairs.items, rs.byteSliceFrom) }))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(option_unwrapOrDefault$1n9qa5p(View.last$array2_u16({ view: rs.runsFrom(rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (p: rs.ByteSlice): rs.u16[] => { + return [p.data[p.start] as rs.u16, p.data[p.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.runsFrom(pairs.items, rs.byteSliceFrom)); + putRuns$2(rs.cowRuns(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.runsFirst(rs.runsFrom(owned2.items, rs.byteSliceFrom)); + if (_183 !== undefined) { + _183.data[_183.start] = _183.data[_183.start] ^ 255; + } + putRuns$2(rs.cowRuns(owned, rs.byteSliceFrom), out); + putRuns$2(rs.cowRuns(borrowed, rs.byteSliceFrom), out); + putRuns$2(rs.runsFrom(rs.cowIntoOwned(borrowed, copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.cowRuns(rs.vecFrom(pairs.items.map(copy$array_u8)), rs.byteSliceFrom), out); + } else { + let item: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(byte(0))); + const runs2: rs.Runs> = rs.runsOne(rs.sliceOfPlace(rs.place(() => item, (value) => item = value)), 1); + rs.idx(runs2, 0); + const _222: rs.ByteVec[] = [rs.byteVecFrom(Uint8Array.of(byte(1), byte(2)))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.replaceIn(rs.sliceView(rs.runsAt(runs2, 0)), _222, 1)[0])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); + } +} + //# sourceMappingURL=slices.ts.map diff --git a/ts/fixtures/lang/slices/src/lib.rs b/ts/fixtures/lang/slices/src/lib.rs index 7d9309df2..cc60d06c8 100644 --- a/ts/fixtures/lang/slices/src/lib.rs +++ b/ts/fixtures/lang/slices/src/lib.rs @@ -24,5 +24,6 @@ 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), ] } diff --git a/ts/fixtures/lang/slices/src/slices.rs b/ts/fixtures/lang/slices/src/slices.rs index df4d7ccdd..d53e608a9 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,119 @@ 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 % 7 { + // 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); + } + // `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); + } + } +} diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index 32fe6fe34..74c60ea2b 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -217,21 +217,21 @@ 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 `Runs` 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 | Runs : never); /** 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 `Runs` of a `[[T; N]]`. */ +export type SliceOf = Slice | ByteSlice | Runs; /** 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 runs. */ +export type CowOf = Cow | ByteCow | Cow>; /** * The pointer to element `index` of `s`, a `[T; N]` or a `Vec`'s storage. A null or @@ -735,12 +735,10 @@ export function sliceLength(s: Elements): number { /** * A copy of the elements of `s`, as an array of its own, as `to_vec` of what JS copies makes - * one, and `*r` of a `&[T; N]` with each element made a value of its own by `copy`, or, of - * objects a write lands in, as a `sliceIn`'s, by `objectCopy`, as a later write would change them. + * one, and `*r` of a `&[T; N]` with each element made a value of its own by `copy`. */ export function sliceToArray(s: Slice, copy?: (value: T) => T): T[] { const items = s.data.slice(s.start, s.start + s.length); - copy ??= writesIn(s.data) ? (value) => (typeof value === "object" && value !== null ? objectCopy(value) : value) : undefined; if (copy) for (let i = 0; i < items.length; i++) items[i] = copy(items[i]); return items; } @@ -819,6 +817,11 @@ export function optionAsSlice(o: T, none?: None): Slice { return sliceFrom(o === none ? [] : [o]); } +/** `optionAsSlice` of an array, which is never `undefined`: the runs of it alone, lent by `of`, or of none. */ +export function optionAsRuns(o: RunArray | undefined, of: (array: RunArray) => S): Runs { + return runsFrom, 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)); @@ -1062,9 +1065,16 @@ export function runsSet(r: Runs, items: ArrayLike> for (let i = 0; i < r.length; i++) runSet(runsAt(r, i), items[i]); } -/** `mem::replace` of what a `&mut [[T; N]; M]`, `r`, points at: its runs as arrays of their own, then `items` written where `r` holds them. */ -export function runsReplace(r: Runs, items: ArrayLike>): RunArray[] { - const old = runsToArray(r, runCopy); +/** + * What a run's element is copied by, as a copy of the runs 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 + * runs back would change. + */ +export type RunCopy = (value: never) => unknown; + +/** `mem::replace` of what a `&mut [[T; N]; M]`, `r`, points at: its runs as arrays of their own, each element copied by `copy`, then `items` written where `r` holds them. */ +export function runsReplace(r: Runs, items: ArrayLike>, copy?: RunCopy): RunArray[] { + const old = runsCopy(r, copy); runsSet(r, items); return old; } @@ -1078,13 +1088,18 @@ function runSet(s: Run, value: unknown): void { /** * The run `s` as a `[T; N]` of its own: a copy of its elements, and of the runs it holds at - * any depth, but not of the objects its elements are, which a write of it moves, unless a - * write lands in them, as `sliceToArray` copies them. + * any depth, but not of the objects its elements are, which a write of it moves, unless + * `copy` copies them. */ -function runCopy(s: S): RunArray { +function runCopy(s: S, copy?: RunCopy): RunArray { if (s instanceof ByteSlice) return byteSliceToArray(s) as RunArray; - if (s instanceof Slice) return sliceToArray(s) as RunArray; - return runsToArray(s as Runs, runCopy) as RunArray; + if (s instanceof Slice) return sliceToArray(s, copy as ((value: unknown) => unknown) | undefined) as RunArray; + return runsCopy(s as Runs, copy) as RunArray; +} + +/** The runs of `r` as arrays of their own, as `runCopy` copies each. */ +export function runsCopy(r: Runs, copy?: RunCopy): RunArray[] { + return runsToArray(r, (s) => runCopy(s, copy)); } /** @@ -1111,7 +1126,7 @@ function runSame(a: Run, b: Run): boolean { */ export function runsArray(r: Runs): RunArray[] { if (r.items !== undefined && r.start === 0 && r.length === r.items.length) return r.items as RunArray[]; - return runsToArray(r, runCopy); + return runsCopy(r); } /** `last_chunk` of runs, shared or mutable: the last `n`, or `undefined` if fewer. */ @@ -1130,12 +1145,12 @@ export function runsItems(r: Runs): Slice> { } /** - * `op` of the runs of `r` as a slice of arrays of their own, each a copy, which `op` may + * `op` of the runs 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 runsBy(r: Runs, op: (s: Slice>) => R): R { - const items = runsToArray(r, runCopy); +export function runsBy(r: Runs, op: (s: Slice>) => R, copy?: RunCopy): R { + const items = runsCopy(r, copy); try { return op(sliceFrom(items)); } finally { @@ -1143,12 +1158,12 @@ export function runsBy(r: Runs, op: (s: Slice>) } } -/** `swap` of runs, panicking on either index past the end, `a` first, as std's indexing does. */ -export function runsSwap(r: Runs, a: number, b: number, at?: Location): void { +/** `swap` of runs, each element copied out by `copy`, panicking on either index past the end, `a` first, as std's indexing does. */ +export function runsSwap(r: Runs, a: number, b: number, copy: RunCopy | undefined, at?: Location): void { const x = runsAt(r, idx(r, a, at)); const y = runsAt(r, idx(r, b, at)); - const kept = runCopy(x); - runSet(x, runCopy(y)); + const kept = runCopy(x, copy); + runSet(x, runCopy(y, copy)); runSet(y, kept); } @@ -2631,8 +2646,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`: `Runs` of arrays. */ +export type Cow | Runs = 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. */ @@ -2643,6 +2658,11 @@ export function cowSlice(c: Cow): Slice { return c instanceof Borrowed ? c.slice : sliceFrom(c.items); } +/** `Deref` of a `Cow<[[T; N]]>`: its runs, each of an owned one lent by `of`. */ +export function cowRuns(c: Cow, Runs>, of: (array: RunArray) => S): Runs { + return c instanceof Borrowed ? c.slice : runsFrom(c.items, of); +} + /** `Deref` of a `Cow<[u8]>`: its bytes. */ export function byteCowSlice(c: ByteCow): ByteSlice { return c instanceof ByteVec ? byteVecSlice(c) : c; @@ -2651,9 +2671,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 | Runs = 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 Runs) return vecFrom((clone === undefined ? runsCopy(s) : runsArray(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]>`. */ @@ -2665,7 +2687,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 | Runs = 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)); } @@ -2679,7 +2701,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 | Runs = 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); @@ -2687,7 +2709,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 | Runs = Slice>(size: number, clone?: (value: T) => T, drop?: (item: T) => void, over?: CloneFrom): CloneFrom> { return (old, src) => cowCloneFrom(old, src, size, clone, drop, over); } @@ -2702,7 +2724,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 | Runs = Slice>(c: Cow, f?: (item: T) => void): void { if (!(c instanceof Borrowed)) dropAll(c.items, f); } diff --git a/ts/runtime/rs/task.ts b/ts/runtime/rs/task.ts index 249299638..91ec25267 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 Run, Runs, runsArray, 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 Run, type RunArray, type RunCopy, Runs, runsArray, runsCopy, runsSet, 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"; @@ -913,11 +913,11 @@ export function cellOfPlace(p: Place): Cell { } /** - * `Cell::from_mut` of a `&mut [[T; N]; M]`, which is the runs `r`: a read is `copy`'s of - * them, and a write `set`s them. + * `Cell::from_mut` of a `&mut [[T; N]; M]`, which is the runs `r`: a read is a copy of + * them, each element copied by `copy`, and a write lands where `r` holds them. */ -export function cellOfRuns(r: Runs, copy: (r: Runs) => A, set: (r: Runs, value: A) => void): Cell { - return cellOfPlace(place(() => copy(r), (value) => set(r, value))); +export function cellOfRuns(r: Runs, copy?: RunCopy): Cell[]> { + return cellOfPlace(place(() => runsCopy(r, copy), (value) => runsSet(r, value))); } /** diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index 19e28f1fe..17d590ccf 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -74,7 +74,7 @@ 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_slice(*inner, self.value(*inner, valtree, span)), diff --git a/ts/src/lower/copy.rs b/ts/src/lower/copy.rs index 468aee162..e11f1f86f 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -152,7 +152,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if super::byte(elem) { return Expr::rs("byteSliceToArray", vec![s]); } - if self.uninit_inner(elem).is_array() { + // Runs 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("runsToArray", vec![s, copy]); } @@ -161,6 +162,20 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Expr::rs("sliceToArray", values) } + /// What copies an element of the runs of `ty`, an array or slice of arrays, as runs + /// 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 runs back changes. + pub fn run_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/library.rs b/ts/src/lower/library.rs index 2e4d2af3c..6c83996c3 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -621,6 +621,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("cowRuns", vec![cow, super::array_fn(*elem, "From")]), _ => Expr::rs("cowSlice", vec![cow]), } } @@ -1931,6 +1932,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 runs 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("optionAsRuns", args) + } ("Option", "as_slice") => { args.extend(b.t.none_arg(targ(gargs, 0))); Expr::rs("optionAsSlice", args) @@ -2316,6 +2322,12 @@ fn mapping<'tcx>( Expr::rs("byteSliceEq", args) } ("slice", "to_vec") => slice_to_vec(b, args.pop()?, targ(gargs, 0), span), + // A swap of runs 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.run_copy(targ(gargs, 0), span).unwrap_or_else(Expr::undefined)); + Expr::rs("runsSwap", 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()), @@ -3511,6 +3523,8 @@ fn slices_join<'tcx>( ty::Array(..) => Some(if bytes { "byteSliceFrom" } else { "sliceFrom" }), ty::Ref(_, s, _) if s.is_slice() => None, _ if b.t.std_of(item) == Some(Std::Vec) => Some(if bytes { "byteVecSlice" } else { "vecSlice" }), + // A `Cow` of arrays derefs to its runs, which this reads as no slice. + _ if cow_slice(b.t.tcx, item).is_some_and(|elem| elem.is_array()) => return None, _ if cow_slice(b.t.tcx, item).is_some() => Some(if bytes { "byteCowSlice" } else { "cowSlice" }), _ if box_slice(b.t.tcx, item).is_some() => None, _ => return None, @@ -3556,6 +3570,7 @@ 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("runsCopy", vec![slice]), Expr::Lit(l) if l == "undefined" => Expr::rs("sliceToArray", vec![slice]), clone => items_of(slice, elem).method("map", vec![clone]), } @@ -4184,7 +4199,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 69d72d968..d1ec7c10c 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -663,7 +663,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { "sliceCloneFromSlice", [vec![Expr::ident(name.clone()), source], fns].concat(), ); - let e = crate::lower::runs::wrap(e, ts::Type::Builtin("void"), Vec::new(), vec![(name, to)]); + let copy = self.b.t.run_copy(ty, span); + let by = crate::lower::runs::By { name, value: to, copy }; + let e = crate::lower::runs::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); @@ -1441,9 +1443,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let slice = self.operand(op, span, out); if cell { - let copy = self.b.t.array_copy_fn(ty, span); - let set = crate::lower::array_fn(ty, "Set"); - return Some(Expr::rs("cellOfRuns", vec![slice, copy, set])); + let copy = self.b.t.run_copy(ty, span); + return Some(Expr::rs( + "cellOfRuns", + [vec![slice], copy.into_iter().collect()].concat(), + )); } let n = len.try_to_target_usize(tcx).unwrap_or(0); return Some(Expr::rs("runsOne", vec![slice, Expr::lit(n.to_string())])); @@ -1792,7 +1796,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // Runs, each copied out and written where the slice holds it. Some(p) if crate::lower::runs::of_arrays(self.b.t.uninit_inner(ty)) => { let slice = self.borrowed_slice(place.0, p, span, out); - Expr::rs("runsReplace", vec![slice, value]) + let copy = self.b.t.run_copy(ty, span); + Expr::rs("runsReplace", [vec![slice, value], copy.into_iter().collect()].concat()) } Some(p) => { let slice = self.borrowed_slice(place.0, p, span, out); diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 1706d1cf2..971873105 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -358,9 +358,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ProjectionElem::Deref => self.array_behind(place.local, read, ty), ProjectionElem::Subslice { .. } => in_slice, // A run of a slice of arrays is the slice of its elements. - ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => { - in_slice && self.b.t.uninit_inner(next.ty).is_array() - } + ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => in_slice && next.ty.is_array(), _ => false, }; pty = next; @@ -372,9 +370,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// `rs.Runs`' run, 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 self.b.t.uninit_inner(*elem).is_array() => { - Expr::rs("runsAt", vec![base, i]) - } + ty::Slice(elem) | ty::Array(elem, _) if elem.is_array() => Expr::rs("runsAt", vec![base, i]), _ => slice_at(base, i), } } @@ -439,8 +435,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { 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 self.b.t.uninit_inner(*e).is_array()) + (in_array || ty.is_slice()) && matches!(ty.kind(), ty::Slice(e) | ty::Array(e, _) if e.is_array()) } _ => false, }; diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 373f35715..992276fbc 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -1712,6 +1712,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 runs. + ty::Array(..) => Type::Rs("Cow", vec![self.ty(elem, span), self.slice_ty(elem, span)]), _ => Type::Rs("Cow", vec![self.ty(elem, span)]), } } diff --git a/ts/src/lower/runs.rs b/ts/src/lower/runs.rs index 6e65d406d..95c900b47 100644 --- a/ts/src/lower/runs.rs +++ b/ts/src/lower/runs.rs @@ -77,6 +77,7 @@ pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: t | "splitn_mut" | "rsplitn" | "rsplitn_mut" + | "to_vec" ) } @@ -113,7 +114,12 @@ pub fn give<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec ty::Mutability::Not => Expr::rs("runsItems", vec![value]), ty::Mutability::Mut => { let name = b.fresh("runs"); - given.by.push((name.clone(), value)); + let copy = b.t.run_copy(*inner, call.span); + given.by.push(By { + name: name.clone(), + value, + copy, + }); Expr::ident(name) } }; @@ -132,16 +138,26 @@ pub fn give<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec pub struct Given { /// The arguments std's mapping takes. pub args: Vec, - /// Each `&mut [[T; N]]`'s name in `args`, and its value. - pub by: Vec<(String, Expr)>, + /// 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 runs. + pub value: Expr, + /// What copies an element of the runs out, as [`super::Translator::run_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.runsBy` copies of its runs. -pub fn wrap(e: Expr, ty: Type, stmts: Vec, by: Vec<(String, Expr)>) -> Expr { +pub fn wrap(e: Expr, ty: Type, stmts: Vec, by: Vec) -> Expr { let mut stmts = Some(stmts); let mut e = e; - for (name, value) in by.into_iter().rev() { + 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) => { @@ -150,7 +166,7 @@ pub fn wrap(e: Expr, ty: Type, stmts: Vec, by: Vec<(String, Expr)>) -> Exp } None => Expr::Lambda(vec![param], Box::new(e)), }; - e = Expr::rs("runsBy", vec![value, f]); + e = Expr::rs("runsBy", [vec![value, f], copy.into_iter().collect()].concat()); } e } From 2c7ae6f2c5870cded6a73b7da170b344465501a1 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 19:27:50 -0800 Subject: [PATCH 07/12] fix(ts): runs from an Option's mutable slice, a borrowed Vec's Cow, initialized MaybeUninits, and joined slices of arrays Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/slices/expected/slices.ts | 55 ++++++++++++++++++---- ts/fixtures/lang/slices/src/slices.rs | 43 ++++++++++++++++- ts/runtime/rs.ts | 5 ++ ts/src/lower/library.rs | 54 ++++++++++++++++----- ts/src/lower/mir/call.rs | 7 +++ 5 files changed, 142 insertions(+), 22 deletions(-) diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index 52ec8513f..61e3a6345 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2854,7 +2854,7 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo rs.idx(c, 1); return Uint8Array.of(_33, c.data[c.start + 1]); }), undefined, 2, true); - const _8: rs.u8 = rs.u8Rem(kind, 7); + 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)); @@ -2873,10 +2873,10 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo 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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (p2: rs.ByteSlice): string[] => { - const arg = p2.data[p2.start]; + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (p4: rs.ByteSlice): string[] => { + const arg = p4.data[p4.start]; const _310: string = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f)); - const arg2 = p2.data[p2.start + 1]; + const arg2 = p4.data[p4.start + 1]; return [_310, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg2, f))]; }), undefined, 24, true); const part = rs.min(words.items.length, 1); @@ -2900,8 +2900,8 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo putRuns$2(rs.optionAsRuns(undefined, rs.byteSliceFrom), out); } else if (_8 === 3) { rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOrDefault$0h81s8g(View.last$array2_u8({ view: rs.runsFrom(pairs.items, rs.byteSliceFrom) }))), undefined, true); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(option_unwrapOrDefault$1n9qa5p(View.last$array2_u16({ view: rs.runsFrom(rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (p: rs.ByteSlice): rs.u16[] => { - return [p.data[p.start] as rs.u16, p.data[p.start + 1] as rs.u16]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(option_unwrapOrDefault$1n9qa5p(View.last$array2_u16({ view: rs.runsFrom(rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(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); @@ -2922,12 +2922,51 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo putRuns$2(rs.cowRuns(borrowed, rs.byteSliceFrom), out); putRuns$2(rs.runsFrom(rs.cowIntoOwned(borrowed, copy$array_u8).items, rs.byteSliceFrom), out); putRuns$2(rs.cowRuns(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.runsFirst(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceView))); + const _211: rs.ByteSlice | undefined = rs.runsFirst(some2 === undefined ? rs.runsFrom([], rs.byteSliceFrom) : rs.runsFrom([some2], rs.byteSliceFrom)); + if (_211 !== undefined) { + _211.data[_211.start + 1] = _211.data[_211.start + 1] ^ 90; + } + putRuns$2(rs.optionAsRuns(some2, rs.byteSliceFrom), out); + const _227 = undefined as Uint8Array | undefined; + rs.byteVecPush(out, (_227 === undefined ? rs.runsFrom([], rs.byteSliceFrom) : rs.runsFrom([_227], rs.byteSliceFrom)).length & 0xff); + putRuns$2(rs.cowRuns(new rs.Borrowed(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceFrom), out); + const wrapped2: rs.Vec = rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (_2: rs.ByteSlice): Uint8Array => { + return copy$array_u8(rs.byteSliceToArray(_2)); + }), undefined, 2, true); + putRuns$2(rs.runsOfSlice(rs.sliceFrom(wrapped2.items), rs.byteSliceFrom), out); + const _242: rs.ByteSlice | undefined = rs.runsLast(rs.runsOfSlice(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.runsOfSlice(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.runsOfSlice(boxed2, rs.byteSliceFrom), out); + const half: rs.usize = rs.usizeDiv(pairs.items.length, 2); + putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, undefined, rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([new rs.Borrowed(rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half)), rs.vecFrom(rs.runsArray(rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)).map(copy$array_u8))]), 2, undefined, (c) => rs.runsItems(rs.cowRuns(c, rs.byteSliceFrom)), copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.sliceFrom([rs.byteSliceToArray(rs.byteSliceFrom(Uint8Array.of(238, 255)))]), rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.runsItems(rs.runsFrom([Uint8Array.of(221, 204), Uint8Array.of(187, 170)], rs.byteSliceFrom)), rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); } else { let item: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(byte(0))); const runs2: rs.Runs> = rs.runsOne(rs.sliceOfPlace(rs.place(() => item, (value) => item = value)), 1); rs.idx(runs2, 0); - const _222: rs.ByteVec[] = [rs.byteVecFrom(Uint8Array.of(byte(1), byte(2)))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.replaceIn(rs.sliceView(rs.runsAt(runs2, 0)), _222, 1)[0])), undefined, true); + const _354: rs.ByteVec[] = [rs.byteVecFrom(Uint8Array.of(byte(1), byte(2)))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.replaceIn(rs.sliceView(rs.runsAt(runs2, 0)), _354, 1)[0])), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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); } diff --git a/ts/fixtures/lang/slices/src/slices.rs b/ts/fixtures/lang/slices/src/slices.rs index d53e608a9..3fae0c1f8 100644 --- a/ts/fixtures/lang/slices/src/slices.rs +++ b/ts/fixtures/lang/slices/src/slices.rs @@ -1332,7 +1332,7 @@ fn put_runs(runs: &[[u8; N]], out: &mut Vec) { 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 % 7 { + 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 => { @@ -1406,6 +1406,47 @@ pub fn array_forms(kind: u8, data: &[u8], out: &mut Vec) { 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)]; diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index 0febe7b6e..67e2aa42a 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -1008,6 +1008,11 @@ export function runsFrom(items: readonly A[], of: (array: A) = return new Runs(items, of, undefined, 0, 0, items.length); } +/** The runs 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 runsOfSlice(s: Slice, of: (array: A) => S): Runs { + return new Runs(s.data, of, undefined, 0, s.start, s.length); +} + /** `runsFrom` of `of`, as a function of the arrays, as a `[[T; N]; M]` is lent: one function for each `of`. */ export function runsOf(of: (array: A) => S): (items: readonly A[]) => Runs { let f = LENT.get(of) as ((items: readonly A[]) => Runs) | undefined; diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index f836b083d..8c23ae4b2 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -2310,6 +2310,11 @@ fn mapping<'tcx>( values.push(super::collections::clone_fn(b, elem, span)); Expr::rs("sliceWriteCloneOfSlice", values) } + // Of arrays, the runs 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( + "runsOfSlice", + 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; @@ -2475,7 +2480,13 @@ fn mapping<'tcx>( .boxed_ty() .is_some_and(|t| t.is_slice()) => { - args.pop()? + match targ(gargs, 0).is_array() { + true => Expr::rs( + "runsOfSlice", + 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. @@ -3514,22 +3525,40 @@ fn slices_join<'tcx>( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![sep])], ), + // An array separator is lent as its slice, whose array the join reads. + (true, false) if elem.is_array() => { + Expr::rs("sliceFrom", vec![Expr::Array(vec![b.t.array_copy(sep, elem, span)])]) + } (true, false) => Expr::rs("sliceFrom", vec![Expr::Array(vec![sep])]), + // Runs, as the slice of their arrays. + (false, false) if join && elem.is_array() => Expr::rs("runsItems", 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" }), + // Runs of arrays, as a slice of the arrays. + ty::Ref(_, s, _) if super::runs::of_arrays(*s) => rs("runsItems"), ty::Ref(_, s, _) if s.is_slice() => None, - _ if b.t.std_of(item) == Some(Std::Vec) => Some(if bytes { "byteVecSlice" } else { "vecSlice" }), - // A `Cow` of arrays derefs to its runs, which this reads as no slice. - _ if cow_slice(b.t.tcx, item).is_some_and(|elem| elem.is_array()) => return None, - _ 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("runsItems", 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("runsItems"), _ 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]))); } @@ -4128,16 +4157,15 @@ 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.Runs` +/// 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::Adt(_, args) if byte(args.type_at(0)) => Expr::rs("byteVecSlice", vec![v]), - ty::Adt(..) => Expr::rs("sliceFrom", vec![v.member("items")]), + ty::Array(elem, _) => super::slice_items_from(v, *elem), + ty::Adt(_, args) => vec_view(v, args.type_at(0)), _ => v, } } diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index d1ec7c10c..3cac37a19 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -1014,6 +1014,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 runs 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("runsFrom", 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() { From 2c2f23ceef2db9b5ff6ab8655dbdf3da2da23460 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 20:34:01 -0800 Subject: [PATCH 08/12] fix(ts): lend rows of item-backed runs and join's array separator as they are Co-Authored-By: Claude Opus 5.5 --- .../lang/slices/expected/core/option.ts | 5 +- ts/fixtures/lang/slices/expected/lib.ts | 4 +- .../lang/slices/expected/slices.Probe.ts | 16 +++ ts/fixtures/lang/slices/expected/slices.ts | 136 ++++++++++++++++-- ts/fixtures/lang/slices/src/lib.rs | 1 + ts/fixtures/lang/slices/src/slices.rs | 91 ++++++++++++ ts/runtime/rs.ts | 14 +- ts/src/lower/library.rs | 9 +- 8 files changed, 254 insertions(+), 22 deletions(-) create mode 100644 ts/fixtures/lang/slices/expected/slices.Probe.ts diff --git a/ts/fixtures/lang/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index 5c8ad4e30..e2de74a20 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -1,6 +1,7 @@ // 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"; @@ -36,11 +37,11 @@ export function unwrapOrDefault$0h81s8g(self: Uint8Array | undefined): Uint8Arra return self; } -export function map$1sh08h7(self: rs.u16[] | undefined, f: (a0: rs.u16[]) => rs.u8): rs.u8 | undefined { +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 { diff --git a/ts/fixtures/lang/slices/expected/lib.ts b/ts/fixtures/lang/slices/expected/lib.ts index 6d3c188c3..468e61f99 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, arrayForms } from "./slices.ts"; +import { parts, chunked, subslices, drains, ranges, edits, arrays, arraysMut, arrayForms, arrayIdentity } from "./slices.ts"; import type * as Noisy from "./slices.Noisy.ts"; import type * as Pair from "./slices.Pair.ts"; @@ -53,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], ["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]]); + 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]]); } //# 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..1c6d53bcd --- /dev/null +++ b/ts/fixtures/lang/slices/expected/slices.Probe.ts @@ -0,0 +1,16 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; + +/** What counts its own clones, in itself, so a clone of a copy of it counts none. */ +export interface Probe { + tag: rs.u8; + clones: rs.Cell; +} + +export function clone$Clone(self: Probe): Probe { + rs.cellSet(self.clones, rs.u8Add(self.clones.v, 1)); + return { tag: self.tag, clones: new rs.Cell(0) }; +} + +//# sourceMappingURL=slices.Probe.ts.map diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index 61e3a6345..1bd504987 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2,11 +2,12 @@ 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$mem_MaybeUninit_array_u8, copy$slices_Pair, drop$tuple2_Vec_slices_Noisy_Vec_u8 } from "./lib.ts"; -import { isSomeAnd$1ouf3e6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1n9qa5p as option_unwrapOrDefault$1n9qa5p, unwrapOrDefault$0h81s8g as option_unwrapOrDefault$0h81s8g, 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 { isSomeAnd$1ouf3e6, 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, 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); @@ -2174,7 +2175,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { 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) { @@ -2391,8 +2392,8 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _253: [rs.Slice, rs.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 2); if (_253[1].length >= 2) { const _263: [rs.u16[], rs.u16[]] = [rs.sliceToArray(rs.runsAt(_253[1], 0)), rs.sliceToArray(rs.runsAt(_253[1], _253[1].length - 1))]; - const first2: rs.u16[] = _263[0]; - const last2: rs.u16[] = _263[1]; + const first2: rs.u16[] = copy$array_u16(_263[0]); + const last2: rs.u16[] = copy$array_u16(_263[1]); rs.runsSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1), undefined); rs.runsBy(_253[1], (runs3) => rs.sliceReverse(runs3)); const n2: rs.usize = _253[1].length; @@ -2405,7 +2406,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const kept4: rs.u16[] = rs.sliceToArray(rs.runsAt(_253[1], _282)); const _288: { end: rs.usize } = { end: rs.usizeSub(n2, 1) }; rs.runsCopyWithin(_253[1], 0, _288.end, 1, copy$array_u16); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([first2, last2, kept4], rs.sliceFrom)), (c3: rs.Slice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([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.runsBy(_253[1], (runs7) => rs.sliceSort(runs7, rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true)); @@ -2709,8 +2710,8 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _760: [rs.Runs>>, rs.Runs>] = rs.sliceAsChunks(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0], 2); if (_760[0].length >= 2) { const _768: [rs.u16[][], rs.u16[][]] = [rs.runsToArray(rs.runsAt(_760[0], 0), rs.sliceToArray), rs.runsToArray(rs.runsAt(_760[0], _760[0].length - 1), rs.sliceToArray)]; - const first6: rs.u16[][] = _768[0]; - const last6: rs.u16[][] = _768[1]; + const first6: rs.u16[][] = copy$array_array2_u16(_768[0]); + const last6: rs.u16[][] = copy$array_array2_u16(_768[1]); rs.runsSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1), undefined); rs.runsBy(_760[0], (runs39) => rs.sliceReverse(runs39)); const n6: rs.usize = _760[0].length; @@ -2723,7 +2724,7 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const kept12: rs.u16[][] = rs.runsToArray(rs.runsAt(_760[0], _787), rs.sliceToArray); const _793: { end: rs.usize } = { end: rs.usizeSub(n6, 1) }; rs.runsCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([first6, last6, kept12], rs.runsOf(rs.sliceFrom))), (c23: rs.Runs>): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_u16(first6), copy$array_array2_u16(last6), copy$array_array2_u16(kept12)], rs.runsOf(rs.sliceFrom))), (c23: rs.Runs>): rs.u8 => { const slice64 = rs.runsAt(c23, 0); const _415: rs.u16 = slice64.data[slice64.start]; const slice65 = rs.runsAt(c23, 1); @@ -2959,7 +2960,7 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo const half: rs.usize = rs.usizeDiv(pairs.items.length, 2); putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, undefined, rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([new rs.Borrowed(rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half)), rs.vecFrom(rs.runsArray(rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)).map(copy$array_u8))]), 2, undefined, (c) => rs.runsItems(rs.cowRuns(c, rs.byteSliceFrom)), copy$array_u8).items, rs.byteSliceFrom), out); - putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.sliceFrom([rs.byteSliceToArray(rs.byteSliceFrom(Uint8Array.of(238, 255)))]), rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); + putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.runsItems(rs.runsOne(rs.byteSliceFrom(Uint8Array.of(238, 255)), 2)), rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.runsItems(rs.runsFrom([Uint8Array.of(221, 204), Uint8Array.of(187, 170)], rs.byteSliceFrom)), rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); } else { let item: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(byte(0))); @@ -2972,4 +2973,121 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo } } +/** Whether a callback std lends each row of `rows` gets that row itself, by `ptr::eq`. */ +export function lentRows$2(rows: rs.Runs, out: rs.ByteVec): void { + const iter: rs.Iter = rs.runsIter(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.runsItems(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.Runs>, nested: rs.Runs>, out: rs.ByteVec): void { + const iter: rs.Iter> = rs.runsIter(rows); + while (true) { + const _6: rs.Slice | rs.Done = iter.next(); + if (_6 === rs.DONE) { + break; + } + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.runsIter(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.runsItems(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.runsItems(rows), (held2) => _22(rs.sliceFrom(held2))); + rs.byteVecPush(out, lent ? 1 : 0); + } + const iter2: rs.Iter> = rs.runsIter(nested); + while (true) { + const _29: rs.Runs | rs.Done = iter2.next(); + if (_29 === rs.DONE) { + break; + } + let lent2: boolean = false; + const _35: (a0: rs.Runs) => rs.Ordering = (row4: rs.Runs): rs.Ordering => { + const _36: boolean = rs.runsSame(row4, _29); + lent2 = lent2 || _36; + return rs.cmpSlice(rs.cmpBytes)(row4, _29); + }; + rs.sliceBinarySearchBy(rs.runsItems(nested), (held3) => _35(rs.runsOf(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.runsBy(rs.runsFrom(rows.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 2, true)); + rs.vecDedupBy(rows, rs.eqBytes); + if (rs.u8Rem(kind, 2) === 0) { + lentRows$2(rs.runsFrom(rows.items, rs.byteSliceFrom), out); + const part3 = rs.usizeDiv(rows.items.length, 2); + lentRows$2(rs.runsRange(rs.runsFrom(rows.items, rs.byteSliceFrom), part3), out); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(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.runsWindows(rs.runsFrom(rows.items, rs.byteSliceFrom), 2), (w: rs.Runs): Uint8Array[] => { + rs.idx(w, 0); + const _310: Uint8Array = rs.byteSliceToArray(rs.runsAt(w, 0)); + rs.idx(w, 1); + return [_310, rs.byteSliceToArray(rs.runsAt(w, 1))]; + }), undefined, 4, true); + const part4 = rs.min(words.items.length, 1); + const _36: rs.Runs> = rs.runsRange(rs.runsFrom(words.items, rs.sliceFrom), part4); + const part5 = rs.usizeDiv(nested.items.length, 2); + lentWords(_36, rs.runsRange(rs.runsFrom(nested.items, rs.runsOf(rs.byteSliceFrom)), part5), out); + } else { + const probes: (a0: rs.usize) => rs.Vec = (at: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsRange(rs.runsFrom(rows.items, rs.byteSliceFrom), at)), (r: rs.ByteSlice): Probe.Probe[] => { + return [{ tag: r.data[r.start], clones: new rs.Cell(0) }]; + }), undefined, 2, true); + }; + const _54: rs.Vec = probes(0); + const _53: [rs.Vec, rs.Vec] = [_54, probes(rs.usizeDiv(rows.items.length, 2))]; + const a: rs.Vec = _54; + const b: rs.Vec = _53[1]; + const sep: Probe.Probe[] = [{ tag: 238, clones: new rs.Cell(0) }]; + const _71: rs.Runs> = rs.runsFrom(a.items, rs.sliceFrom); + const _73: rs.Runs> = rs.runsFrom(b.items, rs.sliceFrom); + const part2 = rs.min(1, a.items.length); + const joined: rs.Vec = rs.slicesJoin(rs.sliceFrom([_71, _73, rs.runsRange(rs.runsFrom(a.items, rs.sliceFrom), 0, part2)]), 2, rs.runsItems(rs.runsOne(rs.sliceFrom(sep), 1)), rs.runsItems, (a: Probe.Probe[]) => a.map(Probe.clone$Clone)); + rs.byteVecPush(out, sep[0].clones.v); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom(joined.items, rs.sliceFrom)), (_2: rs.Slice): rs.u8 => { + return _2.data[_2.start].tag; + }), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom(a.items, rs.sliceFrom)), (_23: rs.Slice): rs.u8 => { + return _23.data[_23.start].clones.v; + }), 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 cc60d06c8..298db0185 100644 --- a/ts/fixtures/lang/slices/src/lib.rs +++ b/ts/fixtures/lang/slices/src/lib.rs @@ -25,5 +25,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("slices::arrays", slices::arrays), ("slices::arrays_mut", slices::arrays_mut), ("slices::array_forms", slices::array_forms), + ("slices::array_identity", slices::array_identity), ] } diff --git a/ts/fixtures/lang/slices/src/slices.rs b/ts/fixtures/lang/slices/src/slices.rs index 3fae0c1f8..c187c44c9 100644 --- a/ts/fixtures/lang/slices/src/slices.rs +++ b/ts/fixtures/lang/slices/src/slices.rs @@ -1461,3 +1461,94 @@ pub fn array_forms(kind: u8, data: &[u8], out: &mut Vec) { } } } + +/// What counts its own clones, in itself, so a clone of a copy of it counts none. +struct Probe { + tag: u8, + clones: std::cell::Cell, +} + +impl Clone for Probe { + fn clone(&self) -> Self { + self.clones.set(self.clones.get() + 1); + Probe { + tag: self.tag, + clones: std::cell::Cell::new(0), + } + } +} + +/// 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` in place. + _ => { + let probes = |at: usize| -> Vec<[Probe; 1]> { + rows[at..] + .iter() + .map(|r| { + [Probe { + tag: r[0], + clones: std::cell::Cell::new(0), + }] + }) + .collect() + }; + let (a, b) = (probes(0), probes(rows.len() / 2)); + let sep = [Probe { + tag: 0xee, + clones: std::cell::Cell::new(0), + }]; + let joined = [&a[..], &b[..], &a[..1.min(a.len())]].join(&sep); + out.push(sep[0].clones.get()); + out.extend(joined.iter().map(|[p]| p.tag)); + out.extend(a.iter().map(|[p]| p.clones.get())); + } + } +} diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index 67e2aa42a..d88532f86 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -1129,12 +1129,13 @@ function runSame(a: Run, b: Run): boolean { /** * The runs of `r` as a JS array of arrays, for what only reads them: the arrays themselves - * where `r` is all of them, or else copies, which nothing can tell from them while the - * borrow lives. + * where each run is one, so a callback's `ptr::eq` sees the run it was lent, or else copies + * of the runs `as_chunks` split from one flat slice, which have no array of their own. */ export function runsArray(r: Runs): RunArray[] { - if (r.items !== undefined && r.start === 0 && r.length === r.items.length) return r.items as RunArray[]; - return runsCopy(r); + if (r.items === undefined) return runsCopy(r); + if (r.start === 0 && r.length === r.items.length) return r.items as RunArray[]; + return r.items.slice(r.start, r.start + r.length) as RunArray[]; } /** `last_chunk` of runs, shared or mutable: the last `n`, or `undefined` if fewer. */ @@ -1147,9 +1148,10 @@ export function runsSplitLastChunk(r: Runs, n: number): [Runs< return n > r.length ? undefined : [runPart(r, 0, r.length - n), runPart(r, r.length - n, n)]; } -/** The runs of `r` as a slice of arrays, as `runsArray` reads them. */ +/** The runs of `r` as a slice of arrays, as `runsArray` reads them: a slice of the arrays where each run is one. */ export function runsItems(r: Runs): Slice> { - return sliceFrom(runsArray(r)); + if (r.items !== undefined) return new Slice(r.items as RunArray[], r.start, r.length); + return sliceFrom(runsCopy(r)); } /** diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 8c23ae4b2..e35d53ebe 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -3525,9 +3525,12 @@ fn slices_join<'tcx>( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![sep])], ), - // An array separator is lent as its slice, whose array the join reads. - (true, false) if elem.is_array() => { - Expr::rs("sliceFrom", vec![Expr::Array(vec![b.t.array_copy(sep, elem, span)])]) + // An array separator is the runs 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("runsOne", vec![sep, Expr::lit(n.to_string())]); + Expr::rs("runsItems", vec![one]) } (true, false) => Expr::rs("sliceFrom", vec![Expr::Array(vec![sep])]), // Runs, as the slice of their arrays. From c8d71b2149e48846a37719c044099e728813c270 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 20:37:53 -0800 Subject: [PATCH 09/12] test(ts): a lent row's ptr::eq and join's separator Clone, against native Rust Co-Authored-By: Claude Opus 5.5 --- .../lang/slices/expected/core/option.ts | 8 +++++ .../lang/slices/expected/slices.Probe.ts | 15 +++++++--- ts/fixtures/lang/slices/expected/slices.ts | 29 +++++++++--------- ts/fixtures/lang/slices/src/slices.rs | 30 +++++++++---------- 4 files changed, 48 insertions(+), 34 deletions(-) diff --git a/ts/fixtures/lang/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index e2de74a20..3a8475ca8 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -6,6 +6,14 @@ 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) { diff --git a/ts/fixtures/lang/slices/expected/slices.Probe.ts b/ts/fixtures/lang/slices/expected/slices.Probe.ts index 1c6d53bcd..eb37bf1b9 100644 --- a/ts/fixtures/lang/slices/expected/slices.Probe.ts +++ b/ts/fixtures/lang/slices/expected/slices.Probe.ts @@ -1,16 +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 counts its own clones, in itself, so a clone of a copy of it counts none. */ +/** What logs, as it is cloned, whether it is the one its `home` points at. */ export interface Probe { tag: rs.u8; - clones: rs.Cell; + home: rs.Cell; } export function clone$Clone(self: Probe): Probe { - rs.cellSet(self.clones, rs.u8Add(self.clones.v, 1)); - return { tag: self.tag, clones: new rs.Cell(0) }; + 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.ts b/ts/fixtures/lang/slices/expected/slices.ts index 1bd504987..af12fb329 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -3066,27 +3066,26 @@ export function arrayIdentity(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): const part5 = rs.usizeDiv(nested.items.length, 2); lentWords(_36, rs.runsRange(rs.runsFrom(nested.items, rs.runsOf(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.runsIter(rs.runsRange(rs.runsFrom(rows.items, rs.byteSliceFrom), at)), (r: rs.ByteSlice): Probe.Probe[] => { - return [{ tag: r.data[r.start], clones: new rs.Cell(0) }]; - }), undefined, 2, true); + return [{ tag: r.data[r.start] & 254, home: away }]; + }), undefined, 8, true); }; - const _54: rs.Vec = probes(0); - const _53: [rs.Vec, rs.Vec] = [_54, probes(rs.usizeDiv(rows.items.length, 2))]; - const a: rs.Vec = _54; - const b: rs.Vec = _53[1]; - const sep: Probe.Probe[] = [{ tag: 238, clones: new rs.Cell(0) }]; - const _71: rs.Runs> = rs.runsFrom(a.items, rs.sliceFrom); - const _73: rs.Runs> = rs.runsFrom(b.items, rs.sliceFrom); + 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.Runs> = rs.runsFrom(a.items, rs.sliceFrom); + const _84: rs.Runs> = rs.runsFrom(b.items, rs.sliceFrom); const part2 = rs.min(1, a.items.length); - const joined: rs.Vec = rs.slicesJoin(rs.sliceFrom([_71, _73, rs.runsRange(rs.runsFrom(a.items, rs.sliceFrom), 0, part2)]), 2, rs.runsItems(rs.runsOne(rs.sliceFrom(sep), 1)), rs.runsItems, (a: Probe.Probe[]) => a.map(Probe.clone$Clone)); - rs.byteVecPush(out, sep[0].clones.v); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom(joined.items, rs.sliceFrom)), (_2: rs.Slice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([_82, _84, rs.runsRange(rs.runsFrom(a.items, rs.sliceFrom), 0, part2)]), 8, rs.runsItems(rs.runsOne(rs.sliceFrom(sep), 1)), rs.runsItems, (a: Probe.Probe[]) => a.map(Probe.clone$Clone)).items, rs.sliceFrom)), (_2: rs.Slice): rs.u8 => { return _2.data[_2.start].tag; }), undefined, true); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom(a.items, rs.sliceFrom)), (_23: rs.Slice): rs.u8 => { - return _23.data[_23.start].clones.v; - }), undefined, true); + flush(out); } } diff --git a/ts/fixtures/lang/slices/src/slices.rs b/ts/fixtures/lang/slices/src/slices.rs index c187c44c9..967788a9c 100644 --- a/ts/fixtures/lang/slices/src/slices.rs +++ b/ts/fixtures/lang/slices/src/slices.rs @@ -1462,18 +1462,19 @@ pub fn array_forms(kind: u8, data: &[u8], out: &mut Vec) { } } -/// What counts its own clones, in itself, so a clone of a copy of it counts none. -struct Probe { +/// What logs, as it is cloned, whether it is the one its `home` points at. +struct Probe<'a> { tag: u8, - clones: std::cell::Cell, + home: &'a std::cell::Cell>>, } -impl Clone for Probe { +impl Clone for Probe<'_> { fn clone(&self) -> Self { - self.clones.set(self.clones.get() + 1); + 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, - clones: std::cell::Cell::new(0), + home: self.home, } } } @@ -1527,28 +1528,27 @@ pub fn array_identity(kind: u8, data: &[u8], out: &mut Vec) { 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` in place. + // `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], - clones: std::cell::Cell::new(0), + tag: r[0] & 0xfe, + home: &away, }] }) .collect() }; let (a, b) = (probes(0), probes(rows.len() / 2)); - let sep = [Probe { - tag: 0xee, - clones: std::cell::Cell::new(0), - }]; + 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.push(sep[0].clones.get()); out.extend(joined.iter().map(|[p]| p.tag)); - out.extend(a.iter().map(|[p]| p.clones.get())); + flush(out); } } } From b2a93751e653502a8a810bdd6ad7521bb4f64ff5 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 20:52:27 -0800 Subject: [PATCH 10/12] refactor(ts)!: rename rs.Runs to rs.ArraySlice, with its helpers Matches rs.ByteSlice and rs.RawSlice, as the maintainer decided at the round-3 design checkpoint. Co-Authored-By: Claude Opus 5.5 --- quest/m3/ts-runtime-throws.md | 8 + quest/m3/ts-slice-object.md | 26 +- ts/README.md | 29 +- ts/fixtures/codec/expected/bench.ts | 4 +- ts/fixtures/lang/arrays/expected/arrays.ts | 284 ++++---- ts/fixtures/lang/boxes/expected/boxes.ts | 8 +- .../lang/capacity/expected/capacity.ts | 14 +- ts/fixtures/lang/chunks/expected/chunks.ts | 8 +- ts/fixtures/lang/clones/expected/clones.ts | 54 +- ts/fixtures/lang/clones/expected/lib.ts | 2 +- .../lang/collections/expected/collections.ts | 10 +- .../lang/conversions/expected/conversions.ts | 672 +++++++++--------- .../lang/defaults/expected/defaults.ts | 6 +- ts/fixtures/lang/edits/expected/edits.ts | 14 +- ts/fixtures/lang/hints/expected/hints.ts | 2 +- ts/fixtures/lang/holds/expected/holds.ts | 2 +- ts/fixtures/lang/iters/expected/iters.ts | 6 +- ts/fixtures/lang/joins/expected/joins.ts | 42 +- ts/fixtures/lang/keys/expected/keys.ts | 100 +-- ts/fixtures/lang/lengths/expected/lengths.ts | 200 +++--- ts/fixtures/lang/orders/expected/orders.ts | 12 +- .../lang/pointers/expected/pointers.ts | 14 +- ts/fixtures/lang/refs/expected/refs.ts | 4 +- .../lang/separated/expected/core/option.ts | 4 +- .../lang/separated/expected/separated.ts | 46 +- ts/fixtures/lang/shapes/expected/fmt.ts | 6 +- ts/fixtures/lang/shapes/expected/generics.ts | 4 +- ts/fixtures/lang/shares/expected/shares.ts | 10 +- .../lang/slices/expected/slices.View.ts | 4 +- ts/fixtures/lang/slices/expected/slices.ts | 646 ++++++++--------- ts/runtime/rs.ts | 324 ++++----- ts/runtime/rs/collections.ts | 4 +- ts/runtime/rs/iter.ts | 84 +-- ts/runtime/rs/task.ts | 12 +- ts/src/lower/{runs.rs => array_slice.rs} | 37 +- ts/src/lower/copy.rs | 10 +- ts/src/lower/iter.rs | 6 +- ts/src/lower/lend.rs | 6 +- ts/src/lower/library.rs | 74 +- ts/src/lower/mir/call.rs | 51 +- ts/src/lower/mir/place.rs | 10 +- ts/src/lower/mod.rs | 20 +- ts/src/lower/pointer.rs | 8 +- 43 files changed, 1460 insertions(+), 1427 deletions(-) rename ts/src/lower/{runs.rs => array_slice.rs} (76%) diff --git a/quest/m3/ts-runtime-throws.md b/quest/m3/ts-runtime-throws.md index 5746d6308..06d8e3096 100644 --- a/quest/m3/ts-runtime-throws.md +++ b/quest/m3/ts-runtime-throws.md @@ -45,6 +45,14 @@ consumer in moq-net is form_urlencoded 1.2.2's `src/lib.rs:417`, 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 fd132c949..585f528db 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -2,23 +2,23 @@ ## Goal -[rust2-ts](/ts/README.md) holds a slice of arrays as an `rs.Runs` of the slice each array +[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.runsBy` writes runs back, and `arrayView` and its `View` traps +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.Runs`: +[moq-dev/rust2#608](https://github.com/moq-dev/rust2/pull/608), which made `rs.ArraySlice`: -1. How a `&mut [[T; N]]` holds its runs: +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 run `i`, which replaces the `Runs` and `ByteRuns` `Proxy` views and + 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. @@ -28,13 +28,27 @@ go. Proven by differential tests against native Rust. 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). `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.runsReplace` and `rs.cellOfRuns` do for runs. A raw pointer to an array of arrays +`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. diff --git a/ts/README.md b/ts/README.md index 9280c7154..8c09b3ff4 100644 --- a/ts/README.md +++ b/ts/README.md @@ -104,10 +104,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]`, `rs.Runs` 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.Runs` of the slice each array is for a slice of arrays | +| 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.Cow>` holding the runs of a slice of arrays; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | +| `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 string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | | `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | | `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rs.Slice` of a `[T; N]`'s elements or an `rs.ByteSlice` of a `[u8; N]`'s bytes, which compares by the array or buffer and offset they are at, refused for an array of one, which `array::from_ref`, `from_mut` of a variable, and `Option::as_slice` make of their own, or an `rs.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to other values JS copies, each a place JS makes of its own; `rs.NULL` for null and `rs.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rs.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rs.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rs.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rs` class such as `rs.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | | `MaybeUninit` | `T`: `undefined` until written, `0` for a byte, or an object whose parts kept as objects are there, holding `undefined`, 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 | @@ -171,18 +171,19 @@ JS array, and a `&[T; N]` or `&mut [T; N]` is an `rs.Slice` of its elements wher 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, a `&[[T; N]]`, -`&mut [[T; N]]`, `&[[T; N]; M]`, or `Box<[[T; N]]>`, is an `rs.Runs` of the slice each -array is, `rs.Runs>`, `rs.Runs` for bytes, and `rs.Runs` of -`rs.Runs` for arrays of arrays: its element `i` is the slice of run `i`, read and written -where the runs are, whether each is a JS array of its own, as a `Vec<[T; N]>` or a +`&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.runsFrom(arrays, rs.sliceFrom)`, `rs.byteSliceFrom` -for bytes and `rs.runsOf(rs.sliceFrom)` for arrays of arrays, and reads one as -`rs.runsArray(runs)`, the arrays themselves where the runs are all of them. std's methods -that lend runs or parts of the slice, such as `iter_mut`, `split_at_mut`, `chunks_mut`, -and `swap`, take them where they are; any other, such as `sort` or `rotate_left`, reads -copies of the runs, which a `&mut` one writes back once it returns, as Rust moves their -elements. +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 8e16017bf..5fd039248 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -533,7 +533,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.runsIter(rs.sliceAsChunks(rs.byteVecSlice(packets), 188)[0])); + 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) { @@ -552,7 +552,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.runsIter(rs.sliceAsChunks(rs.byteVecSlice(packets), 188)[0]); + 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 ab2f4be8f..26f822332 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.Runs = rs.runsFrom(grid, rs.byteSliceFrom); - [_97, rs.sliceFrom(named)] as [rs.Runs, rs.Slice]; - const _100: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(_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.Runs = rs.runsFrom(grid, rs.byteSliceFrom); - const _136: rs.Runs = rs.runsFrom(flipped, rs.byteSliceFrom); - const _138: rs.Runs = rs.runsFrom(same2, rs.byteSliceFrom); - [_133, _135, _136, rs.sliceFrom(sums), _138] as [rs.Slice, rs.Runs, rs.Runs, rs.Slice, rs.Runs]; - const _140: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(_135), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); - const _141: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(_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.runsArray(_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)); @@ -304,7 +304,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { } _49[_51].v = _49[_51].v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_21 === 3) { - const rows: rs.ByteSlice[] = rs.runsEach(rs.runsFrom(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.runsEach(rs.runsFrom(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: string): rs.u8 => { return rs.stringLen(w) & 0xff; }); - const rows2: Uint8Array = rs.bytesMap(rs.runsEach(rs.runsFrom(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.runsEach(rs.runsFrom(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]]))); } } - [rs.byteSliceFrom(bytes), rs.sliceFrom(wide), rs.sliceFrom(words), rs.runsFrom(grid, rs.byteSliceFrom), rs.runsFrom(pairs, rs.sliceFrom)] as [rs.ByteSlice, rs.Slice, rs.Slice, rs.Runs, rs.Runs>]; + [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, rs.fmtStr); - const arg5 = rs.runsFrom(grid, rs.byteSliceFrom); - const _161: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(arg5), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); - const arg6 = rs.runsFrom(pairs, rs.sliceFrom); - const args6 = [_158, _159, _160, _161, (f: rs.Formatter) => rs.fmtList(rs.runsArray(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]]))); } @@ -422,14 +422,14 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_46, _48); _46.data[_46.start + _48] = _46.data[_46.start + _48] + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_22 === 3) { - const _59: rs.Runs = rs.runsFrom(grid, rs.byteSliceFrom); + const _59: rs.ArraySlice = rs.arraySliceFrom(grid, rs.byteSliceFrom); const _61: rs.usize = rs.usizeRem(i, 3); rs.idx(_59, _61); - const _66: rs.ByteSlice = rs.runsAt(_59, _61); + 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 = rs.runsAt(_59, _61); + 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]; @@ -439,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.Runs> = rs.runsFrom(pairs, rs.sliceFrom); + const all: rs.ArraySlice> = rs.arraySliceFrom(pairs, rs.sliceFrom); const _93: rs.usize = rs.usizeRem(i, 2); rs.idx(all, _93); - rs.sliceCopyFromSlice(rs.runsAt(all, _93), rs.sliceFrom([op as rs.u32, ((op as rs.u32) << 20) >>> 0])); - rs.runsSwap(all, 0, 1, undefined); + 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); @@ -460,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.Runs = rs.runsFrom(grid, rs.byteSliceFrom); - const _155: rs.Runs> = rs.runsFrom(pairs, rs.sliceFrom); + 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, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.runsArray(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.runsArray(_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, rs.fmtStr), (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]]))); } @@ -551,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.Runs): void { - const iter: rs.Iter = rs.runsIter(arrays); +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) { @@ -563,8 +563,8 @@ export function put$0(out: rs.ByteVec, arrays: rs.Runs): void { } /** Each array's bytes, in order. */ -export function put$1(out: rs.ByteVec, arrays: rs.Runs): void { - const iter: rs.Iter = rs.runsIter(arrays); +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) { @@ -575,8 +575,8 @@ export function put$1(out: rs.ByteVec, arrays: rs.Runs): void { } /** Each array's bytes, in order. */ -export function put$3(out: rs.ByteVec, arrays: rs.Runs): void { - const iter: rs.Iter = rs.runsIter(arrays); +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) { @@ -587,8 +587,8 @@ export function put$3(out: rs.ByteVec, arrays: rs.Runs): void { } /** Each array's bytes, in order. */ -export function put$32(out: rs.ByteVec, arrays: rs.Runs): void { - const iter: rs.Iter = rs.runsIter(arrays); +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) { @@ -599,8 +599,8 @@ export function put$32(out: rs.ByteVec, arrays: rs.Runs): void { } /** Each array's bytes, in order. */ -export function put$40(out: rs.ByteVec, arrays: rs.Runs): void { - const iter: rs.Iter = rs.runsIter(arrays); +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) { @@ -611,8 +611,8 @@ export function put$40(out: rs.ByteVec, arrays: rs.Runs): void { } /** Each array's bytes, in order. */ -export function put$5(out: rs.ByteVec, arrays: rs.Runs): void { - const iter: rs.Iter = rs.runsIter(arrays); +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) { @@ -681,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -690,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -699,31 +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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); - put$0(out, rs.runsFrom(v.items, rs.byteSliceFrom)); - const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); - const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); - const _81: rs.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 0, 1); + 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.runsItems(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { + 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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(v.items, rs.byteSliceFrom), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); rs.idx(_87[1], 1); - put$0(out, rs.runsFrom(v.items, rs.byteSliceFrom)); + 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); - const _115: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 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) { @@ -743,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); + 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)])))); @@ -751,10 +751,10 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$0(out, rs.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); - const _190: rs.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsArray(_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]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -784,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -796,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -811,36 +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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); - put$1(out, rs.runsFrom(v.items, rs.byteSliceFrom)); - const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); - const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); - const _81: rs.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 0, 1); + 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.runsItems(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { + 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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(v.items, rs.byteSliceFrom), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); rs.idx(_87[1], 1); - const slice3 = rs.runsAt(_87[0], 0); - const slice4 = rs.runsAt(_87[1], 1); + 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.runsFrom(v.items, rs.byteSliceFrom)); + 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); - const _115: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 0); + 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) { @@ -868,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); + 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)])))); @@ -876,10 +876,10 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$1(out, rs.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); - const _190: rs.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsArray(_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]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -909,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -921,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -936,36 +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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); - put$3(out, rs.runsFrom(v.items, rs.byteSliceFrom)); - const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); - const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); - const _81: rs.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 0, 1); + 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.runsItems(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { + 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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(v.items, rs.byteSliceFrom), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); rs.idx(_87[1], 1); - const slice3 = rs.runsAt(_87[0], 0); - const slice4 = rs.runsAt(_87[1], 1); + 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.runsFrom(v.items, rs.byteSliceFrom)); + 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); - const _115: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 0); + 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) { @@ -993,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); + 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)])))); @@ -1001,10 +1001,10 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$3(out, rs.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); - const _190: rs.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsArray(_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]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -1034,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -1046,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.runsFrom([copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); + 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); @@ -1061,36 +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.runsFrom([old, copy$array_u8(a), copy$array_u8(b)], rs.byteSliceFrom)); - put$40(out, rs.runsFrom(v.items, rs.byteSliceFrom)); - const _73: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_73), rs.byteSliceView(_75), rs.eqBytes); - const _77: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_77), rs.byteSliceView(_79), rs.eqBytes); - const _81: rs.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 0, 1); + 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.runsItems(_81), rs.byteSliceView(_84), rs.eqBytes)], (a0: boolean): rs.u8 => { + 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.Runs, rs.Runs] = rs.runsSplitAt(rs.runsFrom(v.items, rs.byteSliceFrom), 1); + const _87: [rs.ArraySlice, rs.ArraySlice] = rs.arraySliceSplitAt(rs.arraySliceFrom(v.items, rs.byteSliceFrom), 1); rs.idx(_87[0], 0); rs.idx(_87[1], 1); - const slice3 = rs.runsAt(_87[0], 0); - const slice4 = rs.runsAt(_87[1], 1); + 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.runsFrom(v.items, rs.byteSliceFrom)); + 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); - const _115: rs.Runs = rs.runsFrom(v.items, rs.byteSliceFrom); + 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.runsItems(_115), rs.byteSliceView(_117), rs.eqBytes) ? 1 : 0); + 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) { @@ -1118,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(a))], rs.byteSliceFrom); + 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)])))); @@ -1126,10 +1126,10 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { if (_173 !== undefined) { _173.v = 238; } - put$40(out, rs.runsFrom([copy$array_u8(b)], rs.byteSliceFrom)); - const _190: rs.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsArray(_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]]))); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; @@ -1163,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.runsFrom([copy$array_u8(a), old, copy$array_u8(held.bytes)], rs.byteSliceFrom)); + 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: 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.runsFrom([taken2, copy$array_u8(held.bytes)], rs.byteSliceFrom)); + put$3(out, rs.arraySliceFrom([taken2, copy$array_u8(held.bytes)], rs.byteSliceFrom)); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d: rs.u8): boolean => { return rs.u8Rem(d, 3) === 1; @@ -1189,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.runsFrom([rs.bytes(0), copy$array_u8(a)], rs.byteSliceFrom)); + 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) { @@ -1205,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.runsFrom([taken, copy$array_u8(a)], rs.byteSliceFrom)); + 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) { @@ -1223,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.runsFrom([taken, copy$array_u8(a)], rs.byteSliceFrom)); + 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) { @@ -1241,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.runsFrom([taken, copy$array_u8(a)], rs.byteSliceFrom)); + 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) { @@ -1461,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.runsFrom(copied.items, rs.byteSliceFrom)); + 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) { @@ -1488,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.Runs => { - return rs.runsFrom(v.items, rs.byteSliceFrom); - }), undefined, 8, true)), (value: rs.Runs) => rs.runsIter(value), 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) { @@ -1502,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.runsIter(rs.runsFrom(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.runsOf(rs.byteSliceFrom))), (value: rs.Runs) => rs.runsIter(value), 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) { @@ -1710,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.runsFrom(copied.items, rs.byteSliceFrom)); + 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) { @@ -1737,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.Runs => { - return rs.runsFrom(v.items, rs.byteSliceFrom); - }), undefined, 8, true)), (value: rs.Runs) => rs.runsIter(value), 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) { @@ -1751,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.runsIter(rs.runsFrom(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.runsOf(rs.byteSliceFrom))), (value: rs.Runs) => rs.runsIter(value), 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) { @@ -1959,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.runsFrom(copied.items, rs.byteSliceFrom)); + 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) { @@ -1986,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.Runs => { - return rs.runsFrom(v.items, rs.byteSliceFrom); - }), undefined, 8, true)), (value: rs.Runs) => rs.runsIter(value), 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) { @@ -2000,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.runsIter(rs.runsFrom(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.runsOf(rs.byteSliceFrom))), (value: rs.Runs) => rs.runsIter(value), 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) { diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index de9879505..c2bd2075e 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.Runs = rs.runsFrom(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, rs.byteSliceFrom); - const quadsV: rs.Vec = rs.vecFrom(rs.runsArray(rs.runsFrom(rs.runsArray(quads).map(copy$array_u8), rs.byteSliceFrom))); - const _554: rs.ByteSlice | undefined = rs.runsFirst(rs.runsFrom(quadsV.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.runsIter(quads), rs.runsIter(rs.runsFrom(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 1ca836876..b771f37cd 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.runsItems(rs.runsFrom(rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 24) as rs.usize, copy$array_u64).items, rs.sliceFrom)), 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(rs.runsArray(rs.runsFrom(v.items, rs.sliceFrom))); + 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(rs.runsArray(rs.runsFrom(v.items, rs.sliceFrom))), "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.runsChunksExact(rs.runsFrom(v.items, rs.sliceFrom), 2); + const iter4: rs.Iter>> = rs.arraySliceChunksExact(rs.arraySliceFrom(v.items, rs.sliceFrom), 2); while (true) { - const _392: rs.Runs> | 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(rs.sliceToArray(rs.runsAt(_392, 0))); + 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(rs.sliceToArray(rs.runsAt(_392, 1)))]; + 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 544d936fb..c25982f52 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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceToArray), undefined, 2, true); - rs.iterExtendBytes(out, rs.iterChain(rs.iterMap(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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 88344a87c..81f43d5bd 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -6672,7 +6672,7 @@ 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.runsIter(rs.runsFrom(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); @@ -7746,7 +7746,7 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _263: Logged.Logged = logged(part10); const part11 = at(3); const grid: Logged.Logged[][] = [_249, [_263, logged(part11)]]; - const copy2: Logged.Logged[][] = rs.runsArray(rs.runsFrom(grid, rs.sliceFrom)).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); @@ -7779,7 +7779,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.runsIter(rs.runsFrom(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) { @@ -7924,14 +7924,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); - const _247: rs.Runs> = rs.runsFrom(grid, rs.sliceFrom); - const _248: rs.Runs> = rs.runsFrom(other, rs.sliceFrom); - rs.runsBy(_247, (runs6) => rs.sliceCloneFromSlice(runs6, rs.runsItems(_248), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); + 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.Runs> = rs.runsFrom(other, rs.sliceFrom); - rs.runsBy(rs.runsFrom(grid, rs.sliceFrom), (runs7) => rs.sliceCloneFromSlice(runs7, rs.runsItems(_260), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); + 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); @@ -7953,29 +7953,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); - const _330: rs.Runs> = rs.runsFrom(rows.items, rs.sliceFrom); - const _332: rs.Runs> = rs.runsFrom(other2, rs.sliceFrom); - rs.runsBy(_330, (runs2) => rs.sliceCloneFromSlice(runs2, rs.runsItems(_332), (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); + 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); - const _338: rs.Runs> = rs.runsRange(rs.runsFrom(rows.items, rs.sliceFrom), 0, 1); + 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.runsBy(_338, (runs3) => rs.sliceFill(runs3, _341, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); + 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.Runs> = rs.runsFrom(rows.items, rs.sliceFrom); + const _349: rs.ArraySlice> = rs.arraySliceFrom(rows.items, rs.sliceFrom); const part31 = at(8); const _352: Logged.Logged = logged(part31); const part32 = at(9); const _351: Logged.Logged[] = [_352, logged(part32)]; - rs.runsBy(_349, (runs4) => rs.sliceFill(runs4, _351, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); + 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.Runs> = rs.runsFrom([], rs.sliceFrom); + const _375: rs.ArraySlice> = rs.arraySliceFrom([], rs.sliceFrom); const part34 = at(10); const _378: Logged.Logged = logged(part34); const part35 = at(11); const _377: Logged.Logged[] = [_378, logged(part35)]; - rs.runsBy(_375, (runs5) => rs.sliceFill(runs5, _377, (a: Logged.Logged[]) => a.map(Logged.clone$Clone), drop$array2_clones_Logged, rs.arrayCloneFromFn(Logged.clone$Clone, rs.drop)), copy$clones_Logged); + 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); @@ -8022,19 +8022,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.Runs> = (from2: rs.usize, n3: rs.usize): rs.Runs> => { - return rs.runsFrom(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, rs.sliceFrom); }; const part12 = len(8); - let c3: rs.Runs> = ones(8, part12); + let c3: rs.ArraySlice> = ones(8, part12); const part13 = len(12); - const d2: rs.Runs> = ones(12, part13); + const d2: rs.ArraySlice> = ones(12, part13); flush(log.value, out); - c3 = rs.runsBoxCloneFrom(c3, d2, rs.sliceFrom, (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.Runs>, rs.Runs>]); + 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 => { @@ -8050,10 +8050,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.Runs> = rs.runsFrom(grid2, rs.sliceFrom); + const _584: rs.ArraySlice> = rs.arraySliceFrom(grid2, rs.sliceFrom); const _586: Kept.Kept[][] = [[kept(7), kept(8)]]; - const _585: rs.Runs> = rs.runsFrom(_586, rs.sliceFrom); - rs.runsBy(_584, (runs) => rs.sliceCloneFromSlice(runs, rs.runsItems(_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); + 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); @@ -8144,7 +8144,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.runsIter(rs.runsFrom(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 aae621282..c12eb1503 100644 --- a/ts/fixtures/lang/clones/expected/lib.ts +++ b/ts/fixtures/lang/clones/expected/lib.ts @@ -116,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.Runs>, rs.Runs>]): 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 bcdbe56f2..08d35d55a 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -3735,7 +3735,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.Runs = rs.runsFrom(pairs.items, rs.byteSliceFrom); + 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 => { @@ -4712,12 +4712,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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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); @@ -4727,13 +4727,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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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 3e069719e..7dbb8f04e 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -519,73 +519,73 @@ 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.Runs, value: Uint8Array): Uint8Array { +export function writeFirst$array0_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); const old: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); const _10: Uint8Array = value; rs.idx(s, 0); - const slice = rs.runsAt(s, 0); + 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.Runs, value: Uint8Array): Uint8Array { +export function writeFirst$array1_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const slice = rs.runsAt(s, 0); + 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); - const slice2 = rs.runsAt(s, 0); + 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.Runs>, 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 _8: rs.u32[] = copy$array_u32(value.slice()); - const old: rs.u32[] = rs.replaceIn(rs.sliceView(rs.runsAt(s, 0)), _8); + const old: rs.u32[] = rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), _8); const _10: rs.u32[] = value; rs.idx(s, 0); - rs.sliceSet(rs.runsAt(s, 0), _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.Runs, value: Uint8Array): Uint8Array { +export function writeFirst$array3_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const slice = rs.runsAt(s, 0); + 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); - const slice2 = rs.runsAt(s, 0); + 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.Runs, value: Uint8Array): Uint8Array { +export function writeFirst$array40_u8(s: rs.ArraySlice, value: Uint8Array): Uint8Array { value = copy$array_u8(value); rs.idx(s, 0); const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); - const slice = rs.runsAt(s, 0); + 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); - const slice2 = rs.runsAt(s, 0); + const slice2 = rs.arraySliceAt(s, 0); slice2.data.set(_10, slice2.start); return old; } @@ -640,81 +640,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.Runs>, value: Array): Array { +export function replaceFirst$Option_u16(s: rs.ArraySlice>, value: Array): Array { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.runsAt(s, 0)), 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.Runs>, value: string[]): string[] { +export function replaceFirst$String(s: rs.ArraySlice>, value: string[]): string[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.runsAt(s, 0)), value); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), value); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$Vec_u32(s: rs.Runs>>, 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.runsAt(s, 0)), 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.Runs>, 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.runsAt(s, 0)), 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.Runs>, value: Uint8Array[]): Uint8Array[] { +export function replaceFirst$array0_u8(s: rs.ArraySlice>, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); 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.Runs>, value: Uint8Array[]): Uint8Array[] { +export function replaceFirst$array1_u8(s: rs.ArraySlice>, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.runsReplace(rs.runsAt(s, 0), copy$array_array1_u8(value)); + 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.Runs>>, value: rs.u32[][]): rs.u32[][] { +export function replaceFirst$array2_u32(s: rs.ArraySlice>>, value: rs.u32[][]): rs.u32[][] { rs.idx(s, 0); - return rs.runsReplace(rs.runsAt(s, 0), copy$array_array2_u32(value)); + 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.Runs>, value: Uint8Array[]): Uint8Array[] { +export function replaceFirst$array3_u8(s: rs.ArraySlice>, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.runsReplace(rs.runsAt(s, 0), copy$array_array3_u8(value)); + 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.Runs>, value: Uint8Array[]): Uint8Array[] { +export function replaceFirst$array40_u8(s: rs.ArraySlice>, value: Uint8Array[]): Uint8Array[] { rs.idx(s, 0); - return rs.runsReplace(rs.runsAt(s, 0), copy$array_array40_u8(value)); + 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.Runs>, 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.runsAt(s, 0)), 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.Runs>, 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.runsAt(s, 0)), 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.Runs>, 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.runsAt(s, 0)), 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.Runs>, 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.runsAt(s, 0)), copy$array_u64(value)); + return rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), copy$array_u64(value)); } /** @@ -779,11 +779,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.runsOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [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.cellOfRuns(rs.runsOne(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); @@ -852,11 +852,11 @@ export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.idx(s, 0); const borrowed8 = s.data; const borrowed9 = s.start; - put$conversions_Value_String(replaceFirst$String(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [make$conversions_Value_String(data, 27)])[0], out); + put$conversions_Value_String(replaceFirst$String(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [make$conversions_Value_String(data, 27)])[0], out); rs.idx(s, 0); const borrowed10 = s.data; const borrowed11 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1)), [[make$conversions_Value_String(data, 28)]])[0][0], out); + put$conversions_Value_String(rs.cellReplace(rs.cellOfArraySlice(rs.arraySliceOne(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8)), 1)), [[make$conversions_Value_String(data, 28)]])[0][0], out); rs.idx(s, 0); s.data[s.start] = other; rs.idx(s, 0); @@ -914,11 +914,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.runsOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), rs.objectCopy), [[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); @@ -976,11 +976,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.runsOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), rs.objectCopy), [[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); @@ -994,7 +994,7 @@ 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.Runs = rs.runsOne(to, 0); + 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); @@ -1003,22 +1003,22 @@ export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: r rs.byteSliceFrom(other); rs.idx(s, 0); put$conversions_Value_array0_u8(rs.byteSliceFrom(other), out); - const t: rs.Runs = rs.runsFrom(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); + 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.idx(t, 1); rs.idx(t, 0); rs.idx(s, 0); rs.idx(t, 0); - put$conversions_Value_array0_u8(rs.runsAt(t, 0), out); + put$conversions_Value_array0_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array0_u8(rs.runsAt(t, 1), out); + put$conversions_Value_array0_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - rs.runsOne(rs.runsAt(s, 0), 0); + 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.runsAt(s, 0); + 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); @@ -1026,21 +1026,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.runsAt(s, 0), 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.runsAt(s, 0))), 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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 0)), [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.runsOne(rs.runsOne(rs.runsAt(s, 0), 0), 1), [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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 0), 1)), [[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 _159: rs.ByteSlice = rs.byteSliceFrom(other); - const slice = rs.runsAt(s, 0); + const slice = rs.arraySliceAt(s, 0); slice.data.set(rs.byteSliceToArray(_159), slice.start); rs.idx(s, 0); - put$conversions_Value_array0_u8(rs.runsAt(s, 0), out); + put$conversions_Value_array0_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1050,49 +1050,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.Runs = rs.runsOne(to, 1); + 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 _16: rs.ByteSlice = rs.byteSliceFrom(other); - const slice = rs.runsAt(s, 0); + 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 slice2 = rs.runsAt(s, 0); + const slice2 = rs.arraySliceAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); _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.Runs = rs.runsFrom(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); + 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); rs.idx(t, 1); - const slice3 = rs.runsAt(s, 0); - const slice4 = rs.runsAt(t, 1); + 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); rs.idx(s, 0); - const slice5 = rs.runsAt(t, 0); - const slice6 = rs.runsAt(s, 0); + 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.runsAt(t, 0), out); + put$conversions_Value_array1_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array1_u8(rs.runsAt(t, 1), out); + put$conversions_Value_array1_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Runs = rs.runsOne(rs.runsAt(s, 0), 1); + 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.runsReplace(a, _77)[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.runsAt(s, 0); + 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); @@ -1100,21 +1100,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.runsAt(s, 0), 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.runsAt(s, 0))), 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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 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.runsOne(rs.runsOne(rs.runsAt(s, 0), 1), 1), [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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 1), 1)), [[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 _159: rs.ByteSlice = rs.byteSliceFrom(other); - const slice7 = rs.runsAt(s, 0); + const slice7 = rs.arraySliceAt(s, 0); slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); - put$conversions_Value_array1_u8(rs.runsAt(s, 0), out); + put$conversions_Value_array1_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1124,40 +1124,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.Runs> = rs.runsOne(to, 2); + 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 _16: rs.Slice = rs.sliceFrom(other); - rs.sliceSet(_16, rs.replaceIn(rs.sliceView(rs.runsAt(s, 0)), 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 slice2 = rs.runsAt(s, 0); + 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.Runs> = rs.runsFrom(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); + 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); rs.idx(t, 1); - const slice3 = rs.runsAt(s, 0); - const slice4 = rs.runsAt(t, 1); + 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); rs.idx(s, 0); - const slice5 = rs.runsAt(t, 0); - const slice6 = rs.runsAt(s, 0); + 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.runsAt(t, 0), out); + put$conversions_Value_array2_u32(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array2_u32(rs.runsAt(t, 1), out); + put$conversions_Value_array2_u32(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Runs> = rs.runsOne(rs.runsAt(s, 0), 2); + 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.runsReplace(a, _77)[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.runsAt(s, 0); + 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); @@ -1165,20 +1165,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.runsAt(s, 0), 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.runsAt(s, 0))), 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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 2)), [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.runsOne(rs.runsOne(rs.runsAt(s, 0), 2), 1), [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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 2), 1)), [[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 _159: rs.Slice = rs.sliceFrom(other); - rs.replaceIn(rs.sliceView(rs.runsAt(s, 0)), rs.sliceToArray(_159)); + rs.replaceIn(rs.sliceView(rs.arraySliceAt(s, 0)), rs.sliceToArray(_159)); rs.idx(s, 0); - put$conversions_Value_array2_u32(rs.runsAt(s, 0), out); + put$conversions_Value_array2_u32(rs.arraySliceAt(s, 0), out); } /** @@ -1188,49 +1188,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.Runs = rs.runsOne(to, 3); + 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 _16: rs.ByteSlice = rs.byteSliceFrom(other); - const slice = rs.runsAt(s, 0); + 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 slice2 = rs.runsAt(s, 0); + const slice2 = rs.arraySliceAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); _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.Runs = rs.runsFrom(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); + 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); rs.idx(t, 1); - const slice3 = rs.runsAt(s, 0); - const slice4 = rs.runsAt(t, 1); + 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); rs.idx(s, 0); - const slice5 = rs.runsAt(t, 0); - const slice6 = rs.runsAt(s, 0); + 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.runsAt(t, 0), out); + put$conversions_Value_array3_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array3_u8(rs.runsAt(t, 1), out); + put$conversions_Value_array3_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Runs = rs.runsOne(rs.runsAt(s, 0), 3); + 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.runsReplace(a, _77)[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.runsAt(s, 0); + 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); @@ -1238,21 +1238,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.runsAt(s, 0), 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.runsAt(s, 0))), 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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 3)), [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.runsOne(rs.runsOne(rs.runsAt(s, 0), 3), 1), [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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 3), 1)), [[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 _159: rs.ByteSlice = rs.byteSliceFrom(other); - const slice7 = rs.runsAt(s, 0); + const slice7 = rs.arraySliceAt(s, 0); slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); - put$conversions_Value_array3_u8(rs.runsAt(s, 0), out); + put$conversions_Value_array3_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1262,49 +1262,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.Runs = rs.runsOne(to, 40); + 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 _16: rs.ByteSlice = rs.byteSliceFrom(other); - const slice = rs.runsAt(s, 0); + 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 slice2 = rs.runsAt(s, 0); + const slice2 = rs.arraySliceAt(s, 0); const swapped2 = rs.byteSliceToArray(_20); _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.Runs = rs.runsFrom(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); + 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); rs.idx(t, 1); - const slice3 = rs.runsAt(s, 0); - const slice4 = rs.runsAt(t, 1); + 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); rs.idx(s, 0); - const slice5 = rs.runsAt(t, 0); - const slice6 = rs.runsAt(s, 0); + 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.runsAt(t, 0), out); + put$conversions_Value_array40_u8(rs.arraySliceAt(t, 0), out); rs.idx(t, 1); - put$conversions_Value_array40_u8(rs.runsAt(t, 1), out); + put$conversions_Value_array40_u8(rs.arraySliceAt(t, 1), out); rs.idx(s, 0); - const a: rs.Runs = rs.runsOne(rs.runsAt(s, 0), 40); + 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.runsReplace(a, _77)[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.runsAt(s, 0); + 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); @@ -1312,21 +1312,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.runsAt(s, 0), 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.runsAt(s, 0))), 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.cellOfRuns(rs.runsOne(rs.runsAt(s, 0), 40)), [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.runsOne(rs.runsOne(rs.runsAt(s, 0), 40), 1), [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.cellOfRuns(rs.runsOne(rs.runsOne(rs.runsAt(s, 0), 40), 1)), [[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 _159: rs.ByteSlice = rs.byteSliceFrom(other); - const slice7 = rs.runsAt(s, 0); + const slice7 = rs.arraySliceAt(s, 0); slice7.data.set(rs.byteSliceToArray(_159), slice7.start); rs.idx(s, 0); - put$conversions_Value_array40_u8(rs.runsAt(s, 0), out); + put$conversions_Value_array40_u8(rs.arraySliceAt(s, 0), out); } /** @@ -1391,12 +1391,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.runsOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), copy$conversions_Logged), [[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](); @@ -1461,11 +1461,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.runsOne(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)), 1), [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.cellOfRuns(rs.runsOne(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5)), 1), copy$conversions_Named), [[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); @@ -1534,11 +1534,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.runsOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [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.cellOfRuns(rs.runsOne(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); @@ -1607,11 +1607,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.runsOne(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)), 1), [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.cellOfRuns(rs.runsOne(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); @@ -2394,10 +2394,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsAt(one, 0)); - put$conversions_Value_array0_u8(rs.runsAt(one, 0), 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); @@ -2413,20 +2413,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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(array, rs.byteSliceFrom).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.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - const slice = rs.runsAt(_116, 0); + const slice = rs.arraySliceAt(_116, 0); slice.data.set(_114, slice.start); - const _124: rs.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - const slice2 = rs.runsAt(_124, 2); + const slice2 = rs.arraySliceAt(_124, 2); slice2.data.set(rs.byteSliceToArray(_130), slice2.start); - const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); + 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) { @@ -2436,27 +2436,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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(list.items, rs.byteSliceFrom).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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice3 = rs.runsAt(_165, 0); + const slice3 = rs.arraySliceAt(_165, 0); slice3.data.set(_163, slice3.start); - const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice4 = rs.runsAt(_173, 1); + const slice4 = rs.arraySliceAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); + 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.runsIter(rs.runsFrom(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) { @@ -2504,10 +2504,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsAt(one, 0)); - put$conversions_Value_array1_u8(rs.runsAt(one, 0), 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); @@ -2523,20 +2523,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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(array, rs.byteSliceFrom).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.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - const slice = rs.runsAt(_116, 0); + const slice = rs.arraySliceAt(_116, 0); slice.data.set(_114, slice.start); - const _124: rs.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - const slice2 = rs.runsAt(_124, 2); + const slice2 = rs.arraySliceAt(_124, 2); slice2.data.set(rs.byteSliceToArray(_130), slice2.start); - const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); + 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) { @@ -2546,27 +2546,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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(list.items, rs.byteSliceFrom).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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice3 = rs.runsAt(_165, 0); + const slice3 = rs.arraySliceAt(_165, 0); slice3.data.set(_163, slice3.start); - const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice4 = rs.runsAt(_173, 1); + const slice4 = rs.arraySliceAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); + 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.runsIter(rs.runsFrom(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) { @@ -2613,10 +2613,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.Runs> = rs.runsFrom([b], rs.sliceFrom); + const one: rs.ArraySlice> = rs.arraySliceFrom([b], rs.sliceFrom); rs.byteVecPush(out, one.length & 0xff); - const copied: rs.u32[] = rs.sliceToArray(rs.runsAt(one, 0)); - put$conversions_Value_array2_u32(rs.runsAt(one, 0), 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)); @@ -2632,18 +2632,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.runsFrom(array, rs.sliceFrom).length, rs.runsFrom(array, rs.sliceFrom).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.Runs> = rs.runsFrom(array, rs.sliceFrom); + const _116: rs.ArraySlice> = rs.arraySliceFrom(array, rs.sliceFrom); rs.idx(_116, 0); - rs.sliceSet(rs.runsAt(_116, 0), _114); - const _124: rs.Runs> = rs.runsFrom(array, rs.sliceFrom); + rs.sliceSet(rs.arraySliceAt(_116, 0), _114); + const _124: rs.ArraySlice> = rs.arraySliceFrom(array, rs.sliceFrom); rs.idx(_124, 2); const _130: rs.Slice = rs.sliceFrom(c); - rs.replaceIn(rs.sliceView(rs.runsAt(_124, 2)), rs.sliceToArray(_130)); - const iter: rs.Iter> = rs.runsIter(rs.runsFrom(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) { @@ -2653,25 +2653,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.runsFrom(list.items, rs.sliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.sliceFrom).length, rs.runsFrom(none.items, rs.sliceFrom).length, rs.runsFrom(list.items, rs.sliceFrom).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.Runs> = rs.runsFrom(list.items, rs.sliceFrom); + const _165: rs.ArraySlice> = rs.arraySliceFrom(list.items, rs.sliceFrom); rs.idx(_165, 0); - rs.sliceSet(rs.runsAt(_165, 0), _163); - const _173: rs.Runs> = rs.runsFrom(list.items, rs.sliceFrom); + rs.sliceSet(rs.arraySliceAt(_165, 0), _163); + const _173: rs.ArraySlice> = rs.arraySliceFrom(list.items, rs.sliceFrom); rs.idx(_173, 1); const _179: rs.Slice = rs.sliceFrom(c); - rs.replaceIn(rs.sliceView(rs.runsAt(_173, 1)), rs.sliceToArray(_179)); - rs.runsSwap(rs.runsFrom(list.items, rs.sliceFrom), 0, 1, undefined); + 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.runsIter(rs.runsFrom(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) { @@ -2718,10 +2718,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsAt(one, 0)); - put$conversions_Value_array3_u8(rs.runsAt(one, 0), 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); @@ -2737,20 +2737,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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(array, rs.byteSliceFrom).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.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - const slice = rs.runsAt(_116, 0); + const slice = rs.arraySliceAt(_116, 0); slice.data.set(_114, slice.start); - const _124: rs.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - const slice2 = rs.runsAt(_124, 2); + const slice2 = rs.arraySliceAt(_124, 2); slice2.data.set(rs.byteSliceToArray(_130), slice2.start); - const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); + 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) { @@ -2760,27 +2760,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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(list.items, rs.byteSliceFrom).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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice3 = rs.runsAt(_165, 0); + const slice3 = rs.arraySliceAt(_165, 0); slice3.data.set(_163, slice3.start); - const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice4 = rs.runsAt(_173, 1); + const slice4 = rs.arraySliceAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); + 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.runsIter(rs.runsFrom(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) { @@ -2829,10 +2829,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.Runs = rs.runsFrom([rs.byteSliceView(rs.byteSliceFrom(b))], rs.byteSliceFrom); + 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.runsAt(one, 0)); - put$conversions_Value_array40_u8(rs.runsAt(one, 0), 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); @@ -2848,20 +2848,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.runsFrom(array, rs.byteSliceFrom).length, rs.runsFrom(array, rs.byteSliceFrom).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.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _116: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_116, 0); - const slice = rs.runsAt(_116, 0); + const slice = rs.arraySliceAt(_116, 0); slice.data.set(_114, slice.start); - const _124: rs.Runs = rs.runsFrom(array, rs.byteSliceFrom); + const _124: rs.ArraySlice = rs.arraySliceFrom(array, rs.byteSliceFrom); rs.idx(_124, 2); const _130: rs.ByteSlice = rs.byteSliceFrom(c); - const slice2 = rs.runsAt(_124, 2); + const slice2 = rs.arraySliceAt(_124, 2); slice2.data.set(rs.byteSliceToArray(_130), slice2.start); - const iter: rs.Iter = rs.runsIter(rs.runsFrom(array, rs.byteSliceFrom)); + 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) { @@ -2871,27 +2871,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.runsFrom(list.items, rs.byteSliceFrom).length, list.items.length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(none.items, rs.byteSliceFrom).length, rs.runsFrom(list.items, rs.byteSliceFrom).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.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _165: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_165, 0); - const slice3 = rs.runsAt(_165, 0); + const slice3 = rs.arraySliceAt(_165, 0); slice3.data.set(_163, slice3.start); - const _173: rs.Runs = rs.runsFrom(list.items, rs.byteSliceFrom); + const _173: rs.ArraySlice = rs.arraySliceFrom(list.items, rs.byteSliceFrom); rs.idx(_173, 1); const _179: rs.ByteSlice = rs.byteSliceFrom(c); - const slice4 = rs.runsAt(_173, 1); + const slice4 = rs.arraySliceAt(_173, 1); slice4.data.set(rs.byteSliceToArray(_179), slice4.start); - rs.runsSwap(rs.runsFrom(list.items, rs.byteSliceFrom), 0, 1, undefined); + 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.runsIter(rs.runsFrom(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) { @@ -3660,15 +3660,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.Runs = rs.runsFrom(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, rs.byteSliceFrom); - let into: rs.Runs = rs.runsFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + 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, rs.byteSliceFrom); - into = rs.runsBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.runsIter(into), rs.runsIter(whole)); + 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) { @@ -3712,15 +3712,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.Runs = rs.runsFrom(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, rs.byteSliceFrom); - let into: rs.Runs = rs.runsFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + 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, rs.byteSliceFrom); - into = rs.runsBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.runsIter(into), rs.runsIter(whole)); + 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) { @@ -3764,15 +3764,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.Runs> = rs.runsFrom(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, rs.sliceFrom); - let into: rs.Runs> = rs.runsFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u32[] => { + 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, rs.sliceFrom); - into = rs.runsBoxCloneFrom(into, whole, rs.sliceFrom, copy$array_u32); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.sliceFrom, copy$array_u32); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter> = rs.iterChain(rs.runsIter(into), rs.runsIter(whole)); + 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) { @@ -3816,15 +3816,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.Runs = rs.runsFrom(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, rs.byteSliceFrom); - let into: rs.Runs = rs.runsFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + 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, rs.byteSliceFrom); - into = rs.runsBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.runsIter(into), rs.runsIter(whole)); + 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) { @@ -3868,15 +3868,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.Runs = rs.runsFrom(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, rs.byteSliceFrom); - let into: rs.Runs = rs.runsFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + 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, rs.byteSliceFrom); - into = rs.runsBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); + into = rs.arraySliceBoxCloneFrom(into, whole, rs.byteSliceFrom, copy$array_u8); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.runsIter(into), rs.runsIter(whole)); + 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) { @@ -4351,19 +4351,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.Runs = rs.runsOne(rs.byteSliceFrom(a), 0); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 0); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); 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.runsOne(rs.byteSliceFrom(held.value), 0), 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.runsOne(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(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); - const _53: rs.Runs = rs.runsOne(rs.byteSliceFrom(c), 0); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 0); const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); - const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 0)); + 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) { @@ -4386,23 +4386,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.Runs = rs.runsOne(rs.byteSliceFrom(a), 1); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 1); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 5)); - const slice = rs.runsAt(s, 0); + 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.runsOne(rs.byteSliceFrom(held.value), 1), 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.runsOne(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(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); - const _53: rs.Runs = rs.runsOne(rs.byteSliceFrom(c), 1); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 1); const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); - const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 1)); + 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) { @@ -4425,20 +4425,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.Runs> = rs.runsOne(rs.sliceFrom(a), 2); + const s: rs.ArraySlice> = rs.arraySliceOne(rs.sliceFrom(a), 2); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); 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(rs.runsAt(s, 0)), _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.runsOne(rs.sliceFrom(held.value), 2), 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.runsOne(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(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); - const _53: rs.Runs> = rs.runsOne(rs.sliceFrom(c), 2); + const _53: rs.ArraySlice> = rs.arraySliceOne(rs.sliceFrom(c), 2); const _55: rs.u32[] = copy$array_u32(b.slice()); - rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u32)); - const iter: rs.Iter> = rs.runsIter(rs.runsOne(rs.sliceFrom(a), 2)); + 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) { @@ -4461,23 +4461,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.Runs = rs.runsOne(rs.byteSliceFrom(a), 3); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 3); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 5)); - const slice = rs.runsAt(s, 0); + 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.runsOne(rs.byteSliceFrom(held.value), 3), 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.runsOne(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(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); - const _53: rs.Runs = rs.runsOne(rs.byteSliceFrom(c), 3); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 3); const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); - const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 3)); + 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) { @@ -4500,23 +4500,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.Runs = rs.runsOne(rs.byteSliceFrom(a), 40); + const s: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(a), 40); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 5)); - const slice = rs.runsAt(s, 0); + 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.runsOne(rs.byteSliceFrom(held.value), 40), 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.runsOne(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(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); - const _53: rs.Runs = rs.runsOne(rs.byteSliceFrom(c), 40); + const _53: rs.ArraySlice = rs.arraySliceOne(rs.byteSliceFrom(c), 40); const _55: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); - rs.runsBy(_53, (runs) => rs.sliceFill(runs, _55, copy$array_u8)); - const iter: rs.Iter = rs.runsIter(rs.runsOne(rs.byteSliceFrom(a), 40)); + 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) { @@ -4930,8 +4930,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 0, true)); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -4939,7 +4939,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.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 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; @@ -4960,11 +4960,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(rs.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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(rs.runsItems(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) { @@ -4993,8 +4993,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 1, true)); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -5002,7 +5002,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.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 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; @@ -5023,11 +5023,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(rs.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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(rs.runsItems(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 +5056,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.runsBy(rs.runsFrom(v.items, rs.sliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpSlice(rs.cmp)), 8, true)); - const tagged: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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 +5065,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.Runs> = rs.runsRange(rs.runsFrom(v.items, rs.sliceFrom), 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; @@ -5086,11 +5086,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(rs.runsItems(s), rs.sliceItems(_56), rs.cmpSlice(rs.cmp)), rs.sliceBinarySearchBy(rs.runsItems(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(rs.runsItems(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) { @@ -5119,8 +5119,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 3, true)); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -5128,7 +5128,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.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 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; @@ -5149,11 +5149,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(rs.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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(rs.runsItems(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) { @@ -5182,8 +5182,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.runsBy(rs.runsFrom(v.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 40, true)); - const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.runsIter(rs.runsFrom(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(); @@ -5191,7 +5191,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.Runs = rs.runsRange(rs.runsFrom(v.items, rs.byteSliceFrom), 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; @@ -5212,11 +5212,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(rs.runsItems(s), rs.byteSliceView(_56), rs.cmpBytes), rs.sliceBinarySearchBy(rs.runsItems(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(rs.runsItems(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) { @@ -5771,14 +5771,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.runsFrom(array, rs.byteSliceFrom), out); - readAs$array3_u8_ref_ref_slice_array3_u8(rs.runsRange(rs.runsFrom(array, rs.byteSliceFrom), 1), out); - readAs$array3_u8_ref_array3_array3_u8(rs.runsFrom(array, rs.byteSliceFrom), 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.runsFrom(array, rs.byteSliceFrom), make$conversions_Value_array3_u8(data, 18)); - writeAs$array3_u8_mut_array3_array3_u8(rs.runsFrom(array, rs.byteSliceFrom), 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; @@ -5805,8 +5805,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.runsFrom(array, rs.byteSliceFrom), rs.runsFrom(list.items, rs.byteSliceFrom), out).length & 0xff); - const iter: rs.Iter = rs.iterChain(rs.runsIter(rs.runsFrom(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) { @@ -6301,9 +6301,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.Runs = rs.runsFrom(b.items, rs.byteSliceFrom); + const s: rs.ArraySlice = rs.arraySliceFrom(b.items, rs.byteSliceFrom); rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.runsIter(s); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6315,9 +6315,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.Runs = rs.runsFrom(b.items, rs.byteSliceFrom); + const s: rs.ArraySlice = rs.arraySliceFrom(b.items, rs.byteSliceFrom); rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.runsIter(s); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6328,10 +6328,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.Runs, out: rs.ByteVec): void { - const s: rs.Runs = 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.runsIter(s); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6343,9 +6343,9 @@ export function readAs$array3_u8_ref_array3_array3_u8(b: rs.Runs, /** 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.Runs = rs.runsFrom(b.items, rs.byteSliceFrom); + const s: rs.ArraySlice = rs.arraySliceFrom(b.items, rs.byteSliceFrom); rs.byteVecPush(out, s.length & 0xff); - const iter: rs.Iter = rs.runsIter(s); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6356,10 +6356,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.Runs, out: rs.ByteVec): void { - const s: rs.Runs = 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.runsIter(s); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6370,10 +6370,10 @@ export function readAs$array3_u8_ref_ref_slice_array3_u8(b: rs.Runs, out: rs.ByteVec): void { - const s: rs.Runs = 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.runsIter(s); + const iter: rs.Iter = rs.arraySliceIter(s); while (true) { const _10: rs.ByteSlice | rs.Done = iter.next(); if (_10 === rs.DONE) { @@ -6752,16 +6752,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.runsLast(rs.runsFrom(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.Runs, 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.runsLast(b); + const _3: rs.ByteSlice | undefined = rs.arraySliceLast(b); if (_3 !== undefined) { _3.data.set(value, _3.start); } @@ -6770,16 +6770,16 @@ export function writeAs$array3_u8_mut_array3_array3_u8(b: rs.Runs, /** 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.runsLast(rs.runsFrom(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.Runs, 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.runsLast(b); + const _3: rs.ByteSlice | undefined = rs.arraySliceLast(b); if (_3 !== undefined) { _3.data.set(value, _3.start); } @@ -7691,7 +7691,7 @@ export function compared$ref_slice_Vec_u8(a: rs.Slice, b: rs.Slice, b: rs.Runs, out: rs.ByteVec): rs.Runs { +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 2b993b97c..a0deaf9b2 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.runsFrom(grid, rs.sliceFrom), rs.byteSliceFrom(bytes)] as [rs.Slice, rs.Runs>, 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.runsFrom(grid, rs.sliceFrom); - const _38: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.runsArray(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/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 24784ef7e..bd28a28cf 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -1102,7 +1102,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.runsIter(rs.runsFrom(pairs.items, rs.sliceFrom)), rs.runsIter(rs.runsFrom(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) { @@ -1124,7 +1124,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void _325[1] = rs.u16Add(_325[1], 10); } rs.vecAppend(pairs, moved, 4); - const iter6: rs.Iter = rs.iterFlatten(rs.runsIter(rs.runsFrom(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) { @@ -1148,7 +1148,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.runsIter(rs.runsFrom(keys.items, rs.byteSliceFrom)), rs.runsIter(rs.runsFrom(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) { @@ -1161,7 +1161,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.runsIter(rs.runsFrom(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); @@ -1368,7 +1368,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.runsIter(rs.runsFrom(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) { @@ -1718,7 +1718,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]])))), 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.runsIter(rs.runsFrom(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) { @@ -1731,7 +1731,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.runsIter(rs.runsFrom(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 9f7d73c32..26c1e478b 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -1950,7 +1950,7 @@ 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.runsIter(rs.runsFrom(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); diff --git a/ts/fixtures/lang/holds/expected/holds.ts b/ts/fixtures/lang/holds/expected/holds.ts index 894c9a0ee..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.runsIter(rs.runsFrom(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 062e4eb68..e18c45481 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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.runsIter(rs.runsFrom(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) { @@ -1002,7 +1002,7 @@ 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.runsIter(rs.runsFrom(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)); diff --git a/ts/fixtures/lang/joins/expected/joins.ts b/ts/fixtures/lang/joins/expected/joins.ts index 41719d1bd..9d26345be 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.runsItems(rs.runsFrom([hashA, hashB], rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([hashA, hashB], rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([hashA, hashB], rs.byteSliceFrom)), 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.runsItems(rs.runsFrom(quads.items, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(quads.items, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(quads.items, rs.byteSliceFrom)), 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.runsItems(rs.runsFrom(zeros.items, rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(zeros.items, rs.byteSliceFrom)), rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom(zeros.items, rs.byteSliceFrom)), seps, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([], rs.byteSliceFrom)), undefined, rs.byteSliceFrom), out); - bytes(rs.byteSlicesJoin(rs.runsItems(rs.runsFrom([], rs.byteSliceFrom)), 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,16 +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.runsItems(rs.runsFrom(pairs.items, rs.sliceFrom)), 2, undefined, rs.sliceFrom), out); - wides(rs.slicesJoin(rs.runsItems(rs.runsFrom(pairs.items, rs.sliceFrom)), 2, rs.sliceFrom([sep2]), rs.sliceFrom), out); - const _231: rs.Runs> = rs.runsFrom(pairs.items, rs.sliceFrom); + 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.runsItems(_231), 2, _233, rs.sliceFrom), out); + 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.runsItems(rs.runsFrom(zeros2.items, rs.sliceFrom)), 2, undefined, rs.sliceFrom), out); - wides(rs.slicesJoin(rs.runsItems(rs.runsFrom(zeros2.items, rs.sliceFrom)), 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); @@ -176,11 +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.runsItems(rs.runsFrom(pairs2, rs.sliceFrom)), 8, undefined, rs.sliceFrom, Logged.clone$Clone), log.value, out); - ids(rs.slicesJoin(rs.runsItems(rs.runsFrom(pairs2, rs.sliceFrom)), 8, rs.sliceFrom([sep3]), rs.sliceFrom, Logged.clone$Clone), log.value, out); - const _383: rs.Runs> = rs.runsFrom(pairs2, rs.sliceFrom); + 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.runsItems(_383), 8, _385, rs.sliceFrom, Logged.clone$Clone), log.value, out); + 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 e6413f0fc..632a80521 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -929,7 +929,7 @@ 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.runsIter(rs.runsFrom(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); @@ -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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(members.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, 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.runsBy(rs.runsFrom(values.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, 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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(members.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 0, true)); - rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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,7 +4266,7 @@ 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.runsIter(rs.runsFrom(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.runsIter(rs.runsFrom(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; }); @@ -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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsFirst(rs.runsFrom(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.runsBy(rs.runsFrom(values.items, rs.byteSliceFrom), (runs2) => rs.sliceSort(runs2, rs.cmpLt(rs.cmpBytes), 0, true)); - rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(members.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 2, true)); - rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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,7 +4567,7 @@ 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.runsIter(rs.runsFrom(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.runsIter(rs.runsFrom(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; }); @@ -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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsFirst(rs.runsFrom(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.runsBy(rs.runsFrom(values.items, rs.byteSliceFrom), (runs2) => rs.sliceSort(runs2, rs.cmpLt(rs.cmpBytes), 2, true)); - rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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 0720e8f1b..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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); - recloned$u32_0(rs.runsFrom(wide.items, rs.sliceFrom), 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.runsFrom(rows.items, rs.byteSliceFrom), out); - swapped$u32_0(data, rs.runsFrom(wide.items, rs.sliceFrom), 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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); - recloned$u32_1(rs.runsFrom(wide.items, rs.sliceFrom), 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.runsFrom(rows.items, rs.byteSliceFrom), out); - swapped$u32_1(data, rs.runsFrom(wide.items, rs.sliceFrom), 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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); - recloned$u32_17(rs.runsFrom(wide.items, rs.sliceFrom), 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.runsFrom(rows.items, rs.byteSliceFrom), out); - swapped$u32_17(data, rs.runsFrom(wide.items, rs.sliceFrom), 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.runsIter(rs.runsFrom(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.runsFrom(rows.items, rs.byteSliceFrom), out); - recloned$u32_3(rs.runsFrom(wide.items, rs.sliceFrom), 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.runsFrom(rows.items, rs.byteSliceFrom), out); - swapped$u32_3(data, rs.runsFrom(wide.items, rs.sliceFrom), 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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.Runs, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.Runs, 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.Runs, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.Runs, 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.Runs, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.Runs, 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.Runs, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.Runs, out: rs.ByteVec): void { } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_0(rows: rs.Runs>, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.Runs>, out: rs.ByteVec) } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_1(rows: rs.Runs>, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.Runs>, out: rs.ByteVec) } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_17(rows: rs.Runs>, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.Runs>, out: rs.ByteVec } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_3(rows: rs.Runs>, out: rs.ByteVec): void { - const iter: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(rows)); +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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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,9 +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]; - const _108: rs.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + 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.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _110)); + 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); @@ -524,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.runsIter(rs.runsFrom(_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); @@ -558,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.runsIter(rs.runsFrom(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) { @@ -596,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.runsIter(rs.runsFrom(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) { @@ -615,9 +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]; - const _108: rs.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + 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.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _110)); + 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); @@ -625,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.runsIter(rs.runsFrom(_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); @@ -659,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.runsIter(rs.runsFrom(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) { @@ -697,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.runsIter(rs.runsFrom(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) { @@ -716,9 +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]; - const _108: rs.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + 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.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _110)); + 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); @@ -726,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.runsIter(rs.runsFrom(_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); @@ -760,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.runsIter(rs.runsFrom(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) { @@ -798,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.runsIter(rs.runsFrom(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) { @@ -817,9 +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]; - const _108: rs.Runs = rs.runsFrom(slot[0], rs.byteSliceFrom); + 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.runsBy(_108, (runs) => rs.sliceRotateLeft(runs, _110)); + 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); @@ -827,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.runsIter(rs.runsFrom(_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); @@ -1954,15 +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.Runs>, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + 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); @@ -1987,13 +1987,13 @@ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Runs 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.runsAt(rows, _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.runsIter(rs.runsFrom(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); } @@ -2005,15 +2005,15 @@ export function swapped$u32_0(data: rs.ByteSlice, rows: rs.Runs * 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.Runs>, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + 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); @@ -2038,13 +2038,13 @@ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Runs 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.runsAt(rows, _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.runsIter(rs.runsFrom(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); } @@ -2056,15 +2056,15 @@ export function swapped$u32_1(data: rs.ByteSlice, rows: rs.Runs * 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.Runs>, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + 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); @@ -2089,13 +2089,13 @@ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Runs | 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.runsAt(rows, _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.runsIter(rs.runsFrom(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); } @@ -2107,15 +2107,15 @@ export function swapped$u32_17(data: rs.ByteSlice, rows: rs.Runs>, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Runs>] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + 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.Runs 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.runsAt(rows, _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.runsIter(rs.runsFrom(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,15 +2158,15 @@ export function swapped$u32_3(data: rs.ByteSlice, rows: rs.Runs * 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.Runs, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2191,13 +2191,13 @@ export function swapped$u8_0(data: rs.ByteSlice, rows: rs.Runs, 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.runsAt(rows, _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.runsIter(rs.runsFrom(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); } @@ -2209,15 +2209,15 @@ export function swapped$u8_0(data: rs.ByteSlice, rows: rs.Runs, 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_1(data: rs.ByteSlice, rows: rs.Runs, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2242,13 +2242,13 @@ export function swapped$u8_1(data: rs.ByteSlice, rows: rs.Runs, 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.runsAt(rows, _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.runsIter(rs.runsFrom(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); } @@ -2260,15 +2260,15 @@ export function swapped$u8_1(data: rs.ByteSlice, rows: rs.Runs, 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_17(data: rs.ByteSlice, rows: rs.Runs, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2293,13 +2293,13 @@ export function swapped$u8_17(data: rs.ByteSlice, rows: rs.Runs, o 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.runsAt(rows, _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.runsIter(rs.runsFrom(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); } @@ -2311,15 +2311,15 @@ export function swapped$u8_17(data: rs.ByteSlice, rows: rs.Runs, o * 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.Runs, out: rs.ByteVec): void { - const _6: [rs.ByteSlice, rs.Runs] | undefined = rs.runsSplitFirst(rows); +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.runsFirst(_6[1]); + const _9: rs.ByteSlice | undefined = rs.arraySliceFirst(_6[1]); if (_9 !== undefined) { const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); @@ -2344,13 +2344,13 @@ export function swapped$u8_3(data: rs.ByteSlice, rows: rs.Runs, 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.runsAt(rows, _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.runsIter(rs.runsFrom(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 38511b8cc..e3b1a7cce 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -519,13 +519,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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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.runsIter(rs.runsFrom(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) { @@ -534,15 +534,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.runsIter(rs.runsFrom(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.runsBy(rs.runsFrom(arrays.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 2, true)); - rs.iterExtendBytes(out, rs.iterFlatten(rs.runsIter(rs.runsFrom(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/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index ca87f1724..47f3383dd 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.runsToArray(rs.runsFrom(nested, rs.sliceFrom), rs.sliceToArray)); + 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)); }), ["", "x"]]); const first: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 0)]); - const last: rs.Slice = rs.optionUnwrap(rs.runsLast(rs.runsFrom(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)]); _20.data[_20.start] = _20.data[_20.start] + "y"; const _24: rs.u8 = rs.sliceSame(first, rs.sliceFrom(v.items[rs.idx(v.items, 0)])) ? 1 : 0; @@ -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.runsFirst(rs.sliceAsChunks(rs.sliceFrom(a), 2)[0])), 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.runsLast(rs.sliceAsRchunks(rs.sliceFrom(a), 2)[1])), 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.runsIter(rs.sliceAsChunks(rs.sliceFrom(v.items), 2)[0]), 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.runsIter(rs.runsFrom(pairs.items, rs.sliceFrom)).next())), rs.optionUnwrap(rs.runsFirst(rs.runsFrom(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.runsLast(rs.runsFrom(nested, rs.sliceFrom))), rs.optionUnwrap(rs.iterNth(rs.runsIter(rs.runsFrom(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](); diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index c06269d6c..bfd1f4937 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -715,7 +715,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.runsIter(rs.runsFrom(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) { @@ -738,7 +738,7 @@ export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { for (const _168 of pairs.items) { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_168[0], option_unwrapOr$1fr498u(_168[1], 238)))); } - const iter10: rs.Iter = rs.iterFlatten(rs.runsIter(rs.runsFrom(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 66e245bae..f61e0a552 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$13p7ywa(self: rs.Slice | undefined, _: (a0: rs.Slice return sumTexts(self); } -export function map$1w7gh4m(self: rs.Runs | undefined, _: (a0: rs.Runs) => 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$1dcbyoa(self: rs.Slice | undefined, default_: rs.u return sumTexts(self); } -export function mapOr$1kivo4d(self: rs.Runs | undefined, default_: rs.u8, _: (a0: rs.Runs) => 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 86baba947..7e74df34e 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$13p7ywa as option_map$13p7ywa, map$1w7gh4m as option_map$1w7gh4m, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1dcbyoa as option_mapOr$1dcbyoa, mapOr$1kivo4d as option_mapOr$1kivo4d, 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$13p7ywa as option_map$13p7ywa, 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$1dcbyoa as option_mapOr$1dcbyoa, 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.Runs): rs.u8 { - return rs.iterFold(rs.runsIter(part), 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.Runs | undefined; + let _751!: rs.ArraySlice | undefined; let _784!: rs.i32; - let p14!: rs.Runs | undefined; - let _862!: rs.Runs | undefined; + let p14!: rs.ArraySlice | undefined; + let _862!: rs.ArraySlice | undefined; let _895!: rs.i32; - let p16!: rs.Runs | undefined; + let p16!: rs.ArraySlice | undefined; let _971!: rs.ByteSlice | undefined; let _1002!: rs.i32; let p18!: rs.ByteSlice | undefined; @@ -572,7 +572,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back7: boolean = _740; - const it15: rs.Iter> = rs.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); + const it15: rs.Iter> = rs.arraySliceRsplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos); hint(it15.sizeHint(), out); flush(log, out); while (true) { @@ -592,7 +592,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it16: rs.Iter> = rs.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); + 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) { @@ -601,19 +601,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$1kivo4d(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$1w7gh4m(rs.iterNth(rs.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos), 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$1w7gh4m(rs.iterNthBack(rs.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos), 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$1w7gh4m(rs.iterLast(rs.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos)), 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.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos)) & 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.runsRsplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos)), 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) { @@ -622,7 +622,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back8: boolean = _851; - const it17: rs.Iter> = rs.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); + const it17: rs.Iter> = rs.arraySliceSplit(rs.arraySliceFrom(twos.items, rs.byteSliceFrom), testTwos); hint(it17.sizeHint(), out); flush(log, out); while (true) { @@ -642,7 +642,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it18: rs.Iter> = rs.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos); + 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) { @@ -651,19 +651,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$1kivo4d(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$1w7gh4m(rs.iterNth(rs.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos), 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$1w7gh4m(rs.iterNthBack(rs.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos), 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$1w7gh4m(rs.iterLast(rs.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos)), 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.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos)) & 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.runsSplit(rs.runsFrom(twos.items, rs.byteSliceFrom), testTwos)), 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 87f582eb9..4515b1473 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.runsIter(rs.runsFrom(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])])); - const part6 = ends$iters_slice_IterMut_array2_u8(rs.runsIter(rs.runsFrom(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"])])); const _174: rs.Iter = rs.iterSlice([]); const _176: rs.Iter = rs.byteVecIntoIter(new rs.ByteVec()); @@ -1870,7 +1870,7 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 12, true).items)), front, back); const args147 = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.fmtStr, ["Iter"]), "it")]; put(out, rs.fmtFormat([args147[0], "|", rs.fmtSpec({ alternate: true }, args147[0])])); - const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.runsIter(rs.runsFrom(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); diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index 68064aba5..06f9b85dc 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.runsFirst(rs.runsFrom((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.runsFirst(rs.runsFrom((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 4e9046f84..8dfdc4fc0 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.runsFrom(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, rs.byteSliceFrom)); - let copy: rs.Arc> = rs.arcClone(quads); - const _79: rs.ByteSlice | undefined = rs.runsFirst(rs.arcMakeMut(rs.place(() => copy, (value2) => copy = value2), (a02: rs.Runs): rs.Runs => { - return rs.runsFrom(rs.runsArray(a02).map(copy$array_u8), 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.runsIter(quads.value), rs.runsIter(copy.value)); + 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/slices.View.ts b/ts/fixtures/lang/slices/expected/slices.View.ts index 852fd1b2b..ab14d9c1b 100644 --- a/ts/fixtures/lang/slices/expected/slices.View.ts +++ b/ts/fixtures/lang/slices/expected/slices.View.ts @@ -10,12 +10,12 @@ export interface View { /** Its last element, if any. */ export function last$array2_u16(self: View): rs.u16[] | undefined { - return copy$Option_array2_u16(rs.optionMap(rs.runsLast(self.view as rs.Runs>), rs.sliceItems)); + 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.runsLast(self.view as rs.Runs), rs.byteSliceView)); + 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 af12fb329..13e94faa4 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2096,81 +2096,81 @@ 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.Runs, rs.ByteSlice] = rs.sliceAsChunks(data, 2); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_17[0]), (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.Runs] = rs.sliceAsRchunks(data, 3); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_28[1]), (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.Runs>, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(words.items), 3); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_39[0]), (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.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 1); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_52[1]), (_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.Runs>, rs.Slice] = rs.sliceAsChunks(rs.sliceFrom(items.items), 3); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_63[0]), (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.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(items.items), 2); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_80[1]), (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.Runs, rs.ByteSlice] = rs.sliceAsChunks(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.Runs>] = 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.Runs, rs.ByteSlice] = rs.sliceAsChunks(rs.byteSliceRange(data, start), 3); - const iter: rs.Iter = rs.runsIter(_123[0]); + 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.Runs, rs.ByteSlice] = rs.sliceAsChunks(_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 slice3 = rs.runsAt(_134[0], 0); + 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.Runs>] = rs.sliceAsRchunks(rs.sliceRange(rs.sliceFrom(words.items), start), 2); - rs.iterExtendBytes(out, rs.iterOption(option_map$0duedp1(rs.runsLast(_155[1]), (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.Runs, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 2); - const _169: [rs.ByteSlice, rs.Runs] = rs.sliceAsRchunks(rs.byteSliceRange(rs.byteVecSlice(bytes), 1), 2); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([isSomeAnd$1ouf3e6(zip$0wdt346(rs.runsFirst(_165[0]), 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.runsFirst(_165[0]), rs.runsFirst(rs.sliceAsChunks(rs.byteVecSlice(bytes), 2)[0])), (_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.runsLast(_169[1]), rs.runsLast(_165[0])), (_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.runsFirst(_165[0]), 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.runsFirst(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0]), 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; @@ -2247,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.Runs, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 3); - const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.runsIter(_16[0])); + 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) { @@ -2258,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.runsIter(_16[0])), 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) { @@ -2267,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.runsIter(_16[0]), (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; })); @@ -2286,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.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 2); - const iter4: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.runsIter(_83[1])); + 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) { @@ -2299,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.runsIter(rs.sliceAsChunks(rs.byteSliceRange(rs.byteVecSlice(bytes), part7), 2)[0]); + 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) { @@ -2307,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.runsFirst(rs.sliceAsChunks(rs.byteVecSlice(bytes), 2)[0]), rs.byteSliceView)); - const keptWords: rs.u16[] | undefined = copy$Option_array2_u16(rs.optionMap(rs.runsFirst(rs.sliceAsChunks(rs.sliceFrom(words.items), 2)[0]), 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); @@ -2316,366 +2316,366 @@ 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.Runs, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 2); + const _142: [rs.ArraySlice, rs.ByteSlice] = rs.sliceAsChunks(rs.byteVecSlice(bytes), 2); if (_142[0].length >= 2) { - const _152: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(rs.runsAt(_142[0], 0)), rs.byteSliceToArray(rs.runsAt(_142[0], _142[0].length - 1))]; + 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.runsSwap(_142[0], 0, rs.usizeSub(_142[0].length, 1), undefined); - rs.runsBy(_142[0], (runs48) => rs.sliceReverse(runs48)); + 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.runsBy(rs.runsRange(_142[0], 1), (runs49) => rs.sliceReverse(runs49)); - rs.runsBy(_142[0], (runs50) => rs.sliceRotateLeft(runs50, 1)); + 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.runsBy(_142[0], (runs51) => rs.sliceRotateRight(runs51, _168)); + 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 = rs.byteSliceToArray(rs.runsAt(_142[0], _171)); + const kept2: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_142[0], _171)); const _177: { end: rs.usize } = { end: rs.usizeSub(n, 1) }; - rs.runsCopyWithin(_142[0], 0, _177.end, 1, copy$array_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_u8(first), copy$array_u8(last), 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.runsBy(_142[0], (runs52) => rs.sliceSort(runs52, rs.cmpLt(rs.cmpBytes), 2, true)); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_142[0]), (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.runsBy(_142[0], (runs53) => rs.sliceSort(runs53, rs.keyLt((held12) => f12(rs.byteSliceFrom(held12)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 2, true)); - rs.runsBy(_142[0], (runs54) => rs.sliceSortUnstable(runs54, 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.runsBy(_142[0], (runs55) => rs.sliceSortByCachedKey(runs55, (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.Runs, rs.Runs] = rs.runsSplitAt(_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 _204: rs.usize = rs.usizeSub(n, 2); rs.idx(_196[1], _204); - const slice79 = rs.runsAt(_196[0], 0); - const slice80 = rs.runsAt(_196[1], _204); + 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 slice81 = rs.runsAt(_142[0], 0); + 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); - const slice82 = rs.runsAt(_142[0], _216); + const slice82 = rs.arraySliceAt(_142[0], _216); slice82.data.set(copy$array_u8(old), slice82.start); rs.idx(_142[0], 1); - const kept3: Uint8Array = rs.byteSliceToArray(rs.runsAt(_142[0], 1)); + const kept3: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_142[0], 1)); rs.idx(_142[0], 0); - const _226: Uint8Array = rs.byteSliceToArray(rs.runsAt(_142[0], 0)); + const _226: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_142[0], 0)); rs.idx(_142[0], 1); - const slice83 = rs.runsAt(_142[0], 1); + const slice83 = rs.arraySliceAt(_142[0], 1); slice83.data.set(_226, slice83.start); rs.idx(_142[0], 0); - const slice84 = rs.runsAt(_142[0], 0); + const slice84 = rs.arraySliceAt(_142[0], 0); slice84.data.set(copy$array_u8(kept3), slice84.start); - const _239: rs.ByteSlice | undefined = rs.runsLast(_142[0]); + 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.runsIter(_142[0]), (c32: rs.ByteSlice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_142[0]), (c32: rs.ByteSlice): rs.u8 => { return digest(c32); }), undefined, true); - const _247: rs.Runs = rs.runsRange(_142[0], rs.usizeDiv(n, 2)); + const _247: rs.ArraySlice = rs.arraySliceRange(_142[0], rs.usizeDiv(n, 2)); const _251: Uint8Array = Uint8Array.of(9, 10); - rs.runsBy(_247, (runs56) => rs.sliceFill(runs56, _251, copy$array_u8)); + rs.arraySliceBy(_247, (arrays56) => rs.sliceFill(arrays56, _251, copy$array_u8)); } } else if (_12 === 2) { - const _253: [rs.Slice, rs.Runs>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 2); + const _253: [rs.Slice, rs.ArraySlice>] = rs.sliceAsRchunks(rs.sliceFrom(words.items), 2); if (_253[1].length >= 2) { - const _263: [rs.u16[], rs.u16[]] = [rs.sliceToArray(rs.runsAt(_253[1], 0)), rs.sliceToArray(rs.runsAt(_253[1], _253[1].length - 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.runsSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1), undefined); - rs.runsBy(_253[1], (runs3) => rs.sliceReverse(runs3)); + 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.runsBy(rs.runsRange(_253[1], 1), (runs4) => rs.sliceReverse(runs4)); - rs.runsBy(_253[1], (runs5) => rs.sliceRotateLeft(runs5, 1)); + 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.runsBy(_253[1], (runs6) => rs.sliceRotateRight(runs6, _279)); + 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[] = rs.sliceToArray(rs.runsAt(_253[1], _282)); + const kept4: rs.u16[] = rs.sliceToArray(rs.arraySliceAt(_253[1], _282)); const _288: { end: rs.usize } = { end: rs.usizeSub(n2, 1) }; - rs.runsCopyWithin(_253[1], 0, _288.end, 1, copy$array_u16); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_u16(first2), copy$array_u16(last2), copy$array_u16(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.runsBy(_253[1], (runs7) => rs.sliceSort(runs7, rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true)); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_253[1]), (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.runsBy(_253[1], (runs8) => rs.sliceSort(runs8, rs.keyLt((held2) => f2(rs.sliceFrom(held2)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true)); - rs.runsBy(_253[1], (runs9) => rs.sliceSortUnstable(runs9, 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.runsBy(_253[1], (runs10) => rs.sliceSortByCachedKey(runs10, (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.Runs>, rs.Runs>] = rs.runsSplitAt(_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 _315: rs.usize = rs.usizeSub(n2, 2); rs.idx(_307[1], _315); - const slice10 = rs.runsAt(_307[0], 0); - const slice11 = rs.runsAt(_307[1], _315); + 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.runsAt(_253[1], 0)), [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); - rs.sliceSet(rs.runsAt(_253[1], _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[] = rs.sliceToArray(rs.runsAt(_253[1], 1)); + const kept5: rs.u16[] = rs.sliceToArray(rs.arraySliceAt(_253[1], 1)); rs.idx(_253[1], 0); - const _337: rs.u16[] = rs.sliceToArray(rs.runsAt(_253[1], 0)); + const _337: rs.u16[] = rs.sliceToArray(rs.arraySliceAt(_253[1], 0)); rs.idx(_253[1], 1); - rs.sliceSet(rs.runsAt(_253[1], 1), _337); + rs.sliceSet(rs.arraySliceAt(_253[1], 1), _337); rs.idx(_253[1], 0); - rs.sliceSet(rs.runsAt(_253[1], 0), copy$array_u16(kept5)); - const _350: rs.Slice | undefined = rs.runsLast(_253[1]); + 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.runsIter(_253[1]), (c7: rs.Slice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_253[1]), (c7: rs.Slice): rs.u8 => { return digestWords(c7); }), undefined, true); - const _358: rs.Runs> = rs.runsRange(_253[1], rs.usizeDiv(n2, 2)); + const _358: rs.ArraySlice> = rs.arraySliceRange(_253[1], rs.usizeDiv(n2, 2)); const _362: rs.u16[] = [9, 10]; - rs.runsBy(_358, (runs11) => rs.sliceFill(runs11, _362, copy$array_u16)); + rs.arraySliceBy(_358, (arrays11) => rs.sliceFill(arrays11, _362, copy$array_u16)); } - const _364: [rs.ByteSlice, rs.Runs] = rs.sliceAsRchunks(rs.byteVecSlice(bytes), 4); + const _364: [rs.ByteSlice, rs.ArraySlice] = rs.sliceAsRchunks(rs.byteVecSlice(bytes), 4); if (_364[1].length >= 2) { - const _374: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(rs.runsAt(_364[1], 0)), rs.byteSliceToArray(rs.runsAt(_364[1], _364[1].length - 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.runsSwap(_364[1], 0, rs.usizeSub(_364[1].length, 1), undefined); - rs.runsBy(_364[1], (runs12) => rs.sliceReverse(runs12)); + 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.runsBy(rs.runsRange(_364[1], 1), (runs13) => rs.sliceReverse(runs13)); - rs.runsBy(_364[1], (runs14) => rs.sliceRotateLeft(runs14, 1)); + 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.runsBy(_364[1], (runs15) => rs.sliceRotateRight(runs15, _390)); + 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 = rs.byteSliceToArray(rs.runsAt(_364[1], _393)); + const kept6: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_364[1], _393)); const _399: { end: rs.usize } = { end: rs.usizeSub(n3, 1) }; - rs.runsCopyWithin(_364[1], 0, _399.end, 1, copy$array_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_u8(first3), copy$array_u8(last3), 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.runsBy(_364[1], (runs16) => rs.sliceSort(runs16, rs.cmpLt(rs.cmpBytes), 4, true)); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_364[1]), (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.runsBy(_364[1], (runs17) => rs.sliceSort(runs17, rs.keyLt((held4) => f4(rs.byteSliceFrom(held4)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true)); - rs.runsBy(_364[1], (runs18) => rs.sliceSortUnstable(runs18, 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.runsBy(_364[1], (runs19) => rs.sliceSortByCachedKey(runs19, (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.Runs, rs.Runs] = rs.runsSplitAt(_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 _426: rs.usize = rs.usizeSub(n3, 2); rs.idx(_418[1], _426); - const slice19 = rs.runsAt(_418[0], 0); - const slice20 = rs.runsAt(_418[1], _426); + 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 slice21 = rs.runsAt(_364[1], 0); + 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); - const slice22 = rs.runsAt(_364[1], _438); + const slice22 = rs.arraySliceAt(_364[1], _438); slice22.data.set(copy$array_u8(old3), slice22.start); rs.idx(_364[1], 1); - const kept7: Uint8Array = rs.byteSliceToArray(rs.runsAt(_364[1], 1)); + const kept7: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_364[1], 1)); rs.idx(_364[1], 0); - const _448: Uint8Array = rs.byteSliceToArray(rs.runsAt(_364[1], 0)); + const _448: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(_364[1], 0)); rs.idx(_364[1], 1); - const slice23 = rs.runsAt(_364[1], 1); + const slice23 = rs.arraySliceAt(_364[1], 1); slice23.data.set(_448, slice23.start); rs.idx(_364[1], 0); - const slice24 = rs.runsAt(_364[1], 0); + const slice24 = rs.arraySliceAt(_364[1], 0); slice24.data.set(copy$array_u8(kept7), slice24.start); - const _461: rs.ByteSlice | undefined = rs.runsLast(_364[1]); + 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.runsIter(_364[1]), (c12: rs.ByteSlice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_364[1]), (c12: rs.ByteSlice): rs.u8 => { return digest(c12); }), undefined, true); - const _469: rs.Runs = rs.runsRange(_364[1], rs.usizeDiv(n3, 2)); + const _469: rs.ArraySlice = rs.arraySliceRange(_364[1], rs.usizeDiv(n3, 2)); const _473: Uint8Array = rs.bytes(4).fill(5); - rs.runsBy(_469, (runs20) => rs.sliceFill(runs20, _473, copy$array_u8)); + rs.arraySliceBy(_469, (arrays20) => rs.sliceFill(arrays20, _473, copy$array_u8)); } - const _479: [rs.Runs>, rs.Runs] = rs.sliceAsChunks(rs.sliceAsChunks(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 _487: [Uint8Array[], Uint8Array[]] = [rs.runsToArray(rs.runsAt(_479[0], 0), rs.byteSliceToArray), rs.runsToArray(rs.runsAt(_479[0], _479[0].length - 1), rs.byteSliceToArray)]; + 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.runsSwap(_479[0], 0, rs.usizeSub(_479[0].length, 1), undefined); - rs.runsBy(_479[0], (runs21) => rs.sliceReverse(runs21)); + 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.runsBy(rs.runsRange(_479[0], 1), (runs22) => rs.sliceReverse(runs22)); - rs.runsBy(_479[0], (runs23) => rs.sliceRotateLeft(runs23, 1)); + 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.runsBy(_479[0], (runs24) => rs.sliceRotateRight(runs24, _503)); + 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[] = rs.runsToArray(rs.runsAt(_479[0], _506), rs.byteSliceToArray); + const kept8: Uint8Array[] = rs.arraySliceToArray(rs.arraySliceAt(_479[0], _506), rs.byteSliceToArray); const _512: { end: rs.usize } = { end: rs.usizeSub(n4, 1) }; - rs.runsCopyWithin(_479[0], 0, _512.end, 1, copy$array_array2_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_u8(first4), copy$array_array2_u8(last4), copy$array_array2_u8(kept8)], rs.runsOf(rs.byteSliceFrom))), (c13: rs.Runs): rs.u8 => { - const slice28 = rs.runsAt(c13, 0); + 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.runsAt(c13, 1); + const slice29 = rs.arraySliceAt(c13, 1); return _342 ^ slice29.data[slice29.start + 1]; }), undefined, true); - rs.runsBy(_479[0], (runs25) => rs.sliceSort(runs25, rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true)); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_479[0]), (c14: rs.Runs): rs.u8 => { - const slice30 = rs.runsAt(c14, 0); + 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.runsAt(c14, 1); + const slice31 = rs.arraySliceAt(c14, 1); return _346 ^ slice31.data[slice31.start + 1]; }), undefined, true); - const f6 = (c15: rs.Runs): Uint8Array => { - return rs.byteSliceToArray(rs.runsAt(c15, 1)); + const f6 = (c15: rs.ArraySlice): Uint8Array => { + return rs.byteSliceToArray(rs.arraySliceAt(c15, 1)); }; - rs.runsBy(_479[0], (runs26) => rs.sliceSort(runs26, rs.keyLt((held6) => f6(rs.runsOf(rs.byteSliceFrom)(held6)), rs.cmpLt(rs.cmpReverse(rs.cmpBytes))), 4, true)); - rs.runsBy(_479[0], (runs27) => rs.sliceSortUnstable(runs27, rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true, true)); - const f7 = (c16: rs.Runs): Uint8Array => { - return rs.byteSliceToArray(rs.runsAt(c16, 0)); + 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.runsBy(_479[0], (runs28) => rs.sliceSortByCachedKey(runs28, (held7) => f7(rs.runsOf(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.Runs>, rs.Runs>] = rs.runsSplitAt(_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 _539: rs.usize = rs.usizeSub(n4, 2); rs.idx(_531[1], _539); - const slice32 = rs.runsAt(_531[0], 0); - const slice33 = rs.runsAt(_531[1], _539); - rs.runsSet(slice33, rs.runsReplace(slice32, rs.runsToArray(slice33, rs.byteSliceToArray))); + 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 _550: Uint8Array[] = [Uint8Array.of(1, 2), Uint8Array.of(3, 4)]; - const old4: Uint8Array[] = rs.runsReplace(rs.runsAt(_479[0], 0), _550); + const old4: Uint8Array[] = rs.arraySliceReplace(rs.arraySliceAt(_479[0], 0), _550); const _553: rs.usize = rs.usizeSub(n4, 1); rs.idx(_479[0], _553); - rs.runsSet(rs.runsAt(_479[0], _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[] = rs.runsToArray(rs.runsAt(_479[0], 1), rs.byteSliceToArray); + const kept9: Uint8Array[] = rs.arraySliceToArray(rs.arraySliceAt(_479[0], 1), rs.byteSliceToArray); rs.idx(_479[0], 0); - const _563: Uint8Array[] = rs.runsToArray(rs.runsAt(_479[0], 0), rs.byteSliceToArray); + const _563: Uint8Array[] = rs.arraySliceToArray(rs.arraySliceAt(_479[0], 0), rs.byteSliceToArray); rs.idx(_479[0], 1); - rs.runsSet(rs.runsAt(_479[0], 1), _563); + rs.arraySliceSet(rs.arraySliceAt(_479[0], 1), _563); rs.idx(_479[0], 0); - rs.runsSet(rs.runsAt(_479[0], 0), copy$array_array2_u8(kept9)); - const _576: rs.Runs | undefined = rs.runsLast(_479[0]); + 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.runsSet(_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.runsIter(_479[0]), (c17: rs.Runs): rs.u8 => { - const slice38 = rs.runsAt(c17, 0); + 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.runsAt(c17, 1); + const slice39 = rs.arraySliceAt(c17, 1); return _353 ^ slice39.data[slice39.start + 1]; }), undefined, true); - const _586: rs.Runs> = rs.runsRange(_479[0], rs.usizeDiv(n4, 2)); + const _586: rs.ArraySlice> = rs.arraySliceRange(_479[0], rs.usizeDiv(n4, 2)); const _590: Uint8Array[] = [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]; - rs.runsBy(_586, (runs29) => rs.sliceFill(runs29, _590, copy$array_array2_u8)); + rs.arraySliceBy(_586, (arrays29) => rs.sliceFill(arrays29, _590, copy$array_array2_u8)); } - const _600: [rs.Runs>>, rs.Runs>] = rs.sliceAsChunks(rs.sliceAsChunks(rs.sliceAsChunks(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 _615: [Uint8Array[][], Uint8Array[][]] = [rs.runsToArray(rs.runsAt(_600[0], 0), (s) => rs.runsToArray(s, rs.byteSliceToArray)), rs.runsToArray(rs.runsAt(_600[0], _600[0].length - 1), (s) => rs.runsToArray(s, rs.byteSliceToArray))]; + 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.runsSwap(_600[0], 0, rs.usizeSub(_600[0].length, 1), undefined); - rs.runsBy(_600[0], (runs30) => rs.sliceReverse(runs30)); + 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.runsBy(rs.runsRange(_600[0], 1), (runs31) => rs.sliceReverse(runs31)); - rs.runsBy(_600[0], (runs32) => rs.sliceRotateLeft(runs32, 1)); + 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.runsBy(_600[0], (runs33) => rs.sliceRotateRight(runs33, _631)); + 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[][] = rs.runsToArray(rs.runsAt(_600[0], _634), (s) => rs.runsToArray(s, rs.byteSliceToArray)); + 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.runsCopyWithin(_600[0], 0, _640.end, 1, copy$array_array2_array2_u8); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_array2_u8(first5), copy$array_array2_array2_u8(last5), copy$array_array2_array2_u8(kept10)], rs.runsOf(rs.runsOf(rs.byteSliceFrom)))), (c18: rs.Runs>): rs.u8 => { - const slice44 = rs.runsAt(rs.runsAt(c18, 0), 0); + 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.runsAt(rs.runsAt(c18, 1), 1); + const slice46 = rs.arraySliceAt(rs.arraySliceAt(c18, 1), 1); return _356 ^ slice46.data[slice46.start + 1]; }), undefined, true); - rs.runsBy(_600[0], (runs34) => rs.sliceSort(runs34, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true)); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_600[0]), (c19: rs.Runs>): rs.u8 => { - const slice48 = rs.runsAt(rs.runsAt(c19, 0), 0); + 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.runsAt(rs.runsAt(c19, 1), 1); + const slice50 = rs.arraySliceAt(rs.arraySliceAt(c19, 1), 1); return _357 ^ slice50.data[slice50.start + 1]; }), undefined, true); - const f8 = (c20: rs.Runs>): Uint8Array[] => { - return rs.runsToArray(rs.runsAt(c20, 1), rs.byteSliceToArray); + const f8 = (c20: rs.ArraySlice>): Uint8Array[] => { + return rs.arraySliceToArray(rs.arraySliceAt(c20, 1), rs.byteSliceToArray); }; - rs.runsBy(_600[0], (runs35) => rs.sliceSort(runs35, rs.keyLt((held8) => f8(rs.runsOf(rs.runsOf(rs.byteSliceFrom))(held8)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)))), 8, true)); - rs.runsBy(_600[0], (runs36) => rs.sliceSortUnstable(runs36, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true, true)); - const f9 = (c21: rs.Runs>): Uint8Array[] => { - return rs.runsToArray(rs.runsAt(c21, 0), rs.byteSliceToArray); + 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.runsBy(_600[0], (runs37) => rs.sliceSortByCachedKey(runs37, (held9) => f9(rs.runsOf(rs.runsOf(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.Runs>>, rs.Runs>>] = rs.runsSplitAt(_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 _667: rs.usize = rs.usizeSub(n5, 2); rs.idx(_659[1], _667); - const slice51 = rs.runsAt(_659[0], 0); - const slice52 = rs.runsAt(_659[1], _667); - rs.runsSet(slice52, rs.runsReplace(slice51, rs.runsToArray(slice52, (s) => rs.runsToArray(s, rs.byteSliceToArray)))); + 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.runsReplace(rs.runsAt(_600[0], 0), copy$array_array2_array2_u8(one)); + 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); - rs.runsSet(rs.runsAt(_600[0], _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[][] = rs.runsToArray(rs.runsAt(_600[0], 1), (s) => rs.runsToArray(s, rs.byteSliceToArray)); + const kept11: Uint8Array[][] = rs.arraySliceToArray(rs.arraySliceAt(_600[0], 1), (s) => rs.arraySliceToArray(s, rs.byteSliceToArray)); rs.idx(_600[0], 0); - const _688: Uint8Array[][] = rs.runsToArray(rs.runsAt(_600[0], 0), (s) => rs.runsToArray(s, rs.byteSliceToArray)); + const _688: Uint8Array[][] = rs.arraySliceToArray(rs.arraySliceAt(_600[0], 0), (s) => rs.arraySliceToArray(s, rs.byteSliceToArray)); rs.idx(_600[0], 1); - rs.runsSet(rs.runsAt(_600[0], 1), _688); + rs.arraySliceSet(rs.arraySliceAt(_600[0], 1), _688); rs.idx(_600[0], 0); - rs.runsSet(rs.runsAt(_600[0], 0), copy$array_array2_array2_u8(kept11)); - const _701: rs.Runs> | undefined = rs.runsLast(_600[0]); + 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.runsSet(_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.runsIter(_600[0]), (c22: rs.Runs>): rs.u8 => { - const slice58 = rs.runsAt(rs.runsAt(c22, 0), 0); + 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.runsAt(rs.runsAt(c22, 1), 1); + const slice60 = rs.arraySliceAt(rs.arraySliceAt(c22, 1), 1); return _367 ^ slice60.data[slice60.start + 1]; }), undefined, true); - const _711: rs.Runs>> = rs.runsRange(_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); @@ -2683,13 +2683,13 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _715: Uint8Array[][] = Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array2_u8(item2); }); - rs.runsBy(_711, (runs38) => rs.sliceFill(runs38, _715, 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.Runs>>>, rs.Runs>>] = rs.sliceAsChunks(rs.sliceAsChunks(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.runsSwap(_729[0], 0, 1, undefined); + 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) { @@ -2707,114 +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.Runs>>, rs.Runs>] = rs.sliceAsChunks(rs.sliceAsChunks(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 _768: [rs.u16[][], rs.u16[][]] = [rs.runsToArray(rs.runsAt(_760[0], 0), rs.sliceToArray), rs.runsToArray(rs.runsAt(_760[0], _760[0].length - 1), rs.sliceToArray)]; + 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.runsSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1), undefined); - rs.runsBy(_760[0], (runs39) => rs.sliceReverse(runs39)); + 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.runsBy(rs.runsRange(_760[0], 1), (runs40) => rs.sliceReverse(runs40)); - rs.runsBy(_760[0], (runs41) => rs.sliceRotateLeft(runs41, 1)); + 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.runsBy(_760[0], (runs42) => rs.sliceRotateRight(runs42, _784)); + 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[][] = rs.runsToArray(rs.runsAt(_760[0], _787), rs.sliceToArray); + const kept12: rs.u16[][] = rs.arraySliceToArray(rs.arraySliceAt(_760[0], _787), rs.sliceToArray); const _793: { end: rs.usize } = { end: rs.usizeSub(n6, 1) }; - rs.runsCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(rs.runsFrom([copy$array_array2_u16(first6), copy$array_array2_u16(last6), copy$array_array2_u16(kept12)], rs.runsOf(rs.sliceFrom))), (c23: rs.Runs>): rs.u8 => { - const slice64 = rs.runsAt(c23, 0); + 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.runsAt(c23, 1); + const slice65 = rs.arraySliceAt(c23, 1); return (_415 ^ slice65.data[slice65.start + 1]) & 0xff; }), undefined, true); - rs.runsBy(_760[0], (runs43) => rs.sliceSort(runs43, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true)); - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_760[0]), (c24: rs.Runs>): rs.u8 => { - const slice66 = rs.runsAt(c24, 0); + 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.runsAt(c24, 1); + const slice67 = rs.arraySliceAt(c24, 1); return (_416 ^ slice67.data[slice67.start + 1]) & 0xff; }), undefined, true); - const f10 = (c25: rs.Runs>): rs.u16[] => { - return rs.sliceToArray(rs.runsAt(c25, 1)); + const f10 = (c25: rs.ArraySlice>): rs.u16[] => { + return rs.sliceToArray(rs.arraySliceAt(c25, 1)); }; - rs.runsBy(_760[0], (runs44) => rs.sliceSort(runs44, rs.keyLt((held10) => f10(rs.runsOf(rs.sliceFrom)(held10)), rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmp)))), 8, true)); - rs.runsBy(_760[0], (runs45) => rs.sliceSortUnstable(runs45, rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true, true)); - const f11 = (c26: rs.Runs>): rs.u16[] => { - return rs.sliceToArray(rs.runsAt(c26, 0)); + 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.runsBy(_760[0], (runs46) => rs.sliceSortByCachedKey(runs46, (held11) => f11(rs.runsOf(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.Runs>>, rs.Runs>>] = rs.runsSplitAt(_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 _820: rs.usize = rs.usizeSub(n6, 2); rs.idx(_812[1], _820); - const slice68 = rs.runsAt(_812[0], 0); - const slice69 = rs.runsAt(_812[1], _820); - rs.runsSet(slice69, rs.runsReplace(slice68, rs.runsToArray(slice69, rs.sliceToArray))); + 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 _831: rs.u16[][] = [[1, 2], [3, 4]]; - const old6: rs.u16[][] = rs.runsReplace(rs.runsAt(_760[0], 0), _831); + 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); - rs.runsSet(rs.runsAt(_760[0], _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[][] = rs.runsToArray(rs.runsAt(_760[0], 1), rs.sliceToArray); + const kept13: rs.u16[][] = rs.arraySliceToArray(rs.arraySliceAt(_760[0], 1), rs.sliceToArray); rs.idx(_760[0], 0); - const _844: rs.u16[][] = rs.runsToArray(rs.runsAt(_760[0], 0), rs.sliceToArray); + const _844: rs.u16[][] = rs.arraySliceToArray(rs.arraySliceAt(_760[0], 0), rs.sliceToArray); rs.idx(_760[0], 1); - rs.runsSet(rs.runsAt(_760[0], 1), _844); + rs.arraySliceSet(rs.arraySliceAt(_760[0], 1), _844); rs.idx(_760[0], 0); - rs.runsSet(rs.runsAt(_760[0], 0), copy$array_array2_u16(kept13)); - const _857: rs.Runs> | undefined = rs.runsLast(_760[0]); + 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.runsSet(_857, [[5, 6], [7, 8]]); + rs.arraySliceSet(_857, [[5, 6], [7, 8]]); } - rs.iterExtendBytes(out, rs.iterMap(rs.runsIter(_760[0]), (c27: rs.Runs>): rs.u8 => { - const slice74 = rs.runsAt(c27, 0); + 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.runsAt(c27, 1); + const slice75 = rs.arraySliceAt(c27, 1); return (_417 ^ slice75.data[slice75.start + 1]) & 0xff; }), undefined, true); - const _867: rs.Runs>> = rs.runsRange(_760[0], rs.usizeDiv(n6, 2)); + const _867: rs.ArraySlice>> = rs.arraySliceRange(_760[0], rs.usizeDiv(n6, 2)); const _871: rs.u16[][] = [[5, 6], [7, 8]]; - rs.runsBy(_867, (runs47) => rs.sliceFill(runs47, _871, copy$array_array2_u16)); + rs.arraySliceBy(_867, (arrays47) => rs.sliceFill(arrays47, _871, copy$array_array2_u16)); } } else if (_12 === 3) { - const _875: [rs.Runs>, rs.Slice] = rs.sliceAsChunks(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 first7: Item.Item[] = rs.replaceIn(rs.sliceView(rs.runsAt(_875[0], 0)), [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.runsSwap(_875[0], 0, 1, rs.objectCopy); - rs.runsBy(_875[0], (runs) => rs.sliceReverse(runs), rs.objectCopy); + 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.runsBy(_875[0], (runs2) => rs.sliceSort(runs2, rs.keyLt((held) => f(rs.sliceFrom(held)), rs.lt), 2, true), rs.objectCopy); + 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(rs.runsAt(_875[0], 1)); - rs.sliceSet(rs.runsAt(_875[0], 1), first7); + rs.dropAll(rs.arraySliceAt(_875[0], 1)); + rs.sliceSet(rs.arraySliceAt(_875[0], 1), first7); flush(out); rs.idx(_875[0], 0); - const slice4 = rs.runsAt(_875[0], 0); + const slice4 = rs.arraySliceAt(_875[0], 0); slice4.data[slice4.start + 1][Symbol.dispose](); - const slice5 = rs.runsAt(_875[0], 0); + const slice5 = rs.arraySliceAt(_875[0], 0); slice5.data[slice5.start + 1] = new Item.Item(67); flush(out); - const _909: [rs.Runs>, rs.Runs>] = rs.runsSplitAt(_875[0], 1); + const _909: [rs.ArraySlice>, rs.ArraySlice>] = rs.arraySliceSplitAt(_875[0], 1); rs.idx(_909[0], 0); rs.idx(_909[1], 0); - const slice6 = rs.runsAt(_909[0], 0); - const slice7 = rs.runsAt(_909[1], 0); + 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.runsIter(_875[0]), (c2: rs.Slice): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.arraySliceIter(_875[0]), (c2: rs.Slice): rs.u8 => { return _11(c2); }), undefined, true); } } else { - const _929: [rs.Runs, rs.ByteSlice] = rs.sliceAsChunks(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))); } @@ -2831,9 +2831,9 @@ export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } /** Puts each run's bytes. */ -export function putRuns$2(runs: rs.Runs, out: rs.ByteVec): void { +export function putRuns$2(runs: rs.ArraySlice, out: rs.ByteVec): void { rs.byteVecPush(out, runs.length & 0xff); - const iter: rs.Iter = rs.runsIter(runs); + const iter: rs.Iter = rs.arraySliceIter(runs); while (true) { const _8: rs.ByteSlice | rs.Done = iter.next(); if (_8 === rs.DONE) { @@ -2862,26 +2862,26 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo let r: rs.Cell = cell; a = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); const copy: rs.Cell[] = rs.sliceToArray(a); - const runs: rs.Runs>> = rs.runsOne(a, 1); + const runs: rs.ArraySlice>> = rs.arraySliceOne(a, 1); const _25: rs.Cell[][] = [[other]]; - const _24: rs.Cell[][] = rs.runsReplace(runs, _25); + 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.runsSwap(rs.runsFrom(refs, rs.sliceFrom), 0, 1, undefined); + 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.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (p4: rs.ByteSlice): string[] => { + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.arraySliceIter(rs.arraySliceFrom(pairs.items, rs.byteSliceFrom)), (p4: rs.ByteSlice): string[] => { const arg = p4.data[p4.start]; const _310: string = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f)); const arg2 = p4.data[p4.start + 1]; return [_310, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg2, f))]; }), undefined, 24, true); const part = rs.min(words.items.length, 1); - const cloned: rs.Vec = rs.vecFrom(rs.runsArray(rs.runsRange(rs.runsFrom(words.items, rs.sliceFrom), part)).map((a: string[]) => a.slice())); + const cloned: rs.Vec = rs.vecFrom(rs.arraySliceItems(rs.arraySliceRange(rs.arraySliceFrom(words.items, rs.sliceFrom), part)).map((a: string[]) => a.slice())); rs.byteVecPush(out, cloned.items.length & 0xff); const iter: rs.Iter> = rs.iterLend(rs.iterSlice(cloned.items), rs.sliceFrom); while (true) { @@ -2891,17 +2891,17 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo } rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(_85.data[_85.start]), rs.strBytes(_85.data[_85.start + 1])), undefined, true); } - const boxed: rs.Runs = rs.runsFrom(rs.vecFrom(pairs.items.map(copy$array_u8)).items, rs.byteSliceFrom); - putRuns$2(rs.runsFrom(rs.runsArray(boxed).map(copy$array_u8), rs.byteSliceFrom), out); - putRuns$2(rs.runsFrom(rs.vecFrom(rs.runsArray(boxed)).items, rs.byteSliceFrom), out); + 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.runsFrom([Uint8Array.of(1, 2), Uint8Array.of(3, 4)], rs.byteSliceFrom), out); - putRuns$2(rs.runsFrom([], rs.byteSliceFrom), out); - putRuns$2(rs.optionAsRuns(copy$Option_array2_u8(rs.optionMap(rs.runsFirst(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceView)), rs.byteSliceFrom), out); - putRuns$2(rs.optionAsRuns(undefined, rs.byteSliceFrom), out); + 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.runsFrom(pairs.items, rs.byteSliceFrom) }))), undefined, true); - rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(option_unwrapOrDefault$1n9qa5p(View.last$array2_u16({ view: rs.runsFrom(rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (p3: rs.ByteSlice): rs.u16[] => { + 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; @@ -2910,39 +2910,39 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo 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.runsFrom(pairs.items, rs.byteSliceFrom)); - putRuns$2(rs.cowRuns(borrowed, rs.byteSliceFrom), out); - let owned: rs.Cow> = rs.cowClone(borrowed, copy$array_u8); + 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.runsFirst(rs.runsFrom(owned2.items, rs.byteSliceFrom)); + 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.cowRuns(owned, rs.byteSliceFrom), out); - putRuns$2(rs.cowRuns(borrowed, rs.byteSliceFrom), out); - putRuns$2(rs.runsFrom(rs.cowIntoOwned(borrowed, copy$array_u8).items, rs.byteSliceFrom), out); - putRuns$2(rs.cowRuns(rs.vecFrom(pairs.items.map(copy$array_u8)), rs.byteSliceFrom), out); + 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.runsFirst(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceView))); - const _211: rs.ByteSlice | undefined = rs.runsFirst(some2 === undefined ? rs.runsFrom([], rs.byteSliceFrom) : rs.runsFrom([some2], rs.byteSliceFrom)); + 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.optionAsRuns(some2, rs.byteSliceFrom), out); + putRuns$2(rs.optionAsArraySlice(some2, rs.byteSliceFrom), out); const _227 = undefined as Uint8Array | undefined; - rs.byteVecPush(out, (_227 === undefined ? rs.runsFrom([], rs.byteSliceFrom) : rs.runsFrom([_227], rs.byteSliceFrom)).length & 0xff); - putRuns$2(rs.cowRuns(new rs.Borrowed(rs.runsFrom(pairs.items, rs.byteSliceFrom)), rs.byteSliceFrom), out); - const wrapped2: rs.Vec = rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(pairs.items, rs.byteSliceFrom)), (_2: rs.ByteSlice): Uint8Array => { + 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.runsOfSlice(rs.sliceFrom(wrapped2.items), rs.byteSliceFrom), out); - const _242: rs.ByteSlice | undefined = rs.runsLast(rs.runsOfSlice(rs.sliceFrom(wrapped2.items), rs.byteSliceFrom)); + 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.runsOfSlice(rs.sliceFrom(wrapped2.items), rs.byteSliceFrom), out); + 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; }); @@ -2956,26 +2956,26 @@ export function arrayForms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo rs.ptrWrite(uninit, copy$array_u8(rs.byteSliceToArray(_267[1]))); rs.byteSliceFrom(uninit); } - putRuns$2(rs.runsOfSlice(boxed2, rs.byteSliceFrom), out); + putRuns$2(rs.arraySliceOfSlice(boxed2, rs.byteSliceFrom), out); const half: rs.usize = rs.usizeDiv(pairs.items.length, 2); - putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, undefined, rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); - putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([new rs.Borrowed(rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half)), rs.vecFrom(rs.runsArray(rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)).map(copy$array_u8))]), 2, undefined, (c) => rs.runsItems(rs.cowRuns(c, rs.byteSliceFrom)), copy$array_u8).items, rs.byteSliceFrom), out); - putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.runsItems(rs.runsOne(rs.byteSliceFrom(Uint8Array.of(238, 255)), 2)), rs.runsItems, copy$array_u8).items, rs.byteSliceFrom), out); - putRuns$2(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), 0, half), rs.runsRange(rs.runsFrom(pairs.items, rs.byteSliceFrom), half)]), 2, rs.runsItems(rs.runsFrom([Uint8Array.of(221, 204), Uint8Array.of(187, 170)], rs.byteSliceFrom)), rs.runsItems, 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, 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.Runs> = rs.runsOne(rs.sliceOfPlace(rs.place(() => item, (value) => item = value)), 1); + 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.runsAt(runs2, 0)), _354, 1)[0])), undefined, true); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(rs.cellReplace(rs.cellOfRuns(rs.runsOne(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(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.Runs, out: rs.ByteVec): void { - const iter: rs.Iter = rs.runsIter(rows); +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) { @@ -2987,19 +2987,19 @@ export function lentRows$2(rows: rs.Runs, out: rs.ByteVec): void { lent = lent || _32; return rs.cmpBytes(row, _5); }; - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceBinarySearchBy(rs.runsItems(rows), (held) => _11(rs.byteSliceFrom(held))).ok ? 1 : 0, lent ? 1 : 0)), undefined, true); + 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.Runs>, nested: rs.Runs>, out: rs.ByteVec): void { - const iter: rs.Iter> = rs.runsIter(rows); +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.runsIter(rows), (row: rs.Slice): boolean => { + 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 => { @@ -3008,29 +3008,29 @@ export function lentWords(rows: rs.Runs>, nested: rs.Runs _19(rs.sliceFrom(held))) & 0xff); + 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.runsItems(rows), (held2) => _22(rs.sliceFrom(held2))); + rs.sliceBinarySearchBy(rs.arraySliceAsSlice(rows), (held2) => _22(rs.sliceFrom(held2))); rs.byteVecPush(out, lent ? 1 : 0); } - const iter2: rs.Iter> = rs.runsIter(nested); + const iter2: rs.Iter> = rs.arraySliceIter(nested); while (true) { - const _29: rs.Runs | rs.Done = iter2.next(); + const _29: rs.ArraySlice | rs.Done = iter2.next(); if (_29 === rs.DONE) { break; } let lent2: boolean = false; - const _35: (a0: rs.Runs) => rs.Ordering = (row4: rs.Runs): rs.Ordering => { - const _36: boolean = rs.runsSame(row4, _29); + 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.runsItems(nested), (held3) => _35(rs.runsOf(rs.byteSliceFrom)(held3))); + rs.sliceBinarySearchBy(rs.arraySliceAsSlice(nested), (held3) => _35(rs.arraySliceOf(rs.byteSliceFrom)(held3))); rs.byteVecPush(out, lent2 ? 1 : 0); } } @@ -3046,29 +3046,29 @@ export function arrayIdentity(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): rs.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); }), undefined, 2, true); - rs.runsBy(rs.runsFrom(rows.items, rs.byteSliceFrom), (runs) => rs.sliceSort(runs, rs.cmpLt(rs.cmpBytes), 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.runsFrom(rows.items, rs.byteSliceFrom), out); + lentRows$2(rs.arraySliceFrom(rows.items, rs.byteSliceFrom), out); const part3 = rs.usizeDiv(rows.items.length, 2); - lentRows$2(rs.runsRange(rs.runsFrom(rows.items, rs.byteSliceFrom), part3), out); - const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.runsIter(rs.runsFrom(rows.items, rs.byteSliceFrom)), (r2: rs.ByteSlice): rs.u16[] => { + 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.runsWindows(rs.runsFrom(rows.items, rs.byteSliceFrom), 2), (w: rs.Runs): Uint8Array[] => { + 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.runsAt(w, 0)); + const _310: Uint8Array = rs.byteSliceToArray(rs.arraySliceAt(w, 0)); rs.idx(w, 1); - return [_310, rs.byteSliceToArray(rs.runsAt(w, 1))]; + return [_310, rs.byteSliceToArray(rs.arraySliceAt(w, 1))]; }), undefined, 4, true); const part4 = rs.min(words.items.length, 1); - const _36: rs.Runs> = rs.runsRange(rs.runsFrom(words.items, rs.sliceFrom), part4); + const _36: rs.ArraySlice> = rs.arraySliceRange(rs.arraySliceFrom(words.items, rs.sliceFrom), part4); const part5 = rs.usizeDiv(nested.items.length, 2); - lentWords(_36, rs.runsRange(rs.runsFrom(nested.items, rs.runsOf(rs.byteSliceFrom)), part5), out); + 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.runsIter(rs.runsRange(rs.runsFrom(rows.items, rs.byteSliceFrom), at)), (r: rs.ByteSlice): Probe.Probe[] => { + 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); }; @@ -3079,10 +3079,10 @@ export function arrayIdentity(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): 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.Runs> = rs.runsFrom(a.items, rs.sliceFrom); - const _84: rs.Runs> = rs.runsFrom(b.items, rs.sliceFrom); + 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.runsIter(rs.runsFrom(rs.slicesJoin(rs.sliceFrom([_82, _84, rs.runsRange(rs.runsFrom(a.items, rs.sliceFrom), 0, part2)]), 8, rs.runsItems(rs.runsOne(rs.sliceFrom(sep), 1)), rs.runsItems, (a: Probe.Probe[]) => a.map(Probe.clone$Clone)).items, rs.sliceFrom)), (_2: rs.Slice): rs.u8 => { + 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); diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index d88532f86..a4e65f497 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -217,21 +217,21 @@ 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, and the `Runs` of a `[[T; N]; M]`'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 | Runs : never); +export type Ptr = T | Place | ByteSlice | (T extends readonly (infer E)[] ? Slice | ArraySlice : never); /** 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`, the `ByteSlice` of a `[u8]`, or the `Runs` of a `[[T; N]]`. */ -export type SliceOf = Slice | ByteSlice | Runs; +/** 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`, the `ByteCow` of a `Cow<[u8]>`, or the `Cow` of a `Cow<[[T; N]]>`'s runs. */ -export type CowOf = Cow | ByteCow | Cow>; +/** 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 @@ -719,11 +719,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 | Runs; +export type Elements = ArrayLike | Slice | Vec | ArraySlice; -/** The array `s`'s elements are in: a slice's storage, a `Vec`'s items, the arrays of runs as `runsArray` reads them, 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 instanceof Runs ? (runsArray(s) as unknown as ArrayLike) : 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)`. */ @@ -820,9 +820,9 @@ export function optionAsSlice(o: T, none?: None): Slice { return sliceFrom(o === none ? [] : [o]); } -/** `optionAsSlice` of an array, which is never `undefined`: the runs of it alone, lent by `of`, or of none. */ -export function optionAsRuns(o: RunArray | undefined, of: (array: RunArray) => S): Runs { - return runsFrom, S>(o === undefined ? [] : [o], of); +/** `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. */ @@ -965,22 +965,22 @@ export function sliceReverse(s: Slice): void { byValue(s, (items) => items.reverse()); } -// Slices of arrays: `Runs`. +// Slices of arrays: `ArraySlice`. -/** What a `&[T; N]` is, as a slice of arrays lends each of its runs: a slice of its elements, of its bytes, or of its own runs. */ -export type Run = Slice | ByteSlice | Runs; +/** 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 run `S` lends: its elements' array, its bytes, or its runs' arrays. */ -export type RunArray = S extends ByteSlice ? Uint8Array : S extends Slice ? T[] : S extends Runs ? RunArray[] : never; +/** 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` runs from `start`, each lent - * as `S`, the slice a `&[T; N]` is, so a run is read and written where the slice holds it. - * The runs are each a `[T; N]`'s own array, `items[i]`, as a `Vec<[T; N]>` or a + * 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. */ -export class Runs { +export class ArraySlice { readonly items: readonly unknown[] | undefined; readonly of: ((array: never) => S) | undefined; readonly flat: S | undefined; @@ -999,224 +999,224 @@ export class Runs { } /** - * All of `items`, the arrays of a `[[T; N]; M]` or a `Vec<[T; N]>`, as runs, each lent by - * `of`. Runs of none take their type from where they go, as `[]` says nothing of it. + * 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 runsFrom(items: readonly [], of: (array: NoInfer>) => S): Runs; -export function runsFrom(items: readonly A[], of: (array: A) => S): Runs; -export function runsFrom(items: readonly A[], of: (array: A) => S): Runs { - return new Runs(items, of, undefined, 0, 0, items.length); +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); } -/** The runs 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 runsOfSlice(s: Slice, of: (array: A) => S): Runs { - return new Runs(s.data, of, undefined, 0, s.start, s.length); +/** 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); } -/** `runsFrom` of `of`, as a function of the arrays, as a `[[T; N]; M]` is lent: one function for each `of`. */ -export function runsOf(of: (array: A) => S): (items: readonly A[]) => Runs { - let f = LENT.get(of) as ((items: readonly A[]) => Runs) | undefined; - if (f === undefined) LENT.set(of, (f = (items: readonly A[]) => runsFrom(items, of))); +/** `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; } -/** `runsOf`'s functions, by the `of` each lends with. */ +/** `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 runsAt(r: Runs, i: number): S { +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 runPart(r.flat as S, k * r.n, r.n); + return arrayRefPart(r.flat as S, k * r.n, r.n); } /** `length` elements of `s` from `start`: a slice of the same storage, of the same class. */ -function runPart(s: S, start: number, length: number): S { +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 Runs; - return new Runs(r.items, r.of, r.flat, r.n, r.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; } -/** Runs `start` to `end` of `r`, in bounds already. */ -export function runsPart(r: Runs, start: number, end: number = r.length): Runs { - return runPart(r, start, end - start); +/** 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 runsRange(r: Runs, start: number, end: number = r.length, at?: Location): Runs { +export function arraySliceRange(r: ArraySlice, start: number, end: number = r.length, at?: Location): ArraySlice { rangeCheck(r.length, start, end, at); - return runPart(r, start, end - start); + return arrayRefPart(r, start, end - start); } -/** Each run of `r`, lent where `r` holds it, as `each_ref` and `each_mut` of a `[[T; N]; M]` lend them. */ -export function runsEach(r: Runs): S[] { +/** 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] = runsAt(r, i); + 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 runs of it alone. */ -export function runsOne(s: S, n: number): Runs { - return new Runs(undefined, undefined, s, n, 0, 1); +/** `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 run copied by `copy`, an array of its own. */ -export function runsToArray(r: Runs, copy: (run: S) => A): A[] { +/** `*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(runsAt(r, i)); + 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 run written where `r` holds it. */ -export function runsSet(r: Runs, items: ArrayLike>): void { - for (let i = 0; i < r.length; i++) runSet(runsAt(r, i), items[i]); +/** `*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]); } /** - * What a run's element is copied by, as a copy of the runs reads it: a `Copy` value JS + * 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 - * runs back would change. + * arrays back would change. */ -export type RunCopy = (value: never) => unknown; +export type ElemCopy = (value: never) => unknown; -/** `mem::replace` of what a `&mut [[T; N]; M]`, `r`, points at: its runs as arrays of their own, each element copied by `copy`, then `items` written where `r` holds them. */ -export function runsReplace(r: Runs, items: ArrayLike>, copy?: RunCopy): RunArray[] { - const old = runsCopy(r, copy); - runsSet(r, items); +/** `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 run `s`: its elements moved into where `s` holds them. */ -function runSet(s: Run, value: unknown): void { +/** 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 runsSet(s, value as ArrayLike); + else arraySliceSet(s, value as ArrayLike); } /** - * The run `s` as a `[T; N]` of its own: a copy of its elements, and of the runs it holds at + * 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. */ -function runCopy(s: S, copy?: RunCopy): RunArray { - if (s instanceof ByteSlice) return byteSliceToArray(s) as RunArray; - if (s instanceof Slice) return sliceToArray(s, copy as ((value: unknown) => unknown) | undefined) as RunArray; - return runsCopy(s as Runs, copy) as RunArray; +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; } -/** The runs of `r` as arrays of their own, as `runCopy` copies each. */ -export function runsCopy(r: Runs, copy?: RunCopy): RunArray[] { - return runsToArray(r, (s) => runCopy(s, copy)); +/** 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)); } /** - * Whether pointers to `[[T; N]; M]`s, `a` and `b`, point at the same place: the same run of + * 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 runsSame(a: Runs, b: Runs): boolean { - if (!(a instanceof Runs && b instanceof Runs)) return a === b; +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 runSame(runPart(a.flat!, a.start * a.n, 0), runPart(b.flat!, b.start * b.n, 0)); + return arrayRefSame(arrayRefPart(a.flat!, a.start * a.n, 0), arrayRefPart(b.flat!, b.start * b.n, 0)); } /** Whether `a` and `b`, slices a pointer to a `[T; N]` is, point at the same place. */ -function runSame(a: Run, b: Run): boolean { +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 Runs && runsSame(a, b); + return b instanceof ArraySlice && arraySliceSame(a, b); } /** - * The runs of `r` as a JS array of arrays, for what only reads them: the arrays themselves - * where each run is one, so a callback's `ptr::eq` sees the run it was lent, or else copies - * of the runs `as_chunks` split from one flat slice, which have no array of their own. + * 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 runsArray(r: Runs): RunArray[] { - if (r.items === undefined) return runsCopy(r); - if (r.start === 0 && r.length === r.items.length) return r.items as RunArray[]; - return r.items.slice(r.start, r.start + r.length) as RunArray[]; +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[]; } -/** `last_chunk` of runs, shared or mutable: the last `n`, or `undefined` if fewer. */ -export function runsLastChunk(r: Runs, n: number): Runs | undefined { - return n > r.length ? undefined : runPart(r, r.length - n, n); +/** `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 runs, shared or mutable: the rest and the last `n`, or `undefined` if fewer. */ -export function runsSplitLastChunk(r: Runs, n: number): [Runs, Runs] | undefined { - return n > r.length ? undefined : [runPart(r, 0, r.length - n), runPart(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 runs of `r` as a slice of arrays, as `runsArray` reads them: a slice of the arrays where each run is one. */ -export function runsItems(r: Runs): Slice> { - if (r.items !== undefined) return new Slice(r.items as RunArray[], r.start, r.length); - return sliceFrom(runsCopy(r)); +/** 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 runs of `r` as a slice of arrays of their own, each a copy, its elements by `copy`, which `op` may + * `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 runsBy(r: Runs, op: (s: Slice>) => R, copy?: RunCopy): R { - const items = runsCopy(r, copy); +export function arraySliceBy(r: ArraySlice, op: (s: Slice>) => R, copy?: ElemCopy): R { + const items = arraySliceCopy(r, copy); try { return op(sliceFrom(items)); } finally { - runsSet(r, items); + arraySliceSet(r, items); } } -/** `swap` of runs, each element copied out by `copy`, panicking on either index past the end, `a` first, as std's indexing does. */ -export function runsSwap(r: Runs, a: number, b: number, copy: RunCopy | undefined, at?: Location): void { - const x = runsAt(r, idx(r, a, at)); - const y = runsAt(r, idx(r, b, at)); - const kept = runCopy(x, copy); - runSet(x, runCopy(y, copy)); - runSet(y, kept); +/** `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 runs: the first run, or `undefined` if empty. */ -export function runsFirst(r: Runs): S | undefined { - return r.length === 0 ? undefined : runsAt(r, 0); +/** `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 runs: the last run, or `undefined` if empty. */ -export function runsLast(r: Runs): S | undefined { - return r.length === 0 ? undefined : runsAt(r, r.length - 1); +/** `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 runs: the run at `index`, or `undefined` past the end. */ -export function runsGet(r: Runs, index: number): S | undefined { - return index < r.length ? runsAt(r, index) : undefined; +/** `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 runs, shared or mutable: the part, or `undefined` unless it is within them. */ -export function runsGetRange(r: Runs, start: number, end: number = r.length): Runs | undefined { - return start <= end && end <= r.length ? runPart(r, start, end - start) : 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 runs: the first and the rest, or `undefined` if empty. */ -export function runsSplitFirst(r: Runs): [S, Runs] | undefined { - return r.length === 0 ? undefined : [runsAt(r, 0), runPart(r, 1, r.length - 1)]; +/** `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 runs: the last and the rest, or `undefined` if empty. */ -export function runsSplitLast(r: Runs): [S, Runs] | undefined { +/** `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 : [runsAt(r, n), runPart(r, 0, n)]; + return n < 0 ? undefined : [arraySliceAt(r, n), arrayRefPart(r, 0, n)]; } -/** `split_at` and `split_at_mut` of runs, panicking past the length. */ -export function runsSplitAt(r: Runs, n: number, at?: Location): [Runs, Runs] { +/** `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 [runPart(r, 0, n), runPart(r, n, r.length - n)]; + return [arrayRefPart(r, 0, n), arrayRefPart(r, n, r.length - n)]; } -/** `split_at_checked` and `split_at_mut_checked` of runs: the halves, or `undefined` past the length. */ -export function runsSplitAtChecked(r: Runs, n: number): [Runs, Runs] | undefined { - return n > r.length ? undefined : [runPart(r, 0, n), runPart(r, n, r.length - n)]; +/** `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. */ @@ -1235,19 +1235,19 @@ export function sliceSplitLastChunk(s: Slice, n: number): [Slice, Slice } /** - * `as_chunks` and `as_chunks_mut` of a slice of any element: each run of `n` elements from + * `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. */ -export function sliceAsChunks(s: S, n: number, at?: Location): [Runs, S] { +export function sliceAsChunks(s: S, n: number, at?: Location): [ArraySlice, S] { const count = chunkCount(s.length, n, at); - return [new Runs(undefined, undefined, s, n, 0, count), runPart(s, count * n, s.length - count * n)]; + return [new ArraySlice(undefined, undefined, s, n, 0, count), arrayRefPart(s, count * n, s.length - count * n)]; } -/** `as_rchunks` and `as_rchunks_mut` of a slice of any element: the rest, and each run of `n` elements up to the back, as `sliceAsChunks` lends them. */ -export function sliceAsRchunks(s: S, n: number, at?: Location): [S, Runs] { +/** `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 [runPart(s, 0, rest), new Runs(undefined, undefined, runPart(s, rest, count * n), 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. */ @@ -1498,11 +1498,11 @@ export function sliceCopyWithin(s: Slice, start: number, end: number, dest for (let i = 0; i < items.length; i++) d[s.start + dest + i] = copy === undefined ? items[i] : copy(items[i]); } -/** `copy_within` of runs: `r[start..end]` copied to index `dest`, each run read, and copied by `copy` if given, before any is written, panicking out of bounds. */ -export function runsCopyWithin(r: Runs, start: number, end: number, dest: number, copy?: (value: RunArray) => RunArray, at?: Location): void { +/** `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) => runCopy(runsAt(r, start + i))); - for (let i = 0; i < items.length; i++) runSet(runsAt(r, dest + i), copy === undefined ? items[i] : copy(items[i])); + 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. */ @@ -1570,19 +1570,19 @@ export function boxSliceCloneFrom(dst: Slice, src: Slice, clone?: (valu } /** - * `Clone::clone_from` of a `Box<[[T; N]]>`, the runs `dst`: itself, by `clone_from_slice`, - * where the lengths match, or else the runs `of` makes of a clone of `src`'s arrays, as + * `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 runsBoxCloneFrom(dst: Runs, src: Runs, of: (array: RunArray) => S, clone?: (value: RunArray) => RunArray, drop?: (item: RunArray) => void, over?: CloneFrom>, at?: Location): Runs { - if (dst.length !== src.length) return runsFrom(boxSliceCloneFrom(runsItems(dst), runsItems(src), clone, drop, over, at).data, of); - runsBy(dst, (d) => sliceCloneFromSlice(d, runsItems(src), clone, drop, over, at)); +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; } -/** `runsBoxCloneFrom` as a `CloneFrom`. */ -export function runsBoxCloneFromFn(of: (array: RunArray) => S, clone?: (value: RunArray) => RunArray, drop?: (item: RunArray) => void, over?: CloneFrom>, at?: Location): CloneFrom> { - return (old, src) => runsBoxCloneFrom(old, src, of, clone, drop, over, at); +/** `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`. */ @@ -2656,8 +2656,8 @@ export class Borrowed { } } -/** `Cow<[T]>`: the `Vec` it owns, or the slice it borrows, `S`: `Runs` of arrays. */ -export type Cow | Runs = Slice> = 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. */ @@ -2668,9 +2668,9 @@ export function cowSlice(c: Cow): Slice { return c instanceof Borrowed ? c.slice : sliceFrom(c.items); } -/** `Deref` of a `Cow<[[T; N]]>`: its runs, each of an owned one lent by `of`. */ -export function cowRuns(c: Cow, Runs>, of: (array: RunArray) => S): Runs { - return c instanceof Borrowed ? c.slice : runsFrom(c.items, of); +/** `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. */ @@ -2681,10 +2681,10 @@ 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 | Runs = Slice>(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; const s = c.slice; - if (s instanceof Runs) return vecFrom((clone === undefined ? runsCopy(s) : runsArray(s).map(clone as (item: unknown) => unknown)) as T[]); + 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)); } @@ -2697,7 +2697,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 | Runs = Slice>(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)); } @@ -2711,7 +2711,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 | Runs = Slice>(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); @@ -2719,7 +2719,7 @@ export function cowCloneFrom | Runs = Slice>(c: Co } /** `cowCloneFrom` as a `CloneFrom`. */ -export function cowCloneFromFn | Runs = Slice>(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); } @@ -2734,7 +2734,7 @@ export function byteCowCloneFromFn(): CloneFrom { } /** Drop a `Cow<[T]>`: the items it owns, by `f` if given. */ -export function cowDrop | Runs = Slice>(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 66e58c91b..cbbd765bb 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 { ByteSlice, ByteVec, Runs, 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, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; +import { ByteSlice, ByteVec, ArraySlice, 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, 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 { Hashing } from "./hash.ts"; import { type Limbs, lt, type u64, type usize } from "./int.ts"; @@ -335,7 +335,7 @@ 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 Runs) { + if (s instanceof ArraySlice) { const items = sliceData(s) as ArrayLike; return [items.length, (i) => items[i]]; } diff --git a/ts/runtime/rs/iter.ts b/ts/runtime/rs/iter.ts index 294be0f95..0cfa45158 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, type Run, type Runs, runsArray, runsAt, runsEach, runsPart, 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, arraySliceEach, 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,29 +475,29 @@ 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 runs: the parts between the runs `f` is true of, each lent where the slice holds it. */ -export function runsSplit(r: Runs, f: (run: S) => boolean): Iter> { - return new SplitIter(r, runsEach(r), 0, runsPart, f, false, false); +/** `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, arraySliceEach(r), 0, arraySlicePart, f, false, false); } -/** `slice::rsplit` and `rsplit_mut` of runs. */ -export function runsRsplit(r: Runs, f: (run: S) => boolean): Iter> { - return new SplitIter(r, runsEach(r), 0, runsPart, f, true, false); +/** `slice::rsplit` and `rsplit_mut` of an array slice. */ +export function arraySliceRsplit(r: ArraySlice, f: (run: S) => boolean): Iter> { + return new SplitIter(r, arraySliceEach(r), 0, arraySlicePart, f, true, false); } -/** `slice::split_inclusive` and `split_inclusive_mut` of runs. */ -export function runsSplitInclusive(r: Runs, f: (run: S) => boolean): Iter> { - return new SplitIter(r, runsEach(r), 0, runsPart, f, false, true); +/** `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, arraySliceEach(r), 0, arraySlicePart, f, false, true); } -/** `slice::splitn` and `splitn_mut` of runs. */ -export function runsSplitn(r: Runs, n: number, f: (run: S) => boolean): Iter> { - return new SplitIter(r, runsEach(r), 0, runsPart, f, false, false, n); +/** `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, arraySliceEach(r), 0, arraySlicePart, f, false, false, n); } -/** `slice::rsplitn` and `rsplitn_mut` of runs. */ -export function runsRsplitn(r: Runs, n: number, f: (run: S) => boolean): Iter> { - return new SplitIter(r, runsEach(r), 0, runsPart, f, true, 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, arraySliceEach(r), 0, arraySlicePart, f, true, false, n); } /** `slice::split` and `split_mut` of bytes, whose parts are views already. */ @@ -541,35 +541,35 @@ 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 runs: each run, lent where the slice holds it. */ -export function runsIter(r: Runs): Iter { - return new RunsIter(r); +/** `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 runs. */ -export function runsWindows(r: Runs, size: number, at?: Location): Iter> { +/** `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, runsPart); + return new PartsIter(r, r.length, size, 1, Math.max(r.length - size + 1, 0), false, arraySlicePart); } -/** `slice::chunks` and `chunks_mut` of runs. */ -export function runsChunks(r: Runs, size: number, at?: Location): Iter> { - return chunks(r, r.length, size, false, false, runsPart, at); +/** `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 runs. */ -export function runsChunksExact(r: Runs, size: number, at?: Location): Iter> { - return chunks(r, r.length, size, true, false, runsPart, 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 runs. */ -export function runsRchunks(r: Runs, size: number, at?: Location): Iter> { - return chunks(r, r.length, size, false, true, runsPart, 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 runs. */ -export function runsRchunksExact(r: Runs, size: number, at?: Location): Iter> { - return chunks(r, r.length, size, true, true, runsPart, 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`. */ @@ -2048,24 +2048,24 @@ class SliceIter extends Iter implements Disposable { } } -/** The runs of a slice of arrays, from both ends, each lent where the slice holds it. */ -class RunsIter extends Iter { - private readonly r: Runs; +/** 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: Runs) { + constructor(r: ArraySlice) { super(); this.r = r; this.back = r.length; } next(): S | Done { - return this.front < this.back ? runsAt(this.r, this.front++) : DONE; + return this.front < this.back ? arraySliceAt(this.r, this.front++) : DONE; } override nextBack(): S | Done { - return this.front < this.back ? runsAt(this.r, --this.back) : DONE; + return this.front < this.back ? arraySliceAt(this.r, --this.back) : DONE; } override len(): number { @@ -2077,11 +2077,11 @@ class RunsIter extends Iter { } override remaining(): Iterable { - return runsArray(runsPart(this.r, this.front, this.back)); + return arraySliceItems(arraySlicePart(this.r, this.front, this.back)); } override clone(): Iter { - const it = new RunsIter(this.r); + const it = new ArraySliceIter(this.r); it.front = this.front; it.back = this.back; return it; diff --git a/ts/runtime/rs/task.ts b/ts/runtime/rs/task.ts index 39ec77627..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 Run, type RunArray, type RunCopy, Runs, runsArray, runsCopy, runsSet, 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,9 +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 | Runs | 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 Runs) dropRange(runsArray(values) as unknown as ArrayLike, f, from, 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); } @@ -913,11 +913,11 @@ export function cellOfPlace(p: Place): Cell { } /** - * `Cell::from_mut` of a `&mut [[T; N]; M]`, which is the runs `r`: a read is a copy of + * `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 cellOfRuns(r: Runs, copy?: RunCopy): Cell[]> { - return cellOfPlace(place(() => runsCopy(r, copy), (value) => runsSet(r, value))); +export function cellOfArraySlice(r: ArraySlice, copy?: ElemCopy): Cell[]> { + return cellOfPlace(place(() => arraySliceCopy(r, copy), (value) => arraySliceSet(r, value))); } /** diff --git a/ts/src/lower/runs.rs b/ts/src/lower/array_slice.rs similarity index 76% rename from ts/src/lower/runs.rs rename to ts/src/lower/array_slice.rs index 95c900b47..205d33afd 100644 --- a/ts/src/lower/runs.rs +++ b/ts/src/lower/array_slice.rs @@ -1,10 +1,11 @@ -//! Slices of arrays, which are `rs.Runs`: a `&[[T; N]]` lends each run as the slice a -//! `&[T; N]` is, where the slice holds it, whether its runs are each an array's own, as a +//! 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 -//! `runs` functions map std's methods that lend runs or parts. Any other method of a slice -//! of arrays reads it as an `rs.Slice` of JS arrays: shared, of its arrays or copies of its -//! runs, which a shared borrow can't tell from them, and mutable, of copies that -//! `rs.runsBy` writes back once it returns, as Rust moves their elements. +//! `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}; @@ -12,13 +13,13 @@ 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.Runs`. +/// 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 runs where the slice holds them. +/// 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; @@ -82,13 +83,13 @@ pub fn native<'tcx>(tcx: TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args: t } /// `args` as std's mapping of `call` reads them, unless [`native`] maps it: each -/// `&[[T; N]]` it reads as a slice given as `rs.runsItems`' copies, and each `&mut` one by -/// name, which [`wrap`] binds to `rs.runsBy`'s copies. A function that returns a borrow, +/// `&[[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 runs as their type says. + // 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); } @@ -111,10 +112,10 @@ pub fn give<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec any = true; let value = std::mem::replace(&mut given.args[i], Expr::undefined()); given.args[i] = match mutability { - ty::Mutability::Not => Expr::rs("runsItems", vec![value]), + ty::Mutability::Not => Expr::rs("arraySliceAsSlice", vec![value]), ty::Mutability::Mut => { - let name = b.fresh("runs"); - let copy = b.t.run_copy(*inner, call.span); + let name = b.fresh("arrays"); + let copy = b.t.elem_copy(*inner, call.span); given.by.push(By { name: name.clone(), value, @@ -146,14 +147,14 @@ pub struct Given { pub struct By { /// Its name in the arguments. pub name: String, - /// The runs. + /// The arrays. pub value: Expr, - /// What copies an element of the runs out, as [`super::Translator::run_copy`] says. + /// 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.runsBy` copies of its runs. +/// 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; @@ -166,7 +167,7 @@ pub fn wrap(e: Expr, ty: Type, stmts: Vec, by: Vec) -> Expr { } None => Expr::Lambda(vec![param], Box::new(e)), }; - e = Expr::rs("runsBy", [vec![value, f], copy.into_iter().collect()].concat()); + e = Expr::rs("arraySliceBy", [vec![value, f], copy.into_iter().collect()].concat()); } e } diff --git a/ts/src/lower/copy.rs b/ts/src/lower/copy.rs index e11f1f86f..b55b0f1ea 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -152,20 +152,20 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if super::byte(elem) { return Expr::rs("byteSliceToArray", vec![s]); } - // Runs of arrays, as a slice holds them, but not of a wrapper's, which is an element. + // 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("runsToArray", vec![s, copy]); + 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 runs of `ty`, an array or slice of arrays, as runs + /// 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 runs back changes. - pub fn run_copy(&mut self, ty: Ty<'tcx>, span: Span) -> Option { + /// `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; diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index b7db3f795..776cce359 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -830,9 +830,9 @@ 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 run, where a slice of arrays holds it. + // 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("runsIter", vec![value])) + 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)])) @@ -1040,7 +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("runsIter", 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)?)); diff --git a/ts/src/lower/lend.rs b/ts/src/lower/lend.rs index fe178634c..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) || super::runs::native(tcx, def_id, args) { + 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,11 +405,11 @@ 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() { - // Runs, lent each as its own `From` lends it, and given as copies, which a `&` reads. + // 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("runsArray".into()), + (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"), diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index e35d53ebe..e312f8277 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -621,7 +621,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("cowRuns", vec![cow, super::array_fn(*elem, "From")]), + ty::Slice(elem) if elem.is_array() => Expr::rs("cowArraySlice", vec![cow, super::array_fn(*elem, "From")]), _ => Expr::rs("cowSlice", vec![cow]), } } @@ -1473,7 +1473,7 @@ 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 given = match super::runs::give(b, call, args) { + let given = match super::array_slice::give(b, call, args) { Ok(given) => given, Err(e) => return Some(e), }; @@ -1483,7 +1483,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec out.extend(stmts); } else { let ty = b.t.ty(b.t.sig(call.def_id, call.args).output(), call.span); - e = super::runs::wrap(e, ty, stmts, given.by); + 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); @@ -1932,10 +1932,10 @@ 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 runs of the one it holds, if any. + // 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("optionAsRuns", args) + Expr::rs("optionAsArraySlice", args) } ("Option", "as_slice") => { args.extend(b.t.none_arg(targ(gargs, 0))); @@ -2113,7 +2113,7 @@ fn mapping<'tcx>( false => name.strip_suffix("_mut")?, }; let of = match elem.is_array() { - true => "runs", + true => "arraySlice", false => "slice", }; rt2(values, of, &super::camel(name)) @@ -2121,7 +2121,7 @@ fn mapping<'tcx>( ("slice", "windows" | "chunks" | "chunks_exact" | "rchunks" | "rchunks_exact") => { rt2(args, slice_of_elem(targ(gargs, 0)), &super::camel(&name)) } - // Runs of `N` lent where the slice holds them, shared or mutable alike, of any slice. + // 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; @@ -2164,7 +2164,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, "runs", &super::camel(name.strip_suffix("_mut")?)), + 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())); @@ -2310,9 +2310,9 @@ fn mapping<'tcx>( values.push(super::collections::clone_fn(b, elem, span)); Expr::rs("sliceWriteCloneOfSlice", values) } - // Of arrays, the runs of the same arrays, which a slice of their `MaybeUninit`s holds. + // 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( - "runsOfSlice", + "arraySliceOfSlice", vec![args.pop()?, super::array_fn(targ(gargs, 0), "From")], ), ("slice", "assume_init_ref" | "assume_init_mut") => args.pop()?, @@ -2327,11 +2327,11 @@ fn mapping<'tcx>( Expr::rs("byteSliceEq", args) } ("slice", "to_vec") => slice_to_vec(b, args.pop()?, targ(gargs, 0), span), - // A swap of runs copies each out, as a write of it back reads it. + // 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.run_copy(targ(gargs, 0), span).unwrap_or_else(Expr::undefined)); - Expr::rs("runsSwap", values) + 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)) { @@ -2482,7 +2482,7 @@ fn mapping<'tcx>( { match targ(gargs, 0).is_array() { true => Expr::rs( - "runsOfSlice", + "arraySliceOfSlice", vec![args.pop()?, super::array_fn(targ(gargs, 0), "From")], ), false => args.pop()?, @@ -3106,7 +3106,7 @@ fn mapping<'tcx>( return Some(Expr::rs("slicePlaces", vec![s])); } if elem.is_array() { - return Some(Expr::rs("runsEach", vec![s])); + return Some(Expr::rs("arraySliceEach", vec![s])); } let a = match byte(elem) { true => Expr::rs("byteSliceView", vec![s]), @@ -3324,12 +3324,15 @@ pub(super) fn box_slice_clone_from<'tcx>( } /// 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 runs' own, which makes runs +/// 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); match elem.is_array() { - true => ("runsBoxCloneFrom", [vec![super::array_fn(elem, "From")], fns].concat()), + true => ( + "arraySliceBoxCloneFrom", + [vec![super::array_fn(elem, "From")], fns].concat(), + ), false => ("boxSliceCloneFrom", fns), } } @@ -3525,16 +3528,16 @@ fn slices_join<'tcx>( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![sep])], ), - // An array separator is the runs of it alone, whose elements the join clones as + // 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("runsOne", vec![sep, Expr::lit(n.to_string())]); - Expr::rs("runsItems", vec![one]) + 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])]), - // Runs, as the slice of their arrays. - (false, false) if join && elem.is_array() => Expr::rs("runsItems", 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()?; @@ -3542,8 +3545,8 @@ fn slices_join<'tcx>( let rs = |f: &str| Some(Expr::Rs(f.into())); let slice = match item.kind() { ty::Array(..) => rs(if bytes { "byteSliceFrom" } else { "sliceFrom" }), - // Runs of arrays, as a slice of the arrays. - ty::Ref(_, s, _) if super::runs::of_arrays(*s) => rs("runsItems"), + // 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) => rs(if bytes { "byteVecSlice" } else { "vecSlice" }), _ if let Some(elem) = cow_slice(b.t.tcx, item) @@ -3554,10 +3557,13 @@ fn slices_join<'tcx>( name: "c".into(), ty: None, }; - Some(Expr::Lambda(vec![param], Box::new(Expr::rs("runsItems", vec![runs])))) + 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("runsItems"), + _ 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, }; @@ -3602,7 +3608,7 @@ 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("runsCopy", vec![slice]), + 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 => items_of(slice, elem).method("map", vec![clone]), } @@ -4059,11 +4065,11 @@ pub fn primitive(ty: Ty<'_>) -> bool { } /// The prefix of the runtime's functions of a slice of `elem`: `byteSlice` of bytes, and -/// `runs` of arrays. +/// `arraySlice` of arrays. fn slice_of_elem(elem: Ty<'_>) -> &'static str { match elem.kind() { _ if byte(elem) => "byteSlice", - ty::Array(..) => "runs", + ty::Array(..) => "arraySlice", _ => "slice", } } @@ -4099,7 +4105,7 @@ 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]), - // Copies of the runs of a slice of arrays, which a read can't tell from them. + // 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]), @@ -4119,10 +4125,10 @@ pub fn slice_items(s: Expr) -> Expr { } /// The elements of `s`, a slice of `elem`s, as [`slice_items`] reads them: of arrays, the -/// arrays of its runs, as `rs.runsArray` reads them. +/// 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, "runsArray"), + true => array_of(s, "arraySliceItems"), false => slice_items(s), } } @@ -4140,7 +4146,7 @@ fn array_of(s: Expr, read: &str) -> Expr { 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 == "runsFrom") && read == "runsArray" => { + 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]), @@ -4160,7 +4166,7 @@ pub fn slice_from(items: Expr) -> Expr { } } -/// The slice of a slice, array, or `Vec`, a `ty`: an `rs.ByteSlice` of bytes, an `rs.Runs` +/// 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 { diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 3cac37a19..65b288a1f 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -655,17 +655,17 @@ 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 runs' arrays, as `rs.runsBy` writes them back. + // Of an array of arrays, the arrays' arrays, as `rs.arraySliceBy` writes them back. if elem.is_array() { - let name = self.b.fresh("runs"); - let source = Expr::rs("runsItems", vec![source]); + 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.run_copy(ty, span); - let by = crate::lower::runs::By { name, value: to, copy }; - let e = crate::lower::runs::wrap(e, ts::Type::Builtin("void"), Vec::new(), vec![by]); + 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); @@ -1014,10 +1014,10 @@ 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 runs of it alone, which a write lands in, or of none. + // 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("runsFrom", vec![Expr::Array(items), of.clone()]); + 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); } @@ -1153,7 +1153,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ if crate::lower::byte(elem) => "byteSliceCopyWithin", ty::Array(..) => { values.extend(self.b.t.copy_fn(elem, span)); - "runsCopyWithin" + "arraySliceCopyWithin" } _ => { values.extend(self.b.t.copy_fn(elem, span)); @@ -1443,21 +1443,21 @@ 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 runs of that one, and a - // cell of an array of arrays reads a copy of the runs it views and writes into them. + // 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.run_copy(ty, span); + let copy = self.b.t.elem_copy(ty, span); return Some(Expr::rs( - "cellOfRuns", + "cellOfArraySlice", [vec![slice], copy.into_iter().collect()].concat(), )); } let n = len.try_to_target_usize(tcx).unwrap_or(0); - return Some(Expr::rs("runsOne", vec![slice, Expr::lit(n.to_string())])); + return Some(Expr::rs("arraySliceOne", vec![slice, Expr::lit(n.to_string())])); } if !cell && crate::lower::byte(ty) { return Some(self.err( @@ -1800,11 +1800,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { 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 old = match array { - // Runs, each copied out and written where the slice holds it. - Some(p) if crate::lower::runs::of_arrays(self.b.t.uninit_inner(ty)) => { + // 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.run_copy(ty, span); - Expr::rs("runsReplace", [vec![slice, value], copy.into_iter().collect()].concat()) + 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.borrowed_slice(place.0, p, span, out); @@ -1874,7 +1877,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { return None; } - // A run of a slice of arrays, which is the slice of its elements, in no slot. + // An array of a slice of arrays, which is the slice of its elements, in no slot. if self.in_array(target) { return None; } @@ -1991,9 +1994,9 @@ 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), - // A run of a slice of arrays is the slice of its elements already. + // 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("runsAt", vec![base, checked]), true))); + 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), @@ -2061,8 +2064,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 => "runsRange", - _ if elem_ty.is_array() => "runsGetRange", + _ if elem_ty.is_array() && !get => "arraySliceRange", + _ if elem_ty.is_array() => "arraySliceGetRange", (false, false) => "sliceRange", (false, true) => "sliceGetRange", }; @@ -2286,7 +2289,7 @@ 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" | "runsToArray")) => { + 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 971873105..e18914eec 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -283,7 +283,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // A range of parts, which the pattern that took it checked the length for. if elem_ty.is_array() { let end = base.clone().member("length").binary("-", Expr::lit(to.to_string())); - e = Expr::rs("runsPart", vec![base, Expr::lit(from.to_string()), end]); + 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())); @@ -315,7 +315,7 @@ 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( - "runsPart", + "arraySlicePart", vec![base, Expr::lit(from.to_string()), Expr::lit(end.to_string())], ), // In bounds of the array's. @@ -357,7 +357,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { in_slice = match elem { ProjectionElem::Deref => self.array_behind(place.local, read, ty), ProjectionElem::Subslice { .. } => in_slice, - // A run of a slice of arrays is the slice of its elements. + // An array of a slice of arrays is the slice of its elements. ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => in_slice && next.ty.is_array(), _ => false, }; @@ -367,10 +367,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// Element `i` of `base`, the slice a place of `ty`, a `[T]` or a `[T; N]`, is: an - /// `rs.Runs`' run, lent as the slice of its elements, of arrays. + /// 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("runsAt", vec![base, i]), + ty::Slice(elem) | ty::Array(elem, _) if elem.is_array() => Expr::rs("arraySliceAt", vec![base, i]), _ => slice_at(base, i), } } diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 245efa5a6..7284d1f24 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; @@ -24,7 +25,6 @@ mod mir; pub(crate) mod names; mod num; pub mod pointer; -pub mod runs; mod stock; mod task; mod time; @@ -1517,13 +1517,13 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// 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.Runs` of + /// 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("Runs", vec![self.slice_ty(*inner, span)]), + ty::Array(inner, _) => Type::Rs("ArraySlice", vec![self.slice_ty(*inner, span)]), _ => Type::Rs("Slice", vec![self.ty(elem, span)]), } } @@ -1717,7 +1717,7 @@ 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 runs. + // 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)]), } @@ -2363,14 +2363,14 @@ 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, `runs{name}` of arrays, and else `slice{name}`. `From` -/// of arrays, which lends each by its own `From`, is `rs.runsOf` of that. +/// `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 ty.kind() { _ if byte_array(ty) => "byteSlice", ty::Array(elem, _) if elem.is_array() => match name { - "From" => return ts::Expr::rs("runsOf", vec![array_fn(*elem, "From")]), - _ => "runs", + "From" => return ts::Expr::rs("arraySliceOf", vec![array_fn(*elem, "From")]), + _ => "arraySlice", }, _ => "slice", }; @@ -2386,11 +2386,11 @@ pub fn array_slice(ty: Ty<'_>, value: ts::Expr) -> ts::Expr { } /// `items`, a JS array of `elem`s, or their `Uint8Array`, as the slice of all of them: an -/// `rs.ByteSlice`, an `rs.Runs` of arrays, lending each by its own slice, or an `rs.Slice`. +/// `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("runsFrom", vec![items, array_fn(elem, "From")]), + ty::Array(..) => ts::Expr::rs("arraySliceFrom", vec![items, array_fn(elem, "From")]), _ => library::slice_from(items), } } diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index b901066b0..ee8cd1fb1 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -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) } @@ -504,10 +504,10 @@ pub fn call<'tcx>( ty::Array(elem, _) => super::slice_items_from(e, *elem), _ => super::library::slice_from(e), }; - // The runs of an array of arrays have no JS array to write through. + // 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::runs::of_arrays(ty) => b.err( + 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"), ), From d028e1b43e3a12672bea00907fb5780a6a771560 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 22:13:49 -0800 Subject: [PATCH 11/12] fix(ts): array slices from a deque, a heap, and raw pointers to slices of arrays VecDeque's as_slices, as_mut_slices, and make_contiguous and BinaryHeap's as_slice of arrays lend an rs.ArraySlice of their own arrays, and a raw pointer to a slice of arrays is an rs.RawArraySlice of it, so Box::into_raw and from_raw give back the same storage. Co-Authored-By: Claude Opus 5.5 --- .../lang/slices/expected/core/option.ts | 7 ++ ts/fixtures/lang/slices/expected/lib.ts | 4 +- ts/fixtures/lang/slices/expected/slices.ts | 73 ++++++++++++++++++- ts/fixtures/lang/slices/src/lib.rs | 1 + ts/fixtures/lang/slices/src/slices.rs | 70 ++++++++++++++++++ ts/runtime/rs.ts | 31 ++++++++ ts/runtime/rs/collections.ts | 13 +++- ts/src/lower/collections.rs | 11 ++- ts/src/lower/mir/rvalue.rs | 11 ++- ts/src/lower/pointer.rs | 18 ++++- 10 files changed, 227 insertions(+), 12 deletions(-) diff --git a/ts/fixtures/lang/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index 3a8475ca8..32e5bc006 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -108,6 +108,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 468e61f99..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, arrayForms, arrayIdentity } 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"; @@ -53,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], ["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]]); + 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.ts b/ts/fixtures/lang/slices/expected/slices.ts index 096498545..fbf9ca419 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2,7 +2,7 @@ import * as rs from "./rs.ts"; import { copy$Option_array2_u16, copy$Option_array2_u8, copy$array_array2_array2_u8, copy$array_array2_u16, copy$array_array2_u8, copy$array_u16, copy$array_u8, copy$mem_MaybeUninit_array_u8, copy$slices_Pair, drop$tuple2_Vec_slices_Noisy_Vec_u8 } from "./lib.ts"; -import { isSomeAnd$1ouf3e6, 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, zip$0wdt346, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; +import { isSomeAnd$1ouf3e6, 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"; @@ -3091,4 +3091,75 @@ export function arrayIdentity(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): } } +/** 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, 4); + 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 { + const leaked: rs.ArraySlice = rs.arraySliceFrom(rs.vecFrom(rows.items.map(copy$array_u8)).items, rs.byteSliceFrom); + const _155: rs.ByteSlice | undefined = rs.arraySliceFirst(leaked); + if (_155 !== undefined) { + const _158: rs.u8 = rs.u8WrappingAdd(_155.data[_155.start], 1); + _155.data[_155.start] = _158; + } + 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 298db0185..f59a820eb 100644 --- a/ts/fixtures/lang/slices/src/lib.rs +++ b/ts/fixtures/lang/slices/src/lib.rs @@ -26,5 +26,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("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 967788a9c..74a0ce915 100644 --- a/ts/fixtures/lang/slices/src/slices.rs +++ b/ts/fixtures/lang/slices/src/slices.rs @@ -1552,3 +1552,73 @@ pub fn array_identity(kind: u8, data: &[u8], out: &mut Vec) { } } } + +/// 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 % 4 { + // 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 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 06ae6689b..3b89746af 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -500,6 +500,37 @@ 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; + } +} + +/** 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); diff --git a/ts/runtime/rs/collections.ts b/ts/runtime/rs/collections.ts index edee93bed..32ea02364 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 { ArraySlice, 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, 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, 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"; @@ -3717,6 +3717,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 +3909,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/src/lower/collections.rs b/ts/src/lower/collections.rs index ee0cacf8d..f1a6ea7bd 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -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/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 4b4517e78..ac197dadd 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -96,9 +96,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]), } } }, diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index ee8cd1fb1..8bb077767 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, } @@ -184,6 +184,9 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { _ => 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"), }, @@ -515,9 +518,10 @@ pub fn call<'tcx>( }; // 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())]), @@ -1144,6 +1148,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 { From 1a700327d4441a5e42c8d97f1c8ab7859b25ef55 Mon Sep 17 00:00:00 2001 From: Luke Curley <432854+kixelated@users.noreply.github.com> Date: Fri, 6 Nov 2026 23:17:37 -0800 Subject: [PATCH 12/12] fix(ts): array slices from a rest pattern, a MaybeUninit reborrow, and a borrowed Cow, and split arrays lent lazily Co-Authored-By: Claude Opus 5.5 --- ts/fixtures/lang/arrays/expected/arrays.ts | 26 +++++++++++++++ ts/fixtures/lang/arrays/expected/lib.ts | 12 +++---- ts/fixtures/lang/arrays/src/arrays.rs | 20 ++++++++++++ ts/fixtures/lang/arrays/src/lib.rs | 1 + .../lang/slices/expected/core/option.ts | 7 ++++ ts/fixtures/lang/slices/expected/slices.ts | 32 +++++++++++++++---- ts/fixtures/lang/slices/src/slices.rs | 24 +++++++++++++- ts/runtime/rs/iter.ts | 27 ++++++++++------ ts/src/lower/mir/place.rs | 21 ++++++++---- ts/src/lower/mir/rvalue.rs | 5 ++- 10 files changed, 144 insertions(+), 31 deletions(-) diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index 36f3992f5..ad2b01845 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -2033,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/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index 32e5bc006..abc12b842 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -22,6 +22,13 @@ export function isSomeAnd$1ouf3e6(self: [rs.ByteSlice, rs.ByteSlice] | undefined return f(self); } +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_; diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index 899f9c7ef..4b89d5fc8 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -2,7 +2,7 @@ import * as rs from "./rs.ts"; import { copy$Option_array2_u16, copy$Option_array2_u8, copy$array_array2_array2_u8, copy$array_array2_u16, copy$array_array2_u8, copy$array_u16, copy$array_u8, copy$mem_MaybeUninit_array_u8, copy$slices_Pair, drop$tuple2_Vec_slices_Noisy_Vec_u8 } from "./lib.ts"; -import { isSomeAnd$1ouf3e6, 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 { 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"; @@ -3099,7 +3099,7 @@ export function arraySources(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): rs.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); }), undefined, 2, true); - const _7: rs.u8 = rs.u8Rem(kind, 4); + 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)); @@ -3151,12 +3151,32 @@ export function arraySources(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): 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 _155: rs.ByteSlice | undefined = rs.arraySliceFirst(leaked); - if (_155 !== undefined) { - const _158: rs.u8 = rs.u8WrappingAdd(_155.data[_155.start], 1); - _155.data[_155.start] = _158; + 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); } diff --git a/ts/fixtures/lang/slices/src/slices.rs b/ts/fixtures/lang/slices/src/slices.rs index 74a0ce915..9ad2481c6 100644 --- a/ts/fixtures/lang/slices/src/slices.rs +++ b/ts/fixtures/lang/slices/src/slices.rs @@ -1556,7 +1556,7 @@ pub fn array_identity(kind: u8, data: &[u8], out: &mut Vec) { /// 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 % 4 { + 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(); @@ -1612,6 +1612,28 @@ pub fn array_sources(kind: u8, data: &[u8], out: &mut Vec) { 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(); diff --git a/ts/runtime/rs/iter.ts b/ts/runtime/rs/iter.ts index 0cfa45158..6a94f6897 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, type ArrayRef, type ArraySlice, arraySliceItems, arraySliceAt, arraySliceEach, 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 { 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"; @@ -477,27 +477,27 @@ export function sliceRsplitn(s: Slice, n: number, f: (item: T) => boolean) /** `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, arraySliceEach(r), 0, arraySlicePart, f, false, false); + 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, arraySliceEach(r), 0, arraySlicePart, f, true, false); + 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, arraySliceEach(r), 0, arraySlicePart, f, false, true); + 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, arraySliceEach(r), 0, arraySlicePart, f, false, false, n); + 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, arraySliceEach(r), 0, arraySlicePart, f, true, false, n); + 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. */ @@ -2264,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; @@ -2280,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; @@ -2295,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; @@ -2355,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; @@ -2372,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/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 8b0627d77..e0917d952 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -509,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])) } @@ -681,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"), diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 85a68a128..ed8018851 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -63,7 +63,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match (pointee.is_array(), self.in_array(*place)) { (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, } }