diff --git a/quest/m3/README.md b/quest/m3/README.md index d719b579d..852b7296e 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -32,7 +32,8 @@ generic std gap is planned here even when moq never calls it. - [A closure that drops given to a string's edit or search](/quest/m3/ts-string-closures.md) - `String::retain` and `str`'s searches by a closure that owns a value that drops translate - [Waiting: a slice object for a mutable part of other values](/quest/m3/ts-slice-object.md) - waits on a moq profile showing the `Proxy` view's traps matter, then decides on an `rt.ByteSlice`-like form - [Port the workflow guard to kixelated/quest](/quest/m3/quest-workflow-guard.md) - quest's environment guard parses YAML as this repository's does -- [A deque's two slices](/quest/m3/ts-deque-slices.md) - `VecDeque::as_slices` and `{:?}` of a deque's `Iter`, `IterMut`, and `Drain` translate, split where std's are +- [A comparison of two constants](/quest/m3/ts-constant-compares.md) - `size_of::() == 1` in a generic function translates to TypeScript `tsc` accepts +- [A vector's exact capacity as it shrinks](/quest/m3/ts-vec-exact-capacity.md) - a deque made from a `Vec` splits its slices where std's does - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number - [Rc and Arc of a slice](/quest/m3/ts-shared-slices.md) - `Rc<[T]>` and `Arc<[T]>` from a `Vec`, a slice, or an iterator translate - [The rest of a vector's methods](/quest/m3/ts-vec-rest.md) - `append`, `resize`, `split_off`, `try_reserve`, and `Vec::from(VecDeque)` translate diff --git a/quest/m3/ts-constant-compares.md b/quest/m3/ts-constant-compares.md new file mode 100644 index 000000000..7f3e67e24 --- /dev/null +++ b/quest/m3/ts-constant-compares.md @@ -0,0 +1,18 @@ +# [S] A comparison of two constants + +## Goal + +[rust2-ts](/ts/README.md) translates a comparison whose sides are both constants once a +generic function is monomorphized, such as `size_of::() == 1` in a function generic +over `T`, into TypeScript `tsc` accepts, proven by a fixture that runs it for a `T` of each +outcome against native Rust. + +## Plan + +Found writing the deque's slices fixture +([moq-dev/rust2#443](https://github.com/moq-dev/rust2/pull/443)): each instance writes +`12 === 1`, which `tsc` rejects as TS2367, two literal types with no overlap, so the +crate fails to translate. Fold the comparison to its value, or widen a side, where both are +literals. + +Public API: the translator's output. diff --git a/quest/m3/ts-deque-slices.md b/quest/m3/ts-deque-slices.md deleted file mode 100644 index 89405b040..000000000 --- a/quest/m3/ts-deque-slices.md +++ /dev/null @@ -1,29 +0,0 @@ -# [M] A deque's two slices - -## Goal - -[rust2-ts](/ts/README.md) translates `VecDeque::as_slices` and `as_mut_slices`, and `{:?}` -of `vec_deque::Iter`, `IterMut`, and `Drain`, writing the same text as std, proven by -differential tests against native Rust on wrapped deques. - -## Plan - -Left by [moq-dev/rust2#317](https://github.com/moq-dev/rust2/pull/317), which translated -the rest of std's iterators' `Debug`. - -- `Iter` and `IterMut` write the two slices of the ring buffer as `as_slices` splits it: - `Iter([3], [1, 2])`, each half as consumed so far, the second taking the first's place - once it empties (`vec_deque/iter.rs`). The split depends on the buffer's capacity and - where its head sits. -- The runtime's deque does not split where std's does: it grows to a power of two of at - least 4 and moves its head to 0, ignores `with_capacity`, and shifts items one at a time - in `insert` and `remove`. std keeps `RawVec`'s capacity, moves the shorter segment as it - grows (`handle_capacity_increase`), and moves the shorter side in `insert`, `remove`, and - the rest. Every function that places items must place them where std's does. -- Open: a deque holds only what std guarantees of its capacity, doubling as it grows - (decided 2026-11-01 to keep pushes cheap), so splitting where std's does needs its exact - capacity, at a cost to measure, or the maintainer's call to drop the split. -- `Drain` writes its counts, `Drain(drain_len, idx, tail_len, remaining)`, which the - runtime's drain does not keep. - -Public API: the translator's output. diff --git a/quest/m3/ts-vec-exact-capacity.md b/quest/m3/ts-vec-exact-capacity.md new file mode 100644 index 000000000..142a4f610 --- /dev/null +++ b/quest/m3/ts-vec-exact-capacity.md @@ -0,0 +1,27 @@ +# [M] A vector's exact capacity as it shrinks + +## Goal + +[rust2-ts](/ts/README.md) holds a `Vec`'s exact capacity through every step, as it now +does a `VecDeque`'s, so a deque made from a `Vec` splits its slices where std's does, +proven by differential tests against native Rust. + +## Plan + +Found splitting a deque's slices where std's does +([moq-dev/rust2#443](https://github.com/moq-dev/rust2/pull/443)): a deque now holds std's +exact capacity, but one made from a `Vec`, by `From>` or by `collect`, takes the +capacity the runtime models for the `Vec`, which holds only std's guarantees (decided +2026-11-01) and so recomputes from its length after a pop, `truncate`, or `drain`. A +`Vec` already holds its exact capacity as its buffer's length. + +- Recording the capacity on the array where a step shrinks the length (a `peak` each pop + raises) was measured on `push/stack`, which pushes onto a `Vec`, popping one every + fourth push, then pops it empty: 1.24x in Node, 1.11x in Chrome, 2.3x in Bun, and 2.8x + in Firefox, every other workload within noise. The maintainer kept the guarantee-only + model on 2026-11-02, accepting that a deque made from a shrunk `Vec` may split + differently from std's. +- Untried: a `Vec` as a wrapper object holding its own length and capacity over its + array, measured on the same workload before it is weighed against that decision. + +Public API: the translator's output. diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index cdb89c444..aeaea18fd 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -18,11 +18,20 @@ through `rt.hashI8` to `rt.hashI128`, `rt.hashUsize`, or `rt.hashIsize`, as its Rust impl calls `write_i8` and the rest. `rt.hashOne` takes the hasher it hashes into, as in `rt.hashOne(rt.buildHasher(state), value, hash)`. -- `rt.vecCapacity`, `rt.vecReserve`, `rt.vecReserveExact`, and `rt.dequeReserve` are now - `Vec::capacity`, `reserve`, and `reserve_exact` and `VecDeque::reserve` of a vector, its - element size in bytes last, as in `rt.vecReserve(v, additional, 4)`, not the arithmetic - an extend reserved by; `rt.vecPush` and `rt.vecGrow` are gone. `rt.dequeClone` and - `rt.heapClone` take the element size after the clone function. +- `rt.vecCapacity`, `rt.vecReserve`, and `rt.vecReserveExact` are now `Vec::capacity`, + `reserve`, and `reserve_exact` of a vector, its element size in bytes last, as in + `rt.vecReserve(v, additional, 4)`, not the arithmetic an extend reserved by; + `rt.vecPush` and `rt.vecGrow` are gone. `rt.heapClone` takes the element size after the + clone function. +- `rt.vecExtendFromSlice` takes the element size in bytes after the slice, as in + `rt.vecExtendFromSlice(v, s, 4)`. `rt.iterToArray` and `rt.iterToByteVec` take the + source element size of a `collect` that may reuse its source's buffer last. +- An `rt.VecDeque` holds std's capacity as its buffer's length and its item size as `s`, + and a deque of bytes is a `Uint8Array`: `rt.dequeNew`, `rt.dequeWithCapacity`, and + `rt.dequeFromVec` take the item size and whether it holds bytes, as in + `rt.dequeNew(4)`, and `rt.dequeCapacity`, `rt.dequeReserve`, `rt.dequeReserveExact`, + `rt.dequeShrinkTo`, `rt.dequeClone`, `rt.dequeExtend`, and `rt.dequePart` no longer take + it. `rt.dequeIter` no longer takes a dropper: `rt.dequeIntoIter` is `into_iter`. - Every translation needs `tsc` 7.0 or later on `PATH`, not only one with bindings: it type-checks the output, and fails at the Rust span of each error, where it succeeded before. diff --git a/ts/README.md b/ts/README.md index 829eaea40..a31c0026d 100644 --- a/ts/README.md +++ b/ts/README.md @@ -249,9 +249,9 @@ what each holds. `Debug` of a string or `char` escapes by std's Unicode tables, which the runtime carries, not the engine's. `Debug` of std's collections writes their items in the order each iterates, a hash map's or set's included, and of their iterators and `Chars` the items each has left, in std's wrapper; a deque's -`Iter` and `IterMut`, which write its buffer's two halves, and its `Drain`, which writes its -counts, are refused; a list's `Iter` and `IterMut` write what is left and its length, as -std's do. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is +`Iter` and `IterMut` write the two slices of its buffer they have left, swapped as std's +swap them, and its `Drain` its counts; a list's `Iter` and `IterMut` write what is left and +its length, as std's do. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is their derived one, whichever way each is held, and a guard of a cell or a lock, mapped or not, writes what it lends by its own `Debug` and `Display`. A caller prints a `printable` type as `to_string()` and `format!("{err:?}")` @@ -792,11 +792,14 @@ they need. with the maintainer on 2026-11-01). It holds one, as `cap`, only where an operation sets it or a removal reads it, so an insert never reads or writes one, and reading it doubles it from 3 while short of the length. `VecDeque` is a ring buffer over an array - whose length is a power of two. A `Vec`, `VecDeque`, and `BinaryHeap` hold what std + whose length is std's capacity, a `Uint8Array` of bytes, and each step places its items + where std's does, so `as_slices` splits them as std's; one made from a `Vec` takes the + capacity held for the `Vec`. A `Vec` and `BinaryHeap` hold what std guarantees of their capacity: at least their length and what `with_capacity`, `reserve`, and `reserve_exact` ask for, and std's exactly where its doubling fixes it, - as through pushes. `clone_from` and `clone_into`, of which std guarantees only the - length, leave a clone's capacity, not the allocation std reuses. One holds a capacity, as `cap`, only where `with_capacity`, `reserve`, + as through pushes, a `clone_from` into a `Vec` that keeps its own, and a `collect` that + reuses its source's buffer, in place or from a boxed slice, whose capacity is its + length. One holds a capacity, as `cap`, only where `with_capacity`, `reserve`, `shrink_to`, a `clone`, or a `collect` or `extend` set it, so a push never reads or writes one. Reading it doubles it while short of the length, from the least std's `RawVec` allocates for the element size, which a run of pushes grows std's to. A diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index b3f88e384..f0da8c28a 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -443,7 +443,7 @@ export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void let _37!: rt.u32; const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); if (selector === 1) { - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(4) as rt.VecDeque; let iterStart: rt.u32 = 0; const iterEnd: rt.u32 = count2; while ((_18 = iterStart++) < iterEnd) { diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index b6e847b50..e7c8996ba 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -868,13 +868,13 @@ const gets = [0, 0x10].flatMap((text) => { * it tries. */ const capacityCases = [ - ...[["capacity::vecs", 25], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => + ...[["capacity::vecs", 29], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => Array.from({ length: 5 * 2 * (steps as number) * 4 }, (_, i) => { const [kind, first, step, arg] = [i % 5, (Math.floor(i / 5) % 2) * 0x11, Math.floor(i / 10) % (steps as number), [3, 0xc1, 0xe3, 0x16][Math.floor(i / (10 * (steps as number)))]]; return Uint8Array.of(...op(name as string), kind, first, ...[0, 1, 0, 2, 0, 3, 0, 4, 0, 5].map((b, j) => (j % 2 === 0 ? b : b * 41)), step, arg, step, arg ^ 1); }), ), - ...[["capacity::vecs", 25], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => + ...[["capacity::vecs", 29], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) => Array.from({ length: 5 * 2 * (steps as number) }, (_, i) => Uint8Array.of(...op(name as string), i % 5, 0, 0, 1, 3 + (Math.floor(i / 5) % 2), 3, Math.floor(i / 10), 0)), ), ...["capacity::vecs", "capacity::deques", "capacity::heaps"].flatMap((name) => @@ -884,6 +884,31 @@ const capacityCases = [ ...Array.from({ length: 8 * 6 }, (_, i) => Uint8Array.of(...op("capacity::collects"), i % 8, [0, 1, 2, 5, 9, 23][Math.floor(i / 8)], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), ]; +/** + * `rings::slices` of each item type, from a deque made by `new`, `with_capacity` of 5, and + * from a `Vec` of 7: pushed at both ends and popped at the front to wrap it, past a few + * capacities, then each step by a few arguments, twice. + */ +const ringsCases = Array.from({ length: 5 * 3 * 4 * 24 * 3 }, (_, i) => { + const [kind, first, wraps, step, arg] = [i % 5, [0, 0x15, 0x1e][Math.floor(i / 5) % 3], [1, 3, 6, 10][Math.floor(i / 15) % 4], Math.floor(i / 60) % 24, [0, 0x5b, 0xe7][Math.floor(i / 1440)]]; + const wrap = Array.from({ length: wraps }, (_, j) => [j % 3 === 2 ? 4 : 0, j * 3, 6, 0, 4, j]).flat(); + return Uint8Array.of(...op("rings::slices"), kind, first, ...wrap, step, arg, step, arg ^ 0x25); +}); + +/** + * `rings::slices` remaking each wrapped deque each way and with a few skips: a clone, + * `clone_from`, `clone_into`, its `into_iter` read in part and by `nth`, from a `Vec` as it + * is and filtered in place, and a `Vec`'s `into_iter` read in part, collected as it is and + * cloned; then pushed at both ends. + */ +const remadeCases = [0, 5, 0x2d, 0x37, 0x64, 0x6e, 1, 0x10, 2, 0x11, 3, 0x21, 0x0e, 0x13, 0x45, 0x5f].flatMap((arg) => + Array.from({ length: 5 * 3 * 4 }, (_, i) => { + const [kind, first, wraps] = [i % 5, [0, 0x15, 0x1e][Math.floor(i / 5) % 3], [1, 3, 6, 10][Math.floor(i / 15)]]; + const wrap = Array.from({ length: wraps }, (_, j) => [j % 3 === 2 ? 4 : 0, j * 3, 6, 0, 4, j]).flat(); + return Uint8Array.of(...op("rings::slices"), kind, first, ...wrap, 22, arg, 0, 9, 4, 9); + }), +); + /** * `sorts` cases of each length std's thresholds part, of each run of keys; `disorders` * cases of each length, kind of item, and sort; and `btrees` cases of each length. @@ -894,4 +919,4 @@ const sortCases = [ ...Array.from({ length: 20 * 5 }, (_, i) => Uint8Array.of(...op("sorts::btrees"), i % 20, Math.floor(i / 20), 2, 9)), ]; -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...placeCompares, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases, ...sortCases]; +export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...placeCompares, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases, ...ringsCases, ...remadeCases, ...sortCases]; diff --git a/ts/fixtures/lang/expected/bounds.ts b/ts/fixtures/lang/expected/bounds.ts index 11be217b4..5fc1955b0 100644 --- a/ts/fixtures/lang/expected/bounds.ts +++ b/ts/fixtures/lang/expected/bounds.ts @@ -179,7 +179,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(out); rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes2)), undefined, true); } else if (_28 === 2) { - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(1) as rt.VecDeque; const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))); while (true) { const _104: [rt.usize, rt.u8] | rt.Done = iter2.next(); diff --git a/ts/fixtures/lang/expected/boxes.ts b/ts/fixtures/lang/expected/boxes.ts index f2640e2ef..a0a3a774a 100644 --- a/ts/fixtures/lang/expected/boxes.ts +++ b/ts/fixtures/lang/expected/boxes.ts @@ -9,7 +9,7 @@ import { then$0ea5h05 } from "./core/bool.ts"; import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$11c0we2 as option_unwrapOr$11c0we2, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0w2m0zn as option_asDeref$0w2m0zn, asDeref$0avuzwv as option_asDeref$0avuzwv, flatten$08boupk as option_flatten$08boupk } from "./core/option.ts"; import { map$0nfi04k as result_map$0nfi04k, asDeref$1fldd5d as result_asDeref$1fldd5d, asDeref$04i8i5u as result_asDeref$04i8i5u, unwrapOr$0e4foht as result_unwrapOr$0e4foht, copied$0bbq7yi as result_copied$0bbq7yi } from "./core/result.ts"; import { put as fmt_put } from "./fmt.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** Puts what was logged since the last flush, after a marker. */ export function flush(log: rt.RefCell, out: rt.ByteVec): void { @@ -265,7 +265,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, rt.u64Eq(hash$boxed_Box_slice_u16(collected2), hash$slice_u16(rt.sliceRange(collected2, 0))) ? 1 : 0); const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(collected2, f, rt.u16Debug)]; fmt_put(out, rt.fmtFormat([args4[0]])); - const v3: rt.u16[] = fromVec2; + const v3: rt.u16[] = rt.vecExact(fromVec2, 2); v3.push(5); wides(v3, out); let slot2: rt.u16[] = fromArray2; @@ -275,7 +275,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const taken = slot2; slot2 = []; wides(taken, out); - const it: rt.Iter = rt.iterSlice(wide); + const it: rt.Iter = rt.iterSlice(rt.vecExact(wide, 2)); rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(rt.iterToOption(it.nextBack()), 0)).reverse()), undefined, true); rt.byteVecPush(out, it.len() & 0xff); rt.iterExtendBytes(out, rt.iterMap(it, (x4: rt.u16): rt.u8 => { @@ -309,7 +309,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { collected3[0][Symbol.dispose](); collected3[0] = _444; flush(log.value, out); - const it2: rt.Iter = rt.iterSlice(cloned3, rt.drop); + const it2: rt.Iter = rt.iterSlice(rt.vecExact(cloned3, 8), rt.drop); const _454: boxes_Logged.Logged | rt.Done = it2.next(); if (_454 !== rt.DONE) { const first: boxes_Logged.Logged = _454; @@ -321,7 +321,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.drop(it2); flush(log.value, out); rt.drop(back); - const v4: boxes_Logged.Logged[] = fromRef3; + const v4: boxes_Logged.Logged[] = rt.vecExact(fromRef3, 8); ids(v4, out); rt.dropAll(v4); flush(log.value, out); @@ -368,7 +368,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); }), undefined, 2, true); - const quadsV: Uint8Array[] = quads.map(copy$array_u8); + const quadsV: Uint8Array[] = rt.vecExact(quads.map(copy$array_u8), 2); const _554: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(quadsV), rt.byteSliceFrom); if (_554 !== undefined) { _554.data[_554.start] = 119; @@ -410,7 +410,7 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_634[1]).reverse()), undefined, true); } } else { - const s: string = text(data2); + const s: string = strs_text(data2); const fromRef4: string = s; const fromString: string = s; const into2: string = s; @@ -855,11 +855,11 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_113[1]).reverse()), undefined, true); } let s: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, 0, half))), (_222: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_222))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(_222))); }), undefined, 12, true); const t: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, half, rt.usizeMul(half, 2)))), (_223: rt.u8): string => { const x11: rt.u8 = _223; - return text(rt.byteSliceFrom(Uint8Array.of(x11, x11))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(x11, x11))); }), undefined, 12, true); s = rt.boxSliceCloneFrom(s, t); const _138: rt.Place | undefined = rt.sliceFirstMut(s); @@ -910,7 +910,7 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.dropAll(m); flush(log.value, out); let t2: string = "ab"; - t2 = text(data2); + t2 = strs_text(data2); fmt_put(out, t2); } else if (_23 === 1) { let a2: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); @@ -942,7 +942,7 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const v3: rt.ByteVec = rt.byteSliceToByteVec(data2); rt.byteVecPush(v3, 102); bytes(rt.byteVecSlice(v3), out); - let s2: string = text(data2); + let s2: string = strs_text(data2); s2 = s2 + "#"; fmt_put(out, s2); const w2: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_28: rt.u8): rt.u16 => { @@ -1019,7 +1019,7 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_Logged(r2); flush(log.value, out); } else { - const s3: string = text(data2); + const s3: string = strs_text(data2); const a6: rt.ByteSlice = rt.stringAsBytes(s3); rt.byteSliceView(a6).reverse(); bytes(a6, out); diff --git a/ts/fixtures/lang/expected/capacity.ts b/ts/fixtures/lang/expected/capacity.ts index 3ea560670..3887980c3 100644 --- a/ts/fixtures/lang/expected/capacity.ts +++ b/ts/fixtures/lang/expected/capacity.ts @@ -93,7 +93,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { v.push(copy$array_u64(make(arg))); } else if (_42 === 2) { @@ -101,7 +101,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 1280); } else { rt.vecReserveExact(v, additional, 1280); @@ -131,14 +131,13 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); } else if (_42 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$array_u64); - Known.loose(k); + rt.vecExtendFromSlice(v, rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 24) as rt.usize, copy$array_u64), 1280, copy$array_u64); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: rt.u64[]): boolean => { + rt.vecRetain(v, (_29: rt.u64[]): boolean => { return keep(); }); Known.loose(k); @@ -149,14 +148,14 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d v = rt.vecExact(v.map(copy$array_u64), 1280); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 1280); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: rt.u64[]): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: rt.u64[]): boolean => { return keep2(); - }), "next", 1280); - Known.remade(k, false); + }), "next", 1280, false, 1280); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -169,18 +168,18 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d rt.iterToOption(it.nextBack()); } } - v = rt.iterToArray(it, "next", 1280, true); - Known.remade(k, false); + v = rt.iterToArray(it, "next", 1280, true, 1280); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: rt.u64[][] = rt.replaceIn(v, []); - const _196: rt.u64[] = copy$array_u64(make(arg)); - taken.push(_196); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 1280); - Known.put(k, out, _199, _201); - const _205: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 1280); + const _197: rt.u64[] = copy$array_u64(make(arg)); + taken.push(_197); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 1280); + Known.put(k, out, _200, _202); + const _206: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 1280); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 1280)); } else if (_42 === 21) { @@ -193,23 +192,42 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToArray(it2.clone({ v: copy$array_u64 }), "next", 1280, true); + const exact: boolean = k.exact; + v = rt.iterToArray(it2.clone({ v: copy$array_u64 }), "next", 1280, true, 1280); Known.remade(k, true); - const rest: rt.u64[][] = rt.iterToArray(it2, "next", 1280, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 1280)); + const rest: rt.u64[][] = rt.iterToArray(it2, "next", 1280, true, 1280); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 1280)); } else if (_42 === 24) { v = rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$array_u64); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIf(v, (_26: rt.u64[]): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.map(copy$array_u64), 1280), v], 1280, undefined, undefined, copy$array_u64); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 1280)), "next", 1280, true, 1280); + Known.remade(k, true); + } else if (_42 === 28) { + let own: rt.u64[][] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 1280); + const _296: rt.u64[] = copy$array_u64(make(arg)); + own.push(_296); + own = rt.vecClonedInto(rt.vecExact(v.map(copy$array_u64), 1280), own, 1280); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 1280); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 1280); + Known.put(k, out, _305, _307); } } @@ -239,7 +257,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { v.push(copy$tuple2_u64_u8(make(arg))); } else if (_42 === 2) { @@ -247,7 +265,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 16); } else { rt.vecReserveExact(v, additional, 16); @@ -277,14 +295,13 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); } else if (_42 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)], copy$tuple2_u64_u8); - Known.loose(k); + rt.vecExtendFromSlice(v, rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 24) as rt.usize, copy$tuple2_u64_u8), 16, copy$tuple2_u64_u8); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: [rt.u64, rt.u8]): boolean => { + rt.vecRetain(v, (_29: [rt.u64, rt.u8]): boolean => { return keep(); }); Known.loose(k); @@ -295,14 +312,14 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, v = rt.vecExact(v.map(copy$tuple2_u64_u8), 16); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 16); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: [rt.u64, rt.u8]): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: [rt.u64, rt.u8]): boolean => { return keep2(); - }), "next", 16); - Known.remade(k, false); + }), "next", 16, false, 16); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -315,18 +332,18 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, rt.iterToOption(it.nextBack()); } } - v = rt.iterToArray(it, "next", 16, true); - Known.remade(k, false); + v = rt.iterToArray(it, "next", 16, true, 16); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: [rt.u64, rt.u8][] = rt.replaceIn(v, []); - const _196: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); - taken.push(_196); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 16); - Known.put(k, out, _199, _201); - const _205: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); + const _197: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + taken.push(_197); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 16); + Known.put(k, out, _200, _202); + const _206: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 16)); } else if (_42 === 21) { @@ -339,23 +356,42 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter<[rt.u64, rt.u8]> = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToArray(it2.clone({ v: copy$tuple2_u64_u8 }), "next", 16, true); + const exact: boolean = k.exact; + v = rt.iterToArray(it2.clone({ v: copy$tuple2_u64_u8 }), "next", 16, true, 16); Known.remade(k, true); - const rest: [rt.u64, rt.u8][] = rt.iterToArray(it2, "next", 16, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 16)); + const rest: [rt.u64, rt.u8][] = rt.iterToArray(it2, "next", 16, true, 16); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 16)); } else if (_42 === 24) { v = rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$tuple2_u64_u8); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIf(v, (_26: [rt.u64, rt.u8]): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.map(copy$tuple2_u64_u8), 16), v], 16, undefined, undefined, copy$tuple2_u64_u8); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 16)), "next", 16, true, 16); + Known.remade(k, true); + } else if (_42 === 28) { + let own: [rt.u64, rt.u8][] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 16); + const _296: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + own.push(_296); + own = rt.vecClonedInto(rt.vecExact(v.map(copy$tuple2_u64_u8), 16), own, 16); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 16); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 16); + Known.put(k, out, _305, _307); } } @@ -385,7 +421,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { v.push(make(arg)); } else if (_42 === 2) { @@ -393,7 +429,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 2); } else { rt.vecReserveExact(v, additional, 2); @@ -423,14 +459,13 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); } else if (_42 === 12) { - rt.vecExtendFromSlice(v, [make(arg), make(arg)]); - Known.loose(k); + rt.vecExtendFromSlice(v, rt.vecFromElem(make(arg), rt.u8Rem(arg, 24) as rt.usize, undefined), 2); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: rt.u16): boolean => { + rt.vecRetain(v, (_29: rt.u16): boolean => { return keep(); }); Known.loose(k); @@ -441,14 +476,14 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n v = rt.vecExact(v.slice(), 2); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 2); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: rt.u16): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: rt.u16): boolean => { return keep2(); - }), "next", 2); - Known.remade(k, false); + }), "next", 2, false, 2); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -461,18 +496,18 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n rt.iterToOption(it.nextBack()); } } - v = rt.iterToArray(it, "next", 2, true); - Known.remade(k, false); + v = rt.iterToArray(it, "next", 2, true, 2); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: rt.u16[] = rt.replaceIn(v, []); - const _196: rt.u16 = make(arg); - taken.push(_196); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 2); - Known.put(k, out, _199, _201); - const _205: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); + const _197: rt.u16 = make(arg); + taken.push(_197); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 2); + Known.put(k, out, _200, _202); + const _206: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 2)); } else if (_42 === 21) { @@ -485,23 +520,42 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToArray(it2.clone(), "next", 2, true); + const exact: boolean = k.exact; + v = rt.iterToArray(it2.clone({ v: rt.itself }), "next", 2, true, 2); Known.remade(k, true); - const rest: rt.u16[] = rt.iterToArray(it2, "next", 2, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 2)); + const rest: rt.u16[] = rt.iterToArray(it2, "next", 2, true, 2); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 2)); } else if (_42 === 24) { v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIfMut(v, (_26: rt.Place): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.slice(), 2), v], 2); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 2)), "next", 2, true, 2); + Known.remade(k, true); + } else if (_42 === 28) { + let own: rt.u16[] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 2); + const _296: rt.u16 = make(arg); + own.push(_296); + own = rt.vecClonedInto(rt.vecExact(v.slice(), 2), own, 2); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 2); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 2); + Known.put(k, out, _305, _307); } } @@ -531,7 +585,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { rt.byteVecPush(v, make(arg)); } else if (_42 === 2) { @@ -539,7 +593,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.byteVecReserve(v, additional); } else { rt.byteVecReserveExact(v, additional); @@ -569,14 +623,13 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu } else if (_42 === 11) { rt.iterExtendBytes(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); } else if (_42 === 12) { - rt.byteVecExtendFromSlice(v, rt.byteSliceFrom(Uint8Array.of(make(arg), make(arg)))); - Known.loose(k); + rt.byteVecExtendFromSlice(v, rt.byteVecSlice(rt.byteVecOf(make(arg), rt.u8Rem(arg, 24) as rt.usize))); } else if (_42 === 13) { rt.byteVecClear(v); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.byteVecRetain(v, (_28: rt.u8): boolean => { + rt.byteVecRetain(v, (_29: rt.u8): boolean => { return keep(); }); Known.loose(k); @@ -588,15 +641,15 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu Known.remade(k, true); } else if (_42 === 17) { v = rt.byteSliceToByteVec(rt.byteVecSlice(v)); - Known.remade(k, false); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteVecView(v)), (_26: rt.u8): boolean => { + v = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(v), (_28: rt.u8): boolean => { return keep2(); - }), "next"); - Known.remade(k, false); + }), "next", false, 1); + Known.remade(k, k.exact); } else if (_42 === 19) { - const it: rt.Iter = rt.iterSlice(rt.byteVecView(v)); + const it: rt.Iter = rt.byteVecIntoIter(v); const _174: rt.u8 = rt.u8Rem(arg, 8); let iterStart: rt.u8 = 0; const iterEnd: rt.u8 = _174; @@ -607,16 +660,16 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu rt.iterToOption(it.nextBack()); } } - v = rt.iterToByteVec(it, "next", true); - Known.remade(k, false); + v = rt.iterToByteVec(it, "next", true, 1); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: rt.ByteVec = rt.replaceIn(v, new rt.ByteVec()); - const _196: rt.u8 = make(arg); - rt.byteVecPush(taken, _196); + const _197: rt.u8 = make(arg); + rt.byteVecPush(taken, _197); Known.put(k, out, taken.length, taken.data.length); - const _205: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); + const _206: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, taken.data.length); } else if (_42 === 21) { @@ -628,20 +681,39 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu rt.byteVecDedup(v); Known.loose(k); } else if (_42 === 23) { - const it2: rt.Iter = rt.iterSlice(rt.byteVecView(v)); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const it2: rt.Iter = rt.byteVecIntoIter(v); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next()); } - v = rt.iterToByteVec(it2.clone(), "next", true); + const exact: boolean = k.exact; + v = rt.iterToByteVec(it2.clone({ v: rt.itself }), "next", true, 1); Known.remade(k, true); - const rest: rt.ByteVec = rt.iterToByteVec(it2, "next", true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rest.data.length); + const rest: rt.ByteVec = rt.iterToByteVec(it2, "next", true, 1); + Known.put({ exact, floor: 0 }, out, rest.length, rest.data.length); } else if (_42 === 24) { v = rt.byteVecOf(make(arg), rt.u8Rem(arg, 6) as rt.usize); Known.remade(k, false); + } else if (_42 === 25) { + rt.byteVecPopIf(v, (_26: rt.Place): boolean => { + return rt.u8Rem(arg, 2) === 1; + }); + Known.loose(k); + } else if (_42 === 26) { + v = rt.byteSlicesJoin([rt.byteVecFrom(rt.byteVecView(v)), v], undefined, rt.byteVecSlice); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToByteVec(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v))), "next", true, 1); + Known.remade(k, true); + } else if (_42 === 28) { + let own: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 8) as rt.usize); + const _296: rt.u8 = make(arg); + rt.byteVecPush(own, _296); + own = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(v)), own); + v = own; + Known.remade(k, true); } Known.put(k, out, v.length, v.data.length); } @@ -673,7 +745,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; const op: rt.u8 = _33[0]; const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 25); + const _42: rt.u8 = rt.u8Rem(op, 29); if (_42 === 0 || _42 === 1) { const _44: undefined[] = v; make(arg); @@ -683,7 +755,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: Known.loose(k); } else if (_42 === 3 || _42 === 4) { const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 25) === 3) { + if (rt.u8Rem(op, 29) === 3) { rt.vecReserve(v, additional, 0); } else { rt.vecReserveExact(v, additional, 0); @@ -716,17 +788,15 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } else if (_42 === 11) { rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); } else if (_42 === 12) { - const _121: undefined[] = v; + const _120: undefined[] = v; make(arg); - make(arg); - rt.vecExtendFromSlice(_121, [undefined, undefined]); - Known.loose(k); + rt.vecExtendFromSlice(_120, rt.vecFromElem(undefined, rt.u8Rem(arg, 24) as rt.usize, undefined), 0); } else if (_42 === 13) { rt.vecTruncate(v, 0); Known.loose(k); } else if (_42 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: undefined): boolean => { + rt.vecRetain(v, (_29: undefined): boolean => { return keep(); }); Known.loose(k); @@ -737,14 +807,14 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: v = rt.vecExact(v.slice(), 0); Known.remade(k, true); } else if (_42 === 17) { - v = v; - Known.remade(k, false); + v = rt.vecExact(v, 0); + Known.remade(k, true); } else if (_42 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_26: undefined): boolean => { + v = rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_28: undefined): boolean => { return keep2(); }), "next", 0); - Known.remade(k, false); + Known.remade(k, k.exact); } else if (_42 === 19) { const it: rt.Iter = rt.iterSlice(v); const _174: rt.u8 = rt.u8Rem(arg, 8); @@ -758,17 +828,17 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } } v = rt.iterToArray(it, undefined, 0, true); - Known.remade(k, false); + Known.remade(k, k.exact); } else if (_42 === 20) { let taken: undefined[] = rt.replaceIn(v, []); make(arg); taken.push(undefined); - const _199: rt.usize = taken.length; - const _201: rt.usize = rt.vecCapacity(taken, 0); - Known.put(k, out, _199, _201); - const _205: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); + const _200: rt.usize = taken.length; + const _202: rt.usize = rt.vecCapacity(taken, 0); + Known.put(k, out, _200, _202); + const _206: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); const old = taken; - taken = _205; + taken = _206; v = old; Known.put(Known.new(0), out, taken.length, rt.vecCapacity(taken, 0)); } else if (_42 === 21) { @@ -781,24 +851,43 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: Known.loose(k); } else if (_42 === 23) { const it2: rt.Iter = rt.iterSlice(v); - const _236: rt.u8 = rt.u8Rem(arg, 4); + const _237: rt.u8 = rt.u8Rem(arg, 4); let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _236; + const iterEnd2: rt.u8 = _237; while (iterStart2++ < iterEnd2) { rt.iterToOption(it2.next(), rt.None); } - v = rt.iterToArray(it2.clone(), undefined, 0, true); + const exact: boolean = k.exact; + v = rt.iterToArray(it2.clone({ v: rt.itself }), undefined, 0, true); Known.remade(k, true); const rest: undefined[] = rt.iterToArray(it2, undefined, 0, true); - Known.put({ exact: false, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 0)); + Known.put({ exact, floor: 0 }, out, rest.length, rt.vecCapacity(rest, 0)); } else if (_42 === 24) { make(arg); v = rt.vecFromElem(undefined, rt.u8Rem(arg, 6) as rt.usize, undefined); Known.remade(k, false); + } else if (_42 === 25) { + rt.vecPopIfMut(v, (_26: rt.Place): boolean => { + return rt.u8Rem(arg, 2) === 1; + }, undefined, rt.None); + Known.loose(k); + } else if (_42 === 26) { + v = rt.slicesJoin([rt.vecExact(v.slice(), 0), v], 0); + Known.remade(k, true); + } else if (_42 === 27) { + v = rt.iterToArray(rt.iterSlice(rt.vecExact(v, 0)), undefined, 0, true); + Known.remade(k, true); + } else if (_42 === 28) { + let own: undefined[] = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 0); + make(arg); + own.push(undefined); + own = rt.vecClonedInto(rt.vecExact(v.slice(), 0), own, 0); + v = own; + Known.remade(k, true); } - const _267: rt.usize = v.length; - const _269: rt.usize = rt.vecCapacity(v, 0); - Known.put(k, out, _267, _269); + const _305: rt.usize = v.length; + const _307: rt.usize = rt.vecCapacity(v, 0); + Known.put(k, out, _305, _307); } } @@ -840,104 +929,86 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1280) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(1280) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 1280)); - put(out, rt.dequeCapacity(q, 1280)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, copy$array_u64(make(arg))); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, copy$array_u64(make(arg))); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 1280); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 1280); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 1280); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 1280); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$array_u64(make(arg))); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 1280); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: rt.u64[]): boolean => { + rt.dequeRetain(q, (_25: rt.u64[]): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, copy$array_u64, 1280); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1280, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1280, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q, copy$array_u64); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 1280) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 1280, true), 1280) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u64[]): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: rt.u64[]): boolean => { return keep2(); - }), "next", 1280)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 1280), 1280) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone({ v: copy$array_u64 }), undefined, 1280, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 1280, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 1280)); + q = rt.dequeFromIntoIter(it.clone({ v: copy$array_u64 }), 1280) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 1280) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: rt.u64[][] = [copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))]; - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_196), undefined, 1280, true); - Known.remade(k, false); + q = rt.dequeFromArray([copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))], 1280) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 1280); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -952,104 +1023,86 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 16) as rt.VecDeque<[rt.u64, rt.u8]>; } else { - q = rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>; + q = rt.dequeNew(16) as rt.VecDeque<[rt.u64, rt.u8]>; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 16)); - put(out, rt.dequeCapacity(q, 16)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, copy$tuple2_u64_u8(make(arg))); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, copy$tuple2_u64_u8(make(arg))); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 16); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 16); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 16); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 16); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$tuple2_u64_u8(make(arg))); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 16); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: [rt.u64, rt.u8]): boolean => { + rt.dequeRetain(q, (_25: [rt.u64, rt.u8]): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, copy$tuple2_u64_u8, 16); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q, copy$tuple2_u64_u8); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: [rt.u64, rt.u8]): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: [rt.u64, rt.u8]): boolean => { return keep2(); - }), "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter<[rt.u64, rt.u8]> = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + } else if (_39 === 19) { + const it: rt.Iter<[rt.u64, rt.u8]> = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone({ v: copy$tuple2_u64_u8 }), undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.remade(k, false); - const rest: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.iterToArray(it, undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 16)); + q = rt.dequeFromIntoIter(it.clone({ v: copy$tuple2_u64_u8 }), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + const rest: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromIntoIter(it, 16) as rt.VecDeque<[rt.u64, rt.u8]>; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: [rt.u64, rt.u8][] = [copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))]; - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque<[rt.u64, rt.u8]>, rt.iterSlice(_196), undefined, 16, true); - Known.remade(k, false); + q = rt.dequeFromArray([copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))], 16) as rt.VecDeque<[rt.u64, rt.u8]>; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 16); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1064,104 +1117,86 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 2) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(2) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 2)); - put(out, rt.dequeCapacity(q, 2)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, make(arg)); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, make(arg)); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 2); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 2); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 2); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 2); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 2); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: rt.u16): boolean => { + rt.dequeRetain(q, (_25: rt.u16): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, undefined, 2); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 2, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 2, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 2) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 2, true), 2) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u16): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: rt.u16): boolean => { return keep2(); - }), "next", 2)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 2), 2) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone(), undefined, 2, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 2, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 2)); + q = rt.dequeFromIntoIter(it.clone(), 2) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 2) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: rt.u16[] = [make(arg), make(arg), make(arg)]; - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_196), undefined, 2, true); - Known.remade(k, false); + q = rt.dequeFromArray([make(arg), make(arg), make(arg)], 2) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 2); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1174,106 +1209,88 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: }); const first: rt.u8 = _7[0]; if ((first & 1) === 1) { - q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1) as rt.VecDeque; + q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1, true) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(1, true) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 1)); - put(out, rt.dequeCapacity(q, 1)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { rt.dequePushBack(q, make(arg)); - } else if (_42 === 1) { + } else if (_39 === 1) { rt.dequePushFront(q, make(arg)); - } else if (_42 === 2) { + } else if (_39 === 2) { rt.dequePopFront(q); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 1); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 1); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 1); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 1); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { + } else if (_39 === 8) { rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); - } else if (_42 === 9) { + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 1); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: rt.u8): boolean => { + rt.dequeRetain(q, (_25: rt.u8): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, undefined, 1); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 1, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIter(q), undefined, true))) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 1, true) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: rt.u8): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: rt.u8): boolean => { return keep2(); - }), "next", 1)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 1), 1, true) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next()); } - q = rt.dequeFromVec(rt.iterToArray(it.clone(), undefined, 1, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 1, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 1)); + q = rt.dequeFromIntoIter(it.clone(), 1, true) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 1, true) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { - const _196: Uint8Array = Uint8Array.of(make(arg), make(arg), make(arg)); - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_196), undefined, 1, true); - Known.remade(k, false); + q = rt.dequeFromArray(Uint8Array.of(make(arg), make(arg), make(arg)), 1, true) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 1); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1288,113 +1305,96 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen if ((first & 1) === 1) { q = rt.dequeWithCapacity(first >> 3 as rt.usize, 0) as rt.VecDeque; } else { - q = rt.dequeNew() as rt.VecDeque; + q = rt.dequeNew(0) as rt.VecDeque; } - const k: Known.Known = Known.new(rt.dequeCapacity(q, 0)); - put(out, rt.dequeCapacity(q, 0)); + put(out, rt.dequeCapacity(q)); const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); while (true) { - const _27: rt.ByteSlice | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { break; } - rt.idx(_27, 0); - const _33: [rt.u8, rt.u8] = [_27.data[_27.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_27, 1), 0)]; - const op: rt.u8 = _33[0]; - const arg: rt.u8 = _33[1]; - const _42: rt.u8 = rt.u8Rem(op, 21); - if (_42 === 0) { - const _44: rt.VecDeque = q; + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const _39: rt.u8 = rt.u8Rem(op, 21); + if (_39 === 0) { + const _41: rt.VecDeque = q; make(arg); - rt.dequePushBack(_44, undefined); - } else if (_42 === 1) { - const _46: rt.VecDeque = q; + rt.dequePushBack(_41, undefined); + } else if (_39 === 1) { + const _43: rt.VecDeque = q; make(arg); - rt.dequePushFront(_46, undefined); - } else if (_42 === 2) { + rt.dequePushFront(_43, undefined); + } else if (_39 === 2) { rt.dequePopFront(q, rt.None); - Known.loose(k); - } else if (_42 === 3 || _42 === 4) { + } else if (_39 === 3 || _39 === 4) { const additional: rt.usize = amount(arg, q.n, size); if (rt.u8Rem(op, 21) === 3) { - rt.dequeReserve(q, additional, 0); + rt.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional, 0); + rt.dequeReserveExact(q, additional); } - Known.reserved(k, q.n, additional); - } else if (_42 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize, 0); - Known.shrunk(k, q.n, rt.u8Rem(arg, 40) as rt.usize); - } else if (_42 === 6) { - rt.dequeShrinkTo(q, 0, 0); - Known.shrunk(k, q.n, 0); - k.exact = true; - } else if (_42 === 7) { + } else if (_39 === 5) { + rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + } else if (_39 === 6) { + rt.dequeShrinkTo(q, 0); + } else if (_39 === 7) { rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); - Known.loose(k); - } else if (_42 === 8) { - const _90: rt.VecDeque = q; - const _91: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + } else if (_39 === 8) { + const _63: rt.VecDeque = q; + const _64: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); make(arg); - rt.dequeInsert(_90, _91, undefined); - } else if (_42 === 9) { + rt.dequeInsert(_63, _64, undefined); + } else if (_39 === 9) { rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), rt.None); - Known.loose(k); - } else if (_42 === 10) { + } else if (_39 === 10) { rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { return rt.u8Rem(i, 3) !== 0; - }), make), "next", 0); - } else if (_42 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); - } else if (_42 === 12) { + }), make), "next"); + } else if (_39 === 11) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + } else if (_39 === 12) { rt.dequeClear(q); - Known.loose(k); - } else if (_42 === 13) { + } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_28: undefined): boolean => { + rt.dequeRetain(q, (_25: undefined): boolean => { return keep(); }); - Known.loose(k); - } else if (_42 === 14) { - rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) }); - Known.loose(k); - } else if (_42 === 15) { - q = rt.dequeClone(q, undefined, 0); - Known.remade(k, true); - } else if (_42 === 16) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 0, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 17) { - q = rt.dequeFromVec(rt.iterToArray(rt.dequeIter(q), undefined, 0, true)) as rt.VecDeque; - Known.remade(k, false); - } else if (_42 === 18) { + } else if (_39 === 14) { + rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + } else if (_39 === 15) { + q = rt.dequeClone(q); + } else if (_39 === 16) { + q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 0) as rt.VecDeque; + } else if (_39 === 17) { + q = rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; + } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIter(q), (_26: undefined): boolean => { + q = rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.dequeIntoIter(q), (_23: undefined): boolean => { return keep2(); - }), "next", 0)) as rt.VecDeque; - Known.remade(k, true); - } else if (_42 === 19) { - const it: rt.Iter = rt.dequeIter(q); - const _173: rt.u8 = rt.u8Rem(arg, 4); + }), "next", 0), 0) as rt.VecDeque; + } else if (_39 === 19) { + const it: rt.Iter = rt.dequeIntoIter(q); + const _127: rt.u8 = rt.u8Rem(arg, 4); let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _173; + const iterEnd: rt.u8 = _127; while (iterStart++ < iterEnd) { rt.iterToOption(it.next(), rt.None); } - q = rt.dequeFromVec(rt.iterToArray(it.clone(), undefined, 0, true)) as rt.VecDeque; - Known.remade(k, false); - const rest: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(it, undefined, 0, true)) as rt.VecDeque; - Known.put({ exact: false, floor: 0 }, out, rest.n, rt.dequeCapacity(rest, 0)); + q = rt.dequeFromIntoIter(it.clone(), 0) as rt.VecDeque; + const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 0) as rt.VecDeque; + put(out, rest.n); + put(out, rt.dequeCapacity(rest)); } else { make(arg); make(arg); make(arg); - q = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([undefined, undefined, undefined]), undefined, 0, true); - Known.remade(k, false); + q = rt.dequeFromArray([undefined, undefined, undefined], 0) as rt.VecDeque; } - const _204: rt.usize = q.n; - const _206: rt.usize = rt.dequeCapacity(q, 0); - Known.put(k, out, _204, _206); + put(out, q.n); + put(out, rt.dequeCapacity(q)); } } @@ -1880,20 +1880,20 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void if (_20 === 0) { const halves: rt.u32[] = rt.iterToArray(rt.iterMap(rt.iterSlice(pairs2), (_27: [rt.u32, rt.u32]): rt.u32 => { return _27[0]; - }), "next", 4, true); + }), "next", 4, true, 8); const _28: rt.usize = halves.length; const _30: rt.usize = rt.vecCapacity(halves, 4); - Known.put(loose, out, _28, _30); + Known.put(exact, out, _28, _30); } else if (_20 === 1) { const bytes: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 3)); const _37: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); rt.byteVecExtendFromSlice(bytes, _37); Known.put(exact, out, bytes.length, bytes.data.length); - const odd: rt.ByteVec = rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteVecView(rt.byteVecFrom(rt.byteVecView(bytes)))), (b5: rt.u8): boolean => { + const odd: rt.ByteVec = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(rt.byteVecFrom(rt.byteVecView(bytes))), (b5: rt.u8): boolean => { return rt.u8Rem(b5, 2) === 1; - }), "next"); - Known.put(loose, out, odd.length, odd.data.length); - const wide: rt.u16[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteVecView(bytes)), (a0: rt.u8): rt.u16 => { + }), "next", false, 1); + Known.put(exact, out, odd.length, odd.data.length); + const wide: rt.u16[] = rt.iterToArray(rt.iterMap(rt.byteVecIntoIter(bytes), (a0: rt.u8): rt.u16 => { return a0 as rt.u16; }), undefined, 2, true); const _64: rt.usize = wide.length; @@ -1903,14 +1903,14 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _71: rt.Iter<[rt.u32, rt.u32]> = rt.iterCopied(rt.iterFilter(rt.iterSlice(pairs2), (_22: [rt.u32, rt.u32]): boolean => { return rt.u32Rem(_22[0], 2) === 0; }), copy$tuple2_u32_u32); - const _70: [rt.u32[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew() as rt.VecDeque] as [rt.u32[], rt.VecDeque], _71, [rt.vecPart(4), rt.dequePart(4)]); + const _70: [rt.u32[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew(4) as rt.VecDeque] as [rt.u32[], rt.VecDeque], _71, [rt.vecPart(4), rt.dequePart()]); const a: rt.u32[] = _70[0]; const b: rt.VecDeque = _70[1]; const _78: rt.usize = a.length; const _80: rt.usize = rt.vecCapacity(a, 4); Known.put(exact, out, _78, _80); const _84: rt.usize = b.n; - const _86: rt.usize = rt.dequeCapacity(b, 4); + const _86: rt.usize = rt.dequeCapacity(b); Known.put(exact, out, _84, _86); const _91: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(rt.iterSlice(pairs2), (_26: [rt.u32, rt.u32]): [rt.u8, rt.u32] => { return [_26[0] & 0xff, _26[1]] as [rt.u8, rt.u32]; @@ -1934,14 +1934,14 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else if (_20 === 4) { put(out, rt.vecCapacity(rt.vecWithCapacity(rt.usizeSub(4294967295, n), 8), 8)); } else if (_20 === 5) { - put(out, rt.dequeCapacity(rt.dequeWithCapacity(rt.usizeAdd(268435456, n), 16) as rt.VecDeque<[rt.u64, rt.u64]>, 16)); + put(out, rt.dequeCapacity(rt.dequeWithCapacity(rt.usizeAdd(268435456, n), 16) as rt.VecDeque<[rt.u64, rt.u64]>)); } else if (_20 === 6) { const bytes2: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 5)); const _138: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); rt.byteVecExtendFromSlice(bytes2, _138); - const q2: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(bytes2)))) as rt.VecDeque; + const q2: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(bytes2))), 1, true) as rt.VecDeque; const _147: rt.usize = q2.n; - const _149: rt.usize = rt.dequeCapacity(q2, 1); + const _149: rt.usize = rt.dequeCapacity(q2); Known.put(loose, out, _147, _149); const heap: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(bytes2), rt.le, rt.ge, rt.lt); const _155: rt.usize = heap.d.length; diff --git a/ts/fixtures/lang/expected/chars.ts b/ts/fixtures/lang/expected/chars.ts index 98f915966..859c35d39 100644 --- a/ts/fixtures/lang/expected/chars.ts +++ b/ts/fixtures/lang/expected/chars.ts @@ -94,7 +94,7 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_4 === 2) { const cs: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(scalars(data)), (a0: rt.u32): rt.char | undefined => { return rt.charFromU32(a0); - }), "next", 4); + }), "next", 4, false, 4); const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; const seen: rt.HashSet = rt.hashNew() as rt.HashSet; const iter3: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(cs)); diff --git a/ts/fixtures/lang/expected/clones.ts b/ts/fixtures/lang/expected/clones.ts index 63df0a599..a8dd1c354 100644 --- a/ts/fixtures/lang/expected/clones.ts +++ b/ts/fixtures/lang/expected/clones.ts @@ -2533,7 +2533,7 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure rt.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); + const other: rt.Iter = it.clone({ o: { v: rt.itself } }); rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6547,7 +6547,7 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur rt.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); + const other: rt.Iter = it.clone({ v: rt.itself }); rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); let ended: boolean = false; @@ -6614,7 +6614,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x68: rt.u8): rt.u8 => { return x68; }, out); - turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), (it76: rt.Iter): rt.u8 | undefined => { + turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), (it76: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it76.nextBack()); }, plan, (x69: rt.u8): rt.u8 => { return x69; @@ -6861,7 +6861,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, out); turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { return rt.byteSliceToByteVec(c3); - }), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value))), (it43: rt.Iter): rt.u8 | undefined => { + }), (value: rt.ByteVec) => rt.byteVecIntoIter(value)), (it43: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it43.nextBack()); }, plan, (x47: rt.u8): rt.u8 => { return x47; @@ -7005,7 +7005,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(zip3.clone(), zip3), (x29: rt.u8): rt.u8 => { return x29 ^ 64; }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); } else if (_9 === 8) { it = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); let iterStart5: rt.usize = 0; @@ -7145,7 +7145,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { unordered$iter_Copied_collections_hash_set_Difference_u8_hash_RandomState(rt.hashDifference(a4, b5), plan, out); unordered$iter_Copied_collections_hash_set_SymmetricDifference_u8_hash_RandomState(rt.hashSymmetricDifference(a4, b5), plan, out); } else if (_9 === 12) { - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; for (const b6 of rt.byteSliceView(data)) { if (rt.u8Rem(b6, 2) === 0) { rt.dequePushFront(q, b6); @@ -7158,7 +7158,7 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { }, plan, (x10: rt.u8): rt.u8 => { return x10; }, out); - turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(rt.dequeIter(rt.dequeClone(q, undefined, 1)), (it8: rt.Iter): rt.u8 | undefined => { + turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(rt.dequeIntoIter(rt.dequeClone(q)), (it8: rt.Iter): rt.u8 | undefined => { return rt.iterToOption(it8.nextBack()); }, plan, (x11: rt.u8): rt.u8 => { return x11; @@ -7252,9 +7252,9 @@ export function unordered$iter_Copied_collections_hash_map_Keys_u8_u8(it: rt.Ite const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7270,9 +7270,9 @@ export function unordered$iter_Copied_collections_hash_map_Values_u8_u8(it: rt.I const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7288,9 +7288,9 @@ export function unordered$iter_Copied_collections_hash_set_Difference_u8_hash_Ra const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7306,9 +7306,9 @@ export function unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_ const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; const rest: rt.ByteVec = _17; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.iterSlice(rt.byteVecView(rest)), undefined, true); + rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(all)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); } /** @@ -7324,9 +7324,9 @@ export function unordered$iter_Copied_collections_hash_set_Iter_u8(it: rt.Iter { + turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(rt.dequeIntoIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_22: rt.u8): clones_Logged.Logged => { return logged(_22 & 112); - }), undefined, 8, true)) as rt.VecDeque, rt.drop), (it7: rt.Iter): clones_Logged.Logged | undefined => { + }), undefined, 8, true), 8) as rt.VecDeque, rt.drop), (it7: rt.Iter): clones_Logged.Logged | undefined => { return rt.iterToOption(it7.nextBack()); }, plan, (x2: clones_Logged.Logged): rt.u8 => { const _07: rt.u8 = clones_Logged.id(x2); diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index dca3bffdb..9e9aafdeb 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -929,7 +929,7 @@ export function touch(q: rt.VecDeque): rt.VecDeque { /** `VecDeque`: a ring buffer, pushed and popped at both ends past its capacity. */ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { let drained2!: rt.ByteVec; - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; const pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeWithCapacity(2, 2) as rt.VecDeque<[rt.u8, rt.u8]>; for (const b of rt.byteSliceView(data)) { const _12: rt.u8 = rt.u8Rem(b, 7); @@ -957,8 +957,8 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeSwapRemove(q, at, true), 232)); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeSwapRemove(q, at), 231)); - rt.dequeShrinkTo(touch(q), 0, 1); - rt.dequeReserve(touch(q), 1, 1); + rt.dequeShrinkTo(touch(q), 0); + rt.dequeReserve(touch(q), 1); rt.byteVecPush(out, q.n & 0xff); rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); if (!((q.n === 0))) { @@ -980,8 +980,8 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, q.n === 0 ? 1 : 0); const tallies: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): collections_Tally.Tally => { return { n: _25 as rt.u16 }; - }), undefined, 2, true)) as rt.VecDeque; - const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally, 2); + }), undefined, 2, true), 2) as rt.VecDeque; + const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally); const _115: collections_Tally.Tally | undefined = rt.dequeEnd(copy); if (_115 !== undefined) { _115.n = _115.n ^ 255; @@ -993,7 +993,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { return t3.n & 0xff; }), undefined, true); const _129: rt.Iter = rt.dequeIter(tallies); - rt.dequeExtend(copy, rt.iterMap(_129, copy$collections_Tally), undefined, 2, true); + rt.dequeExtend(copy, rt.iterMap(_129, copy$collections_Tally), undefined, true); const _131: collections_Tally.Tally | undefined = rt.dequeEnd(copy, true); if (_131 !== undefined) { _131.n = _131.n ^ 255; @@ -1018,7 +1018,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { return t7.n & 0xff; }), undefined, true); const _162: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.dequeExtend(q, _162, undefined, 1, true); + rt.dequeExtend(q, _162, undefined, true); rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66); rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeRemove(q, 1), 233)); rt.dequeTruncate(q, 5); @@ -1026,7 +1026,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); const a: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, 8); const b2: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0) as rt.usize, 8); - const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true)) as rt.VecDeque; + const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), 1, true) as rt.VecDeque; const _201: rt.usize = rt.usizeRem(a, 4); if (_201 === 0) { drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2)), "next"); @@ -1202,7 +1202,7 @@ export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); const tally: collections_Tally.Tally = { n: a as rt.u16 }; - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; rt.dequePushBack(q, copy$collections_Tally(tally)); rt.dequePushFront(q, copy$collections_Tally(tally)); rt.dequeInsert(q, 1, copy$collections_Tally(tally)); @@ -3695,7 +3695,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi }), undefined, 2, true)), undefined, 4, true); putEq(rt.eqSeq(Odd.eq$cmp_PartialEq_ref_collections_Right_ref)(_210, refs), log, out); const half: rt.usize = rt.usizeDiv(data.length, 2); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const iter: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, half)))); while (true) { const _226: rt.u8 | rt.Done = iter.next(); @@ -3736,7 +3736,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi putEq(rt.eqSeq((a32: Left.Left, b30: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a32, b30); })(q, _295), log, out); - const bytes: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const bytes: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; const iter3: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, half)))); while (true) { const _305: rt.u8 | rt.Done = iter3.next(); @@ -3746,7 +3746,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.dequePushFront(bytes, _305); } const _313: rt.ByteSlice = rt.byteSliceRange(data, half); - rt.dequeExtend(bytes, rt.iterSlice(rt.byteSliceView(_313)), undefined, 1, true); + rt.dequeExtend(bytes, rt.iterSlice(rt.byteSliceView(_313)), undefined, true); const stepped: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_27: [rt.usize, rt.u8]): rt.u8 => { return _27[1] ^ (_27[0] === byEq ? 1 : 0); }), undefined, true); @@ -3756,8 +3756,8 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi putEq(rt.eqSeq(rt.same)(bytes, _334), log, out); const wide: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.dequeIter(bytes), (_28: rt.u8): rt.u16 => { return _28 as rt.u16; - }), undefined, 2, true)) as rt.VecDeque; - const wrapped: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + }), undefined, 2, true), 2) as rt.VecDeque; + const wrapped: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const iter4: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(stepped)))); while (true) { const _351: rt.u8 | rt.Done = iter4.next(); @@ -3767,7 +3767,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.dequePushFront(wrapped, _351 as rt.u16); } putEq(rt.eqSeq(rt.same)(wide, wrapped), log, out); - const _366: rt.VecDeque[] = [rt.dequeClone(wide, undefined, 2)]; + const _366: rt.VecDeque[] = [rt.dequeClone(wide)]; const _371: rt.VecDeque[] = [wrapped]; putEq(rt.eqSlice(rt.eqSeq(rt.same))(_366, _371), log, out); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice([lefts(), lefts(), lefts()])); @@ -3791,7 +3791,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi })(a035, a135); }) !== undefined, log, out); rt.byteVecPush(out, rt.iterCount(it) & 0xff); - const it2: rt.Peekable> = rt.iterPeekable(rt.iterSlice([rt.dequeClone(bytes, undefined, 1), bytes])); + const it2: rt.Peekable> = rt.iterPeekable(rt.iterSlice([rt.dequeClone(bytes), bytes])); const _430: rt.ByteVec = rt.byteSliceToByteVec(data); putEq(rt.peekableNextIfEq(it2, _430, (a037: rt.VecDeque, a137: rt.ByteVec): boolean => { return rt.eqSeq(rt.same)(a037, a137); @@ -3808,7 +3808,7 @@ export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi */ export function wrapped$collections_Picky(v: collections_Picky.Picky[]): rt.VecDeque { const half: rt.usize = rt.usizeDiv(v.length, 2); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const iter: rt.Iter = rt.iterRev(rt.iterSlice(rt.sliceRange(v, 0, half))); while (true) { const _12: collections_Picky.Picky | rt.Done = iter.next(); @@ -3819,7 +3819,7 @@ export function wrapped$collections_Picky(v: collections_Picky.Picky[]): rt.VecD rt.dequePushFront(q, _18); } const _21: rt.Iter = rt.iterMap(rt.iterSlice(rt.sliceRange(v, half)), collections_Picky.clone$Clone); - rt.dequeExtend(q, _21, undefined, 8, true); + rt.dequeExtend(q, _21, undefined, true); return q; } @@ -4736,10 +4736,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_147, _152, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_161, _164)], (a022: boolean): rt.u8 => { return a022 ? 1 : 0; })), undefined, true); - const _171: ByRef.ByRef[] = [a, b]; - const _170: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_171), undefined, 4, true); - const _174: ByRef.ByRef[] = [b, a]; - const _173: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_174), undefined, 4, true); + const _170: rt.VecDeque = rt.dequeFromArray([a, b], 4) as rt.VecDeque; + const _173: rt.VecDeque = rt.dequeFromArray([b, a], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_170, _173) ? 1 : 0); const _180: ByRef.ByRef = a; const _182: ByRef.ByRef = b; @@ -4860,10 +4858,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_458, _463, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_472, _475)], (a067: boolean): rt.u8 => { return a067 ? 1 : 0; })), undefined, true); - const _482: ByRef.ByRef[] = [a2, b2]; - const _481: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_482), undefined, 4, true); - const _485: ByRef.ByRef[] = [b2, a2]; - const _484: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_485), undefined, 4, true); + const _481: rt.VecDeque = rt.dequeFromArray([a2, b2], 4) as rt.VecDeque; + const _484: rt.VecDeque = rt.dequeFromArray([b2, a2], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_481, _484) ? 1 : 0); const _491: ByRef.ByRef = a2; const _493: ByRef.ByRef = b2; @@ -4984,10 +4980,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_761, _766, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_775, _778)], (a0112: boolean): rt.u8 => { return a0112 ? 1 : 0; })), undefined, true); - const _785: ByVal.ByVal[] = [a3, b3]; - const _784: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_785), undefined, 4, true); - const _788: ByVal.ByVal[] = [b3, a3]; - const _787: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_788), undefined, 4, true); + const _784: rt.VecDeque = rt.dequeFromArray([a3, b3], 4) as rt.VecDeque; + const _787: rt.VecDeque = rt.dequeFromArray([b3, a3], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_784, _787) ? 1 : 0); const _794: ByVal.ByVal = a3; const _796: ByVal.ByVal = b3; @@ -5108,10 +5102,8 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1068, _1073, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_1082, _1085)], (a0157: boolean): rt.u8 => { return a0157 ? 1 : 0; })), undefined, true); - const _1092: ByVal.ByVal[] = [a4, b4]; - const _1091: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1092), undefined, 4, true); - const _1095: ByVal.ByVal[] = [b4, a4]; - const _1094: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_1095), undefined, 4, true); + const _1091: rt.VecDeque = rt.dequeFromArray([a4, b4], 4) as rt.VecDeque; + const _1094: rt.VecDeque = rt.dequeFromArray([b4, a4], 4) as rt.VecDeque; rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_1091, _1094) ? 1 : 0); const _1101: ByVal.ByVal = a4; const _1103: ByVal.ByVal = b4; @@ -5281,7 +5273,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs, 1), first, ByRef.eq$cmp_PartialEq_ref) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs, rt.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs.slice(), 4)) as rt.VecDeque, xs[rt.idx(xs, rt.usizeDiv(xs.length, 2))], ByRef.eq$cmp_PartialEq_ref) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs.slice(), 4), 4) as rt.VecDeque, xs[rt.idx(xs, rt.usizeDiv(xs.length, 2))], ByRef.eq$cmp_PartialEq_ref) ? 1 : 0); const _1541: [ByVal.ByVal[], rt.ByteVec] = [rt.iterToArray(rt.iterSlice(byVal), undefined, 4, true), out]; const xs2: ByVal.ByVal[] = _1541[0]; const sorted2: ByVal.ByVal[] = rt.vecExact(xs2.slice(), 4); @@ -5330,7 +5322,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs2, 1), first2, ByVal.eq$cmp_PartialEq) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs2, rt.cmpLe(ByVal.partialCmp$cmp_PartialOrd)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs2.slice(), 4)) as rt.VecDeque, xs2[rt.idx(xs2, rt.usizeDiv(xs2.length, 2))], ByVal.eq$cmp_PartialEq) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs2.slice(), 4), 4) as rt.VecDeque, xs2[rt.idx(xs2, rt.usizeDiv(xs2.length, 2))], ByVal.eq$cmp_PartialEq) ? 1 : 0); const _1651: [Mixed.Mixed[], rt.ByteVec] = [rt.iterToArray(rt.iterSlice(mixed), undefined, 4, true), out]; const xs3: Mixed.Mixed[] = _1651[0]; const sorted3: Mixed.Mixed[] = rt.vecExact(xs3.slice(), 4); @@ -5379,7 +5371,7 @@ export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo return rt.sliceContains(rt.sliceRange(xs3, 1), first3, Mixed.eq$cmp_PartialEq) ? 1 : 0; })), undefined, true); rt.byteVecPush(out, rt.sliceIsSorted(xs3, rt.cmpLe(Mixed.partialCmp$cmp_PartialOrd)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs3.slice(), 4)) as rt.VecDeque, xs3[rt.idx(xs3, rt.usizeDiv(xs3.length, 2))], Mixed.eq$cmp_PartialEq) ? 1 : 0); + rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecExact(xs3.slice(), 4), 4) as rt.VecDeque, xs3[rt.idx(xs3, rt.usizeDiv(xs3.length, 2))], Mixed.eq$cmp_PartialEq) ? 1 : 0); } export function hashed$ref_orders_Option_ref_collections_ByRef(value: ByRef.ByRef | undefined): Uint8Array { diff --git a/ts/fixtures/lang/expected/conversions.ts b/ts/fixtures/lang/expected/conversions.ts index 02ed59fbb..34d170b04 100644 --- a/ts/fixtures/lang/expected/conversions.ts +++ b/ts/fixtures/lang/expected/conversions.ts @@ -321,12 +321,12 @@ export function cloneFromParam$String(to: rt.Place, from: string): void /** `clone_from` through a `&mut` whose place only the caller knows. */ export function cloneFromParam$Vec_u32(to: rt.u32[], from: rt.u32[]): void { - rt.replaceIn(to, rt.vecExact(from.slice(), 4)); + rt.replaceIn(to, rt.vecClonedInto(rt.vecExact(from.slice(), 4), to, 4)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ export function cloneFromParam$Vec_u8(to: rt.ByteVec, from: rt.ByteVec): void { - rt.replaceIn(to, rt.byteVecFrom(rt.byteVecView(from))); + rt.replaceIn(to, rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(from)), to)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ @@ -391,12 +391,12 @@ export function cloneIntoParam$String(from: string, to: rt.Place): void /** `clone_into` through a `&mut` whose place only the caller knows. */ export function cloneIntoParam$Vec_u32(from: rt.u32[], to: rt.u32[]): void { - rt.replaceIn(to, rt.vecExact(from.slice(), 4)); + rt.replaceIn(to, rt.vecClonedInto(rt.vecExact(from.slice(), 4), to, 4)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ export function cloneIntoParam$Vec_u8(from: rt.ByteVec, to: rt.ByteVec): void { - rt.replaceIn(to, rt.byteVecFrom(rt.byteVecView(from))); + rt.replaceIn(to, rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(from)), to)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ @@ -892,21 +892,23 @@ export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { let a: rt.u32[] = make$conversions_Value_Vec_u32(data, 0); const b: rt.u32[] = make$conversions_Value_Vec_u32(data, 3); const owned: rt.u32[] = rt.vecExact(a.slice(), 4); - a = rt.vecExact(b.slice(), 4); + a = rt.vecClonedInto(rt.vecExact(b.slice(), 4), a, 4); put$conversions_Value_Vec_u32(owned, out); put$conversions_Value_Vec_u32(a, out); let c: rt.u32[] = make$conversions_Value_Vec_u32(data, 6); - c = rt.vecExact(owned.slice(), 4); + c = rt.vecClonedInto(rt.vecExact(owned.slice(), 4), c, 4); put$conversions_Value_Vec_u32(c, out); cloneFromParam$Vec_u32(c, b); cloneIntoParam$Vec_u32(owned, a); put$conversions_Value_Vec_u32(c, out); put$conversions_Value_Vec_u32(a, out); const held: conversions_Held.Held = new conversions_Held.Held(make$conversions_Value_Vec_u32(data, 1)); - held.value = rt.vecExact(c.slice(), 4); + held.value = rt.vecClonedInto(rt.vecExact(c.slice(), 4), held.value, 4); const v: rt.u32[][] = [make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]; - v[rt.idx(v, 1)] = rt.vecExact(held.value.slice(), 4); - v[rt.idx(v, 0)] = rt.vecExact(b.slice(), 4); + const at = rt.idx(v, 1); + v[at] = rt.vecClonedInto(rt.vecExact(held.value.slice(), 4), v[at], 4); + const at2 = rt.idx(v, 0); + v[at2] = rt.vecClonedInto(rt.vecExact(b.slice(), 4), v[at2], 4); put$conversions_Value_Vec_u32(held.value, out); put$conversions_Value_Vec_u32(v[rt.idx(v, 0)], out); put$conversions_Value_Vec_u32(v[rt.idx(v, 1)], out); @@ -914,7 +916,7 @@ export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, one.length & 0xff); const copied: rt.u32[] = rt.vecExact(one[0].slice(), 4); put$conversions_Value_Vec_u32(one[0], out); - a = rt.vecExact(copied.slice(), 4); + a = rt.vecClonedInto(rt.vecExact(copied.slice(), 4), a, 4); put$conversions_Value_Vec_u32(copied, out); put$conversions_Value_Vec_u32(a, out); const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value) => c = value)); @@ -939,7 +941,7 @@ export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { _116[0] = _114; const _124: rt.u32[][] = array; rt.idx(_124, 2); - _124[2] = rt.vecExact(c.slice(), 4); + _124[2] = rt.vecClonedInto(rt.vecExact(c.slice(), 4), _124[2], 4); for (const _134 of array) { put$conversions_Value_Vec_u32(_134, out); } @@ -953,21 +955,23 @@ export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { let a: rt.ByteVec = make$conversions_Value_Vec_u8(data, 0); const b: rt.ByteVec = make$conversions_Value_Vec_u8(data, 3); const owned: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(a)); - a = rt.byteVecFrom(rt.byteVecView(b)); + a = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(b)), a); put$conversions_Value_Vec_u8(owned, out); put$conversions_Value_Vec_u8(a, out); let c: rt.ByteVec = make$conversions_Value_Vec_u8(data, 6); - c = rt.byteVecFrom(rt.byteVecView(owned)); + c = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(owned)), c); put$conversions_Value_Vec_u8(c, out); cloneFromParam$Vec_u8(c, b); cloneIntoParam$Vec_u8(owned, a); put$conversions_Value_Vec_u8(c, out); put$conversions_Value_Vec_u8(a, out); const held: conversions_Held.Held = new conversions_Held.Held(make$conversions_Value_Vec_u8(data, 1)); - held.value = rt.byteVecFrom(rt.byteVecView(c)); + held.value = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(c)), held.value); const v: rt.ByteVec[] = [make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]; - v[rt.idx(v, 1)] = rt.byteVecFrom(rt.byteVecView(held.value)); - v[rt.idx(v, 0)] = rt.byteVecFrom(rt.byteVecView(b)); + const at = rt.idx(v, 1); + v[at] = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(held.value)), v[at]); + const at2 = rt.idx(v, 0); + v[at2] = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(b)), v[at2]); put$conversions_Value_Vec_u8(held.value, out); put$conversions_Value_Vec_u8(v[rt.idx(v, 0)], out); put$conversions_Value_Vec_u8(v[rt.idx(v, 1)], out); @@ -975,7 +979,7 @@ export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, one.length & 0xff); const copied: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(one[0])); put$conversions_Value_Vec_u8(one[0], out); - a = rt.byteVecFrom(rt.byteVecView(copied)); + a = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(copied)), a); put$conversions_Value_Vec_u8(copied, out); put$conversions_Value_Vec_u8(a, out); const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value) => c = value)); @@ -1000,7 +1004,7 @@ export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { _116[0] = _114; const _124: rt.ByteVec[] = array; rt.idx(_124, 2); - _124[2] = rt.byteVecFrom(rt.byteVecView(c)); + _124[2] = rt.byteVecClonedInto(rt.byteVecFrom(rt.byteVecView(c)), _124[2]); for (const _134 of array) { put$conversions_Value_Vec_u8(_134, out); } diff --git a/ts/fixtures/lang/expected/cows.ts b/ts/fixtures/lang/expected/cows.ts index ce8f97f48..5659f6c47 100644 --- a/ts/fixtures/lang/expected/cows.ts +++ b/ts/fixtures/lang/expected/cows.ts @@ -6,7 +6,7 @@ import * as cows_Named from "./cows.Named.ts"; import * as cows_Run from "./cows.Run.ts"; import * as cows_Tally from "./cows.Tally.ts"; import { put as fmt_put } from "./fmt.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** `to_mut` of a `Result`'s payload, which the store rebuilds the `Result` around. */ export function exclaimed(r: rt.Result): rt.Result { @@ -25,7 +25,7 @@ export function cow(s: string, owned: boolean): string { export function cows(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let r!: rt.Result; - const s: string = text(data); + const s: string = strs_text(data); const owned: boolean = (kind & 128) !== 0; const first: string = option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, "/").next()), ""); const _14: rt.u8 = rt.u8Rem(kind, 6); diff --git a/ts/fixtures/lang/expected/cycles.ts b/ts/fixtures/lang/expected/cycles.ts index 3f2e05d0d..b87c7ad48 100644 --- a/ts/fixtures/lang/expected/cycles.ts +++ b/ts/fixtures/lang/expected/cycles.ts @@ -975,7 +975,7 @@ export function cycles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _22[0] ^ _22[1]; }), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterStepBy(rt.iterSkip(rt.iterCycle(new rt.RangeInclusive(1, 3, rt.u8Step)), n), 2), m), "next"); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next"))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next")), undefined, true); rt.byteVecPush(out, rt.iterAny(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), (_23: rt.u8): boolean => { return _23 === 7; }) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/edits.ts b/ts/fixtures/lang/expected/edits.ts index 59bf36638..5fb68a94b 100644 --- a/ts/fixtures/lang/expected/edits.ts +++ b/ts/fixtures/lang/expected/edits.ts @@ -8,7 +8,7 @@ import * as edits_Named from "./edits.Named.ts"; import * as Stamp from "./edits.Stamp.ts"; import * as edits_Tally from "./edits.Tally.ts"; import { put as fmt_put } from "./fmt.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** Into an `Option`, as a parameter that takes either. */ export function optional$Option_edits_Named(n: edits_Named.Named | undefined): edits_Named.Named | undefined { @@ -29,10 +29,10 @@ export function putU16s(out: rt.ByteVec, v: rt.u16[]): void { export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _104: (a0: rt.u16) => edits_Named.Named = (w: rt.u16): edits_Named.Named => { - return { id: w, name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8Div(w & 0xff, 16)))) }; + return { id: w, name: strs_text(rt.byteSliceFrom(Uint8Array.of(rt.u8Div(w & 0xff, 16)))) }; }; const _604: (a0: rt.u16) => edits_Named.Named = (w2: rt.u16): edits_Named.Named => { - return { id: w2, name: text(rt.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; + return { id: w2, name: strs_text(rt.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; }; const _605: (a0: edits_Named.Named[]) => rt.u16[] = (v8: edits_Named.Named[]): rt.u16[] => { return rt.iterToArray(rt.iterMap(rt.iterSlice(v8), (n: edits_Named.Named): rt.u16 => { @@ -67,7 +67,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putU16s(out, [_33[0], _33[1]]); } const names: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_233: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_233))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(_233))); }), undefined, 12, true); rt.vecRetain(names, (s3: string): boolean => { return rt.stringLen(s3) > 1; @@ -141,7 +141,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fmt_put(out, _144.name); } const names2: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_226, 3)))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_226, 3)))); }), undefined, 12, true); rt.vecDedupBy(names2, rt.same); rt.byteVecPush(out, names2.length & 0xff); @@ -192,7 +192,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } const names3: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_221: rt.u8): string => { const b8: rt.u8 = _221; - return text(rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16)))); + return strs_text(rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16)))); }), undefined, 12, true); rt.sliceSort(names3, rt.cmpLt(rt.cmpStr), 12, true); for (const _263 of names3) { @@ -219,9 +219,9 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { putU16s(out, v6); const named: edits_Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_212: rt.u16): edits_Named.Named => { const w6: rt.u16 = _212; - return { id: w6, name: text(rt.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; + return { id: w6, name: strs_text(rt.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; }), undefined, 16, true); - const probe: edits_Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3)))) }; + const probe: edits_Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: strs_text(rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3)))) }; rt.byteVecPush(out, rt.sliceContains(named, probe, edits_Named.eq$cmp_PartialEq) ? 1 : 0); rt.byteVecPush(out, rt.sliceContains(words, rt.u16Mul(at(2) as rt.u16, 3), rt.same) ? 1 : 0); const _361: rt.u8 = at(3); @@ -237,7 +237,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_8 === 4) { const named2: edits_Named.Named[] = rt.iterToArray(rt.iterMap(rt.iterSlice(words), (_28: rt.u16): edits_Named.Named => { const w4: rt.u16 = _28; - return { id: w4, name: text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; + return { id: w4, name: strs_text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; }), undefined, 16, true); const cloned: edits_Named.Named[] = rt.vecExact(named2.map(edits_Named.clone$Clone), 16); rt.byteVecPush(out, rt.eqSlice(edits_Named.eq$cmp_PartialEq)(cloned, named2) ? 1 : 0); @@ -250,7 +250,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, !rt.eqSlice(edits_Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); rt.byteVecPush(out, rt.cmpSlice(edits_Named.partialCmp$cmp_PartialOrd)(changed, named2) === -1 ? 1 : 0); const _435: edits_Named.Named[] = rt.sliceRange(named2, 0, rt.usizeDiv(named2.length, 2)); - rt.vecExtendFromSlice(changed, _435, edits_Named.clone$Clone); + rt.vecExtendFromSlice(changed, _435, 16, edits_Named.clone$Clone); rt.byteVecPush(out, changed.length & 0xff); const nested: rt.u16[][] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u16[] => { const b5: rt.u8 = _29; @@ -262,7 +262,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.vecExact(a027.slice(), 2); }), 12); rt.byteVecPush(out, rt.eqSlice(rt.eqSlice(rt.same))(_453, nested) ? 1 : 0); - const pair: [string, rt.u8] = [text(data), at(0)]; + const pair: [string, rt.u8] = [strs_text(data), at(0)]; const copy: [string, rt.u8] = rt.tupleClone(pair, [undefined, undefined]); fmt_put(out, copy[0]); const _470: [rt.u8, string] = [copy[1], copy[0]]; @@ -272,18 +272,18 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _491: [rt.u8, rt.u8] = [at(1), at(0)]; rt.byteVecPush(out, rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])(_483, _491) === -1 ? 1 : 0); const grown: rt.u16[] = rt.vecExact(words.slice(), 2); - rt.vecExtendFromSlice(grown, words); + rt.vecExtendFromSlice(grown, words, 2); putU16s(out, grown); } else if (_8 === 5) { - let tally: edits_Tally.Tally = { n: at(0), names: [text(data)] }; + let tally: edits_Tally.Tally = { n: at(0), names: [strs_text(data)] }; const default_ = edits_Tally.default$Default(); const taken3 = tally; tally = default_; rt.byteVecPush(out, taken3.n); rt.byteVecPush(out, tally.n); fmt_put(out, tally.names[rt.idx(tally.names, 0)]); - let queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(words), undefined, 2, true)) as rt.VecDeque; - const default_2 = rt.dequeNew() as rt.VecDeque; + let queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(words), undefined, 2, true), 2) as rt.VecDeque; + const default_2 = rt.dequeNew(2) as rt.VecDeque; const taken4 = queue; queue = default_2; rt.byteVecPush(out, taken4.n & 0xff); @@ -370,7 +370,7 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, 6 & 0xff); rt.byteVecPush(out, rt.u8Mul(4 & 0xff, 1 & 0xff)); } else { - const s2: string = text(data); + const s2: string = strs_text(data); const sep: rt.char[] = [47, 97]; rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(sep)) ? 1 : 0); rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(rt.sliceRange(sep, 0))) ? 1 : 0); diff --git a/ts/fixtures/lang/expected/elements.ts b/ts/fixtures/lang/expected/elements.ts index 179126a4b..9e79c751b 100644 --- a/ts/fixtures/lang/expected/elements.ts +++ b/ts/fixtures/lang/expected/elements.ts @@ -117,7 +117,7 @@ export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { const one: rt.Place = rt.sliceAsPtr(a, 2); one.v = one.v ^ 15; rt.byteVecPush(out, one.v); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); segment[Symbol.dispose](); } diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index ec7fb96f6..80617720d 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -750,7 +750,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(q), f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0])])); const wrapped: rt.VecDeque = rt.dequeWithCapacity(4, 4) as rt.VecDeque; - rt.dequeExtend(wrapped, rt.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, 4, true); + rt.dequeExtend(wrapped, rt.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, true); const _48: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; rt.dequePushFront(wrapped, _48); const _57: Hex.Hex = { _0: at(1) as rt.u32 }; @@ -761,14 +761,11 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { rt.dequePopBack(wrapped); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, mid), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(wrapped), f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f))]; put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", rt.fmtSpec({ alternate: true }, args6[1]), "|", rt.fmtSpec({ width: 6 }, args6[1])])); - const empty: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - const units: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(at(2), 3)), (_2: rt.u8): undefined => {}), undefined, 0, true)) as rt.VecDeque; + const empty: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; + const units: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(0, rt.u8Rem(at(2), 3)), (_2: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(empty), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(units), f, rt.fmtUnit)]; put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]])); - const _114: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - const _116: fmt_Pair.Pair[] = [{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }]; - const _113: rt.VecDeque[] = [_114, rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_116), undefined, 16, true)]; - const part = rt.dequeExtend(rt.dequeNew() as rt.VecDeque>, rt.iterSlice(_113), undefined, 16, true); + const part = rt.dequeFromArray([rt.dequeNew(16) as rt.VecDeque, rt.dequeFromArray([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rt.VecDeque], 16) as rt.VecDeque>; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(part), f, (value: rt.VecDeque, f: rt.Formatter) => rt.fmtList(rt.dequeIter(value), f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f)))]; put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0])])); const _135: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.u8 | undefined => { @@ -787,7 +784,7 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { } const b2: rt.u8 = _154; rt.dequePushFront(rt.entryOrInsertWith(rt.entry(map, rt.u8Rem(b2, 4)), (): rt.VecDeque => { - return rt.dequeNew() as rt.VecDeque; + return rt.dequeNew(16) as rt.VecDeque; }), { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }); } const _176: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; @@ -1012,7 +1009,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { }), undefined, 16, true)), front, back); const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part3, f, (value: fmt_Pair.Pair, f: rt.Formatter) => fmt_Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); - const part4 = ends$iters_vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(data))), front, back); + const part4 = ends$iters_vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), front, back); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part4, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args8[0])])); const it4: rt.Iter = ends$iters_vec_Drain_fmt_Hex(rt.vecDrain(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_23: rt.u8): Hex.Hex => { @@ -1041,7 +1038,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([args16[0]])); const _165: Array = []; const _174: rt.Iter = rt.iterSlice(_165); - const _176: rt.Iter = rt.iterSlice(rt.byteVecView(new rt.ByteVec())); + const _176: rt.Iter = rt.byteVecIntoIter(new rt.ByteVec()); const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_174, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["Iter"]), (f: rt.Formatter) => rt.fmtIter(_176, f, rt.u8Debug, ["IntoIter"])]; put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); @@ -1055,10 +1052,10 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it8, f, rt.u8Debug, [["Drain", "iter"], "Drain"])]; put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0])])); rt.drop(it8); - const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rt.dequeIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined => { + const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rt.dequeIntoIter(rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined => { const b4: rt.u8 = _27; return thenSome$0d5am30(rt.u8Rem(b4, 3) !== 0, b4); - }), undefined, 2, true)) as rt.VecDeque), front, back); + }), undefined, 2, true), 2) as rt.VecDeque), front, back); const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part9, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["IntoIter"])]; put(out, rt.fmtFormat([args26[0], "|", rt.fmtSpec({ alternate: true }, args26[0])])); const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.char => { diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 7fd1ea045..4616ae1b2 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -50,6 +50,7 @@ import { lists as pointers_lists, shared as pointers_shared, places as pointers_ import { refs, toRefs, adapted as refs_adapted, compared } from "./refs.ts"; import { results as results_results } from "./results.ts"; import { returns } from "./returns.ts"; +import { slices as rings_slices } from "./rings.ts"; import { u8s as saturates_u8s, u16s as saturates_u16s, u32s as saturates_u32s, u64s as saturates_u64s, u128s as saturates_u128s, usizes as saturates_usizes, i8s as saturates_i8s, i16s as saturates_i16s, i32s as saturates_i32s, i64s as saturates_i64s, i128s as saturates_i128s, isizes as saturates_isizes } from "./saturates.ts"; import { separated } from "./separated.ts"; import { copies as shapes_copies, order as shapes_order, discriminants, loops, patterns, uninhabited, closures as shapes_closures, library, flows } from "./shapes.ts"; @@ -300,12 +301,14 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) hashes_own(data106, out107); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::compared", (a0159: rt.u8, a1159: rt.ByteSlice, a2159: rt.ByteVec): undefined => { compared(a0159, a1159.data, a1159.start, a1159.length, a2159); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["rings::slices", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => { + rings_slices(a0160, a1160.data, a1160.start, a1160.length, a2160); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::objects", (_2207: rt.u8, data107: rt.ByteSlice, out108: rt.ByteVec): undefined => { fmt_objects(data107, out108); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::sorts", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => { - sorts(a0160, a1160.data, a1160.start, a1160.length, a2160); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a0162: rt.u8, a1162: rt.ByteSlice, a2162: rt.ByteVec): undefined => { - sorts_btrees(a0162, a1162.data, a1162.start, a1162.length, a2162); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::sorts", (a0161: rt.u8, a1161: rt.ByteSlice, a2161: rt.ByteVec): undefined => { + sorts(a0161, a1161.data, a1161.start, a1161.length, a2161); + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a0163: rt.u8, a1163: rt.ByteSlice, a2163: rt.ByteVec): undefined => { + sorts_btrees(a0163, a1163.data, a1163.start, a1163.length, a2163); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index ed4cd9dba..bc9e248aa 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -162,6 +162,7 @@ export function walk$collections_vec_deque_Drain_u8(it: rt.Iter, steps: r } put(out, it.sizeHint()); } + rt.drop(it); } /** @@ -1961,7 +1962,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_312 === 0) { walk$slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); } else if (_312 === 1) { - walk$vec_IntoIter_u8(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(bytes))), steps, out); + walk$vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(bytes)), steps, out); } else if (_312 === 2) { walk$array_IntoIter_u8_3(rt.iterSlice(Uint8Array.of(at(3), at(4), at(5))), steps, out); } else if (_312 === 3) { @@ -2081,7 +2082,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { walk$collections_btree_map_Values_u8_u8(rt.btreeValues(map2), steps, out); } } else if (_37 === 20) { - const deque: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true)) as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), 1, true) as rt.VecDeque; const v: rt.ByteVec = rt.byteSliceToByteVec(bytes); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), rt.le, rt.ge, rt.lt); const half2: rt.usize = rt.usizeDiv(bytes.length, 2); @@ -2623,10 +2624,10 @@ export function fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hi rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2693,10 +2694,10 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2763,10 +2764,10 @@ export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_Range rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2833,10 +2834,10 @@ export function fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rt.iterExtend(v2, items, undefined, 1100, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1100, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1100, true), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 1100, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 1100, true), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2903,10 +2904,10 @@ export function fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v2, items, "next", 1100); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1100), 1100) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1100); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(copy$array_u32(copy$array_u32(seed)), 2, copy$array_u32), 1100) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).d.length; @@ -2972,10 +2973,10 @@ export function fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hint rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3041,10 +3042,10 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3110,10 +3111,10 @@ export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeIn rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3179,10 +3180,10 @@ export function fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_clos rt.iterExtend(v2, items, undefined, 0, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 0, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 0, true), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 0, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 0, true), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3248,10 +3249,10 @@ export function fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_ rt.iterExtend(v2, items, "next", 0); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 0), 0) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 0); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(hints_Unit.clone$Clone(seed), 2, hints_Unit.clone$Clone), 0) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 0), rt.cmpLe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(hints_Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(hints_Unit.partialCmp$cmp_PartialOrd)).d.length; @@ -3318,10 +3319,10 @@ export function fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_h rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3388,10 +3389,10 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3458,10 +3459,10 @@ export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Rang rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3528,10 +3529,10 @@ export function fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_c rt.iterExtend(v2, items, undefined, 16, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 16, true)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, undefined, 16, true); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 16, true), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3598,10 +3599,10 @@ export function fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hin rt.iterExtend(v2, items, "next", 16); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16)) as rt.VecDeque<[rt.u64, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8)) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next", 16); + const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(copy$tuple2_u64_u8(copy$tuple2_u64_u8(seed)), 2, copy$tuple2_u64_u8), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).d.length; @@ -3667,10 +3668,10 @@ export function fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32 rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3736,10 +3737,10 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3805,10 +3806,10 @@ export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_Ra rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3874,10 +3875,10 @@ export function fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v2, items, undefined, 3, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 3, true)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 3, true), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, undefined, 3, true); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 3, true), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -3943,10 +3944,10 @@ export function fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_h rt.iterExtend(v2, items, "next", 3); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>)).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next", 3); + const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).d.length; @@ -4012,10 +4013,10 @@ export function fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4081,10 +4082,10 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4150,10 +4151,10 @@ export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4219,10 +4220,10 @@ export function fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u3 rt.iterExtend(v2, items, undefined, 4, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 4, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 4, true), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 4, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 4, true), rt.le, rt.ge, rt.lt).d.length; @@ -4288,10 +4289,10 @@ export function fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_c rt.iterExtend(v2, items, "next", 4); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 4), 4) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined)) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 4); + const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 4), rt.le, rt.ge, rt.lt).d.length; @@ -4357,10 +4358,10 @@ export function fill$u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; @@ -4426,10 +4427,10 @@ export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; @@ -4495,10 +4496,10 @@ export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_ rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; @@ -4564,10 +4565,10 @@ export function fill$u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_ rt.iterExtendBytes(v2, items, undefined, true); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1, true)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, undefined, 1, true), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, undefined, 1, true), rt.le, rt.ge, rt.lt).d.length; @@ -4633,10 +4634,10 @@ export function fill$u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_cl rt.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1)) as rt.VecDeque)).n; + len = ((rt.dequeFromVec(rt.iterToArray(items, "next", 1), 1, true) as rt.VecDeque)).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2))) as rt.VecDeque; - rt.dequeExtend(q, items, "next", 1); + const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; + rt.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { len = rt.heapFrom(rt.iterToArray(items, "next", 1), rt.le, rt.ge, rt.lt).d.length; diff --git a/ts/fixtures/lang/expected/holds.ts b/ts/fixtures/lang/expected/holds.ts index 234798d63..7b4590a02 100644 --- a/ts/fixtures/lang/expected/holds.ts +++ b/ts/fixtures/lang/expected/holds.ts @@ -123,7 +123,7 @@ export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { const _31: rt.u8 = rt.u8WrappingAdd(v.data[at], i2 & 0xff); v.data[at] = _31; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); } /** diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index cee7de7d0..4c45f7da8 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -340,12 +340,12 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 204, (v: rt.ByteVec): rt.u8 => { return v.length & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { return rt.byteVecFrom(Uint8Array.of(_23)); }), (a4: rt.ByteVec, b7: rt.ByteVec): rt.ByteVec => { - rt.iterExtendBytes(a4, rt.iterSlice(rt.byteVecView(b7)), undefined, true); + rt.iterExtendBytes(a4, rt.byteVecIntoIter(b7), undefined, true); return a4; - })))), undefined, true); + }))), undefined, true); const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); const _38: rt.Place | undefined = rt.peekablePeekMut(it, true); if (_38 !== undefined) { @@ -367,7 +367,7 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_73 !== undefined) { rt.byteVecPush(_73, 153); } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next())))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next()))), undefined, true); const _87: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(first)); rt.byteVecPush(out, option_mapOr$1a3irjf(rt.peekableNextIfEq(words, _87, rt.eqBytes), 136, (w: rt.ByteVec): rt.u8 => { return w.data[rt.idx(w, 0)]; @@ -380,8 +380,8 @@ export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { if (_94 !== undefined) { _94.v = 119; } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(log), undefined, true); } export function eq$cmp_PartialEq_iters_Quarter_u8(self: rt.u8, other: Quarter.Quarter): boolean { @@ -567,7 +567,7 @@ export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { }), 170, (b9: rt.Place): rt.u8 => { return b9.v; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); const it11: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Quarter.Quarter => { return { _0: _210, _1: calls }; })); @@ -1990,9 +1990,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2299[0] as rt.u32, _2299[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_41 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z, (_2298: [rt.u8, rt.u8]): rt.u8 => { return _2298[0] ^ _2298[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_41 === 5) { rt.byteVecPush(out, rt.iterFold(z, 0, (acc7: rt.u8, p20: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc7, 3) ^ _40(p20); @@ -2179,9 +2179,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2268[0] as rt.u32, _2268[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_202 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z3, (_2267: [rt.u8, rt.u8]): rt.u8 => { return _2267[0] ^ _2267[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_202 === 5) { rt.byteVecPush(out, rt.iterFold(z3, 0, (acc6: rt.u8, p18: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc6, 3) ^ _201(p18); @@ -2366,9 +2366,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2237[0] as rt.u32, _2237[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_381 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z5, (_2236: [rt.u8, rt.u8]): rt.u8 => { return _2236[0] ^ _2236[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_381 === 5) { rt.byteVecPush(out, rt.iterFold(z5, 0, (acc5: rt.u8, p16: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc5, 3) ^ _380(p16); @@ -2526,12 +2526,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_28 === 2) { if (!other) { if ((kind & 16) === 0) { - const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x138: rt.u8): rt.u8 => { + const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x138: rt.u8): rt.u8 => { const _6178: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6178.value, x138 ^ 7); rt.refMutRelease(_6178); return x138; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x139: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x139: rt.u8): rt.u8 => { const _6179: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6179.value, x139 ^ 8); rt.refMutRelease(_6179); @@ -2553,9 +2553,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2206[0] as rt.u32, _2206[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_574 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z7, (_2205: [rt.u8, rt.u8]): rt.u8 => { return _2205[0] ^ _2205[1]; - }), undefined, true))), undefined, true); + }), undefined, true, 1)), undefined, true); } else if (_574 === 5) { rt.byteVecPush(out, rt.iterFold(z7, 0, (acc4: rt.u8, p14: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc4, 3) ^ _573(p14); @@ -2588,12 +2588,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _612: rt.usize = rt.usizeRem(data.length, 8); if (_612 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x135: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x135: rt.u8): rt.u8 => { const _6176: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6176.value, x135 ^ 7); rt.refMutRelease(_6176); return x135; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x136: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x136: rt.u8): rt.u8 => { const _6177: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6177.value, x136 ^ 8); rt.refMutRelease(_6177); @@ -2602,12 +2602,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2198[0], 2) === 0; })) & 0xff); } else if (_612 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x132: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x132: rt.u8): rt.u8 => { const _6174: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6174.value, x132 ^ 7); rt.refMutRelease(_6174); return x132; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x133: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x133: rt.u8): rt.u8 => { const _6175: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6175.value, x133 ^ 8); rt.refMutRelease(_6175); @@ -2616,12 +2616,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2197[0], _2197[1]); })) & 0xff); } else if (_612 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x129: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x129: rt.u8): rt.u8 => { const _6172: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6172.value, x129 ^ 7); rt.refMutRelease(_6172); return x129; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x130: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x130: rt.u8): rt.u8 => { const _6173: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6173.value, x130 ^ 8); rt.refMutRelease(_6173); @@ -2630,12 +2630,12 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2196[0] < 128; })) & 0xff); } else if (_612 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x127: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x127: rt.u8): rt.u8 => { const _6170: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6170.value, x127 ^ 7); rt.refMutRelease(_6170); return x127; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x128: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x128: rt.u8): rt.u8 => { const _6171: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6171.value, x128 ^ 8); rt.refMutRelease(_6171); @@ -2644,48 +2644,48 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2195[0] & 0xff; })), 238)); } else if (_612 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x125: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x125: rt.u8): rt.u8 => { const _6168: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6168.value, x125 ^ 7); rt.refMutRelease(_6168); return x125; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x126: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x126: rt.u8): rt.u8 => { const _6169: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6169.value, x126 ^ 8); rt.refMutRelease(_6169); return x126; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_612 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x123: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x123: rt.u8): rt.u8 => { const _6166: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6166.value, x123 ^ 7); rt.refMutRelease(_6166); return x123; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x124: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x124: rt.u8): rt.u8 => { const _6167: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6167.value, x124 ^ 8); rt.refMutRelease(_6167); return x124; }), "len"), n)) & 0xff); } else if (_612 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x121: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x121: rt.u8): rt.u8 => { const _6164: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6164.value, x121 ^ 7); rt.refMutRelease(_6164); return x121; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x122: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x122: rt.u8): rt.u8 => { const _6165: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6165.value, x122 ^ 8); rt.refMutRelease(_6165); return x122; }), "len"), n)) & 0xff); } else { - const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), (x119: rt.u8): rt.u8 => { + const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x119: rt.u8): rt.u8 => { const _6162: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6162.value, x119 ^ 7); rt.refMutRelease(_6162); return x119; - }), rt.iterMap(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(b2))), (x120: rt.u8): rt.u8 => { + }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x120: rt.u8): rt.u8 => { const _6163: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6163.value, x120 ^ 8); rt.refMutRelease(_6163); @@ -2695,7 +2695,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } } else if ((kind & 16) === 0) { - const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x107: rt.u8): rt.u8 => { + const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x107: rt.u8): rt.u8 => { const _6158: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6158.value, x107 ^ 9); rt.refMutRelease(_6158); @@ -2723,9 +2723,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2193[0] as rt.u32, _2193[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_751 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z9, (_2192: [rt.u8, rt.u8]): rt.u8 => { return _2192[0] ^ _2192[1]; - }), undefined, true))), undefined, true); + }), undefined, true, 1)), undefined, true); } else if (_751 === 5) { rt.byteVecPush(out, rt.iterFold(z9, 0, (acc3: rt.u8, p12: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc3, 3) ^ _750(p12); @@ -2758,7 +2758,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _789: rt.usize = rt.usizeRem(data.length, 8); if (_789 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x104: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x104: rt.u8): rt.u8 => { const _6156: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6156.value, x104 ^ 9); rt.refMutRelease(_6156); @@ -2773,7 +2773,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8Rem(_2184[0], 2) === 0; })) & 0xff); } else if (_789 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x101: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x101: rt.u8): rt.u8 => { const _6154: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6154.value, x101 ^ 9); rt.refMutRelease(_6154); @@ -2788,7 +2788,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u8CheckedSub(_2182[0], _2182[1]); })) & 0xff); } else if (_789 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x98: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x98: rt.u8): rt.u8 => { const _6152: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6152.value, x98 ^ 9); rt.refMutRelease(_6152); @@ -2803,7 +2803,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2180[0] < 128; })) & 0xff); } else if (_789 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x96: rt.u8): rt.u8 => { + rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x96: rt.u8): rt.u8 => { const _6150: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6150.value, x96 ^ 9); rt.refMutRelease(_6150); @@ -2818,7 +2818,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return _2178[0] & 0xff; })), 238)); } else if (_789 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x94: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x94: rt.u8): rt.u8 => { const _6148: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6148.value, x94 ^ 9); rt.refMutRelease(_6148); @@ -2831,7 +2831,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x95; }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); } else if (_789 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x92: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x92: rt.u8): rt.u8 => { const _6146: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6146.value, x92 ^ 9); rt.refMutRelease(_6146); @@ -2844,7 +2844,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x93; }), "len"), n)) & 0xff); } else if (_789 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x90: rt.u8): rt.u8 => { + rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x90: rt.u8): rt.u8 => { const _6144: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6144.value, x90 ^ 9); rt.refMutRelease(_6144); @@ -2857,7 +2857,7 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x91; }), "len"), n)) & 0xff); } else { - const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.iterSlice(rt.byteVecView(rt.byteSliceToByteVec(a2))), 1), (x88: rt.u8): rt.u8 => { + const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x88: rt.u8): rt.u8 => { const _6142: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_6142.value, x88 ^ 9); rt.refMutRelease(_6142); @@ -2905,9 +2905,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2171[0] as rt.u32, _2171[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_927 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z11, (_2170: [rt.u8, rt.u8]): rt.u8 => { return _2170[0] ^ _2170[1]; - }), "next"))), undefined, true); + }), "next")), undefined, true); } else if (_927 === 5) { rt.byteVecPush(out, rt.iterFold(z11, 0, (acc2: rt.u8, p10: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc2, 3) ^ _926(p10); @@ -3116,9 +3116,9 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return rt.u32Add(_2131[0] as rt.u32, _2131[1] as rt.u32); }), rt.u32Add, 0)).reverse()), undefined, true); } else if (_1102 === 4) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z13, (_2130: [rt.u8, rt.u8]): rt.u8 => { return _2130[0] ^ _2130[1]; - }), undefined, true))), undefined, true); + }), undefined, true)), undefined, true); } else if (_1102 === 5) { rt.byteVecPush(out, rt.iterFold(z13, 0, (acc: rt.u8, p8: [rt.u8, rt.u8]): rt.u8 => { return rt.u8WrappingMul(acc, 3) ^ _1101(p8); @@ -4610,7 +4610,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = new rt.ByteVec(); const _22: rt.Iter = rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), 3); rt.iterExtendBytes(v, _22, undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.iterSlice([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)])), 5), "next"); rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatMap(it(), (x: rt.u8): rt.RangeFrom => { return new rt.RangeFrom(rt.u8Div(x, 4), rt.u8Step); @@ -4625,7 +4625,7 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rt.u8, rt.usize]): rt.u8 => { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next"))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next")), undefined, true); rt.iterExtendBytes(out, rt.strBytes(rt.stringExtendChars("", rt.iterTake(new rt.RangeFrom(97, rt.charStep), rt.usizeRem(n, 6)))), undefined, true); const _77: [rt.usize, rt.usize | undefined] = rt.iterZip(it(), new rt.RangeFrom(lo, rt.u8Step), "len").sizeHint(); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$02k4ito(_77[1], 238, (h: rt.usize): rt.u8 => { @@ -4691,7 +4691,7 @@ export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, return c & 0xff; })); } else { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true)), undefined, true); } } diff --git a/ts/fixtures/lang/expected/joins.ts b/ts/fixtures/lang/expected/joins.ts index 3c10edf32..5d1391760 100644 --- a/ts/fixtures/lang/expected/joins.ts +++ b/ts/fixtures/lang/expected/joins.ts @@ -6,7 +6,7 @@ import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$1j4op5y as option import { put as fmt_put } from "./fmt.ts"; import * as joins_Logged from "./joins.Logged.ts"; import * as Sentinel from "./joins.Sentinel.ts"; -import { text } from "./strs.ts"; +import { text as strs_text } from "./strs.ts"; /** Puts what was logged since the last flush, after a marker. */ export function flush(log: rt.RefCell, out: rt.ByteVec): void { @@ -187,9 +187,9 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { log[Symbol.dispose](); } else if (_26 === 4) { const owned2: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(parts), (p3: rt.ByteSlice): string => { - return text(p3); + return strs_text(p3); }), undefined, 12, true); - const sep4: string = text(seps); + const sep4: string = strs_text(seps); fmt_put(out, rt.strsJoin(owned2, "")); fmt_put(out, rt.strsJoin(owned2, sep4)); const borrowed: string[] = rt.iterToArray(rt.iterMap(rt.iterSlice(owned2), (a02: string): string => { @@ -229,14 +229,14 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (rt.usizeRem(_214[0], 2) === 0) { return "ab"; } - return text(_214[1]); + return strs_text(_214[1]); }), undefined, 12, true); fmt_put(out, rt.strsJoin(texts, "")); fmt_put(out, rt.strsJoin(texts, "--")); } else { const big: rt.ByteVec = rt.byteVecOf(1, 1 << 16); const wide4: rt.u16[] = rt.vecFromElem(1, 1 << 16, undefined); - const text_: string = text(rt.byteVecSlice(big)); + const text: string = strs_text(rt.byteVecSlice(big)); const refs: (a0: rt.usize) => rt.ByteSlice[] = (n: rt.usize): rt.ByteSlice[] => { return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined); }; @@ -250,9 +250,9 @@ export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_512 === 3) { wides(rt.slicesJoin(rt.vecFromElem(rt.sliceRange(wide4, 0), rt.usizeAdd(1 << 14, 1), undefined), 2), out); } else if (_512 === 4) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 15, 1), undefined), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text, rt.usizeAdd(1 << 15, 1), undefined), "")); } else if (_512 === 5) { - fmt_put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 16, 1), undefined), "")); + fmt_put(out, rt.strsJoin(rt.vecFromElem(text, rt.usizeAdd(1 << 16, 1), undefined), "")); } else { const sep5: Sentinel.Sentinel[] = rt.iterToArray(rt.iterMap(new rt.Range(0, 1 << 16), (i: rt.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index c3997d98f..4f280dac3 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1431,7 +1431,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const map: rt.HashMap = rt.hashNew() as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; const iter: rt.Iter = rt.byteSliceWindows(data, 2); while (true) { @@ -1797,7 +1797,7 @@ export function keyed$Option_u8_2_keys_arrays_closure5(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2053,7 +2053,7 @@ export function keyed$bool_2_keys_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2308,7 +2308,7 @@ export function keyed$char_2_keys_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2564,7 +2564,7 @@ export function keyed$i32_2_keys_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -2819,7 +2819,7 @@ export function keyed$keys_Hop_2_keys_arrays_closure6(data: rt.ByteSlice, make: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3075,7 +3075,7 @@ export function keyed$u16_2_keys_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3331,7 +3331,7 @@ export function keyed$u32_0_keys_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3587,7 +3587,7 @@ export function keyed$u32_275_keys_arrays_closure8(data: rt.ByteSlice, make: (a0 rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3843,7 +3843,7 @@ export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(held)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { return n & 0xff; })), undefined, true); @@ -3972,9 +3972,9 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 0, true); const vec: Uint8Array[] = []; rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 0, true); - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeNew(0) as rt.VecDeque; const _14: rt.Iter = rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom); - rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, 0, true); + rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, true); const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; rt.heapExtend(heap, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), undefined, 0, true); const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; @@ -4089,7 +4089,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r return _22 < 2; }); }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 0)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 0), undefined, true); - const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIter(rt.dequeClone(deque, copy$array_u8, 0)), rt.lending((p4: rt.ByteSlice): boolean => { + const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p4) === 64; }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); const _214: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeek(rest), rt.byteSliceFrom); @@ -4176,7 +4176,7 @@ export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { @@ -4273,9 +4273,9 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const pairs: Uint8Array[] = rt.iterToArray(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 2, true); const vec: Uint8Array[] = []; rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const _14: rt.Iter = rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom); - rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, 2, true); + rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, true); const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; rt.heapExtend(heap, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), undefined, 2, true); const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; @@ -4390,7 +4390,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r return _22 < 2; }); }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 2)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), false, 2), undefined, true); - const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIter(rt.dequeClone(deque, copy$array_u8, 2)), rt.lending((p4: rt.ByteSlice): boolean => { + const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { return rt.byteSliceFirst(p4) === 64; }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); const _214: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeek(rest), rt.byteSliceFrom); @@ -4477,7 +4477,7 @@ export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: r const _332: rt.RefCell = rt.refCellBorrowMut(log); rt.byteVecPush(_332.value, counted2); rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.refCellReplace(log, new rt.ByteVec()))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); const lent: [rt.ByteSlice, rt.ByteSlice][] = rt.iterToArray(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { diff --git a/ts/fixtures/lang/expected/lists.ts b/ts/fixtures/lang/expected/lists.ts index c553e8c4b..33a583b7e 100644 --- a/ts/fixtures/lang/expected/lists.ts +++ b/ts/fixtures/lang/expected/lists.ts @@ -115,10 +115,10 @@ export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_13 === 11) { l = rt.replaceIn(m, l); } else { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { x5.v = rt.u8WrappingAdd(x5.v, 1); return rt.u8Rem(x5.v, 3) === 0; - }), "next"))), undefined, true); + }), "next")), undefined, true); } } } @@ -193,7 +193,7 @@ export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: rt.LinkedList = rt.listClone(whole, undefined); rt.listAppend(from, _64); const _68: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(7, 8)); - rt.listExtend(from, rt.iterSlice(rt.byteVecView(_68))); + rt.listExtend(from, rt.byteVecIntoIter(_68)); items(from, out); const _75: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u8] => { const b: rt.u8 = _2; diff --git a/ts/fixtures/lang/expected/locals.ts b/ts/fixtures/lang/expected/locals.ts index 3ce07f5df..93a7811eb 100644 --- a/ts/fixtures/lang/expected/locals.ts +++ b/ts/fixtures/lang/expected/locals.ts @@ -61,9 +61,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, ((a0: rt.Cell): rt.u32 => { return a0.v; })(COUNT.get()) & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { + rt.iterExtendBytes(out, rt.byteVecIntoIter(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { return rt.byteVecFrom(rt.byteVecView(log2)); - }))), undefined, true); + })), undefined, true); rt.byteVecPush(out, ((p: locals_Polling.Polling): rt.u8 => { return option_mapOr$0ucbp7g(copy$Option_tuple2_u64_u64(p.current.v), 253, (_2: [rt.u64, rt.u64]): rt.u8 => { return rt.u64Low(_2[0]) & 0xff; @@ -165,9 +165,9 @@ export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, withBorrow$0r4ucls(LOG, (log4: rt.ByteVec): rt.u8 => { return log4.length & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op))))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op)))), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(op, op))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(local_take$122f15k(LOG))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(local_take$122f15k(LOG)), undefined, true); rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(1, 2, 3))); const _141: rt.LocalKey> = HELD; const _144: rt.Arc> = rt.arcClone(log); diff --git a/ts/fixtures/lang/expected/nested.ts b/ts/fixtures/lang/expected/nested.ts index c841ab9b5..af5bdbae4 100644 --- a/ts/fixtures/lang/expected/nested.ts +++ b/ts/fixtures/lang/expected/nested.ts @@ -441,7 +441,7 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { }, undefined, rt.None), "next", 2)), (_222: rt.u8 | undefined): rt.u8 => { return code(_222); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(seen)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(seen), undefined, true); let steps: rt.u8 = 0; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterSuccessors(undefined, (_223: undefined): undefined | rt.None => { steps = rt.u8Add(steps, 1); @@ -547,7 +547,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { popped = rt.u8Add(popped, 1); } rt.byteVecPush(out, popped); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; const iter2: rt.Iter<[rt.usize, rt.u8 | undefined]> = rt.iterEnumerate(rt.iterSlice(items)); while (true) { const _167: [rt.usize, rt.u8 | undefined] | rt.Done = iter2.next(); @@ -593,7 +593,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequePopFront(q, rt.None)), code(rt.dequePopBack(q, rt.None)), code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeRemove(q, 0, rt.None)), code(rt.dequeSwapRemove(q, 0, true, rt.None)), code(rt.dequeSwapRemove(q, 0, false, rt.None)))), undefined, true); - const unitQ: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined)) as rt.VecDeque; + const unitQ: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined), 0) as rt.VecDeque; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequeEnd(unitQ, false, rt.None) !== rt.None ? 1 : 0, rt.dequeEnd(unitQ, true, rt.None) !== rt.None ? 1 : 0, rt.dequeGet(unitQ, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequePopBack(unitQ, rt.None) !== rt.None ? 1 : 0, rt.dequeRemove(unitQ, at, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, true, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, false, rt.None) !== rt.None ? 1 : 0, rt.dequePopFront(unitQ, rt.None) !== rt.None ? 1 : 0, unitQ.n & 0xff)), undefined, true); const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterSlice(items), undefined, 2, true), rt.cmpLe(rt.cmpOption(rt.cmp)), rt.cmpGe(rt.cmpOption(rt.cmp)), rt.cmpLt(rt.cmpOption(rt.cmp))); @@ -746,7 +746,7 @@ export function madeAll$nested_Unit(m: nested_Unit.Unit, data: rt.ByteSlice): un export function units(data: rt.ByteSlice, out: rt.ByteVec): void { let f!: (a0: rt.u8) => undefined; const units: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined => {}), undefined, 0, true); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}), undefined, 0, true)) as rt.VecDeque; + const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; const named: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), ignore as (a0: rt.u8) => undefined), undefined, 0, true); const _15: rt.u8 | undefined = rt.byteSliceFirst(data); b0: { @@ -761,7 +761,7 @@ export function units(data: rt.ByteSlice, out: rt.ByteVec): void { const byPointer: undefined[] = pointed(data, f); const generic: undefined[] = each$unit_nested_units_closure3(data, (_25: rt.u8): undefined => {}); const byName: undefined[] = each$unit_nested_ignore(data, ignore as (a0: rt.u8) => undefined); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(each$u8_nested_half(data, half))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(each$u8_nested_half(data, half)), undefined, true); const methods: undefined[] = madeAll$nested_Unit({}, data); const dynamic: undefined[] = rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), rt.lent(ignore as (a0: rt.u8) => undefined)), undefined, 0, true); const iter: rt.Iter = rt.iterSlice([units, named, byPointer, generic, byName, methods, dynamic]); diff --git a/ts/fixtures/lang/expected/objects.ts b/ts/fixtures/lang/expected/objects.ts index 3e94d9b62..47897819a 100644 --- a/ts/fixtures/lang/expected/objects.ts +++ b/ts/fixtures/lang/expected/objects.ts @@ -187,7 +187,7 @@ export function refill(v: rt.Arc[], bytes: rt.ByteVec, with_: rt.Arc, map: rt.HashMap, n: rt.u8): rt.usize { - const old: rt.VecDeque = rt.replaceIn(q, rt.dequeFromVec(rt.iterToArray(new rt.Range(0, rt.u8Rem(n, 5)), undefined, 1, true)) as rt.VecDeque); + const old: rt.VecDeque = rt.replaceIn(q, rt.dequeFromVec(rt.iterToArray(new rt.Range(0, rt.u8Rem(n, 5)), undefined, 1, true), 1, true) as rt.VecDeque); Object.assign(map, rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[n, n] as [rt.u8, rt.u8]]), undefined, undefined, undefined, 469762048)); return old.n; } @@ -442,8 +442,7 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); counts(out, [one, two], w.held); counts(out, [one, two], other); - const _515: Uint8Array = Uint8Array.of(by); - const q: rt.VecDeque = rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice(_515), undefined, 1, true); + const q: rt.VecDeque = rt.dequeFromArray(Uint8Array.of(by), 1, true) as rt.VecDeque; const map: rt.HashMap = rt.hashNew() as rt.HashMap; for (const _519 of rt.byteSliceView(data)) { rt.byteVecPush(out, requeue(q, map, _519) & 0xff); diff --git a/ts/fixtures/lang/expected/orders.ts b/ts/fixtures/lang/expected/orders.ts index 99755a4a4..aa97efa72 100644 --- a/ts/fixtures/lang/expected/orders.ts +++ b/ts/fixtures/lang/expected/orders.ts @@ -381,10 +381,10 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { const bytes: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteSliceToByteVec(data)), rt.le, rt.ge, rt.lt); rt.heapPush(bytes, data.length & 0xff, rt.le); rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.from(bytes.d)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes, undefined, 1), rt.le, rt.ge, rt.lt)))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes, undefined, 1), rt.le, rt.ge, rt.lt))), undefined, true); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(bytes.d, f, rt.u8Debug)]; rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(bytes.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(bytes.d)), undefined, true); const least: rt.BinaryHeap = rt.heapFrom(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { return _2; }), undefined, 1, true), rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); @@ -750,7 +750,7 @@ export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true)) as rt.VecDeque; + }), undefined, 2, true), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -780,7 +780,7 @@ export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { return part(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true)) as rt.VecDeque; + }), undefined, 2, true), 2) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -810,7 +810,7 @@ export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true)) as rt.VecDeque; + }), undefined, 1, true), 1, true) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -840,7 +840,7 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, const _17: rt.usize = at; const d: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true)) as rt.VecDeque; + }), undefined, 1, true), 1, true) as rt.VecDeque; const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); while (true) { const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); @@ -891,7 +891,7 @@ export function held(data: rt.ByteSlice, out: rt.ByteVec): void { return p2.key as rt.f64; } return NaN; - }), undefined, 8, true)) as rt.VecDeque; + }), undefined, 8, true), 8) as rt.VecDeque; }; const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); while (true) { diff --git a/ts/fixtures/lang/expected/pointers.ts b/ts/fixtures/lang/expected/pointers.ts index f4c456db1..d4fd0509b 100644 --- a/ts/fixtures/lang/expected/pointers.ts +++ b/ts/fixtures/lang/expected/pointers.ts @@ -665,7 +665,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { const _33: Log.Log = { bytes: rt.byteVecFrom(Uint8Array.of(n, ~n & 0xff)) }; const old3 = log; log = _33; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(old3.bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(old3.bytes), undefined, true); const old2: Duo.Duo = rt.replaceIn(pair, { _0: n, _1: n ^ 15 }); rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(old2._0, old2._1)), undefined, true); } else if (_24 === 2) { @@ -695,7 +695,7 @@ export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { } } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(log.bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(log.bytes), undefined, true); rt.iterExtendBytes(out, rt.iterSlice(window), undefined, true); } diff --git a/ts/fixtures/lang/expected/refs.ts b/ts/fixtures/lang/expected/refs.ts index 8fb8cd29b..c38e6f6c3 100644 --- a/ts/fixtures/lang/expected/refs.ts +++ b/ts/fixtures/lang/expected/refs.ts @@ -576,7 +576,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { return _25 > ((b4 as rt.u32)); }), (x3: rt.u32): rt.u32 => { return rt.u32Div(x3, 2); - }), "next", 4); + }), "next", 4, false, 4); })(); return held.length === 0; }) as rt.u32))); @@ -593,7 +593,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { const swapped: rt.ByteVec = new rt.ByteVec(); for (const _39 of rt.byteSliceView(data)) { const _45: rt.ByteVec = swap(_39); - rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_45)), undefined, true); + rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_45), undefined, true); } const list: (a0: rt.u8) => undefined = (b6: rt.u8): undefined => { const taken2 = pair[1].listed; @@ -606,7 +606,7 @@ export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { }); for (const _57 of rt.byteSliceView(data)) { const _63: rt.ByteVec = option_unwrapOrDefault$0wx44sw(restock(pair[1], _57)); - rt.iterExtendBytes(swapped, rt.iterSlice(rt.byteVecView(_63)), undefined, true); + rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_63), undefined, true); } const taken3 = pair[1].stale; pair[1].stale = new rt.ByteVec(); @@ -753,7 +753,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { } const hash: rt.HashMap = rt.hashNew() as rt.HashMap; const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(4) as rt.VecDeque; for (const b2 of rt.byteSliceView(data)) { rt.entryOrInsert(rt.entryAndModify(rt.entry(hash, rt.u8Rem(b2, 5)), (x9: [rt.u8, rt.u8]): undefined => { x9[1] = rt.u8WrappingAdd(x9[1], b2); @@ -1041,7 +1041,7 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { rt.byteVecPush(out, k3); rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x5))); } - const iter36: rt.Iter = rt.dequeIter(queue); + const iter36: rt.Iter = rt.dequeIntoIter(queue); while (true) { const _590: rt.u32 | rt.Done = iter36.next(); if (_590 === rt.DONE) { diff --git a/ts/fixtures/lang/expected/rings.Big.ts b/ts/fixtures/lang/expected/rings.Big.ts new file mode 100644 index 000000000..50f04acf6 --- /dev/null +++ b/ts/fixtures/lang/expected/rings.Big.ts @@ -0,0 +1,30 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; + +export function clone$Clone(self: Big): Big { + return { id: self.id, pad: rt.byteSliceToArray(rt.byteSliceFrom(self.pad)) }; +} + +/** Past 1 KiB, which std's grows from one slot rather than four. */ +export interface Big { + id: rt.u8; + pad: Uint8Array; +} + +export function fmt$fmt_Debug(self: Big, f: rt.Formatter): rt.Result { + const part = self.pad[1099]; + const arg = self.id; + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(part, f)]; + return rt.fmtWriteFmt(f, ["B", args2[0], ".", args2[1]]); +} + +export function make$rings_Item(b: rt.u8): Big { + return { id: b, pad: rt.bytes(1100).fill(b) }; +} + +export function bump$rings_Item(self: Big): void { + self.id = rt.u8WrappingAdd(self.id, 1); +} + +//# sourceMappingURL=rings.Big.ts.map diff --git a/ts/fixtures/lang/expected/rings.ts b/ts/fixtures/lang/expected/rings.ts new file mode 100644 index 000000000..b32a05ea5 --- /dev/null +++ b/ts/fixtures/lang/expected/rings.ts @@ -0,0 +1,1417 @@ +// Generated by rust2-ts. Do not edit. + +import * as rt from "./rt.ts"; +import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1ttssgs as option_mapOr$1ttssgs } from "./core/option.ts"; +import * as Big from "./rings.Big.ts"; + +export function make$rings_Item_u8(b: rt.u8): rt.u8 { + return b; +} + +export function bump$rings_Item_u8(self: rt.Place): void { + self.v = rt.u8WrappingAdd(self.v, 1); +} + +export function make$rings_Item_u32(b: rt.u8): rt.u32 { + return (((b as rt.u32)) << 12) >>> 0; +} + +export function bump$rings_Item_u32(self: rt.Place): void { + self.v = rt.u32Add(self.v, 1); +} + +export function make$rings_Item_String(b: rt.u8): string { + const part = rt.u8Rem(b, 16); + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part, f)]; + return rt.fmtFormat(["s", args2[0]]); +} + +export function bump$rings_Item_String(self: rt.Place): void { + self.v = self.v + "!"; +} + +export function make$rings_Item_unit(_1: rt.u8): void { +} + +export function bump$rings_Item_unit(_self: rt.Place): void { +} + +/** Steps a deque of the item type `kind` picks through `data`. */ +export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + const _4: rt.u8 = rt.u8Rem(kind, 5); + if (_4 === 0) { + steps$u8(dataData, dataStart, dataLen, out); + } else if (_4 === 1) { + steps$u32(dataData, dataStart, dataLen, out); + } else if (_4 === 2) { + steps$String(dataData, dataStart, dataLen, out); + } else if (_4 === 3) { + steps$unit(dataData, dataStart, dataLen, out); + } else { + steps$rings_Big(dataData, dataStart, dataLen, out); + } +} + +/** A length or capacity, as four bytes. */ +export function put(out: rt.ByteVec, n: rt.usize): void { + rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(n as rt.u32).reverse())); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_String(out: rt.ByteVec, value: string | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_rings_Big(out: rt.ByteVec, value: Big.Big | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f))]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_u32(out: rt.ByteVec, value: rt.u32 | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_u8(out: rt.ByteVec, value: rt.u8 | undefined): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$Option_ref_unit(out: rt.ByteVec, value: undefined | rt.None): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtUnit, rt.None)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_String(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_rings_Big(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_u32(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_u8(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Drain_unit(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_String(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtStr, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_rings_Big(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_u32(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u32Debug, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_u8(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u8Debug, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_IterMut_unit(out: rt.ByteVec, value: rt.Iter>): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtUnit, "IterMut")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_String(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtStr, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_rings_Big(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_u32(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u32Debug, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_u8(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u8Debug, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$collections_vec_deque_Iter_unit(out: rt.ByteVec, value: rt.Iter): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtUnit, "Iter")]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_String_ref_slice_String(out: rt.ByteVec, value: [string[], string[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.fmtStr)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out: rt.ByteVec, value: [Big.Big[], Big.Big[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtList(value[1], f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_u32_ref_slice_u32(out: rt.ByteVec, value: [rt.u32[], rt.u32[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.u32Debug), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.u32Debug)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_u8_ref_slice_u8(out: rt.ByteVec, value: [rt.ByteSlice, rt.ByteSlice]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value[0]), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value[1]), f, rt.u8Debug)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** What `{:?}` writes of `value`. */ +export function text$tuple2_ref_slice_unit_ref_slice_unit(out: rt.ByteVec, value: [undefined[], undefined[]]): void { + const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.fmtUnit), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.fmtUnit)], f)]; + rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(12) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 12) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.vecFromElem(make$rings_Item_String(first), n, undefined), 12) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, make$rings_Item_String(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, make$rings_Item_String(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, make$rings_Item_String(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: string): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$String(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_String), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_String), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$String(q, arg); + } else { + mutated$String(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_String_ref_slice_String(out, rt.dequeAsSlices(q)); + iterated$String(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$rings_Big(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(1101) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 1101) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.vecFromElem(Big.make$rings_Item(first), n, Big.clone$Clone), 1101) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, Big.make$rings_Item(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, Big.make$rings_Item(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, Big.make$rings_Item(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: Big.Big): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$rings_Big(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), Big.make$rings_Item), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), Big.make$rings_Item), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$rings_Big(q, arg); + } else { + mutated$rings_Big(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rt.dequeAsSlices(q)); + iterated$rings_Big(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$u32(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(4) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 4) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.vecFromElem(make$rings_Item_u32(first), n, undefined), 4) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, make$rings_Item_u32(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, make$rings_Item_u32(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, make$rings_Item_u32(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: rt.u32): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$u32(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_u32), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_u32), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$u32(q, arg); + } else { + mutated$u32(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_u32_ref_slice_u32(out, rt.dequeAsSlices(q)); + iterated$u32(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(1, true) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 1, true) as rt.VecDeque; + } else { + q = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(make$rings_Item_u8(first), n)), 1, true) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + rt.dequePushBack(q, make$rings_Item_u8(arg)); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + rt.dequePushFront(q, make$rings_Item_u8(arg)); + } else if (_46 === 6) { + rt.dequePopFront(q); + } else if (_46 === 7) { + rt.dequePopBack(q); + } else if (_46 === 8) { + rt.dequeInsert(q, at, make$rings_Item_u8(arg)); + } else if (_46 === 9) { + rt.dequeRemove(q, at); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: rt.u8): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$u8(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_u8), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_u8), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$u8(q, arg); + } else { + mutated$u8(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_u8_ref_slice_u8(out, rt.dequeByteSlices(q)); + iterated$u8(q, arg, out); + } +} + +/** + * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and + * each pair after it steps: after each, its length, capacity, and two slices. + */ +export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { + let q!: rt.VecDeque; + const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { + return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; + }); + const first: rt.u8 = _5[0]; + const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); + const _17: rt.u8 = rt.u8Rem(first, 3); + if (_17 === 0) { + q = rt.dequeNew(0) as rt.VecDeque; + } else if (_17 === 1) { + q = rt.dequeWithCapacity(n, 0) as rt.VecDeque; + } else { + make$rings_Item_unit(first); + q = rt.dequeFromVec(rt.vecFromElem(undefined, n, undefined), 0) as rt.VecDeque; + } + const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + while (true) { + const _24: rt.ByteSlice | rt.Done = iter.next(); + if (_24 === rt.DONE) { + break; + } + rt.idx(_24, 0); + const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; + const op: rt.u8 = _30[0]; + const arg: rt.u8 = _30[1]; + const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + b3: { + const _46: rt.u8 = rt.u8Rem(op, 24); + if (0 <= _46) { + if (_46 <= 3) { + const _50: rt.VecDeque = q; + make$rings_Item_unit(arg); + rt.dequePushBack(_50, undefined); + break b3; + } + } + if (_46 === 4 || _46 === 5) { + const _52: rt.VecDeque = q; + make$rings_Item_unit(arg); + rt.dequePushFront(_52, undefined); + } else if (_46 === 6) { + rt.dequePopFront(q, rt.None); + } else if (_46 === 7) { + rt.dequePopBack(q, rt.None); + } else if (_46 === 8) { + const _58: rt.VecDeque = q; + make$rings_Item_unit(arg); + rt.dequeInsert(_58, at, undefined); + } else if (_46 === 9) { + rt.dequeRemove(q, at, rt.None); + } else if (_46 === 10) { + rt.dequeSwapRemove(q, at, false, rt.None); + } else if (_46 === 11) { + rt.dequeSwapRemove(q, at, true, rt.None); + } else if (_46 === 12) { + rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + } else if (_46 === 13) { + let kept: rt.u8 = arg; + rt.dequeRetain(q, (_23: undefined): boolean => { + kept = rt.intRotateLeft(kept, 1, 8, false); + return (kept & 1) === 1; + }); + } else if (_46 === 14) { + drained$unit(q, arg, out); + } else if (_46 === 15) { + rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 16) { + rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 17) { + rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + } else if (_46 === 18) { + rt.dequeShrinkTo(q, 0); + } else if (_46 === 19) { + rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { + return rt.u8Rem(i, 3) !== 0; + }), make$rings_Item_unit as (a0: rt.u8) => undefined), "next"); + } else if (_46 === 20) { + rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_unit as (a0: rt.u8) => undefined), undefined, true); + } else if (_46 === 21) { + rt.dequeClear(q); + } else if (_46 === 22) { + q = remade$unit(q, arg); + } else { + mutated$unit(q, arg, out); + } + } + put(out, q.n); + put(out, rt.dequeCapacity(q)); + text$tuple2_ref_slice_unit_ref_slice_unit(out, rt.dequeAsSlices(q)); + iterated$unit(q, arg, out); + } +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. + */ +export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 12) as rt.VecDeque; + const _18: string = make$rings_Item_String(arg); + rt.dequePushFront(own, _18); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 12) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 12) as rt.VecDeque; + } + if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: string): boolean => { + kept = !kept; + return kept; + }), "next", 12, false, 12), 12) as rt.VecDeque; + } + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true), 12) as rt.VecDeque; + } + const v2: string[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 12, true); + rt.vecReserve(v2, skip, 12); + const it3: rt.Iter = rt.iterSlice(v2); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 12) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 12) as rt.VecDeque; + } + return _0; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. + */ +export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1101) as rt.VecDeque; + const _18: Big.Big = Big.make$rings_Item(arg); + rt.dequePushFront(own, _18); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, Big.clone$Clone); + } else { + rt.dequeCloneFrom(own, q, Big.clone$Clone); + } + return own; + } + return rt.dequeClone(q, Big.clone$Clone); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 1101) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 1101) as rt.VecDeque; + } + if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: Big.Big): boolean => { + kept = !kept; + return kept; + }), "next", 1101, false, 1101), 1101) as rt.VecDeque; + } + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true), 1101) as rt.VecDeque; + } + const v2: Big.Big[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 1101, true); + rt.vecReserve(v2, skip, 1101); + const it3: rt.Iter = rt.iterSlice(v2); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 1101) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: Big.clone$Clone }), 1101) as rt.VecDeque; + } + return _0; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. + */ +export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 4) as rt.VecDeque; + const _18: rt.u32 = make$rings_Item_u32(arg); + rt.dequePushFront(own, _18); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 4) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 4) as rt.VecDeque; + } + if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: rt.u32): boolean => { + kept = !kept; + return kept; + }), "next", 4, false, 4), 4) as rt.VecDeque; + } + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true), 4) as rt.VecDeque; + } + const v2: rt.u32[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 4, true); + rt.vecReserve(v2, skip, 4); + const it3: rt.Iter = rt.iterSlice(v2); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 4) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 4) as rt.VecDeque; + } + return _0; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. + */ +export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1, true) as rt.VecDeque; + const _18: rt.u8 = make$rings_Item_u8(arg); + rt.dequePushFront(own, _18); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next()); + } + rt.iterToOption(it.nextBack()); + return rt.dequeFromIntoIter(it, 1, true) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip); + return rt.dequeFromIntoIter(it2, 1, true) as rt.VecDeque; + } + if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.byteVecIntoIter(v), (_2: rt.u8): boolean => { + kept = !kept; + return kept; + }), "next", 1, false, 1), 1, true) as rt.VecDeque; + } + return rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; + } + const v2: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); + rt.byteVecReserve(v2, skip); + const it3: rt.Iter = rt.byteVecIntoIter(v2); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next()); + } + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 1, true) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 1, true) as rt.VecDeque; + } + return _0; +} + +/** + * A deque made anew from `q`: a clone, or one with room of its own cloned into from it, + * collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, + * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through + * adaptors in place of another. + */ +export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { + let _0!: rt.VecDeque; + const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); + const _8: rt.u8 = rt.u8Rem(arg, 5); + if (_8 === 0) { + if (!((arg & 32) === 0)) { + const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 0) as rt.VecDeque; + make$rings_Item_unit(arg); + rt.dequePushFront(own, undefined); + if ((arg & 64) === 0) { + rt.dequeCloneFrom(own, q, undefined); + } else { + rt.dequeCloneFrom(own, q, undefined); + } + return own; + } + return rt.dequeClone(q); + } + if (_8 === 1) { + const it: rt.Iter = rt.dequeIntoIter(q); + let iterStart: rt.usize = 0; + const iterEnd: rt.usize = skip; + while (iterStart++ < iterEnd) { + rt.iterToOption(it.next(), rt.None); + } + rt.iterToOption(it.nextBack(), rt.None); + return rt.dequeFromIntoIter(it, 0) as rt.VecDeque; + } + if (_8 === 2) { + const it2: rt.Iter = rt.dequeIntoIter(q); + rt.iterNth(it2, skip, undefined, rt.None); + return rt.dequeFromIntoIter(it2, 0) as rt.VecDeque; + } + if (_8 === 3) { + if (!((arg & 32) === 0)) { + const v: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); + let kept: boolean = false; + return rt.dequeFromVec(rt.iterToArray(rt.iterFilter(rt.iterSlice(v), (_2: undefined): boolean => { + kept = !kept; + return kept; + }), "next", 0), 0) as rt.VecDeque; + } + return rt.dequeFromVec(rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; + } + const v2: undefined[] = rt.iterToArray(rt.dequeIntoIter(q), undefined, 0, true); + rt.vecReserve(v2, skip, 0); + const it3: rt.Iter = rt.iterSlice(v2); + let iterStart2: rt.usize = 0; + const iterEnd2: rt.usize = skip; + while (iterStart2++ < iterEnd2) { + rt.iterToOption(it3.next(), rt.None); + } + if ((arg & 64) === 0) { + _0 = rt.dequeFromIntoIter(it3, 0) as rt.VecDeque; + } else { + _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 0) as rt.VecDeque; + } + return _0; +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_String(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_String(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_rings_Big(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_rings_Big(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_u32(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_u32(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_u8(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next()); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack()); + } + text$collections_vec_deque_Drain_u8(out, d); + rt.drop(d); +} + +/** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ +export function drained$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const len: rt.usize = q.n; + const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); + const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); + text$collections_vec_deque_Drain_unit(out, d); + if ((arg & 64) !== 0) { + rt.iterToOption(d.next(), rt.None); + } + if ((arg & 128) !== 0) { + rt.iterToOption(d.nextBack(), rt.None); + } + text$collections_vec_deque_Drain_unit(out, d); + rt.drop(d); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [string[], string[]] = rt.dequeAsSlices(q, true); + const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); + if (_7 !== undefined) { + bump$rings_Item_String(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + if (_11 !== undefined) { + bump$rings_Item_String(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_String(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_String(_29); + } + text$collections_vec_deque_IterMut_String(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [Big.Big[], Big.Big[]] = rt.dequeAsSlices(q, true); + const _7: Big.Big | undefined = rt.sliceFirst(_6[0]); + if (_7 !== undefined) { + Big.bump$rings_Item(_7); + } + const _11: Big.Big | undefined = rt.sliceLast(_6[1]); + if (_11 !== undefined) { + Big.bump$rings_Item(_11); + } + const it: rt.Iter = rt.dequeIter(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: Big.Big | rt.Done = it.next(); + if (_24 !== rt.DONE) { + Big.bump$rings_Item(_24); + } + } + const _29: Big.Big | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + Big.bump$rings_Item(_29); + } + text$collections_vec_deque_IterMut_rings_Big(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [rt.u32[], rt.u32[]] = rt.dequeAsSlices(q, true); + const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); + if (_7 !== undefined) { + bump$rings_Item_u32(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + if (_11 !== undefined) { + bump$rings_Item_u32(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_u32(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_u32(_29); + } + text$collections_vec_deque_IterMut_u32(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [rt.ByteSlice, rt.ByteSlice] = rt.dequeByteSlices(q); + const _7: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_6[0])); + if (_7 !== undefined) { + bump$rings_Item_u8(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_6[1])); + if (_11 !== undefined) { + bump$rings_Item_u8(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_u8(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_u8(_29); + } + text$collections_vec_deque_IterMut_u8(out, it); +} + +/** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ +export function mutated$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + const _6: [undefined[], undefined[]] = rt.dequeAsSlices(q, true); + const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); + if (_7 !== undefined) { + bump$rings_Item_unit(_7); + } + const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + if (_11 !== undefined) { + bump$rings_Item_unit(_11); + } + const it: rt.Iter> = rt.dequeIterMut(q); + const _18: rt.u8 = rt.u8Rem(arg, 4); + let iterStart: rt.u8 = 0; + const iterEnd: rt.u8 = _18; + while (iterStart++ < iterEnd) { + const _24: rt.Place | rt.Done = it.next(); + if (_24 !== rt.DONE) { + bump$rings_Item_unit(_24); + } + } + const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + if (_29 !== undefined) { + bump$rings_Item_unit(_29); + } + text$collections_vec_deque_IterMut_unit(out, it); +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: string | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_String(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: string): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: string): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_String(out, read); + text$collections_vec_deque_Iter_String(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: Big.Big | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_rings_Big(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: Big.Big): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: Big.Big): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_rings_Big(out, read); + text$collections_vec_deque_Iter_rings_Big(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: rt.u32 | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_u32(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: rt.u32): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: rt.u32): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_u32(out, read); + text$collections_vec_deque_Iter_u32(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: rt.u8 | undefined; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_u8(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next()); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack()); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: rt.u8): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: rt.u8): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }); + } else { + read = rt.iterToOption(it.clone().next()); + } + text$Option_ref_u8(out, read); + text$collections_vec_deque_Iter_u8(out, it); + } +} + +/** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ +export function iterated$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { + let _10!: rt.u32; + let read!: undefined | rt.None; + const it: rt.Iter = rt.dequeIter(q); + text$collections_vec_deque_Iter_unit(out, it); + let iterStart: rt.u32 = 0; + const iterEnd: rt.u32 = 3; + while ((_10 = iterStart++) < iterEnd) { + const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); + let count: rt.u8 = (pick >> 3) & 3; + const _22: rt.u8 = rt.u8Rem(pick, 7); + if (_22 === 0) { + read = rt.iterToOption(it.next(), rt.None); + } else if (_22 === 1) { + read = rt.iterToOption(it.nextBack(), rt.None); + } else if (_22 === 2) { + read = rt.iterNth(it, count as rt.usize, undefined, rt.None); + } else if (_22 === 3) { + read = rt.iterNthBack(it, count as rt.usize, undefined, rt.None); + } else if (_22 === 4) { + read = rt.iterFind(it, (_24: undefined): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }, undefined, rt.None); + } else if (_22 === 5) { + read = rt.iterRfind(it, (_2: undefined): boolean => { + count = rt.u8SaturatingSub(count, 1); + return count === 0; + }, undefined, rt.None); + } else { + read = rt.iterToOption(it.clone().next(), rt.None); + } + text$Option_ref_unit(out, read); + text$collections_vec_deque_Iter_unit(out, it); + } +} + +//# sourceMappingURL=rings.ts.map diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index eab900bf9..fedd95002 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -1208,7 +1208,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return x8.tag; }), undefined, true); rt.dropAll(taken); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true)), undefined, true); rt.drop(rt.vecDrain(words, { end: b })); } else if (_31 === 3) { const drain4: rt.Iter = rt.vecDrain(items, new rt.RangeFrom(a, rt.usizeStep), rt.drop); @@ -1263,7 +1263,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const other: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(238)); const _195: rt.Iter = rt.iterRev(rt.byteVecDrain(bytes, new rt.Range(a, b))); rt.iterExtendBytes(other, _195, "fold", true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(other)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(other), undefined, true); rt.dropAll(kept); } flush(out); diff --git a/ts/fixtures/lang/expected/sorts.ts b/ts/fixtures/lang/expected/sorts.ts index d73f3f5ba..83ee0f5db 100644 --- a/ts/fixtures/lang/expected/sorts.ts +++ b/ts/fixtures/lang/expected/sorts.ts @@ -730,7 +730,7 @@ export function btrees(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } const keys_: rt.u16[] = keys(rt.min([0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_8], 300), dataData, dataStart, dataLen); const _17: rt.Iter> = rt.iterSlice(items$unit_sorts_btrees_closure0(keys_, (): undefined => {})); - put$unit(rt.iterToArray(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(sorts_Item.cmp$cmp_Ord_unit) as rt.BTreeSet>, rt.iterToArray(_17, "next", 4, true), 4, true, sorts_Item.lt$cmp_PartialOrd_unit, sorts_Item.eq$cmp_PartialEq_unit)), undefined, 4, true), out); + put$unit(rt.iterToArray(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(sorts_Item.cmp$cmp_Ord_unit) as rt.BTreeSet>, rt.iterToArray(_17, "next", 4, true, 4), 4, true, sorts_Item.lt$cmp_PartialOrd_unit, sorts_Item.eq$cmp_PartialEq_unit)), undefined, 4, true), out); const _27: rt.Iter<[sorts_Item.Item, rt.u16]> = rt.iterMap(rt.iterSlice(items$unit_sorts_btrees_closure1(keys_, (): undefined => {})), (x: sorts_Item.Item): [sorts_Item.Item, rt.u16] => { return [x, x.tag] as [sorts_Item.Item, rt.u16]; }); diff --git a/ts/fixtures/lang/expected/tuples.ts b/ts/fixtures/lang/expected/tuples.ts index e67121585..22d7fbcab 100644 --- a/ts/fixtures/lang/expected/tuples.ts +++ b/ts/fixtures/lang/expected/tuples.ts @@ -82,13 +82,13 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { const _22: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8] => { return [_26] as [rt.u8]; }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(rt.tupleExtendOne([rt.heapNew() as rt.BinaryHeap] as [rt.BinaryHeap], _22, (c3, items3) => rt.heapExtend(c3, items3, rt.le, rt.ge, rt.lt, undefined, 1, true))[0].d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.tupleExtendOne([rt.heapNew() as rt.BinaryHeap] as [rt.BinaryHeap], _22, (c3, items3) => rt.heapExtend(c3, items3, rt.le, rt.ge, rt.lt, undefined, 1, true))[0].d)), undefined, true); const _28: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { return (_210 & 1) === 0; }), (_211: rt.u8): [rt.u8] => { return [_211] as [rt.u8]; }); - rt.iterExtendBytes(out, rt.dequeIter(rt.tupleExtendOne([rt.dequeNew() as rt.VecDeque] as [rt.VecDeque], _28, (c4, items4) => rt.dequeExtend(c4, items4, "next", 1))[0]), undefined, true); + rt.iterExtendBytes(out, rt.dequeIntoIter(rt.tupleExtendOne([rt.dequeNew(1, true) as rt.VecDeque] as [rt.VecDeque], _28, (c4, items4) => rt.dequeExtend(c4, items4, "next"))[0]), undefined, true); const _34: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): [rt.u8] => { return [rt.u8Rem(_212, 16)] as [rt.u8]; }); @@ -103,7 +103,7 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { return [c7.data[c7.start]] as [rt.u8]; }); rt.tupleExtendOne(t, _48, (c8, items7) => rt.iterExtendBytes(c8, items7, undefined, true)); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t[0])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(t[0]), undefined, true); const t2: [string] = ["ab"]; const _56: rt.Iter<[string]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): [string] => { const _84: rt.usize = rt.u8Rem(_214, 3) as rt.usize; @@ -121,8 +121,8 @@ export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { const _64: [[rt.ByteVec, rt.BinaryHeap]] = rt.tupleExtendOne([[new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap]] as [[rt.ByteVec, rt.BinaryHeap]], _65, (c10, items9) => rt.tupleExtend(c10, items9, [rt.byteVecPart(), rt.heapPart(rt.le, 1)])); const v2: rt.ByteVec = _64[0][0]; const heap2: rt.BinaryHeap = _64[0][1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap2.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap2.d)), undefined, true); rt.tupleExtendOne([undefined] as [undefined], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): [undefined] => { return [undefined] as [undefined]; }), (_c11, items10) => rt.iterFold(items10, undefined, () => undefined)); @@ -142,7 +142,7 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _5: [rt.ByteVec, string] = rt.tupleExtend([new rt.ByteVec(), ""] as [rt.ByteVec, string], _6, [rt.byteVecPart(), rt.STRING_CHARS_PART]); const v: rt.ByteVec = _5[0]; const s: string = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); const _16: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): [rt.u8, rt.u8] => { const b2: rt.u8 = _25; @@ -151,36 +151,36 @@ export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { const _15: [rt.ByteVec, rt.BTreeSet] = rt.tupleExtend([new rt.ByteVec(), rt.btreeNew(rt.cmp) as rt.BTreeSet] as [rt.ByteVec, rt.BTreeSet], _16, [rt.byteVecPart(), rt.btreeKeysPart()]); const v2: rt.ByteVec = _15[0]; const tree: rt.BTreeSet = _15[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree), undefined, true); const _23: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): [rt.u8, rt.u16] => { const b3: rt.u8 = _27; return [b3, rt.u16Mul(b3 as rt.u16, 3)] as [rt.u8, rt.u16]; }); - const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew() as rt.VecDeque] as [rt.BinaryHeap, rt.VecDeque], _23, [rt.heapPart(rt.le, 1), rt.dequePart(2)]); + const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew(2) as rt.VecDeque] as [rt.BinaryHeap, rt.VecDeque], _23, [rt.heapPart(rt.le, 1), rt.dequePart()]); const heap: rt.BinaryHeap = _22[0]; const q: rt.VecDeque = _22[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); const _33: rt.Iter<[undefined, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): [undefined, rt.u8] => { return [undefined, _210] as [undefined, rt.u8]; }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1]), undefined, true); const _39: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): boolean => { return _211 > 64; }), (_212: rt.u8): [rt.u16, rt.u8] => { const b6: rt.u8 = _212; return [b6 as rt.u16, b6] as [rt.u16, rt.u8]; }); - const _38: [rt.u16[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew() as rt.VecDeque] as [rt.u16[], rt.VecDeque], _39, [rt.vecPart(2), rt.dequePart(1)]); + const _38: [rt.u16[], rt.VecDeque] = rt.tupleExtend([[], rt.dequeNew(1, true) as rt.VecDeque] as [rt.u16[], rt.VecDeque], _39, [rt.vecPart(2), rt.dequePart()]); const v4: rt.u16[] = _38[0]; const q2: rt.VecDeque = _38[1]; rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v4), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.dequeIter(q2), undefined, true); + rt.iterExtendBytes(out, rt.dequeIntoIter(q2), undefined, true); } /** Triples, of mixed collections, and tuples of collections within one. */ @@ -189,11 +189,11 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const b: rt.u8 = _2; return [b, (((b as rt.u16)) << 8) & 0xffff, rt.u8Add(97, rt.u8Rem(b, 26)) as rt.char] as [rt.u8, rt.u16, rt.char]; }); - const _6: [rt.ByteVec, rt.VecDeque, string] = rt.tupleExtend([new rt.ByteVec(), rt.dequeNew() as rt.VecDeque, ""] as [rt.ByteVec, rt.VecDeque, string], _7, [rt.byteVecPart(), rt.dequePart(2), rt.STRING_CHARS_PART]); + const _6: [rt.ByteVec, rt.VecDeque, string] = rt.tupleExtend([new rt.ByteVec(), rt.dequeNew(2) as rt.VecDeque, ""] as [rt.ByteVec, rt.VecDeque, string], _7, [rt.byteVecPart(), rt.dequePart(), rt.STRING_CHARS_PART]); const v: rt.ByteVec = _6[0]; const q: rt.VecDeque = _6[1]; const s: string = _6[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -210,7 +210,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_25: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_25[0], _25[1] & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); const _35: rt.Iter<[rt.u8, [rt.char, rt.u16]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8, [rt.char, rt.u16]] => { const b3: rt.u8 = _26; return [b3, [b3 as rt.char, rt.u16Add(b3 as rt.u16, 1)] as [rt.char, rt.u16]] as [rt.u8, [rt.char, rt.u16]]; @@ -219,7 +219,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const v2: rt.ByteVec = _34[0]; const s2: string = _34[1][0]; const w: rt.u16[] = _34[1][1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n2: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n2).reverse(); @@ -231,7 +231,7 @@ export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { const _49: [rt.ByteVec, [rt.BTreeSet]] = rt.tupleExtend([new rt.ByteVec(), [rt.btreeNew(rt.cmp) as rt.BTreeSet]] as [rt.ByteVec, [rt.BTreeSet]], _50, [rt.byteVecPart(), rt.tuplePart([rt.btreeKeysPart()])]); const v3: rt.ByteVec = _49[0]; const tree2: rt.BTreeSet = _49[1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(tree2), undefined, true); } @@ -254,7 +254,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { const _28: [rt.u8, [rt.char]] = [b ^ 51, [rt.u8Add(65, rt.u8Rem(b, 26)) as rt.char] as [rt.char]]; return [b, _12, _152, _5[_8], _162, b, _172, _202, _222, _262, undefined, _28] as [rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]]; }); - const _15: [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]] = rt.tupleExtend([new rt.ByteVec(), [], "", "", rt.dequeNew() as rt.VecDeque, rt.heapNew() as rt.BinaryHeap, rt.hashNew() as rt.HashMap, rt.hashNew() as rt.HashSet, rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.btreeNew(rt.cmp) as rt.BTreeSet, undefined, [new rt.ByteVec(), [""]]] as [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]], _16, [rt.byteVecPart(), rt.vecPart(2), rt.STRING_CHARS_PART, rt.STRING_PART, rt.dequePart(1), rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048), rt.hashKeysPart(undefined, 469762048), rt.btreePart(), rt.btreeKeysPart(), rt.UNIT_PART, rt.tuplePart([rt.byteVecPart(), rt.tuplePart([rt.STRING_CHARS_PART])])]); + const _15: [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]] = rt.tupleExtend([new rt.ByteVec(), [], "", "", rt.dequeNew(1, true) as rt.VecDeque, rt.heapNew() as rt.BinaryHeap, rt.hashNew() as rt.HashMap, rt.hashNew() as rt.HashSet, rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.btreeNew(rt.cmp) as rt.BTreeSet, undefined, [new rt.ByteVec(), [""]]] as [rt.ByteVec, rt.u16[], string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]], _16, [rt.byteVecPart(), rt.vecPart(2), rt.STRING_CHARS_PART, rt.STRING_PART, rt.dequePart(), rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048), rt.hashKeysPart(undefined, 469762048), rt.btreePart(), rt.btreeKeysPart(), rt.UNIT_PART, rt.tuplePart([rt.byteVecPart(), rt.tuplePart([rt.STRING_CHARS_PART])])]); const bytes: rt.ByteVec = _15[0]; const wide: rt.u16[] = _15[1]; const chars: string = _15[2]; @@ -267,14 +267,14 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { const keys: rt.BTreeSet = _15[9]; const v: rt.ByteVec = _15[11][0]; const s: string = _15[11][1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(wide), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.strBytes(chars), undefined, true); rt.iterExtendBytes(out, rt.strBytes(texts), undefined, true); - rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(heap.d))), undefined, true); + rt.iterExtendBytes(out, rt.dequeIntoIter(q), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap.d)), undefined, true); entries(map, out); sorted(set, out); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_210: [rt.u8, rt.u16]): Uint8Array => { @@ -284,7 +284,7 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { }); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); rt.iterExtendBytes(out, rt.btreeKeys(keys), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } @@ -293,18 +293,18 @@ export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { * and a map or set keeps an equal key already there. */ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { - const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeExtend(rt.dequeNew() as rt.VecDeque, rt.iterSlice([1]), undefined, 2, true), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; + const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeFromArray([1], 2) as rt.VecDeque, rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; const _16: rt.Iter<[rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8] => { const b: rt.u8 = _2; return [b, b as rt.char, [rt.u8Rem(b, 8), b as rt.u16] as [rt.u8, rt.u16], b as rt.u16, rt.u8Rem(b, 16)] as [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]; }); - rt.tupleExtend(t, _16, [rt.byteVecPart(), rt.STRING_CHARS_PART, rt.btreePart(), rt.dequePart(2), rt.hashKeysPart(undefined, 469762048)]); + rt.tupleExtend(t, _16, [rt.byteVecPart(), rt.STRING_CHARS_PART, rt.btreePart(), rt.dequePart(), rt.hashKeysPart(undefined, 469762048)]); const v: rt.ByteVec = t[0]; const s: string = t[1]; const tree: rt.BTreeMap = t[2]; const q: rt.VecDeque = t[3]; const set: rt.HashSet = t[4]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_22: [rt.u8, rt.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); @@ -319,7 +319,7 @@ export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { return [b2, [rt.u8Rem(b2, 4), b2] as [rt.u8, rt.u8]] as [rt.u8, [rt.u8, rt.u8]]; }); rt.tupleExtend(t2, _45, [rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048)]); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.byteVecFromVec(t2[0].d))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(t2[0].d)), undefined, true); entries(t2[1], out); } @@ -353,7 +353,7 @@ export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { const copied: Spot.Spot[] = t[1]; const map: rt.HashMap = t[2]; const s: string = t[3]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterChain(rt.iterSlice(copied), rt.iterSlice(ones[0])), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); }, (value: Uint8Array) => rt.iterSlice(value), false, 2), undefined, true); @@ -431,7 +431,7 @@ export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { const taken: tuples_Logged.Logged[] = _86[0]; const bytes: rt.ByteVec = _86[1]; flush(log.value, out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); rt.dropAll(taken); flush(log.value, out); rt.hashDrop(keys, rt.drop); @@ -459,7 +459,7 @@ export function panicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _12[0]; const s: string = _12[1]; const w: rt.u16[] = _12[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w), (n: rt.u16): Uint8Array => { return rt.u16ToBeBytes(n).reverse(); @@ -501,7 +501,7 @@ export function reserved(data: rt.ByteSlice, out: rt.ByteVec): void { const _55: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(items, (i2: rt.u32): [rt.u8, rt.u16] => { return [i2 & 0xff, i2 & 0xffff] as [rt.u8, rt.u16]; }); - const _54: [rt.BTreeSet, rt.VecDeque] = rt.tupleExtend([rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.dequeNew() as rt.VecDeque] as [rt.BTreeSet, rt.VecDeque], _55, [rt.btreeKeysPart(), rt.dequePart(2)]); + const _54: [rt.BTreeSet, rt.VecDeque] = rt.tupleExtend([rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.dequeNew(2) as rt.VecDeque] as [rt.BTreeSet, rt.VecDeque], _55, [rt.btreeKeysPart(), rt.dequePart()]); const tree: rt.BTreeSet = _54[0]; const q: rt.VecDeque = _54[1]; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(tree) & 0xff, q.n & 0xff)), undefined, true); @@ -525,7 +525,7 @@ export function shunted(data: rt.ByteSlice, out: rt.ByteVec): void { if (parsed.ok) { const v: rt.ByteVec = parsed.value[0]; const s: string = parsed.value[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); @@ -621,7 +621,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _34: [rt.ByteVec, tuples_Tally.Tally] = rt.tupleExtend([new rt.ByteVec(), tuples_Tally.default$Default()] as [rt.ByteVec, tuples_Tally.Tally], _35, [rt.byteVecPart(), rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)]); const v: rt.ByteVec = _34[0]; const t2: tuples_Tally.Tally = _34[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.byteVecPush(out, t2.sum); calls(out); const _47: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_210: rt.u8): [rt.u8, rt.u16] => { @@ -667,7 +667,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const _96: [rt.ByteVec, [tuples_Tally.Tally]] = rt.tupleExtend([new rt.ByteVec(), [tuples_Tally.default$Default()]] as [rt.ByteVec, [tuples_Tally.Tally]], _97, [rt.byteVecPart(), rt.tuplePart([rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined)])]); const v2: rt.ByteVec = _96[0]; const t5: tuples_Tally.Tally = _96[1][0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v2)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); rt.byteVecPush(out, t5.sum); calls(out); const _107: rt.Iter<[rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_216: rt.u8): [rt.char] => { @@ -685,7 +685,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { }); rt.tupleExtend(t6, _120, [rt.ownPart(tuples_Tally.extend$iter_Extend_u8_Option_u8 as (a0: tuples_Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.byteVecPart(), rt.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rt.Place, a1: rt.char | undefined) => undefined, true)]); rt.byteVecPush(out, t6[0].sum); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(t6[1])), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(t6[1]), undefined, true); Last.put(t6[2], out); calls(out); const parsed: rt.Result<[tuples_Tally.Tally, rt.ByteVec], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_217: rt.u8): rt.Result<[rt.u8, rt.u8], rt.u8> => { @@ -699,7 +699,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { const t7: tuples_Tally.Tally = parsed.value[0]; const v3: rt.ByteVec = parsed.value[1]; rt.byteVecPush(out, t7.sum); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v3)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); } else { rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } @@ -715,7 +715,7 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { } else { const v4: rt.ByteVec = found[0]; const t8: tuples_Tally.Tally = found[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v4)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v4), undefined, true); rt.byteVecPush(out, t8.sum); } calls(out); @@ -798,7 +798,7 @@ export function ownPanicked(data: rt.ByteSlice, out: rt.ByteVec): void { const v: rt.ByteVec = _24[0]; const t: tuples_Tally.Tally = _24[1]; const s: string = _24[2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); rt.byteVecPush(out, t.sum); rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); } else { diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 38e21dd8d..4b3521a46 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -342,7 +342,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBorrow(_166), true, undefined, undefined, 8, true)) & 0xff); bounds$ops_RangeInclusive_u64(out, keyed); const queued: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, ((rt.dequeFromVec(rt.iterToArray(rt.iterBorrow(queued), undefined, 8, true)) as rt.VecDeque)).n & 0xff); + rt.byteVecPush(out, ((rt.dequeFromVec(rt.iterToArray(rt.iterBorrow(queued), undefined, 8, true), 8) as rt.VecDeque)).n & 0xff); bounds$ops_RangeInclusive_u64(out, queued); const hashed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); const _186: rt.RangeInclusive = hashed; @@ -354,7 +354,7 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, held.length & 0xff); bounds$ops_RangeInclusive_u64(out, extended); const narrow: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Low(lo) & 0xff, rt.u64Low(hi) & 0xff, rt.u8Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true))), undefined, true); + rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true)), undefined, true); rt.byteVecPush(out, rt.rangeInclusiveStart(narrow)); rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(narrow) ? 1 : 0); bounds$ops_RangeTo_u64(out, { end: b }); diff --git a/ts/fixtures/lang/src/capacity.rs b/ts/fixtures/lang/src/capacity.rs index 96a12837a..a577f9cd9 100644 --- a/ts/fixtures/lang/src/capacity.rs +++ b/ts/fixtures/lang/src/capacity.rs @@ -1,9 +1,10 @@ //! The capacity std's `Vec`, `VecDeque`, and `BinaryHeap` hold as each step of a case //! grows, shrinks, remakes, or reads one, of elements of each size its growth tells apart: -//! a byte, at most 1 KiB, past it, and none. std fixes it exactly only through steps its -//! doubling decides, such as pushes, `with_capacity`, `reserve`, and `shrink_to`; past -//! any other step, a case checks only what std guarantees. A `HashMap`'s and a -//! `HashSet`'s it checks only by std's guarantees. +//! a byte, at most 1 KiB, past it, and none. A `Vec`'s and a `BinaryHeap`'s it checks +//! exactly through steps that fix it from what they held, such as pushes, `with_capacity`, +//! `reserve`, `shrink_to`, a clone, `clone_from`, and a `collect` in place, and past a +//! step that shortens one only what std guarantees, as the runtime holds no more. A +//! `VecDeque`'s it checks exactly past every step, as where its slices split depends on it. A `HashMap`'s and a `HashSet`'s it checks only by std's guarantees. use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque}; use std::mem; @@ -107,7 +108,7 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) put(out, v.capacity()); for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); - match op % 25 { + match op % 29 { 0 | 1 => v.push(make(arg)), 2 => { drop(v.pop()); @@ -115,7 +116,7 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) } 3 | 4 => { let additional = amount(arg, v.len(), size); - match op % 25 { + match op % 29 { 3 => v.reserve(additional), _ => v.reserve_exact(additional), } @@ -142,10 +143,8 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) // Not `TrustedLen`, so it reserves only once full, and a `TrustedLen` one. 10 => v.extend((0..arg % 24).filter(|i| i % 3 != 0).map(make)), 11 => v.extend((0..arg % 24).map(make)), - 12 => { - v.extend_from_slice(&[make(arg), make(arg)]); - k.loose(); - } + // Room for the whole slice at once, which pushes would double to past it. + 12 => v.extend_from_slice(&vec![make(arg); usize::from(arg % 24)]), 13 => { v.clear(); k.loose(); @@ -165,13 +164,13 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) } 17 => { v = v.into_boxed_slice().into_vec(); - k.remade(false); + k.remade(true); } // In place of its own, and of its own once read from either end. 18 => { let mut keep = alternate(); v = v.into_iter().filter(|_| keep()).collect(); - k.remade(false); + k.remade(k.exact); } 19 => { let mut it = v.into_iter(); @@ -179,7 +178,7 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) drop(if i % 3 == 2 { it.next_back() } else { it.next() }); } v = it.collect(); - k.remade(false); + k.remade(k.exact); } 20 => { let mut taken = mem::take(&mut v); @@ -202,15 +201,38 @@ fn vec_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec) for _ in 0..arg % 4 { drop(it.next()); } + let exact = k.exact; v = it.clone().collect(); k.remade(true); let rest = it.collect::>(); - Known { exact: false, floor: 0 }.put(out, rest.len(), rest.capacity()); + Known { exact, floor: 0 }.put(out, rest.len(), rest.capacity()); } 24 => { v = vec![make(arg); usize::from(arg % 6)]; k.remade(false); } + 25 => { + drop(v.pop_if(|_| arg % 2 == 1)); + k.loose(); + } + // Joined, with room for exactly what it joins. + 26 => { + v = [v.clone(), v].concat(); + k.remade(true); + } + // A boxed slice's `into_iter` reads a `Vec` with room for exactly its elements. + 27 => { + v = v.into_boxed_slice().into_iter().collect(); + k.remade(true); + } + // Into one with room of its own, which std's keeps where it is enough. + 28 => { + let mut own = Vec::with_capacity(usize::from(arg % 8)); + own.push(make(arg)); + own.clone_from(&v); + v = own; + k.remade(true); + } _ => {} } k.put(out, v.len(), v.capacity()); @@ -229,75 +251,40 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec 1 => VecDeque::with_capacity(usize::from(first >> 3)), _ => VecDeque::new(), }; - let mut k = Known::new(q.capacity()); put(out, q.capacity()); for step in steps.chunks(2) { let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); match op % 21 { 0 => q.push_back(make(arg)), 1 => q.push_front(make(arg)), - 2 => { - drop(q.pop_front()); - k.loose(); - } + 2 => drop(q.pop_front()), 3 | 4 => { let additional = amount(arg, q.len(), size); match op % 21 { 3 => q.reserve(additional), _ => q.reserve_exact(additional), } - k.reserved(q.len(), additional); - } - 5 => { - q.shrink_to(usize::from(arg % 40)); - k.shrunk(q.len(), usize::from(arg % 40)); - } - 6 => { - q.shrink_to_fit(); - k.shrunk(q.len(), 0); - k.exact = true; - } - 7 => { - q.truncate(usize::from(arg % 8)); - k.loose(); } + 5 => q.shrink_to(usize::from(arg % 40)), + 6 => q.shrink_to_fit(), + 7 => q.truncate(usize::from(arg % 8)), 8 => q.insert(usize::from(arg) % (q.len() + 1), make(arg)), - 9 => { - drop(q.remove(usize::from(arg) % (q.len() + 1))); - k.loose(); - } + 9 => drop(q.remove(usize::from(arg) % (q.len() + 1))), 10 => q.extend((0..arg % 24).filter(|i| i % 3 != 0).map(make)), 11 => q.extend((0..arg % 24).map(make)), - 12 => { - q.clear(); - k.loose(); - } + 12 => q.clear(), 13 => { let mut keep = alternate(); q.retain(|_| keep()); - k.loose(); - } - 14 => { - drop(q.drain(..q.len().min(usize::from(arg % 4)))); - k.loose(); - } - 15 => { - q = q.clone(); - k.remade(true); } + 14 => drop(q.drain(..q.len().min(usize::from(arg % 4)))), + 15 => q = q.clone(), // Its own, and a `Vec`'s in place of one, and one it collects first. - 16 => { - q = q.into_iter().collect(); - k.remade(false); - } - 17 => { - q = VecDeque::from(q.into_iter().collect::>()); - k.remade(false); - } + 16 => q = q.into_iter().collect(), + 17 => q = VecDeque::from(q.into_iter().collect::>()), 18 => { let mut keep = alternate(); q = q.into_iter().filter(|_| keep()).collect(); - k.remade(true); } 19 => { let mut it = q.into_iter(); @@ -305,16 +292,14 @@ fn deque_steps(data: &[u8], make: fn(u8) -> T, out: &mut Vec drop(it.next()); } q = it.clone().collect(); - k.remade(false); let rest = it.collect::>(); - Known { exact: false, floor: 0 }.put(out, rest.len(), rest.capacity()); - } - _ => { - q = VecDeque::from([make(arg), make(arg), make(arg)]); - k.remade(false); + put(out, rest.len()); + put(out, rest.capacity()); } + _ => q = VecDeque::from([make(arg), make(arg), make(arg)]), } - k.put(out, q.len(), q.capacity()); + put(out, q.len()); + put(out, q.capacity()); } } @@ -406,7 +391,7 @@ pub fn collects(kind: u8, data: &[u8], out: &mut Vec) { // Two `u32`s to one in place, which fit twice as many. 0 => { let halves: Vec = pairs.into_iter().map(|(a, _)| a).collect(); - loose.put(out, halves.len(), halves.capacity()); + exact.put(out, halves.len(), halves.capacity()); } // Bytes in place of bytes, and wider items than bytes, which collect anew. 1 => { @@ -414,7 +399,7 @@ pub fn collects(kind: u8, data: &[u8], out: &mut Vec) { bytes.extend_from_slice(&data[..n.min(data.len())]); exact.put(out, bytes.len(), bytes.capacity()); let odd: Vec = bytes.clone().into_iter().filter(|b| b % 2 == 1).collect(); - loose.put(out, odd.len(), odd.capacity()); + exact.put(out, odd.len(), odd.capacity()); let wide: Vec = bytes.into_iter().map(u16::from).collect(); exact.put(out, wide.len(), wide.capacity()); } diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index 2d78ca385..de239c44b 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -5,8 +5,8 @@ use crate::{ args, arrays, ascii, atomics, borrows, bounds, boxes, capacity, captures, cells, chars, chunks, clones, collections, combinators, conversions, counts, cows, cycles, defaults, durations, dyns, edits, elements, errors, fields, floats, fmt, folds, generics, hashes, hints, holds, ints, iters, joins, keys, lengths, lists, locals, - locks, methods, nested, objects, orders, pointers, refs, results, returns, saturates, separated, shapes, singles, - slices, sorts, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, + locks, methods, nested, objects, orders, pointers, refs, results, returns, rings, saturates, separated, shapes, + singles, slices, sorts, splits, statics, strs, tuples, utf8, wrappers, wraps, zeros, }; /// The native side's entry: [`run`], except that a case starting with 0xff prints a @@ -297,6 +297,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("elements::empty_parts", |_, data, out| elements::empty_parts(data, out)), ("hashes::own", |_, data, out| hashes::own(data, out)), ("refs::compared", refs::compared), + ("rings::slices", rings::slices), ("fmt::objects", |_, data, out| fmt::objects(data, out)), ("sorts::sorts", sorts::sorts), ("sorts::disorders", sorts::disorders), diff --git a/ts/fixtures/lang/src/lib.rs b/ts/fixtures/lang/src/lib.rs index 3375f9f39..3c23eab9c 100644 --- a/ts/fixtures/lang/src/lib.rs +++ b/ts/fixtures/lang/src/lib.rs @@ -90,6 +90,7 @@ mod pointers; mod refs; mod results; mod returns; +mod rings; mod saturates; mod separated; mod shapes; diff --git a/ts/fixtures/lang/src/rings.rs b/ts/fixtures/lang/src/rings.rs new file mode 100644 index 000000000..fc35fc582 --- /dev/null +++ b/ts/fixtures/lang/src/rings.rs @@ -0,0 +1,267 @@ +//! `VecDeque`'s ring buffer, as std places its items: each step that moves them, then +//! where `as_slices` splits them, and `{:?}` of its `Iter`, `IterMut`, and `Drain` read in +//! part, from either end, by `nth`, and by `try_fold`. Run for items of each size std's +//! growth tells apart, bytes, which its slices view, zero-sized ones, and ones that drop. + +use std::collections::VecDeque; +use std::fmt::Debug; + +/// An item a byte makes, which a write through a `&mut` changes. +trait Item: Clone + Debug { + fn make(b: u8) -> Self; + + fn bump(&mut self); +} + +impl Item for u8 { + fn make(b: u8) -> Self { + b + } + + fn bump(&mut self) { + *self = self.wrapping_add(1); + } +} + +impl Item for u32 { + fn make(b: u8) -> Self { + u32::from(b) << 12 + } + + fn bump(&mut self) { + *self += 1; + } +} + +impl Item for String { + fn make(b: u8) -> Self { + format!("s{}", b % 16) + } + + fn bump(&mut self) { + self.push('!'); + } +} + +impl Item for () { + fn make(_: u8) -> Self {} + + fn bump(&mut self) {} +} + +/// Past 1 KiB, which std's grows from one slot rather than four. +#[derive(Clone)] +struct Big { + id: u8, + pad: [u8; 1100], +} + +impl Debug for Big { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "B{}.{}", self.id, self.pad[1099]) + } +} + +impl Item for Big { + fn make(b: u8) -> Self { + Big { id: b, pad: [b; 1100] } + } + + fn bump(&mut self) { + self.id = self.id.wrapping_add(1); + } +} + +/// Steps a deque of the item type `kind` picks through `data`. +pub fn slices(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 5 { + 0 => steps::(data, out), + 1 => steps::(data, out), + 2 => steps::(data, out), + 3 => steps::<()>(data, out), + _ => steps::(data, out), + } +} + +/// A length or capacity, as four bytes. +fn put(out: &mut Vec, n: usize) { + out.extend_from_slice(&(n as u32).to_le_bytes()); +} + +/// What `{:?}` writes of `value`. +fn text(out: &mut Vec, value: &impl Debug) { + out.extend_from_slice(format!("{value:?}").as_bytes()); +} + +/// A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and +/// each pair after it steps: after each, its length, capacity, and two slices. +fn steps(data: &[u8], out: &mut Vec) { + let (first, rest) = data.split_first().map_or((0, &[][..]), |(&b, rest)| (b, rest)); + let n = usize::from(first >> 2) % 12; + let mut q: VecDeque = match first % 3 { + 0 => VecDeque::new(), + 1 => VecDeque::with_capacity(n), + _ => VecDeque::from(vec![T::make(first); n]), + }; + for step in rest.chunks(2) { + let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); + let at = usize::from(arg) % (q.len() + 1); + match op % 24 { + 0..=3 => q.push_back(T::make(arg)), + 4 | 5 => q.push_front(T::make(arg)), + 6 => drop(q.pop_front()), + 7 => drop(q.pop_back()), + 8 => q.insert(at, T::make(arg)), + 9 => drop(q.remove(at)), + 10 => drop(q.swap_remove_front(at)), + 11 => drop(q.swap_remove_back(at)), + 12 => q.truncate(usize::from(arg) % 8), + 13 => { + let mut kept = arg; + q.retain(|_| { + kept = kept.rotate_left(1); + kept & 1 == 1 + }); + } + 14 => drained(&mut q, arg, out), + 15 => q.reserve(usize::from(arg) % 12), + 16 => q.reserve_exact(usize::from(arg) % 12), + 17 => q.shrink_to(usize::from(arg) % 12), + 18 => q.shrink_to_fit(), + // Not `TrustedLen`, so it reserves once full, and a `TrustedLen` one. + 19 => q.extend((0..arg % 8).filter(|i| i % 3 != 0).map(T::make)), + 20 => q.extend((0..arg % 8).map(T::make)), + 21 => q.clear(), + 22 => q = remade(q, arg), + _ => mutated(&mut q, arg, out), + } + put(out, q.len()); + put(out, q.capacity()); + text(out, &q.as_slices()); + iterated(&q, arg, out); + } +} + +/// A deque made anew from `q`: a clone, or one with room of its own cloned into from it, +/// collected from its own `into_iter` or a `Vec`'s read in part, or that one's clone, +/// whose buffers std's takes as they are, or from a `Vec` it collects, directly or through +/// adaptors in place of another. +fn remade(q: VecDeque, arg: u8) -> VecDeque { + let skip = usize::from(arg / 5) % 4; + match arg % 5 { + 0 if arg & 0x20 == 0 => q.clone(), + 0 => { + let mut own = VecDeque::with_capacity(skip * 3); + own.push_front(T::make(arg)); + match arg & 0x40 { + 0 => own.clone_from(&q), + _ => q.clone_into(&mut own), + } + own + } + 1 => { + let mut it = q.into_iter(); + for _ in 0..skip { + drop(it.next()); + } + drop(it.next_back()); + it.collect() + } + // By `advance_by`, which drains the front or clears it all. + 2 => { + let mut it = q.into_iter(); + drop(it.nth(skip)); + it.collect() + } + 3 if arg & 0x20 == 0 => VecDeque::from(q.into_iter().collect::>()), + // Through adaptors in place of a `Vec`, whose buffer std's keeps. + 3 => { + let v: Vec = q.into_iter().collect(); + let mut kept = false; + v.into_iter() + .filter(|_| { + kept = !kept; + kept + }) + .collect() + } + _ => { + let mut v: Vec = q.into_iter().collect(); + v.reserve(skip); + let mut it = v.into_iter(); + for _ in 0..skip { + drop(it.next()); + } + // A clone holds what is left in a buffer of its own. + match arg & 0x40 { + 0 => it.collect(), + _ => it.clone().collect(), + } + } + } +} + +/// A drain of a range `arg` picks, written as it is read from either end and then dropped. +fn drained(q: &mut VecDeque, arg: u8, out: &mut Vec) { + let len = q.len(); + let start = usize::from(arg & 7) % (len + 1); + let end = start + usize::from(arg >> 3 & 7) % (len - start + 1); + let mut d = q.drain(start..end); + text(out, &d); + if arg & 0x40 != 0 { + drop(d.next()); + } + if arg & 0x80 != 0 { + drop(d.next_back()); + } + text(out, &d); +} + +/// Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. +fn mutated(q: &mut VecDeque, arg: u8, out: &mut Vec) { + let (a, b) = q.as_mut_slices(); + if let Some(x) = a.first_mut() { + x.bump(); + } + if let Some(x) = b.last_mut() { + x.bump(); + } + let mut it = q.iter_mut(); + for _ in 0..arg % 4 { + if let Some(x) = it.next() { + x.bump(); + } + } + if let Some(x) = it.next_back() { + x.bump(); + } + text(out, &it); +} + +/// `q`'s `Iter`, written before and after each of three reads `arg` picks. +fn iterated(q: &VecDeque, arg: u8, out: &mut Vec) { + let mut it = q.iter(); + text(out, &it); + for k in 0..3 { + let pick = arg.rotate_left(3 * k); + let mut count = pick >> 3 & 3; + let read = match pick % 7 { + 0 => it.next(), + 1 => it.next_back(), + 2 => it.nth(usize::from(count)), + 3 => it.nth_back(usize::from(count)), + // By `try_fold`, which reads the first slice and then the second, swapping neither. + 4 => it.find(|_| { + count = count.saturating_sub(1); + count == 0 + }), + 5 => it.rfind(|_| { + count = count.saturating_sub(1); + count == 0 + }), + _ => it.clone().next(), + }; + text(out, &read); + text(out, &it); + } +} diff --git a/ts/fixtures/share/expected/harness.ts b/ts/fixtures/share/expected/harness.ts index dd85bf2ff..c1d776e6b 100644 --- a/ts/fixtures/share/expected/harness.ts +++ b/ts/fixtures/share/expected/harness.ts @@ -25,8 +25,8 @@ export function run(input: rt.ByteSlice): rt.ByteVec { rt.idx(w, 1); return Uint8Array.of(_3, w.data[w.start + 1]); }), undefined, 2, true); - const deque: rt.VecDeque = rt.dequeNew() as rt.VecDeque; - rt.dequeExtend(deque, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); + const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; + rt.dequeExtend(deque, rt.iterMap(rt.iterLend(rt.iterSlice(pairs), rt.byteSliceFrom), rt.byteSliceToArray), undefined, true); const _47: rt.Iter = rt.iterFlatMap(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (p: rt.ByteSlice): Uint8Array => { return Uint8Array.of(p.data[p.start], p.data[p.start + 1]); }, (value: Uint8Array) => rt.iterSlice(value), false, 2); diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 767bedf38..d2c515860 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -396,7 +396,7 @@ export function ordered(log: Log.Log, id: rt.u32): void { Log.note(log, _185); const _201: Key.Key = key(12); rt.btreeAdd(set, _201, rt.drop); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; let iterStart: rt.u32 = 20; const iterEnd: rt.u32 = 26; while ((_208 = iterStart++) < iterEnd) { @@ -929,7 +929,7 @@ export function elements(log: Log.Log, id: rt.u32): void { }); const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; Log.note(log, rt.fmtFormat(["called ", args14[0]])); - const q: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; rt.dequePushBack(q, undefined as Guard.Guard | undefined); const _186: Guard.Guard | undefined = guard(4); rt.dequePushBack(q, _186); diff --git a/ts/fixtures/task/expected/drops/closures.ts b/ts/fixtures/task/expected/drops/closures.ts index 9c92c1ca9..0c6c7bc65 100644 --- a/ts/fixtures/task/expected/drops/closures.ts +++ b/ts/fixtures/task/expected/drops/closures.ts @@ -677,7 +677,7 @@ export function iterated(log: Log.Log, id: rt.u32): void { captured22[Symbol.dispose](); }); rt.dropAfter(_475, () => rt.btreeRetain(map, _475, undefined, rt.drop)); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const _479: Guard.Guard = guard(33); rt.dequePushBack(queue, _479); const _484: Guard.Guard = guard(34); diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 5f79e9a92..7e659f31c 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -194,7 +194,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g68; }, (): void => { captured56[Symbol.dispose](); - })), "next", 8, true); + })), "next", 8, true, 8); const _176: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured57 = d; @@ -221,7 +221,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return g66; }, (): void => { captured54[Symbol.dispose](); - })), "next", 8, true)) as rt.VecDeque; + })), "next", 8, true, 8), 8) as rt.VecDeque; const _206: rt.Iter = rt.iterSlice(guards(4, 7), rt.drop); _1089 = false; const captured55 = d; @@ -1473,7 +1473,7 @@ export function closures(log: Log.Log, id: rt.u32): void { g3[Symbol.dispose](); return _06; }); - }), "next", 8); + }), "next", 8, false, 8); const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug))]; Log.note(log, rt.fmtFormat(["kept ", args2[0]])); const part3 = rt.iterFold(rt.iterFilterMap(rt.iterSlice(guards(1, 7), rt.drop), pick, rt.None), 0, (n3: rt.u32, o2: Guard.Guard | undefined): rt.u32 => { @@ -1728,7 +1728,7 @@ export function zips(log: Log.Log, id: rt.u32, arg: rt.u8): void { return rt.u32Sub(rt.u32Add(x2, Guard.id(captured3)), captured4); }, (): void => { captured3[Symbol.dispose](); - })), "next", 4, true); + })), "next", 4, true, 4); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n3, f), (f: rt.Formatter) => rt.fmtOption(at, f, rt.usizeDebug), (f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.usizeDisplay(skipped, f), (f: rt.Formatter) => rt.fmtList(kept, f, rt.u32Debug)]; Log.note(log, rt.fmtFormat(["no coerce ", args8[0], " ", args8[1], " ", args8[2], " ", args8[3], " ", args8[4]])); } else if (arg === 4) { diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 06049bc4d..9238113f8 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -70,7 +70,7 @@ export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _139: rt.usize = v.length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_136, f), (f: rt.Formatter) => rt.usizeDisplay(_139, f)]; Log.note(log, rt.fmtFormat(["drained ", args10[0], " ", args10[1]])); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(6, 9), guard), undefined, 8, true)) as rt.VecDeque; + const q: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterMap(new rt.Range(6, 9), guard), undefined, 8, true), 8) as rt.VecDeque; const it: rt.Iter = rt.dropAfter(new Spent.Spent(guard(11), 0, 2), (range13) => rt.dequeDrain(q, rt.boundsOf(range13, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.drop), rt.drop); const part17 = option_map$1raha9y(rt.iterToOption(it.next()), (g12: Guard.Guard): rt.u32 => { const _012: rt.u32 = Guard.id(g12); diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index 3da86a905..d5945be57 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -72,7 +72,7 @@ export function looped(log: Log.Log, id: rt.u32): void { v2.push(_105); const even: Guard.Guard[] = rt.iterToArray(rt.iterFilter(rt.iterSlice(v2, rt.drop), (g4: Guard.Guard): boolean => { return rt.u32Rem(Guard.id(g4), 2) === 0; - }, rt.drop), "next", 8); + }, rt.drop), "next", 8, false, 8); const part3 = even.length; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["even ", args6[0]])); @@ -316,7 +316,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v.push(_18); const _23: Guard.Guard = guard(3); v.push(_23); - const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next", 8, true); + const same: Guard.Guard[] = rt.iterToArray(rt.iterSlice(v, rt.drop), "next", 8, true, 8); const v2: Guard.Guard[] = []; const _33: Guard.Guard = guard(4); v2.push(_33); @@ -354,7 +354,7 @@ export function collected(log: Log.Log, id: rt.u32): void { return rt.Ok(g2); } return rt.Err(g2); - }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard); + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8, false, 8), lib_drop$Vec_model_Guard); const part = results.ok; const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; Log.note(log, rt.fmtFormat(["result ", args4[0]])); @@ -368,7 +368,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v6.push(_140); const part2 = option_mapOr$0vxyhav(rt.iterCollectOption(rt.iterMap(rt.iterSlice(v6, rt.drop), (g3: Guard.Guard): Guard.Guard | undefined => { return g3; - }), (values: rt.Iter) => rt.iterToArray(values, "next", 8), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { + }), (values: rt.Iter) => rt.iterToArray(values, "next", 8, false, 8), lib_drop$Vec_model_Guard), 0, (v12: Guard.Guard[]): rt.usize => { const _06: rt.usize = v12.length; rt.dropAll(v12); return _06; @@ -383,7 +383,7 @@ export function collected(log: Log.Log, id: rt.u32): void { const _172: [rt.u32, Guard.Guard] = [2, guard(18)]; v7.push(_172); const _155: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterSlice(v7, lib_drop$tuple2_u32_model_Guard); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next", 12, true), 12, true, undefined, undefined, rt.drop); + const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToArray(_155, "next", 12, true, 12), 12, true, undefined, undefined, rt.drop); const part3 = rt.btreeLen(tree); const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; Log.note(log, rt.fmtFormat(["tree ", args8[0]])); @@ -396,7 +396,7 @@ export function collected(log: Log.Log, id: rt.u32): void { const at = rt.idx(same, 0); _2[Symbol.dispose](); return same[at]; - }), "next", 4, true).length; + }), "next", 4, true, 8).length; const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; Log.note(log, rt.fmtFormat(["refs ", args10[0]])); const v9: Guard.Guard[] = []; @@ -404,7 +404,7 @@ export function collected(log: Log.Log, id: rt.u32): void { v9.push(_223); const _228: Guard.Guard = guard(20); v9.push(_228); - const queue: rt.VecDeque = rt.dequeFromVec(rt.iterToArray(rt.iterSlice(v9, rt.drop), "next", 8, true)) as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeFromIntoIter(rt.iterSlice(v9, rt.drop), 8) as rt.VecDeque; const v10: [rt.u32, Guard.Guard][] = []; const _237: [rt.u32, Guard.Guard] = [1, guard(21)]; v10.push(_237); @@ -494,7 +494,7 @@ export function drained(log: Log.Log, id: rt.u32): void { const _63: string = rt.fmtFormat(["set ", args4[0]]); rt.drop(_70); Log.note(log, _63); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; let iterStart: rt.u32 = 15; const iterEnd: rt.u32 = 20; while ((_80 = iterStart++) < iterEnd) { @@ -511,7 +511,7 @@ export function drained(log: Log.Log, id: rt.u32): void { Log.note(log, rt.fmtFormat(["drain ", args6[0]])); rt.drop(range); const _113: rt.usize = queue.n; - const _119: rt.Iter = rt.dequeIter(queue, rt.drop); + const _119: rt.Iter = rt.dequeIntoIter(queue, rt.drop); const _116: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(_119.next()), 0, (g3: Guard.Guard): rt.u32 => { const _07: rt.u32 = Guard.id(g3); g3[Symbol.dispose](); @@ -658,7 +658,7 @@ export function extended(log: Log.Log, id: rt.u32): void { const _192: Key.Key = key(16); v7.push(_192); rt.btreeExtendKeys(ordered, rt.iterSlice(v7, rt.drop), false, rt.drop, "fold"); - const queue: rt.VecDeque = rt.dequeNew() as rt.VecDeque; + const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; const _198: Guard.Guard = guard(18); rt.dequePushBack(queue, _198); const v8: Guard.Guard[] = []; @@ -666,7 +666,7 @@ export function extended(log: Log.Log, id: rt.u32): void { v8.push(_207); const _212: Guard.Guard = guard(20); v8.push(_212); - rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold", 8, true); + rt.dequeExtend(queue, rt.iterSlice(v8, rt.drop), "fold", true); const _221: rt.usize = rt.btreeLen(tree); const _224: rt.usize = rt.btreeLen(ordered); const _227: rt.usize = queue.n; diff --git a/ts/runtime/rt.ts b/ts/runtime/rt.ts index fe9ad5f75..dfb086ad9 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rt.ts @@ -1103,8 +1103,9 @@ export function vecSwapRemove(v: T[], i: number): T { return item; } -/** `Vec::extend_from_slice`: a clone of each element of `s`, pushed in order, as far as they clone. */ -export function vecExtendFromSlice(v: T[], s: ArrayLike, clone?: (item: T) => T): void { +/** `Vec::extend_from_slice` of `size`-byte elements: room reserved for `s`, then a clone of each of its elements pushed in order, as far as they clone. */ +export function vecExtendFromSlice(v: T[], s: ArrayLike, size: number, clone?: (item: T) => T): void { + vecReserve(v, s.length, size); for (let i = 0; i < s.length; i++) v.push(clone === undefined ? s[i] : clone(s[i])); } @@ -1602,6 +1603,21 @@ export function vecShrinkTo(v: T[] & Capped, min: number, size: number): void capSet(v, v.length, capShrink(v.length, vecCapacity(v, size), min), size); } +/** + * `clone`, the clone `clone_from` writes over `v`, with the capacity std's keeps of `v`'s + * for `size`-byte elements: as it was, or grown as `reserve` grows it if it held fewer. + */ +export function vecClonedInto(clone: T[], v: T[] & Capped, size: number): T[] { + capHold(clone, capReserve(0, vecCapacity(v, size), clone.length, size), size); + return clone; +} + +/** `vecClonedInto` of bytes. */ +export function byteVecClonedInto(clone: ByteVec, v: ByteVec): ByteVec { + byteVecReserveExact(clone, capReserve(0, v.data.length, clone.length, 1) - clone.length); + return clone; +} + /** `v`, a new `Vec` of `size`-byte elements, with room for exactly what it holds, as std's `clone` makes one. */ export function vecExact(v: T[], size: number): T[] { capSet(v, v.length, v.length, size); diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rt/collections.ts index b47c42ef7..5560f7465 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rt/collections.ts @@ -15,14 +15,15 @@ // 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, type Capped, capHold, capOf, capReserve, capReserveExact, capSet, capShrink, Err, type None, Ok, type Place, panic, type RangeBound, type Result, rangeCheck, sliceSort, vecExact, vecMax, vecReserve, vecWithCapacity } from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecPush, byteVecReserve, type Capped, capOf, capReserve, capReserveExact, capSet, type Debug, Err, type FmtResult, type Formatter, fmtDebugTupleFields, fmtList, type None, Ok, type Place, panic, type RangeBound, type Result, rangeCheck, sliceSort, sliceView, vecExact, vecMax, vecReserve, vecWithCapacity } from "../rt.ts"; import type { Hashing } from "./hash.ts"; -import { type Limbs, lt, type u64 } from "./int.ts"; +import { type Limbs, lt, type u64, type usize } from "./int.ts"; import { type Clones, DONE, type Done, exactHint, + Folded, Iter, iterChain, iterEmpty, @@ -34,6 +35,7 @@ import { rangeInclusiveEndBound, rangeInclusiveStartBound, type SizeHint, + satAdd, type Take, capNext, trustedUpper, @@ -358,7 +360,7 @@ export function eqArc(eq: (a: T, b: T) => boolean, ident = false): (a: Arc } /** A value as its own clone. */ -function itself(value: T): T { +export function itself(value: T): T { return value; } @@ -982,11 +984,11 @@ function extending(c: C, items: Iter, add: (item: T) => void, take?: Ta } /** - * `extending` a `Vec` or `VecDeque` holding `len`, which with elements `size` bytes each - * reserves as `iterExtend` does, into the capacity `at` holds: a `trusted` iterator up - * front, and any other by `next`, a `deque`'s at its first item too. + * `extending` a `Vec` holding `len`, which with elements `size` bytes each reserves as + * `iterExtend` does, into the capacity `at` holds: a `trusted` iterator up front, and any + * other by `next`. */ -function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false, at: object & Capped = {}, deque = false): C { +function vecExtending(c: C, len: number, items: Iter, add: (item: T) => void, take?: Take, size?: number, trusted = false, at: object & Capped = {}): C { if (size === undefined) return extending(c, items, add, take); let cap = capOf(len, at.cap, size); if (trusted) { @@ -994,8 +996,7 @@ function vecExtending(c: C, len: number, items: Iter, add: (item: T) => return extending(c, items, add, take); } for (let item = items.next(); item !== DONE; item = items.next()) { - if (deque || len === cap) cap = capNext(items, len, cap, size); - deque = false; + if (len === cap) cap = capNext(items, len, cap, size); add(item); len++; } @@ -2602,69 +2603,140 @@ export function btreeFirstEntry(m: BTreeMap, last = false): Entry`: a ring buffer of `b.length` slots, a power of two, holding `n` items - * from `h` on, wrapping past the end, and the capacity an operation set, as a `Vec`'s. + * `VecDeque`: a ring buffer of `b.length` slots, std's capacity, holding `n` items of + * `s` bytes each from `h` on, wrapping past the end. Each step places them where std's + * does, which `as_slices` shows: a deque of bytes is a `Uint8Array`, which its slices view, + * and one of zero-sized items has `usize::MAX` slots, as std's. */ -export interface VecDeque extends Capped { +export interface VecDeque { b: (T | undefined)[]; h: number; n: number; + s: number; +} + +/** `cap` empty slots, bytes if `bytes`. */ +function slots(cap: number, bytes: boolean): (T | undefined)[] { + return bytes ? (new Uint8Array(cap) as unknown as T[]) : new Array(cap); +} + +/** Whether `q` holds bytes in a `Uint8Array`. */ +function holdsBytes(q: VecDeque): boolean { + return q.b instanceof Uint8Array; } -/** `VecDeque::new`. */ -export function dequeNew(): VecDeque { - return { b: [], h: 0, n: 0 }; +/** `VecDeque::new` of `size`-byte items, held as bytes if `bytes`. */ +export function dequeNew(size: number, bytes = false): VecDeque { + return { b: slots(size === 0 ? USIZE_MAX : 0, bytes), h: 0, n: 0, s: size }; } /** `VecDeque::with_capacity` of `size`-byte items, which panics past what it may hold. */ -export function dequeWithCapacity(n: number, size: number): VecDeque { +export function dequeWithCapacity(n: number, size: number, bytes = false): VecDeque { if (n > vecMax(size)) panic("capacity overflow"); - const q = dequeNew(); - capSet(q, 0, n, size); + const q = dequeNew(size, bytes); + if (size !== 0) q.b = slots(n, bytes); return q; } /** A deque of `v`'s items, with its capacity, as std's `From>` keeps it. */ -export function dequeFromVec(v: T[] & Capped): VecDeque { - const q = dequeNew(); - for (const item of v) dequePushBack(q, item); - if (v.cap !== undefined) q.cap = v.cap; +export function dequeFromVec(v: T[] & Capped, size: number, bytes = false): VecDeque { + const q = dequeWithCapacity(capOf(v.length, v.cap, size), size, bytes); + for (let i = 0; i < v.length; i++) q.b[i] = v[i]; + q.n = v.length; return q; } -/** `VecDeque::capacity` of `size`-byte items. */ -export function dequeCapacity(q: VecDeque, size: number): number { - return capOf(q.n, q.cap, size); +/** A deque of `a`'s items, with room for exactly them, as std's `From<[T; N]>` makes it. */ +export function dequeFromArray(a: ArrayLike, size: number, bytes = false): VecDeque { + const q = dequeWithCapacity(a.length, size, bytes); + for (let i = 0; i < a.length; i++) q.b[i] = a[i]; + q.n = a.length; + return q; +} + +/** `VecDeque::capacity`. */ +export function dequeCapacity(q: VecDeque): number { + return q.b.length; +} + +/** `VecDeque::reserve`. */ +export function dequeReserve(q: VecDeque, additional: number): void { + regrow(q, capReserve(q.n, q.b.length, additional, q.s)); } -/** `VecDeque::reserve` of `size`-byte items. */ -export function dequeReserve(q: VecDeque, additional: number, size: number): void { - capHold(q, capReserve(q.n, dequeCapacity(q, size), additional, size), size); +/** `VecDeque::reserve_exact`. */ +export function dequeReserveExact(q: VecDeque, additional: number): void { + regrow(q, capReserveExact(q.n, q.b.length, additional, q.s)); } -/** `VecDeque::reserve_exact` of `size`-byte items. */ -export function dequeReserveExact(q: VecDeque, additional: number, size: number): void { - capHold(q, capReserveExact(q.n, dequeCapacity(q, size), additional, size), size); +/** + * `VecDeque::shrink_to`, and `shrink_to_fit` of 0: the items moved within the slots kept + * as std's moves them, the head to the front if the tail is past them, or else the part + * past them to the front, or the wrapped head to their end. + */ +export function dequeShrinkTo(q: VecDeque, min: number): void { + const cap = q.b.length; + const target = Math.max(min, q.n); + if (q.s === 0 || cap <= target) return; + const end = q.h + q.n; + const tailOutside = end > target && end <= cap; + let h = q.h; + if (q.n === 0 || (q.h >= target && tailOutside)) h = 0; + else if (!tailOutside && q.h > cap - q.n) h = target - (cap - q.h); + place(q, target, h); } -/** `VecDeque::shrink_to` of `size`-byte items, and `shrink_to_fit` of 0. */ -export function dequeShrinkTo(q: VecDeque, min: number, size: number): void { - capSet(q, q.n, capShrink(q.n, dequeCapacity(q, size), min), size); +/** + * The slot `n` past slot `j`, as std's `wrap_index` of a `usize` sum: past `usize::MAX`, + * which only zero-sized items' `usize::MAX` slots reach, it wraps first. + */ +function wrap(q: VecDeque, j: number): number { + if (j < q.b.length) return j; + return j > USIZE_MAX ? j - USIZE_MAX - 1 : j - q.b.length; } /** The slot of item `i`. */ function at(q: VecDeque, i: number): number { - return (q.h + i) & (q.b.length - 1); + return wrap(q, q.h + i); } -/** Room for one more item. */ -function grow(q: VecDeque): void { - if (q.n < q.b.length) return; - const b = new Array(Math.max(4, q.b.length * 2)); - for (let i = 0; i < q.n; i++) b[i] = q.b[at(q, i)]; +/** The slot before `q`'s head, as std's `wrap_sub` finds it. */ +function before(q: VecDeque): number { + return wrap(q, q.h - 1 + q.b.length); +} + +/** + * `q` grown to `cap` slots, if more: the items moved as std's `handle_capacity_increase` + * moves them, the wrapped tail after the old end if it is shorter and fits, or else the + * head to the new end. + */ +function regrow(q: VecDeque, cap: number): void { + const old = q.b.length; + if (cap <= old) return; + let h = q.h; + if (h > old - q.n) { + const head = old - h; + const tail = q.n - head; + if (head <= tail || cap - old < tail) h = cap - head; + } + place(q, cap, h); +} + +/** `q`'s items moved, in order, to `cap` new slots from `h` on. */ +function place(q: VecDeque, cap: number, h: number): void { + const b = slots(cap, holdsBytes(q)); + for (let i = 0, j = h; i < q.n; i++, j = j + 1 === cap ? 0 : j + 1) b[j] = q.b[at(q, i)]; q.b = b; - q.h = 0; + q.h = h; +} + +/** Room for one more item, grown as std's `grow_one`. */ +function grow(q: VecDeque): void { + if (q.n === q.b.length) regrow(q, capReserve(q.n, q.n, 1, q.s)); } export function dequePushBack(q: VecDeque, item: T): void { @@ -2674,7 +2746,7 @@ export function dequePushBack(q: VecDeque, item: T): void { export function dequePushFront(q: VecDeque, item: T): void { grow(q); - q.h = (q.h - 1) & (q.b.length - 1); + q.h = before(q); q.b[q.h] = item; q.n++; } @@ -2745,13 +2817,16 @@ export function dequeDrop(q: VecDeque, f: (item: T) => void): void { dropAll(items, f); } -/** `clear`, which leaves the deque empty and then drops each item, front to back. */ +/** `clear`, which leaves the deque empty, its head at the front, and then drops each item, front to back. */ export function dequeClear(q: VecDeque, f?: (item: T) => void): void { - const old: VecDeque = { b: q.b, h: q.h, n: q.n }; - q.b = []; + const items: T[] = []; + for (let i = 0; i < q.n; i++) { + items.push(q.b[at(q, i)] as T); + q.b[at(q, i)] = undefined; + } q.h = 0; q.n = 0; - if (f !== undefined) dequeDrop(old, f); + if (f !== undefined) dropAll(items, f); } /** `truncate`: the first `len` items, if there are more, and then each other drops in order. */ @@ -2811,133 +2886,342 @@ export function dequeSwapRemove(q: VecDeque, i: number, back = false, none return (back ? dequePopBack(q) : dequePopFront(q)) as T; } -/** `remove`: the item at `i`, with those after it moved up, or else `none`. */ +/** `remove`: the item at `i`, with the shorter side moved over its slot, as std's, or else `none`. */ export function dequeRemove(q: VecDeque, i: number): T | undefined; export function dequeRemove(q: VecDeque, i: number, none: None): T | None; export function dequeRemove(q: VecDeque, i: number, none?: None): T | None | undefined { if (i >= q.n) return none; const item = q.b[at(q, i)] as T; - for (let j = i; j + 1 < q.n; j++) q.b[at(q, j)] = q.b[at(q, j + 1)]; - dequePopBack(q); + if (q.n - i - 1 < i) { + for (let j = i; j + 1 < q.n; j++) q.b[at(q, j)] = q.b[at(q, j + 1)]; + q.b[at(q, q.n - 1)] = undefined; + } else { + for (let j = i; j > 0; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; + q.b[q.h] = undefined; + q.h = at(q, 1); + } + q.n--; return item; } -/** `insert`: `item` at `i`, with those from `i` on moved down. */ +/** `insert`: `item` at `i`, with the shorter side moved to make room, as std's. */ export function dequeInsert(q: VecDeque, i: number, item: T): void { if (i > q.n) panic("index out of bounds"); - dequePushBack(q, item); - for (let j = q.n - 1; j > i; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; + grow(q); + if (q.n - i < i) { + for (let j = q.n; j > i; j--) q.b[at(q, j)] = q.b[at(q, j - 1)]; + } else { + q.h = before(q); + for (let j = 0; j < i; j++) q.b[at(q, j)] = q.b[at(q, j + 1)]; + } q.b[at(q, i)] = item; + q.n++; } /** - * An iterator of a deque's items from index `front` up to `back`, which drops those it - * still holds by `drop` as it drops, if it owns them, as a `drain` does. + * Where the first of the two slices of `q`'s items `start..end` ends, as std's + * `slice_ranges` splits them at the end of its slots. */ -class DequeIter extends Iter implements Disposable { +function firstEnd(q: VecDeque, start: number, end: number): number { + return start === end ? end : Math.min(end, start + q.b.length - at(q, start)); +} + +/** + * A deque's `Iter`, or `IterMut` lending each item's place if `lend`: the items at `f1..e1`, + * then `f2..e2`, the two slices std's walks, which it swaps as one ends, as std's does. + */ +class DequeIter extends Iter> { private readonly q: VecDeque; - private front: number; - private back: number; + private readonly lend: boolean; + private f1: number; + private e1: number; + private f2: number; + private e2: number; + + constructor(q: VecDeque, lend: boolean, f1: number, e1: number, f2: number, e2: number) { + super(); + this.q = q; + this.lend = lend; + this.f1 = f1; + this.e1 = e1; + this.f2 = f2; + this.e2 = e2; + } + + /** Item `i`, or its place. */ + private item(i: number): T | Place { + return this.lend ? new AtIndex(this.q.b as T[], at(this.q, i)) : (this.q.b[at(this.q, i)] as T); + } + + /** The two slices, swapped, as std's once the one it reads from ends. */ + private swap(): void { + [this.f1, this.e1, this.f2, this.e2] = [this.f2, this.e2, this.f1, this.e1]; + } + + /** The items each slice has left, as `as_slices` gives them. */ + slices(): [T[], T[]] { + const items = (f: number, e: number) => { + const out: T[] = []; + for (let i = f; i < e; i++) out.push(this.q.b[at(this.q, i)] as T); + return out; + }; + return [items(this.f1, this.e1), items(this.f2, this.e2)]; + } + + next(): T | Place | Done { + if (this.f1 === this.e1) this.swap(); + return this.f1 < this.e1 ? this.item(this.f1++) : DONE; + } + + override nextBack(): T | Place | Done { + if (this.f2 === this.e2) this.swap(); + return this.f2 < this.e2 ? this.item(--this.e2) : DONE; + } + + override advanceBy(n: number): number { + const k = Math.min(n, this.e1 - this.f1); + this.f1 += k; + if (k === n) return 0; + this.swap(); + const rest = Math.min(n - k, this.e1 - this.f1); + this.f1 += rest; + return n - k - rest; + } + + override advanceBackBy(n: number): number { + const k = Math.min(n, this.e2 - this.f2); + this.e2 -= k; + if (k === n) return 0; + this.swap(); + const rest = Math.min(n - k, this.e2 - this.f2); + this.e2 -= rest; + return n - k - rest; + } + + /** std's `try_fold`, which reads the first slice and then the second, swapping neither, and `try_rfold` the second and then the first. */ + override folded(): Iter> { + return new Folded( + () => (this.f1 < this.e1 ? this.item(this.f1++) : this.f2 < this.e2 ? this.item(this.f2++) : DONE), + () => (this.f2 < this.e2 ? this.item(--this.e2) : this.f1 < this.e1 ? this.item(--this.e1) : DONE), + ); + } + + override remaining(): Iterable { + const [a, b] = this.slices(); + return a.concat(b); + } + + override clone(): Iter> { + return new DequeIter(this.q, this.lend, this.f1, this.e1, this.f2, this.e2); + } + + override len(): number { + return this.e1 - this.f1 + (this.e2 - this.f2); + } + + override sizeHint(): SizeHint { + return exactHint(this.len()); + } +} + +/** A deque's `Iter` over its items `start..end`, split where `as_slices` splits them, or with `lend`, its `IterMut`. */ +function dequeSlices(q: VecDeque, lend: boolean, start: number, end: number): DequeIter { + const mid = firstEnd(q, start, end); + return new DequeIter(q, lend, start, mid, mid, end); +} + +/** `iter` and `iter_mut`. */ +export function dequeIter(q: VecDeque): Iter { + return dequeSlices(q, false, 0, q.n) as Iter; +} + +/** `iter_mut` of items JS copies: the place of each. */ +export function dequeIterMut(q: VecDeque): Iter> { + return dequeSlices(q, true, 0, q.n) as Iter>; +} + +/** `Debug` of a deque's `Iter` or `IterMut`, `name`: the two slices it has left. */ +export function fmtDequeIter(it: Iter, f: Formatter, debug: Debug, name: string): FmtResult { + const [a, b] = (it as DequeIter).slices(); + return fmtDebugTupleFields(f, name, [(f) => fmtList(a, f, debug), (f) => fmtList(b, f, debug)]); +} + +/** `as_slices`, and with `lend`, `as_mut_slices`, whose slices write into the deque. */ +export function dequeAsSlices(q: VecDeque, lend = false): [T[], T[]] { + const p = at(q, 0); + const n = firstEnd(q, 0, q.n); + const part = (start: number, end: number) => (lend ? sliceView(q.b as T[], start, end) : q.b.slice(start, end) as T[]); + return [part(p, p + n), part(0, q.n - n)]; +} + +/** `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); + const b = q.b as unknown as Uint8Array; + return [new ByteSlice(b, at(q, 0), n), new ByteSlice(b, 0, q.n - n)]; +} + +/** + * `into_iter`: the deque itself, popping each item from either end, which drops those it + * still holds by `drop` as it drops, and which `collect` into a deque gives back as it is. + */ +class DequeIntoIter extends Iter implements Disposable { + readonly q: VecDeque; private readonly drop: ((item: T) => void) | undefined; - constructor(q: VecDeque, front: number, back: number, drop?: (item: T) => void) { + constructor(q: VecDeque, drop?: (item: T) => void) { super(); this.q = q; - this.front = front; - this.back = back; this.drop = drop; } next(): T | Done { - return this.front < this.back ? (this.q.b[at(this.q, this.front++)] as T) : DONE; + return this.q.n === 0 ? DONE : (dequePopFront(this.q) as T); } - override remaining(): Iterable { - return new DequeIter(this.q, this.front, this.back); + override nextBack(): T | Done { + return this.q.n === 0 ? DONE : (dequePopBack(this.q) as T); } - /** std's: where it is, or of `into_iter`, what it has left, each cloned in order by `h.v`. */ - override clone(h?: Clones): Iter { - if (h?.v === undefined) return new DequeIter(this.q, this.front, this.back, this.drop); - const clone = h.v as (item: T) => T; - const items: T[] = []; - for (let i = this.front; i < this.back; i++) items.push(clone(this.q.b[at(this.q, i)] as T)); - return iterSlice(items, this.drop); + /** std's: the first `n` drained, or all cleared, either of which drops them in order. */ + override advanceBy(n: number): number { + const len = this.q.n; + if (len < n) dequeClear(this.q, this.drop); + else new DequeDrain(this.q, 0, n, this.drop)[Symbol.dispose](); + return Math.max(n - len, 0); } - override nextBack(): T | Done { - return this.front < this.back ? (this.q.b[at(this.q, --this.back)] as T) : DONE; + /** std's: the last `n` truncated, or all cleared. */ + override advanceBackBy(n: number): number { + const len = this.q.n; + if (len < n) dequeClear(this.q, this.drop); + else dequeTruncate(this.q, len - n, this.drop); + return Math.max(n - len, 0); + } + + override remaining(): Iterable { + return dequeIter(this.q) as Iterable; + } + + /** std's: a clone of the deque, each item cloned in order by `h.v`. */ + override clone(h?: Clones): Iter { + return new DequeIntoIter(dequeClone(this.q, h?.v as ((item: T) => T) | undefined), this.drop); } override len(): number { - return this.back - this.front; + return this.q.n; } override sizeHint(): SizeHint { - return exactHint(this.len()); + return exactHint(this.q.n); } [Symbol.dispose](): void { - if (this.drop === undefined) return; - const items: T[] = []; - while (this.front < this.back) items.push(this.q.b[at(this.q, this.front++)] as T); - dropAll(items, this.drop); + if (this.drop !== undefined) dequeClear(this.q, this.drop); } } +/** `into_iter`, whose items drop by `drop` with it. */ +export function dequeIntoIter(q: VecDeque, drop?: (item: T) => void): Iter { + return new DequeIntoIter(q, drop); +} + /** - * `iter` and `iter_mut`, and with what drops each item, `into_iter`, whose `last`, - * `count`, and skips are a `Vec`'s. + * `collect` into a deque of `size`-byte items, of bytes if `bytes`, from `it`, a deque's + * `into_iter` or a `Vec`'s, which std's gives the buffer of as it is: a deque's, or a + * `Vec`'s with its head where its front was read to. */ -export function dequeIter(q: VecDeque, drop?: (item: T) => void): Iter { - if (drop === undefined) return new DequeIter(q, 0, q.n); - const items: T[] = []; - for (let i = 0; i < q.n; i++) items.push(q.b[at(q, i)] as T); - return iterSlice(items, drop); +export function dequeFromIntoIter(it: Iter, size: number, bytes = false): VecDeque { + if (it instanceof DequeIntoIter) return it.q; + const v = it as unknown as { s: ArrayLike & Capped; front: number; back: number }; + const q = dequeWithCapacity(bytes ? v.s.length : capOf(v.s.length, v.s.cap, size), size, bytes); + q.n = v.back - v.front; + q.h = size === 0 || q.n === 0 ? 0 : v.front; + for (let i = 0; i < q.n; i++) q.b[q.h + i] = v.s[v.front + i]; + return q; } -/** `iter_mut` of items JS copies: the place of each. */ -export function dequeIterMut(q: VecDeque): Iter> { - return new DequePlaces(q); +/** + * `drain`: the items within `r`, which the deque gives up its length past the start of as + * std's does, so one never dropped leaks the rest. Those it still holds as it drops each + * drop by `drop`, front to back, and then the shorter of the items before and after the + * range moves next to the other. + */ +export function dequeDrain(q: VecDeque, r: Bounds, drop?: (item: T) => void): Iter { + const [start, end] = boundsRange(r, q.n); + return new DequeDrain(q, start, end - start, drop); } -/** A deque's `iter_mut` of items JS copies, which lends each as its place. */ -class DequePlaces extends Iter> { +/** A deque's drain, with std's counts: `idx` the next item's index, and `rest` of the range left, std's `remaining`. */ +class DequeDrain extends Iter implements Disposable { private readonly q: VecDeque; - private front = 0; - private back: number; + readonly drainLen: number; + idx: number; + readonly tailLen: number; + rest: number; + private readonly drop: ((item: T) => void) | undefined; + private joined = false; - constructor(q: VecDeque) { + constructor(q: VecDeque, start: number, drainLen: number, drop?: (item: T) => void) { super(); this.q = q; - this.back = q.n; + this.drainLen = drainLen; + this.idx = start; + this.tailLen = q.n - start - drainLen; + this.rest = drainLen; + this.drop = drop; + q.n = start; } - next(): Place | Done { - return this.front < this.back ? new AtIndex(this.q.b as T[], at(this.q, this.front++)) : DONE; + next(): T | Done { + if (this.rest === 0) return DONE; + this.rest--; + return this.q.b[at(this.q, this.idx++)] as T; } - override nextBack(): Place | Done { - return this.front < this.back ? new AtIndex(this.q.b as T[], at(this.q, --this.back)) : DONE; + override nextBack(): T | Done { + if (this.rest === 0) return DONE; + return this.q.b[at(this.q, this.idx + --this.rest)] as T; } override len(): number { - return this.back - this.front; + return this.rest; } override sizeHint(): SizeHint { - return exactHint(this.len()); + return exactHint(this.rest); + } + + [Symbol.dispose](): void { + if (this.joined) return; + this.joined = true; + const q = this.q; + const items: T[] = []; + for (; this.rest > 0; this.rest--) items.push(q.b[at(q, this.idx++)] as T); + if (this.drop !== undefined) dropAll(items, this.drop); + const head = q.n; + const tail = this.tailLen; + const gap = this.drainLen; + q.n = head + tail; + if (q.s === 0) return; + // The shorter side moves next to the other, and the slots it leaves are cleared. + if (head < tail) { + for (let i = head - 1; i >= 0; i--) q.b[at(q, i + gap)] = q.b[at(q, i)]; + for (let i = 0; i < gap; i++) q.b[at(q, i)] = undefined; + } else { + for (let i = 0; i < tail; i++) q.b[at(q, head + i)] = q.b[at(q, head + gap + i)]; + for (let i = 0; i < gap; i++) q.b[at(q, q.n + i)] = undefined; + } + if (q.n === 0) q.h = 0; + else if (head < tail) q.h = at(q, gap); } } -/** `drain`: the items within `r`, taken out at once, which drop by `drop` as `dequeIter`'s. */ -export function dequeDrain(q: VecDeque, r: Bounds, drop?: (item: T) => void): Iter { - const [start, end] = boundsRange(r, q.n); - const taken: VecDeque = { b: [], h: 0, n: 0 }; - for (let i = start; i < end; i++) dequePushBack(taken, q.b[at(q, i)] as T); - for (let i = end; i < q.n; i++) q.b[at(q, i - (end - start))] = q.b[at(q, i)]; - dequeTruncate(q, q.n - (end - start)); - return new DequeIter(taken, 0, taken.n, drop); +/** `Debug` of a deque's `Drain`: its counts, each by `debug`, as std's tuple of them. */ +export function fmtDequeDrain(it: Iter, f: Formatter, debug: Debug): FmtResult { + const d = it as unknown as DequeDrain; + const counts = [d.drainLen, d.idx, d.tailLen, d.rest]; + return fmtDebugTupleFields(f, "Drain", counts.map((n) => (f: Formatter) => debug(n, f))); } /** `slice::range`: the start and end of `r` within `n` elements, panicking as std's does. */ @@ -3122,18 +3406,38 @@ class ByteVecDrain extends Iter implements Disposable { * `extend`, and `collect` into a deque through `dequeNew`, which takes `items` as `take` * says and reserves as `iterExtend` does. */ -export function dequeExtend(q: VecDeque, items: Iter, take?: Take, size?: number, trusted = false): VecDeque { - return vecExtending(q, q.n, items, (item) => dequePushBack(q, item), take, size, trusted, q, true); +export function dequeExtend(q: VecDeque, items: Iter, take?: Take, trusted = false): VecDeque { + if (trusted) { + dequeReserve(q, trustedUpper(items)); + return extending(q, items, (item) => dequePushBack(q, item), take); + } + // std's reserves for the lower bound past each item it reads into a full deque, and the first. + for (let item = items.next(), first = true; item !== DONE; item = items.next(), first = false) { + if (first || q.n === q.b.length) dequeReserve(q, satAdd(items.sizeHint()[0], 1)); + q.b[at(q, q.n++)] = item; + } + if (take !== undefined) dispose(items); + return q; } -/** `clone` of `size`-byte items, with each through its `Clone`, or as itself without one, with room for exactly them. */ -export function dequeClone(q: VecDeque, item: (value: T) => T = itself, size: number): VecDeque { - const out = dequeNew(); - for (let i = 0; i < q.n; i++) dequePushBack(out, item(q.b[at(q, i)] as T)); - capSet(out, out.n, out.n, size); +/** `clone`, with each item through its `Clone`, or as itself without one, with room for exactly them. */ +export function dequeClone(q: VecDeque, item: (value: T) => T = itself): VecDeque { + const out = dequeWithCapacity(q.n, q.s, holdsBytes(q)); + for (let i = 0; i < q.n; i++) out.b[i] = item(q.b[at(q, i)] as T); + out.n = q.n; return out; } +/** + * `clone_from`: `q` cleared, which drops its items in order, then a clone of each of `src`'s + * in its room, as std's `extend` reserves for them. + */ +export function dequeCloneFrom(q: VecDeque, src: VecDeque, item: (value: T) => T = itself, drop?: (item: T) => void): void { + dequeClear(q, drop); + dequeReserve(q, src.n); + for (let i = 0; i < src.n; i++) q.b[at(q, q.n++)] = item(src.b[at(src, i)] as T); +} + // LinkedList /** A `LinkedList` node, linked to the one before, `p`, and after, `x`: the place of its item `v`. */ @@ -3790,9 +4094,9 @@ export function byteVecPart(): Part { return vectorPart(byteVecPush, byteVecReserve); } -/** A `VecDeque` of `size`-byte elements, which pushes each at the back. */ -export function dequePart(size?: number): Part, T> { - return vectorPart(dequePushBack, size === undefined ? undefined : (q, additional) => dequeReserve(q, additional, size)); +/** A `VecDeque`, which pushes each at the back. */ +export function dequePart(): Part, T> { + return vectorPart(dequePushBack, dequeReserve); } /** A `LinkedList`, which pushes each at the back, and never reserves. */ diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index 0f1f20cba..a3b36da58 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/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, byteVecWithCapacity, type Capped, capOf, capReserve, capSet, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, slicePart, sliceView, vecCapacity, vecExtendFromSlice, vecMax, vecWithCapacity } from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, type Capped, capHold, capOf, capReserve, capSet, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, slicePart, sliceView, vecCapacity, vecExtendFromSlice, vecMax, vecWithCapacity } from "../rt.ts"; import { AtIndex, BTreeIter, HashIter, type Ordering } from "./collections.ts"; import { type Hasher, hash8 } from "./hash.ts"; import { charStep, intToBig, type Limbs, lt as wideLt, type Step } from "./int.ts"; @@ -41,7 +41,7 @@ const USIZE_MAX = 0xffffffff; type Drop = (value: T) => void; /** `a + b`, saturating at `usize::MAX` as std's size hints do. */ -function satAdd(a: number, b: number): number { +export function satAdd(a: number, b: number): number { return Math.min(a + b, USIZE_MAX); } @@ -256,7 +256,7 @@ abstract class Calling extends Adaptor { } /** An adaptor folded, whose `next` and `nextBack` are `front` and `back`, which share its state. */ -class Folded extends Iter { +export class Folded extends Iter { readonly front: () => T | Done; readonly back: () => T | Done; @@ -298,6 +298,13 @@ export function iterSlice(s: ArrayLike, drop?: Drop): Iter { return new SliceIter(s, drop); } +/** `Vec::into_iter`: over the vector's whole buffer, whose length is its capacity, which a deque collected from it keeps. */ +export function byteVecIntoIter(v: ByteVec): Iter { + const it = new SliceIter(v.data); + it.back = v.length; + return it; +} + /** `slice::IterMut` of elements JS copies: the place of each. */ export function iterSliceMut(s: { [i: number]: T; length: number }): Iter> { return new SliceMutIter(s); @@ -556,11 +563,11 @@ export function capNext(it: Iter, len: number, cap: number, size: numbe */ export function slicesJoin(items: readonly V[], size: number, sep?: ArrayLike, slice?: (item: V) => ArrayLike, clone?: (item: T) => T): T[] { const parts = slice === undefined ? (items as unknown as readonly ArrayLike[]) : items.map(slice); - joinedLength(parts, sep, size); - const v: T[] = []; + // std's makes one with room for exactly them. + const v = vecWithCapacity(joinedLength(parts, sep, size), size); for (let i = 0; i < parts.length; i++) { - if (i > 0 && sep !== undefined) vecExtendFromSlice(v, sep, clone); - vecExtendFromSlice(v, parts[i], clone); + if (i > 0 && sep !== undefined) vecExtendFromSlice(v, sep, size, clone); + vecExtendFromSlice(v, parts[i], size, clone); } return v; } @@ -1238,8 +1245,36 @@ export function iterGe(a: Iter, b: Iter, cmp: (x: T, y: U) => Orderi return order !== undefined && order >= 0; } -/** `collect` into a `Vec`, as `iterExtend` of an empty one. */ -export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { +/** + * The capacity std's `collect` of `it` into a `Vec` of `size`-byte elements keeps of the + * `Vec` of `src`-byte ones it writes in place of, read before it reads `it`: through + * adaptors, all of its bytes, and of that `Vec`'s own `into_iter`, its buffer while unread + * at the front or at least half full, and else room reserved for what is left. + */ +function keptCapacity(it: Iter, src: number, size: number): number | undefined { + let from: Iter | undefined = it; + while (from !== undefined && !(from instanceof SliceIter)) { + // std's `SourceIter` reads through each adaptor to the iterator it wraps, a zip's first. + const wraps = from as unknown as { inner?: Iter; a?: Iter; outer?: Iter }; + from = wraps.inner ?? wraps.a ?? wraps.outer; + } + if (from === undefined) return undefined; + const s = from.s as ArrayLike & Capped; + const cap = s instanceof Uint8Array ? s.length : vecCapacity(s as unknown[] & Capped, src); + if (from !== it) return Math.floor((cap * src) / size); + const left = from.back - from.front; + return from.front === 0 || left >= Math.floor(cap / 2) ? cap : capReserve(0, 0, left, size); +} + +/** `collect` into a `Vec`, as `iterExtend` of an empty one, in place of a `Vec` of `src`-byte elements if given. */ +export function iterToArray(it: Iter, take?: Take, size?: number, trusted = false, src?: number): T[] { + const kept = src === undefined || size === undefined ? undefined : keptCapacity(it, src, size); + const out = toArray(it, take, size, trusted); + if (kept !== undefined) capHold(out, kept, size!); + return out; +} + +function toArray(it: Iter, take?: Take, size?: number, trusted = false): T[] { if (size !== undefined && !trusted) { const out: T[] = []; let cap = capOf(0, undefined, size); @@ -1262,8 +1297,16 @@ export function iterToArray(it: Iter, take?: Take, size?: number, trusted return out; } -/** `collect` into a `Vec`, as `iterExtendBytes` of an empty one. */ -export function iterToByteVec(it: Iter, take?: Take, trusted = false): ByteVec { +/** `collect` into a `Vec`, as `iterExtendBytes` of an empty one, in place of a `Vec` of `src`-byte elements if given. */ +export function iterToByteVec(it: Iter, take?: Take, trusted = false, src?: number): ByteVec { + const kept = src === undefined ? undefined : keptCapacity(it, src, 1); + const out = toByteVec(it, take, trusted); + if (kept !== undefined && kept > out.data.length) byteVecReserveExact(out, kept - out.length); + else if (kept !== undefined && kept < out.data.length) byteVecShrinkTo(out, kept); + return out; +} + +function toByteVec(it: Iter, take?: Take, trusted = false): ByteVec { // Its own loops: through `iterExtendBytes`, JavaScriptCore took 1.9x as long. if (!trusted) { const out = new ByteVec(); @@ -1528,11 +1571,12 @@ class SliceIter extends Iter implements Disposable { return Array.prototype.slice.call(this.s, this.front, this.back); } - /** std's: what it has left, each cloned in order by `h.v` into storage of its own, or else shared. */ + /** std's: what it has left, each cloned in order by `h.v` into storage of its own, of exactly their capacity, or else shared. */ override clone(h?: Clones): Iter { if (h?.v !== undefined) { - const items = Array.prototype.slice.call(this.s, this.front, this.back) as T[]; + const items = Array.prototype.slice.call(this.s, this.front, this.back) as T[] & Capped; for (let i = 0; i < items.length; i++) items[i] = cloned(items[i], h.v); + items.cap = items.length; return new SliceIter(items, this.drop); } const it = new SliceIter(this.s, this.drop); diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 3587660bc..bcad16603 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -39,7 +39,8 @@ pub fn call<'tcx>( None => match (owner, name, self_std, self_ty) { ("Default", "default", Some(std), Some(t)) | ("Clone", "clone", Some(std), Some(t)) - | ("Clone", "clone_from", Some(std @ Std::LinkedList), Some(t)) + | ("Clone", "clone_from", Some(std @ (Std::LinkedList | Std::VecDeque)), Some(t)) + | ("ToOwned", "clone_into", Some(std @ Std::VecDeque), Some(t)) | ("Index" | "IndexMut", "index" | "index_mut", Some(std), Some(t)) | ("Extend", "extend", Some(std), Some(t)) | ("From", "from", Some(std), Some(t)) @@ -287,7 +288,7 @@ pub fn lending(std: Std) -> bool { /// indices of the collection's type arguments whose runtime function takes what drops each, /// after its own arguments: the key `insert` and `entry` are given if an equal one is there /// already, the key `remove` takes out, the value `or_insert` is given if one is, and what -/// `clear`, `retain`, and `truncate` discard. An iterator, and `extend` and `from`, take +/// `clear`, `retain`, `truncate`, and a deque's `clone_from` and `clone_into` discard. An iterator, and `extend` and `from`, take /// theirs where they map. fn discarded(std: Std, owner: &str, name: &str) -> Option<&'static [usize]> { let map = matches!(std, Std::HashMap | Std::BTreeMap); @@ -299,7 +300,9 @@ fn discarded(std: Std, owner: &str, name: &str) -> Option<&'static [usize]> { (_, "or_insert") if std == Std::Entry => &[1], (_, "clear" | "retain" | "retain_mut") if map => &[0, 1], (_, "clear" | "retain" | "retain_mut") if set => &[0], - (_, "clear" | "retain" | "retain_mut" | "truncate") if std == Std::VecDeque => &[0], + (_, "clear" | "retain" | "retain_mut" | "truncate" | "clone_from" | "clone_into") if std == Std::VecDeque => { + &[0] + } (_, "clear") if std == Std::LinkedList => &[0], (_, "clear" | "retain") if std == Std::BinaryHeap => &[0], _ => return None, @@ -1431,7 +1434,19 @@ fn btree_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Ex /// An empty `VecDeque` of type `coll`. fn deque_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Expr { - empty(b, Expr::rt("dequeNew", vec![]), coll, span) + let made = Expr::rt("dequeNew", deque_items(b, arg(coll, 0), span)); + empty(b, made, coll, span) +} + +/// What a runtime function that makes a `VecDeque` of `item`s is given after its own +/// arguments: their size, by which std's grows it, and whether they are bytes, which it +/// holds in a `Uint8Array` its slices view. +fn deque_items<'tcx>(b: &mut Body<'_, '_, 'tcx>, item: Ty<'tcx>, span: Span) -> Vec { + let bytes = matches!(item.kind(), ty::Uint(ty::UintTy::U8)); + super::iter::tail( + vec![super::iter::size_of(b, item, span)], + vec![Expr::lit(bytes.to_string())], + ) } /// A method of `VecDeque`, or of a trait it implements. @@ -1450,17 +1465,14 @@ fn deque<'tcx>( let back = |values: Vec| flagged(values, true, none); let e = match (owner, name) { (_, "new") | ("Default", "default") => deque_new(b, coll, span), - // What reads or sets a capacity is given the size of the items, by which std's - // grows it. (_, "with_capacity") => { - values.push(super::iter::size_of(b, item, span)); + values.extend(deque_items(b, item, span)); empty(b, Expr::rt("dequeWithCapacity", values), coll, span) } (_, "capacity" | "reserve" | "reserve_exact" | "shrink_to" | "shrink_to_fit") => { if name == "shrink_to_fit" { values.push(Expr::lit("0")); } - values.push(super::iter::size_of(b, item, span)); let f = match name { "capacity" => "dequeCapacity", "reserve" => "dequeReserve", @@ -1495,6 +1507,13 @@ fn deque<'tcx>( } (_, "iter_mut") if b.t.needs_place(item) => Expr::rt("dequeIterMut", values), (_, "iter" | "iter_mut") => Expr::rt("dequeIter", values), + // Each a copy of its part of the buffer, or with `_mut`, a view that writes into it; + // bytes are views either way. + (_, "as_slices" | "as_mut_slices") if matches!(item.kind(), ty::Uint(ty::UintTy::U8)) => { + Expr::rt("dequeByteSlices", values) + } + (_, "as_slices") => Expr::rt("dequeAsSlices", values), + (_, "as_mut_slices") => Expr::rt("dequeAsSlices", flagged(values, true, false)), (_, "drain") => { let ranged = bounds(b, call, values.pop()?); values.push(ranged.bounds.clone()); @@ -1503,18 +1522,32 @@ fn deque<'tcx>( } ("Index" | "IndexMut", "index" | "index_mut") => Expr::rt("dequeIndex", values), ("Clone", "clone") => { + let clone = clone_fn(b, item, span); + Expr::rt("dequeClone", super::iter::tail(values, vec![clone])) + } + // std's clears it, which drops its items, and extends it by clones of the source's, + // keeping its capacity; `clone_into` is the target's `clone_from`. + ("Clone", "clone_from") | ("ToOwned", "clone_into") => { + if name == "clone_into" { + values.reverse(); + } values.push(clone_fn(b, item, span)); - values.push(super::iter::size_of(b, item, span)); - Expr::rt("dequeClone", values) + Expr::rt("dequeCloneFrom", values) } - // `From>` keeps the vector's capacity. + // `From>` keeps the vector's capacity, and `From<[T; N]>` holds exactly `N`. ("From", "from") if b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => { let v = values.pop()?; let v = match matches!(item.kind(), ty::Uint(ty::UintTy::U8)) { true => Expr::rt("byteVecToVec", vec![v]), false => v, }; - empty(b, Expr::rt("dequeFromVec", vec![v]), coll, span) + let made = Expr::rt("dequeFromVec", [vec![v], deque_items(b, item, span)].concat()); + empty(b, made, coll, span) + } + ("From", "from") if library::targ(call.args, 1).is_array() => { + let a = values.pop()?; + let made = Expr::rt("dequeFromArray", [vec![a], deque_items(b, item, span)].concat()); + empty(b, made, coll, span) } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; @@ -1813,7 +1846,13 @@ pub fn extend<'tcx>( ) } Std::Vec => Expr::rt("iterExtend", super::iter::tail(vec![target, items], vec_reserve(b))), - Std::VecDeque => Expr::rt("dequeExtend", super::iter::tail(vec![target, items], vec_reserve(b))), + Std::VecDeque => { + let take = super::iter::iter_take(b, iter, trusted, span); + Expr::rt( + "dequeExtend", + super::iter::tail(vec![target, items], vec![take, Expr::lit(trusted.to_string())]), + ) + } // By `for_each`, reserving nothing. Std::LinkedList => { let take = super::iter::iter_take(b, iter, true, span); @@ -1965,7 +2004,7 @@ fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: let part = match std { Std::Vec if matches!(arg(coll, 0).kind(), ty::Uint(ty::UintTy::U8)) => Expr::rt("byteVecPart", Vec::new()), Std::Vec => Expr::rt("vecPart", super::iter::tail(Vec::new(), size(b))), - Std::VecDeque => Expr::rt("dequePart", super::iter::tail(Vec::new(), size(b))), + Std::VecDeque => Expr::rt("dequePart", Vec::new()), Std::LinkedList => Expr::rt("listPart", Vec::new()), Std::BinaryHeap => { let le = heap_tests(b, arg(coll, 0), false, span); @@ -2983,6 +3022,8 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp _ => return None, }; if !ty.is_ref() { + // A deque's is the deque itself, which it pops from. + let name = if name == "dequeIter" { "dequeIntoIter" } else { name }; let droppers = entry_droppers(b, coll, span); return Some(Expr::rt(name, super::iter::tail(vec![value], droppers))); } @@ -3021,10 +3062,25 @@ pub fn collect<'tcx>( let target = list_new(b, ty, span); extend(b, ty, arg(ty, 0), target, iter, from, span)? } - // std's collects into a `Vec` first, whose capacity it keeps. + // std's takes the buffer of a deque's or a `Vec`'s `into_iter` as it is, and + // collects any other into a `Vec` first, whose capacity it keeps. Std::VecDeque => { - let items = super::iter::to_array(b, iter, from, arg(ty, 0), trusted, span); - empty(b, Expr::rt("dequeFromVec", vec![items]), ty, span) + let item = arg(ty, 0); + let path = from + .ty_adt_def() + .map(|adt| library::std_path(b.t.tcx, adt.did()).join("::")); + let whole = matches!( + path.as_deref(), + Some("collections::vec_deque::into_iter::IntoIter" | "vec::into_iter::IntoIter") + ); + let made = match whole { + true => Expr::rt("dequeFromIntoIter", [vec![iter], deque_items(b, item, span)].concat()), + false => { + let items = super::iter::to_array(b, iter, from, item, trusted, span); + Expr::rt("dequeFromVec", [vec![items], deque_items(b, item, span)].concat()) + } + }; + empty(b, made, ty, span) } _ => return None, }) diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index c0044d356..46dbcf33a 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -76,11 +76,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(Std::Entry) => args.types().next().is_some_and(|k| self.drops(k)), // The items of the `Vec` it owns. Some(Std::Cow) => library::cow_slice(tcx, ty).is_some_and(|elem| self.drops(elem)), - // A `Vec`'s drain moves the vector's tail back as it drops, and a `String`'s takes - // the drained text out of it. + // A `Vec`'s drain moves the vector's tail back as it drops, a deque's joins the + // items before and after the range, and a `String`'s takes the drained text out + // of it. None if { let path = library::std_path(tcx, adt.did()); - path == ["vec", "drain", "Drain"] || path == ["string", "Drain"] + path == ["vec", "drain", "Drain"] + || path == ["collections", "vec_deque", "drain", "Drain"] + || path == ["string", "Drain"] } => { true diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 2848f4b7a..6c0a9bfec 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -467,9 +467,8 @@ pub fn std_impl<'tcx>( } /// `Debug` of one of std's iterators that lists the items it has left, as std writes -/// them, or `None` for another type. A deque's `Iter` and `IterMut` write the two halves of -/// its ring buffer, which the runtime's deque splits elsewhere than std's, and its `Drain` -/// its indices, so they stay refused. +/// them, or `None` for another type. A deque's `Iter` and `IterMut` write the two slices of +/// its ring buffer they have left, and its `Drain` its counts. fn iter_debug<'tcx>( b: &mut Body<'_, '_, 'tcx>, did: DefId, @@ -497,6 +496,20 @@ fn iter_debug<'tcx>( let path: Vec<&str> = path.iter().map(String::as_str).collect(); let (item, wraps): (Item, &[Wrap]) = match path.as_slice() { ["str", "iter", "Chars"] => return Some(Expr::rt("fmtChars", vec![value.clone(), f.clone()])), + [ + "collections", + "vec_deque", + "iter" | "iter_mut", + name @ ("Iter" | "IterMut"), + ] => { + let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); + let call = vec![value.clone(), f.clone(), debug, Expr::Str((*name).into())]; + return Some(Expr::rt("fmtDequeIter", call)); + } + ["collections", "vec_deque", "drain", "Drain"] => { + let len = b.fmt_fn(Trait::Debug, tcx.types.usize, span); + return Some(Expr::rt("fmtDequeDrain", vec![value.clone(), f.clone(), len])); + } // The list it has left, then its length. ["collections", "linked_list", name @ ("Iter" | "IterMut")] => { let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index d495e2942..0b9d08fa2 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -124,8 +124,16 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp unboxed if unboxed != ty => (unboxed, b.t.pointee_value(ty, value)), _ => (ty, value), }; - // A boxed slice owns its elements, as the `Vec` std's `into_iter` makes of it does. - let ty = library::box_slice(tcx, ty).map_or(ty, |elem| Ty::new_slice(tcx, elem)); + // A boxed slice owns its elements, as the `Vec` std's `into_iter` makes of it does, with + // room for exactly them. + let (ty, value) = match library::box_slice(tcx, ty) { + Some(elem) if !matches!(elem.kind(), ty::Uint(ty::UintTy::U8)) => { + let size = size_of(b, elem, span); + (Ty::new_slice(tcx, elem), Expr::rt("vecExact", vec![value, size])) + } + Some(elem) => (Ty::new_slice(tcx, elem), value), + None => (ty, value), + }; let owned = !ty.is_ref(); if b.t.iter_item(ty).is_some() { not_bound(b, ty, span); @@ -180,6 +188,10 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp Std::Vec if places(b, args.type_at(0)) => { Some(Expr::rt("iterSliceMut", vec![library::elements(value, ty)])) } + // A `Vec`'s owned bytes keep its buffer, as a deque collected from them does. + Std::Vec if owned && matches!(args.type_at(0).kind(), ty::Uint(ty::UintTy::U8)) => { + Some(Expr::rt("byteVecIntoIter", vec![value])) + } Std::Vec => { let values = each(b, args.type_at(0), vec![library::elements(value, ty)]); Some(items(Expr::rt("iterSlice", values), args.type_at(0))) @@ -998,9 +1010,14 @@ fn clones<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option< "set", "Iter" | "Range" | "Difference" | "Intersection" | "Union" | "SymmetricDifference", ] => Expr::undefined(), + // std's copies what a `Vec`'s has left into a buffer of its own, even of items that + // clone as themselves, which a deque collected from it takes. + ["vec", "into_iter", "IntoIter"] => match value(b, arg(0)?) { + v if undefined(&v) => parts(vec![("v", Expr::Rt("itself".into()))]), + v => parts(vec![("v", v)]), + }, // Those that own their items, each cloned. - ["vec", "into_iter", "IntoIter"] - | ["array", "iter", "IntoIter"] + ["array", "iter", "IntoIter"] | ["option", "IntoIter"] | ["result", "IntoIter"] | ["iter", "sources", "once", "Once"] @@ -1254,11 +1271,14 @@ fn collect<'tcx>( if let Some(elem) = elem { let v = match elem.kind() { ty::Uint(ty::UintTy::U8) => { - let (folds, by_index) = collect_folds(b, from, elem, span); + let (folds, by_index, src) = collect_folds(b, from, elem, span); let take = iter_take(b, from, folds, span); Expr::rt( "iterToByteVec", - tail(vec![iter], vec![take, Expr::lit((trusted || by_index).to_string())]), + tail( + vec![iter], + vec![take, Expr::lit((trusted || by_index).to_string()), src_size(src)], + ), ) } _ => to_array(b, iter, from, elem, trusted, span), @@ -1437,18 +1457,24 @@ pub(super) fn to_array<'tcx>( trusted: bool, span: Span, ) -> Expr { - let (folds, by_index) = collect_folds(b, from, elem, span); + let (folds, by_index, src) = collect_folds(b, from, elem, span); let take = iter_take(b, from, folds, span); let size = size_of(b, elem, span); Expr::rt( "iterToArray", tail( vec![iter], - vec![take, size, Expr::lit((trusted || by_index).to_string())], + vec![take, size, Expr::lit((trusted || by_index).to_string()), src_size(src)], ), ) } +/// The size of the elements of the `Vec` a `collect` writes in place of, which the runtime +/// keeps the capacity of as std's does, or `undefined`. +fn src_size(src: Option) -> Expr { + src.map_or_else(Expr::undefined, |size| Expr::lit(size.to_string())) +} + /// Whether std's `collect` of an iterator of type `from` into a `Vec` folds it, and /// whether by index, reading no item past its length. In place of the `Vec` its items come /// from, it reads a `TrustedRandomAccessNoCoerce` one by index and any other by `try_fold`, @@ -1456,11 +1482,17 @@ pub(super) fn to_array<'tcx>( /// `next` reads a side once past the other: that one folds, its length reserved as a /// `TrustedLen` one's, and is refused if it holds values that drop, which its `fold` drops /// as each fold ends. Elsewhere, it folds a `TrustedLen` one by its own `fold`, which drops -/// them first, and reads any other by `next`. -fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx>, span: Span) -> (bool, bool) { - if !in_place(b.t, from, elem) { - return (implements(b.t, from, "TrustedLen"), false); - } +/// them first, and reads any other by `next`. Last, the size of the elements of the `Vec` +/// it writes in place of, if it does. +fn collect_folds<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + from: Ty<'tcx>, + elem: Ty<'tcx>, + span: Span, +) -> (bool, bool, Option) { + let Some(src) = in_place(b.t, from, elem) else { + return (implements(b.t, from, "TrustedLen"), false, None); + }; let zips = from.walk().filter_map(|arg| arg.as_type()).any(|t| { matches!(t.kind(), ty::Adt(adt, _) if library::std_path(b.t.tcx, adt.did()).last().map(String::as_str) == Some("Zip")) }); @@ -1473,20 +1505,20 @@ fn collect_folds<'tcx>(b: &mut Body<'_, '_, 'tcx>, from: Ty<'tcx>, elem: Ty<'tcx ), ); } - (by_index, by_index) + (by_index, by_index, Some(src)) } -/// Whether std's `collect` of an iterator of type `iter` into a `Vec` writes in place -/// of the `Vec` its items come from, as its adaptors let it where each item's layout leaves -/// room. -fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> bool { +/// The size of the elements of the `Vec` std's `collect` of an iterator of type `iter` into +/// a `Vec` writes in place of, if it does, as its adaptors let it where each item's +/// layout leaves room. +fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> Option { let tcx = t.tcx; let env = t.typing_env_pub(); let (Some(steps), Some(source)) = (core_trait(tcx, "InPlaceIterable"), core_trait(tcx, "SourceIter")) else { - return false; + return None; }; if !implements(t, iter, "InPlaceIterable") || !implements(t, iter, "SourceIter") { - return false; + return None; } let assoc = |tr: DefId, name: &str| { tcx.associated_items(tr) @@ -1495,18 +1527,16 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> b .map(|item| item.def_id) }; // `::Source`, a `vec::IntoIter` of what it collects in place of. - let Some(src) = assoc(source, "Source").and_then(|item| { + let src = assoc(source, "Source").and_then(|item| { let projection = Ty::new_projection(tcx, ty::IsRigid::No, item, [iter]); tcx.try_normalize_erasing_regions(env, ty::Unnormalized::new_wip(projection)) .ok() - }) else { - return false; - }; + })?; let ty::Adt(adt, src_args) = src.kind() else { - return false; + return None; }; if library::std_path(tcx, adt.did()) != ["vec", "into_iter", "IntoIter"] { - return false; + return None; } // `MERGE_BY` and `EXPAND_BY`: how many source items make how many it collects, if known. let step = |name: &str| -> Option { @@ -1516,19 +1546,20 @@ fn in_place<'tcx>(t: &Translator<'_, 'tcx>, iter: Ty<'tcx>, elem: Ty<'tcx>) -> b Some(value.try_to_scalar_int()?.to_bits_unchecked()) }; let (Some(merge), Some(expand)) = (step("MERGE_BY"), step("EXPAND_BY")) else { - return false; + return None; }; let layout = |ty: Ty<'tcx>| tcx.layout_of(env.as_query_input(ty)).ok(); let (Some(from), Some(to)) = (layout(src_args.type_at(0)), layout(elem)) else { - return false; + return None; }; // As std's `in_place_collectible`, where `None`, an overflow, is 0. - !from.is_zst() + (!from.is_zst() && !to.is_zst() && from.align.abi == to.align.abi && merge > 0 && expand > 0 - && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand + && u128::from(from.size.bytes()) * merge >= u128::from(to.size.bytes()) * expand) + .then_some(from.size.bytes()) } /// Whether the crate's own `Ord` of `ty` has its own `max` or `min`, by `name`, which diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 233cf5007..1fa9c708b 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1421,7 +1421,7 @@ fn mapping<'tcx>( if let Some(elem) = box_slice(tcx, from) && b.t.std_of(to) == Some(Std::Vec) { - return Some(boxed_vec(value, elem)); + return Some(boxed_vec(b, value, elem, span)); } // A heap's `Vec` is its elements. if let ty::Adt(adt, args) = from.kind() @@ -2071,7 +2071,7 @@ fn mapping<'tcx>( super::iter::tail(vec![items, compare], vec![Expr::undefined(), drop]), ) } - ("slice", "into_vec") => boxed_vec(args.pop()?, targ(gargs, 0)), + ("slice", "into_vec") => boxed_vec(b, args.pop()?, targ(gargs, 0), span), ("Vec", "into_boxed_slice") => vec_boxed(args.pop()?, targ(gargs, 0)), // `vec![a, b]`'s array once `mir::vec` took the box away. A `Copy` aggregate's operand // may be shared with where it came from, which the vector must not change. @@ -2156,6 +2156,7 @@ fn mapping<'tcx>( ("Vec", "extend_from_slice") if is_u8(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", args), ("Vec", "extend_from_slice") => { let mut values = args; + values.push(super::iter::size_of(b, targ(gargs, 0), span)); let clone = super::collections::clone_fn(b, targ(gargs, 0), span); if !matches!(&clone, Expr::Lit(l) if l == "undefined") { values.push(clone); @@ -2759,11 +2760,30 @@ pub(super) fn vec_boxed(v: Expr, elem: Ty<'_>) -> Expr { } } -/// The `Vec` that a `Box<[elem]>`, `boxed`, becomes, as `into_vec` makes it. -fn boxed_vec(boxed: Expr, elem: Ty<'_>) -> Expr { +/// `clone`, the `Vec` that `clone_from` writes over `target`, with the capacity std's +/// keeps of `target`'s. +pub(super) fn vec_cloned_into<'tcx>( + b: &mut Body<'_, '_, 'tcx>, + clone: Expr, + target: Expr, + elem: Ty<'tcx>, + span: Span, +) -> Expr { + match elem.kind() { + ty::Uint(ty::UintTy::U8) => Expr::rt("byteVecClonedInto", vec![clone, target]), + _ => Expr::rt( + "vecClonedInto", + vec![clone, target, super::iter::size_of(b, elem, span)], + ), + } +} + +/// The `Vec` that a `Box<[elem]>`, `boxed`, becomes, as `into_vec` makes it, with room +/// for exactly its elements. +fn boxed_vec<'tcx>(b: &mut Body<'_, '_, 'tcx>, boxed: Expr, elem: Ty<'tcx>, span: Span) -> Expr { match elem.kind() { ty::Uint(ty::UintTy::U8) => Expr::rt("byteSliceToByteVec", vec![boxed]), - _ => boxed, + _ => Expr::rt("vecExact", vec![boxed, super::iter::size_of(b, elem, span)]), } } diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index a64e6168d..a887892cf 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -542,9 +542,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } // `*self = source.clone()`, as std's `Clone` for a `T: Clone` has `clone_from` and // its `ToOwned` has `clone_into`, cloning before it drops what it writes over. A - // list's maps, as it clones each element into one of its own nodes. + // list's maps, as it clones each element into one of its own nodes, and a deque's, + // as it clears itself first and keeps its capacity. ("Clone", "clone_from") | ("ToOwned", "clone_into") - if !self.b.t.translated(def_id, gargs) && self.b.t.std_of(targ(0)?) != Some(Std::LinkedList) => + if !self.b.t.translated(def_id, gargs) + && !matches!(self.b.t.std_of(targ(0)?), Some(Std::LinkedList | Std::VecDeque)) => { let ty = targ(0)?; if !ty.is_sized(tcx, self.b.t.typing_env_pub()) { @@ -566,6 +568,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let clone = self .b .call_def(clone, tcx.mk_args(&[ty.into()]), vec![source], span, out); + // std's `Vec` keeps the target's buffer, grown if it holds fewer. + let clone = match ty.kind() { + ty::Adt(_, args) if self.b.t.std_of(ty) == Some(Std::Vec) => { + library::vec_cloned_into(self.b, clone, place.0.clone(), args.type_at(0), span) + } + _ => clone, + }; let drops = self.b.t.drops(ty); let old = self.swap_out(place, ty, clone, drops.then_some("old"), span, out); if drops && let Some(drop) = self.b.t.drop_value(old, ty, span) { diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index 58119d720..3a6f5d9ff 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -271,8 +271,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` /// from `rt.iterSlice(s)`, or `rt.iterSlice(s, drop)` of items it owns, which its drop - /// drops again, and `{ start, end }` from `new rt.Range(start, end)`. A moved one is - /// already made. + /// drops again, the view of `v`'s bytes from `rt.byteVecIntoIter(v)`, and + /// `{ start, end }` from `new rt.Range(start, end)`. A moved one is already made. pub(super) fn stepped_make(&mut self, value: Expr, span: rustc_span::Span) -> Expr { let rt = |f: &Expr, name: &str| matches!(f, Expr::Rt(n) if n == name); let object = |fields: [(&str, Expr); 2]| { @@ -283,6 +283,9 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { args.truncate(1); object([("s", args.pop().unwrap()), ("i", Expr::lit("0"))]) } + Expr::Call(f, args) if rt(&f, "byteVecIntoIter") && args.len() == 1 => { + object([("s", Expr::rt("byteVecView", args)), ("i", Expr::lit("0"))]) + } Expr::New(f, args) if rt(&f, "Range") && args.len() == 2 => { let [start, end] = <[Expr; 2]>::try_from(args).expect("checked above"); object([("start", start), ("end", end)])