diff --git a/quest/m3/README.md b/quest/m3/README.md index d4be3829d..29c50bf47 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -21,7 +21,6 @@ generic std gap is planned here even when moq never calls it. - [Waiting: type-check in process with tsrs](/quest/m3/ts-tsrs.md) - rust2-ts checks bindings through tsrs instead of `tsc` once it is a stable library - [rs.Slice](/quest/m3/ts-slice-object.md) - references to arrays of other values are a runtime slice too, and pointers compare by where they point - [Writes through iter_mut without a Place per item](/quest/m3/ts-iter-mut-places.md) - a loop over `iter_mut()` of copy values writes the slice's array by index -- [rs.String](/quest/m3/ts-string-capacity.md) - `String`, `Box`, and `&str` are a runtime type holding std's capacity - [Throw only where Rust panics](/quest/m3/ts-runtime-throws.md) - no runtime `rust2-ts:` error where native Rust goes on: an exact slower path, or a refusal at translation - [rust2-ts with no ts.toml](/quest/m3/ts-configless.md) - a crate's whole `pub` API translates with no config and no bound items - [Buf on a deque of bytes](/quest/m3/ts-vecdeque-buf.md) - `bytes`' `Buf` for a deque of bytes translates diff --git a/quest/m3/ts-panic-payload-capacity.md b/quest/m3/ts-panic-payload-capacity.md index 372284152..e8be00bf3 100644 --- a/quest/m3/ts-panic-payload-capacity.md +++ b/quest/m3/ts-panic-payload-capacity.md @@ -14,7 +14,3 @@ message). About 64 runtime sites pass such a message. Build each as std's `forma without slowing the paths that never panic. Public API: the runtime's panic sites, not their messages. - -## Required - -- [rs.String](/quest/m3/ts-string-capacity.md) - `String` holds std's capacity, which a hook then reads diff --git a/quest/m3/ts-slice-object.md b/quest/m3/ts-slice-object.md index 72a31a87c..f20b41438 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -40,7 +40,3 @@ stays refused, as do pointers to an array of one, and their exact path is Public API: the translator's output and what a hand-written caller passes for a slice of arrays. - -## Related - -- [rs.String](/quest/m3/ts-string-capacity.md) - the other native mapping becoming a wrapper diff --git a/quest/m3/ts-string-capacity.md b/quest/m3/ts-string-capacity.md deleted file mode 100644 index 638839636..000000000 --- a/quest/m3/ts-string-capacity.md +++ /dev/null @@ -1,43 +0,0 @@ -# [L] rs.String - -## Goal - -[rust2-ts](/ts/README.md) translates `String`, `Box`, and `&str` as a runtime type -rather than a JS `string`, holding what std's do: a `String`'s exact capacity through -`with_capacity`, `reserve`, `reserve_exact`, push growth, `shrink_to_fit`, `shrink_to`, -`format!`'s estimate, and `into_bytes`, `Vec::from`, and `Bytes::from`, which take it. -Differential tests against native Rust prove it, and the refusal of reading a `Bytes`' -capacity where a `String`'s bytes may reach it is lifted. Hand-written callers convert at -the boundary with helpers, as for `rs.Vec`. - -## Plan - -Decided with the maintainer on 2026-11-03: Rust types the runtime can't hold as std's do -get a runtime wrapper, converted at API boundaries, rather than a JS native type. In their -words on [#555](https://github.com/moq-dev/rust2/pull/555), "trying to support native -types is probably a mistake". `Vec` became one there and `Cow` in -[#567](https://github.com/moq-dev/rust2/pull/567). Primitives, `Option`, tuples, and -closures stay native. A native type, aliased or branded, stays where it holds all of std's -semantics with no extra allocation, as a branded `number` does for an integer and a -`Uint8Array` for a `[u8; N]`; prefer one if it holds them, but capacity and the like -usually need a wrapper. - -What it holds: - -- ✅ Measure both, and bring the numbers back as a decision. -- A JS string and its capacity: engine string operations and `Display` stay cheap, but - byte offsets still convert from UTF-16. -- UTF-8 bytes, as `rs.ByteVec` holds: byte indexing and in-place edits are as Rust's, but - every `Display` and JS boundary decodes. - -Measure on `just ts bench` and moq's translated codec in Node, Chrome, Bun, and Firefox, -with an A/A run of main for noise, as #555 did. - -Earlier, on [#532](https://github.com/moq-dev/rust2/pull/532), the maintainer chose to -track capacity rather than refuse it; until this lands, the refusal stays. - -Public API: the translator's output and what a hand-written caller passes for a string. - -## Related - -- [rs.Slice](/quest/m3/ts-slice-object.md) - the other native mapping becoming a wrapper diff --git a/ts/Cargo.lock b/ts/Cargo.lock index 1f61c15c4..d8581eb9d 100644 --- a/ts/Cargo.lock +++ b/ts/Cargo.lock @@ -80,9 +80,6 @@ dependencies = [ [[package]] name = "crates-dep" version = "0.0.0" -dependencies = [ - "bytes", -] [[package]] name = "crates-fixture" diff --git a/ts/README.md b/ts/README.md index 3a9cb0857..bf4427280 100644 --- a/ts/README.md +++ b/ts/README.md @@ -89,7 +89,8 @@ crate translation reaches is refused, and so are two versions of one crate it re | Rust | TypeScript | | --- | --- | -| `bool`, `str`, `String`, `Box` | `boolean`, `string` | +| `bool`, `str`, `Box` | `boolean`, `string` | +| `String` | `rs.String`: its text, `v`, its length in UTF-8 bytes, `len`, and the capacity std's holds, `cap`; `rs.stringFrom(text)` makes one of a JS string with room for exactly its bytes | | `char` | `rs.char`: a `number` branded so, its Unicode scalar value | | `u8`-`u32`, `i8`-`i32`, `usize`, `isize` | `rs.u8` and so on: a `number` branded with its type, checked: overflow panics | | `u64`, `i64`, `u128`, `i128` | `rs.u64` and so on: a branded `number` while a safe integer, 32-bit limbs past 2^53, checked the same way | @@ -107,8 +108,8 @@ crate translation reaches is refused, and so are two versions of one crate it re | tuple, `[T; N]`, `&[T; N]` | an array, and `rs.Slice` of all of it for `&[T; N]`; for bytes, `u8` or `MaybeUninit`, `Uint8Array` for `[u8; N]`, and `rs.ByteSlice` for `&[u8; N]` | | `&[T]`, `&mut [T]`, `Box<[T]>` | `rs.Slice`, a range of an array; `rs.ByteSlice` for bytes | | `Vec` | `rs.Vec`: its items, the array `items`, and the capacity std's holds; `rs.vecFrom(items)` makes one of an array with room for exactly them. `rs.ByteVec` of bytes | -| `Cow<[T]>`, `Cow` | `rs.Cow`: the `Vec` it owns, or an `rs.Borrowed` holding the slice it borrows; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | -| `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | +| `Cow<[T]>`, `Cow` | `rs.Cow`: the `Vec` it owns, or an `rs.Borrowed` holding the slice it borrows; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the `rs.String` it owns or an `rs.Borrowed` holding the string it borrows, whose text `rs.strCowStr` reads | +| `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | | `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rs.Slice` of a `[T; N]`'s elements or an `rs.ByteSlice` of a `[u8; N]`'s bytes, which compares by the array or buffer and offset they are at, refused for an array of one, which `array::from_ref`, `from_mut` of a variable, and `Option::as_slice` make of their own, or an `rs.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to other values JS copies, each a place JS makes of its own; `rs.NULL` for null and `rs.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rs.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rs.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rs.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rs` class such as `rs.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | | `MaybeUninit` | `T`: `undefined` until written, `0` for a byte, or an object whose parts kept as objects are there, holding `undefined` | | `ManuallyDrop` | `T`, which nothing drops but its own `drop`; its `Debug`, comparisons, and constants are refused | @@ -256,7 +257,8 @@ invalid sequence, as std's does, and borrows the text of valid UTF-8, as std's d where `str::from_utf8` fails, so each `Utf8Chunk`'s `invalid` bytes are std's, and `Debug` of it writes what is left as std's does, each invalid byte as `\xNN`. `from_utf8_unchecked`, of a `str` or a `String`, decodes as `from_utf8_lossy` does the UTF-8 its contract promises. -`String::into_bytes` and `Vec::::from` a string encode its UTF-8 anew. +`String::into_bytes` and `Vec::::from` of one encode its UTF-8 into storage of its +capacity, and `Vec::::from` a `&str` into exactly its bytes. An `f64` is a JS number, so its operators are JS's, which round as Rust's do. Where JS differs from std, the runtime has std's: `round` halves away from zero, `max` and @@ -413,23 +415,31 @@ closure, which it calls on each char it reads, in the order std reads them, and returns, or with the iterator it returns, as `split` does, leaving one it borrows to its owner. An offset it returns, from `rfind` or `match_indices`, counts UTF-8 bytes, as Rust's does, and so does one `&s[a..b]` or `&s[a..=b]` takes, which reads the string up to it and panics as std -does inside a char, where `get` gives `None`. A JS string can't change in place, so `String`'s edits, `push_str`, `truncate`, -`insert`, `retain`, `replace_range`, and the rest, assign the edited one to the local or -field the `&mut` borrows, taking and checking byte offsets as std does, and `retain` then -drops its closure. `+`, of a `String`, is JS's `+` of the moved text, as `+=` is, and of a -`Cow` takes either side whole when the other is empty, as std's does. A `&mut str` is -the `rs.Place` of its `String` wherever that is, and a part of one, from `&mut s[a..b]`, +does inside a char, where `get` gives `None`. A `String` is an object, so a `&mut` to one +is that object, and its edits, `push_str`, `truncate`, `insert`, `retain`, +`replace_range`, and the rest, change it in place, taking and checking byte offsets as +std does, and `retain` then drops its closure. Each grows its capacity as `RawVec` grows +a `Vec`'s, by `reserve` of what it adds, or by `push` of each char where std's pushes +each, and `with_capacity`, `reserve`, `reserve_exact`, `shrink_to`, and their `try_` forms +are std's, so `capacity` reads std's. What makes a new one gives it std's room: exactly +its bytes from `to_owned`, `clone`, `join`, and `to_string` of text, a `char`, a `bool`, +or an unsigned integer; a signed integer's most digits and its sign; `format!`'s +estimate, and growth by each write from none for any other `to_string`; the first +item's of a `collect` of `String`s; and std's own reserve and pushes for `replace`, +`to_lowercase`, `from_utf16`, `from_utf8_lossy`, and the rest. `+`, of a `String`, pushes +onto the moved one, as `+=` does, and of a `Cow` takes either side whole when the +other is empty, as std's does. A `&mut str` of a `String` is the `String`, an `rs.Place` +of its text, and a part of one, from `&mut s[a..b]`, `get_mut`, or `split_at_mut`, is `rs.strPart(p, a, b)`, a place of its own that writes the whole string anew, checking its offsets as `&s[a..b]` does. `as_bytes_mut`, `get_unchecked_mut`, and `str::from_utf8_mut` are refused. `extend` and `collect` read their iterator by `for_each`, as std's do, and of chars first reserve its size hint's lower bound, which panics past `isize::MAX`. A `drain` holds the `&mut`'s place and writes the string without the drained text as it drops, so one that -`mem::forget` leaks leaves it as it was, as std's does. A `String` keeps no capacity: -`with_capacity`, `reserve`, and `shrink_to_fit` do nothing, and `capacity` is refused. A `Cow` keeps its +`mem::forget` leaks leaves it as it was, as std's does. A `Cow` keeps its variant in its class, so a `match` reads it, and `to_mut` of a borrowed one stores what it owns in the `Cow`'s place before lending it: a `Cow<[T]>`'s clone of its slice, or a -`Cow`'s text, which a `String` is, so the `&mut` borrows the `Cow`'s own place. A +`Cow`'s `String` of its text, which the `&mut` is. A `Cow<[T]>`'s `clone_from` of an owned one over an owned one clones into the `Vec` it owns, keeping its buffer, as std's does. `Cow::is_borrowed` and `is_owned` are unstable, and refused. @@ -484,7 +494,7 @@ one kept other than in a local, counts as a write into what it points at. A writ not change in place what it passes to or gets from the translation either. A `&mut` to a value JS copies, which no JS value can point at, such as a number, an -`Option`, an enum, a tuple, a `Box`, or a `String`, is an `rs.Place` whose `v` reads and +`Option`, an enum, a tuple, or a `Box`, is an `rs.Place` whose `v` reads and writes where it points. Where it is only read and written through, in the function that borrows it, it is the place it borrows, so a body that passes none on makes none. Passed on, returned, kept in a field, or captured by a value, it is @@ -709,11 +719,8 @@ of them: `Clone`, `Deref`, `AsRef`, `PartialEq` with bytes, `Default`, `Debug`, and `From` between it and `Vec`, `String`, `&'static [u8]`, and `&'static str` map to `rs/bytes.ts`, panicking as `bytes` does, and so do `split_to`, `split_off`, - `truncate`, `clear`, and `slice_ref`, whose panic names no addresses. A `String`'s - bytes are in storage of its capacity, which JS keeps none of, so where any crate makes a - `Bytes` or a `Vec` of them, every crate is refused what reads a `Bytes`' capacity: - `is_unique`, `try_into_mut`, `truncate`, `clear`, `From` into a `BytesMut` or a - `Vec`, and `put` of a `Buf` but a `BytesMut` or a slice into a `BytesMut`. `slice_ref` of + `truncate`, `clear`, and `slice_ref`, whose panic names no addresses. A `Bytes` of a + `String` takes storage of its capacity, as `bytes` does. `slice_ref` of bytes from other storage throws, since Rust may share what JS copied, as a `&'static str`'s bytes that `as_bytes` encodes anew. `Bytes::from_owner` reads its owner's bytes once, as `bytes` does, and is refused for an owner that drops, @@ -912,13 +919,17 @@ they need. the `Some` can already be `undefined`: there it is `rs.None`, as `Pending` is `rs.Pending`, chosen by the type alone, so every function agrees on it. A `rs.None` for every `Option` would cost callers `?.` and `??` everywhere for the few that need it. -- A `Cow` is a JS string, as `str` and `String` are, rather than an object tagged by - its variant: no `Cow` in moq-net or kio tells its variants apart, and a tag would - wrap every value and unwrap it at every read. -- A `Cow<[T]>` is told apart by class, an owned one bare and a borrowed one in an +- A `String` is an `rs.String`, its text as a JS string beside its UTF-8 length and + capacity, rather than a bare JS string, which holds no capacity, or UTF-8 bytes, which + every `Display` and JS boundary would decode. Measured on + [#574](https://github.com/moq-dev/rust2/pull/574), it matched or beat a JS string at + encoding, decoding, and joining, and cost 7-22% writing lines and up to 2.3x in a map + keyed by one, where UTF-8 bytes cost 5.6-9.8x. A `&str` and a `Box` stay JS + strings, which hold all they do. +- A `Cow` is told apart by class, an owned one bare and a borrowed one in an `rs.Borrowed`, so it clones and drops as std's does and only the borrowed side pays a - wrapper. Untagged, as `Cow` is, `to_mut` would clone on every call and a `match` - would be refused; tagged, every `Cow` would be wrapped. + wrapper. Untagged, `to_mut` would clone on every call and a `match` would be refused; + tagged, every `Cow` would be wrapped. - A `Duration` keeps std's fields, whole seconds and nanoseconds, rather than one count of nanoseconds, so its overflow, `checked_*`, and ordering are std's exactly, and a lowering of its methods from core's MIR would read the same fields. diff --git a/ts/bench/main.ts b/ts/bench/main.ts index cf36fccdb..db7a827f4 100644 --- a/ts/bench/main.ts +++ b/ts/bench/main.ts @@ -359,7 +359,7 @@ function render(): string { `- moq: ${text(["git", "-C", checkout, "rev-parse", "HEAD"])}`, ...engines.map((e) => `- ${e.engine}`), "", - "Each cell is nanoseconds per item (a varint, a frame header, a message, a byte iterated, a key, a timestamp converted, added, or compared, a line formatted, or a step): the median", + "Each cell is nanoseconds per item (a varint, a frame header, a message, a byte iterated, a key, a timestamp converted, added, or compared, a line formatted, a step, or a string coded, joined, or keyed): the median", `of ${rounds} samples of at least ${sampleMs} ms, ± half their interquartile range. Each round runs`, `the JS routes and workloads in a new random order, from seed ${seed}. \`native\` is a release`, "build on the host, its workloads in a fixed order. `wasm` is the same", @@ -368,7 +368,8 @@ function render(): string { "`js/net`, called as its own benchmarks call it, for `iter/` the same chain with ES", "iterator helpers (`bench/iter.ts`), for `btree/` a sorted array (`bench/sorted.ts`), for `hash/` a `Map` (`bench/hashed.ts`), and", "for `time/` conversions `bigint`, as moq's `js/hang` converts timescales (`bench/rescale.ts`),", - "for `time/checked-add` and `time/ord` moq's own `Timestamp` (`bench/timestamp.ts`), for `fmt/` a template literal (`bench/fmt.ts`), and for `parts/` a plain array (`bench/parts.ts`).", + "for `time/checked-add` and `time/ord` moq's own `Timestamp` (`bench/timestamp.ts`), for `fmt/` a template literal (`bench/fmt.ts`), for `parts/` a plain array (`bench/parts.ts`), and for `str/`", + "moq's Writer and Cursor, a template literal, and a `Map` (`bench/strings.ts`).", "Each JS route and `wasm` runs alone in a worker of its own, a fresh one each round. `A/A` is the translation again: its", "gap from `translated` is the noise. A `reads` decode is the frame headers above as they", "arrive that many bytes at a time, so a header cut by a read comes up short and is", diff --git a/ts/bench/moq.ts b/ts/bench/moq.ts index a30f39eda..b2487a67d 100644 --- a/ts/bench/moq.ts +++ b/ts/bench/moq.ts @@ -18,6 +18,7 @@ import { order } from "./order.ts"; import { hashed } from "./hashed.ts"; import { packets } from "./packets.ts"; import { parts } from "./parts.ts"; +import { decodeStrings, encodeStrings, join, keyed } from "./strings.ts"; import { push } from "./push.ts"; import { rescale } from "./rescale.ts"; import { ordered } from "./sorted.ts"; @@ -77,6 +78,14 @@ export function run(input: Uint8Array): Uint8Array | Promise { return format(data); case 17: return parts(selector, data); + case 18: + return encodeStrings(selector, data, Lite.DRAFT_06); + case 19: + return decodeStrings(data, Lite.DRAFT_06); + case 20: + return join(selector, data); + case 21: + return keyed(selector, data); default: throw new Error(`unknown workload ${op}`); } diff --git a/ts/bench/strings.ts b/ts/bench/strings.ts new file mode 100644 index 000000000..ca1a92614 --- /dev/null +++ b/ts/bench/strings.ts @@ -0,0 +1,79 @@ +// The `str/` workloads' hand-written route: `bench.rs`'s ops 18 to 21, as moq's TypeScript +// codes a path through its Writer and Cursor, joins it with a template literal, and keys a +// `Map` by it. + +import { Cursor, type StreamVersion, Writer } from "moq/js/net/src/stream.ts"; + +const NAMES = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; +const TRACKS = ["video", "audio", "catalog.json", "字幕"]; +const encoder = new TextEncoder(); + +/** Op 18: the `selector`th name, as many times as `data`'s count, each size-prefixed. */ +export function encodeStrings(selector: number, data: Uint8Array, version: StreamVersion): Promise { + const count = Number(u64(data, 0)); + const name = NAMES[selector % NAMES.length] as string; + return Writer.collect(version, async (w) => { + for (let i = 0; i < count; i++) await w.string(name); + }); +} + +/** Op 19: every string on the wire. */ +export function decodeStrings(wire: Uint8Array, version: StreamVersion): Uint8Array { + const cursor = new Cursor(wire, version); + let count = 0; + let total = 0; + let last = ""; + while (cursor.remaining > 0) { + const start = cursor.offset; + last = cursor.string(); + total += cursor.offset - start; + count++; + } + const size = encoder.encode(last).byteLength; + // Each prefix is the one byte of a QUIC varint under 64. + return u64s(count, total - count, size); +} + +/** Op 20: each path joined and stripped of its name. */ +export function join(selector: number, data: Uint8Array): Uint8Array { + const count = Math.min(Number(u64(data, 0)), 1 << 16); + const name = NAMES[selector % NAMES.length] as string; + // Rust counts UTF-8 bytes: each part's, measured once. + const nameLen = encoder.encode(name).byteLength; + const trackLens = TRACKS.map((t) => encoder.encode(t).byteLength); + let total = 0; + let stripped = 0; + for (let i = 0; i < count; i++) { + const track = TRACKS[i % TRACKS.length] as string; + const path = `${name}/${track}`; + const trackLen = trackLens[i % TRACKS.length] as number; + total += nameLen + 1 + trackLen; + if (path.startsWith(name) && path[name.length] === "/") stripped += trackLen; + } + return u64s(total, stripped); +} + +/** Op 21: each path a key of a `Map`, looked up four times. */ +export function keyed(selector: number, data: Uint8Array): Uint8Array { + const count = Math.min(Number(u64(data, 0)), 1 << 16); + const name = NAMES[selector % NAMES.length] as string; + const keys = Array.from({ length: count }, (_, i) => `${name}/${i}`); + const map = new Map(); + keys.forEach((key, i) => map.set(key, i)); + let sum = 0; + for (let round = 0; round < 4; round++) for (const key of keys) sum += map.get(key) ?? 0; + return u64s(sum, map.size); +} + +function u64(data: Uint8Array, i: number): bigint { + const bytes = new Uint8Array(8); + bytes.set(data.subarray(i * 8, i * 8 + 8)); + return new DataView(bytes.buffer).getBigUint64(0); +} + +function u64s(...values: number[]): Uint8Array { + const out = new Uint8Array(values.length * 8); + const view = new DataView(out.buffer); + values.forEach((v, i) => view.setBigUint64(i * 8, BigInt(v))); + return out; +} diff --git a/ts/bench/workloads.ts b/ts/bench/workloads.ts index 1b7790d07..82a74a00c 100644 --- a/ts/bench/workloads.ts +++ b/ts/bench/workloads.ts @@ -5,7 +5,7 @@ export interface Workload { /** What is coded, such as `varint/quic/2B` or `frames/video/lite-07`, iterated, or converted. */ name: string; - op: "encode" | "decode" | "iterate" | "map" | "convert" | "add" | "compare" | "order" | "push" | "number" | "format" | "write" | "handoff"; + op: "encode" | "decode" | "iterate" | "map" | "convert" | "add" | "compare" | "order" | "push" | "number" | "format" | "write" | "join" | "handoff"; /** Varints, frame headers, messages, items, keys, timestamps, integers, packets, lines, steps, or handoffs per call, which each time is divided by. */ items: number; input: Uint8Array; @@ -129,6 +129,15 @@ export function workloads(encode: (input: Uint8Array) => Uint8Array): Workload[] out.push({ name: `parts/${name}/${size}`, op: "write", items: count, input }); } } + + // `bench.rs`'s ops 18 to 21 over a broadcast path, ASCII or not: coded as moq-net codes + // one, joined to a track and stripped, and a `HashMap`'s keys. + const strings = 256; + ["ascii", "utf8"].forEach((name, selector) => { + pair(`str/${name}`, strings, 18, selector, [BigInt(strings)]); + out.push({ name: `str/join/${name}`, op: "join", items: strings, input: Uint8Array.of(20, selector, ...u64(BigInt(strings))) }); + out.push({ name: `str/keyed/${name}`, op: "map", items: strings, input: Uint8Array.of(21, selector, ...u64(BigInt(strings))) }); + }); return out; } diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 9430b1ac3..3f88f1708 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -10,7 +10,7 @@ import type * as EncodeError from "./coding/encode.EncodeError.ts"; import * as Encoder from "./coding/encode.Encoder.ts"; import { zigzag as varint_zigzag, unzigzag } from "./coding/varint.ts"; import * as Form from "./coding/varint.Form.ts"; -import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, map$1haiqd3 as option_map$1haiqd3, mapOr$1glsik0 as option_mapOr$1glsik0 } from "./core/option.ts"; +import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, map$1haiqd3 as option_map$1haiqd3, mapOr$1glsik0 as option_mapOr$1glsik0 } from "./core/option.ts"; import { form, liteVersion, putU64 as harness_putU64, putUsize, takeU64, decodeError, encodeError } from "./harness.ts"; import * as Group from "./lite/group.Group.ts"; import type * as lite_version_Version from "./lite/version.Version.ts"; @@ -56,6 +56,14 @@ export function run(input: rs.ByteSlice): rs.ByteVec { format(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 17) { parts(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 18) { + encoded(encodeStrings(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 19) { + decoded(decodeStrings(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out), out); + } else if (op === 20) { + join(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); + } else if (op === 21) { + keyed(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { decoded(decodeGroup(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } @@ -501,7 +509,7 @@ export function push(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void */ export function format(data: rs.ByteSlice, out: rs.ByteVec): void { const count2: rs.i64 = rs.i64Cast(rs.u64Min(takeU64(data)[0], 65536)); - let s: string = ""; + const s: rs.String = rs.stringNew(); const iter: rs.Range = new rs.Range(0, count2, rs.i64Step); while (true) { const _14: rs.i64 | rs.Done = iter.next(); @@ -513,14 +521,153 @@ export function format(data: rs.ByteSlice, out: rs.ByteVec): void { const _26: rs.f64 = rs.i64ToF64(i) / 3.0; const _29: rs.i64 = rs.i64Neg(i); const args3 = [(f: rs.Formatter) => rs.i64Display(i, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => rs.f64Display(_26, f), (f: rs.Formatter) => rs.i64Display(_29, f)]; - s = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 6 }, args3[0]), "|", args3[1], "|", rs.fmtSpec({ precision: 2 }, args3[2]), "|", args3[3], "\n"]).s; + rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 6 }, args3[0]), "|", args3[1], "|", rs.fmtSpec({ precision: 2 }, args3[2]), "|", args3[3], "\n"]); } - putUsize(out, rs.stringLen(s)); - harness_putU64(out, rs.iterSum(rs.iterMap(rs.strBytes(s), (a0: rs.u8): rs.u64 => { + putUsize(out, s.len); + harness_putU64(out, rs.iterSum(rs.iterMap(rs.strBytes(s.v), (a0: rs.u8): rs.u64 => { return a0 as rs.u64; }), rs.u64Add, 0)); } +/** + * The `selector`th name of [`NAMES`], `count` times, each size-prefixed, as moq-net's + * `Encoder::string` writes a path. + */ +export function encodeStrings(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): rs.Result { + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, rs.sliceFrom(["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]).length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const w: Encoder.Encoder = Encoder.new(out, { tag: "Quic" } as Form.Form); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = rs.u64Low(count); + while (true) { + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + if (!(iterStart++ < iterEnd)) { + break; + } + const _24: rs.Result = Encoder.string(w, _7[_8]); + if (!_24.ok) { + return _24; + } + } + return rs.OK; +} + +/** + * Every string on the wire, each an owned `String`, as moq-net decodes a path: how many, + * their total length, and the last one's. + */ +export function decodeStrings(wire: rs.ByteSlice, out: rs.ByteVec): rs.Result { + const r: Decoder.Decoder = Decoder.new(wire, { tag: "Quic" } as Form.Form); + let count: rs.usize = 0; + let total: rs.usize = 0; + let last: rs.String = rs.stringNew(); + while (!Decoder.isEmpty(r)) { + const _10: rs.Result = Decoder.string(r); + if (_10.ok) { + last = _10.value; + total = rs.usizeAdd(total, last.len); + count = rs.usizeAdd(count, 1); + } else { + return _10; + } + } + putUsize(out, count); + putUsize(out, total); + putUsize(out, last.len); + return rs.OK; +} + +/** + * `count` paths, each the `selector`th name of [`NAMES`] and a track joined into a + * `String` sized up front, as moq-net's `Path::concat` builds one, then stripped of the + * name at a segment boundary, as `Path::strip_prefix` is: their total length, and the + * stripped tracks'. + */ +export function join(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _25!: rs.usize; + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, rs.sliceFrom(["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]).length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + let total: rs.usize = 0; + let stripped: rs.usize = 0; + const _19: rs.usize = rs.u64Low(rs.u64Min(count, 65536)); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _19; + while ((_25 = iterStart++) < iterEnd) { + const _31: rs.usize = rs.usizeRem(_25, rs.sliceFrom(["video", "audio", "catalog.json", "字幕"]).length); + if (!(_31 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _31); + } + const _30: string[] = ["video", "audio", "catalog.json", "字幕"]; + const path: rs.String = rs.stringWithCapacity(rs.usizeAdd(rs.usizeAdd(rs.stringLen(_7[_8]), 1), rs.stringLen(_30[_31]))); + rs.stringPushStr(path, _7[_8]); + rs.stringPush(path, 47); + rs.stringPushStr(path, _30[_31]); + total = rs.usizeAdd(total, path.len); + const _53: string | undefined = rs.strStripPrefix(path.v, _7[_8]); + if (_53 !== undefined) { + const _58: string | undefined = rs.strStripPrefix(_53, "/"); + if (_58 !== undefined) { + stripped = rs.usizeAdd(stripped, rs.stringLen(_58)); + } + } + } + putUsize(out, total); + putUsize(out, stripped); +} + +/** + * `count` paths, the `selector`th name of [`NAMES`] and a number, each a key of a + * `HashMap` and looked up by its `&str` four times, as moq-net finds a broadcast by its + * path: the sum of what the lookups found. + */ +export function keyed(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const count: rs.u64 = takeU64(data)[0]; + const _8: rs.usize = rs.usizeRem(selector as rs.usize, rs.sliceFrom(["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]).length); + if (!(_8 < 2)) { + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _8); + } + const _7: string[] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + const keys: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u64Low(rs.u64Min(count, 65536))), (i2: rs.u32): rs.String => { + const part = _7[_8]; + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, part), (f: rs.Formatter) => rs.u32Display(i2, f)]; + return rs.fmtFormat([args3[0], "/", args3[1]]); + }), undefined, 12, true); + const map: rs.HashMap = rs.hashNew(rs.HASH_TEXT) as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.String]> = rs.iterEnumerate(rs.iterSlice(keys.items)); + while (true) { + const _32: [rs.usize, rs.String] | rs.Done = iter.next(); + if (_32 === rs.DONE) { + break; + } + const i: rs.usize = _32[0]; + const _39: rs.String = rs.stringClone(_32[1]); + rs.hashInsert(map, _39, i as rs.u64); + } + let sum: rs.u64 = 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 4; + l3: while (iterStart++ < iterEnd) { + const iterS: rs.String[] = keys.items; + let iterI: number = 0; + while (true) { + const _51: rs.String | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_51 === rs.DONE) { + continue l3; + } + sum = rs.u64Add(sum, option_unwrapOr$15hbiwd(rs.hashGet(map, (_51.v as unknown) as rs.String), 0)); + } + } + harness_putU64(out, sum); + putUsize(out, rs.hashLen(map)); +} + /** * `count` TS packets of 188 bytes, each written by element through `as_chunks_mut`, then * numbered by continuity counter as moq-mux's `container/ts/export.rs` numbers them; with diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index 702625c71..e24464964 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -241,13 +241,13 @@ export function bytes(self: Decoder): DecodeError.DecodeError | undefined { } /** Read a varint length, then that many bytes of UTF-8. */ -export function string(self: Decoder): rs.Result { +export function string(self: Decoder): rs.Result { const err: DecodeError.DecodeError | undefined = bytes(self); const part: Uint8Array = out$ref_slice_u8.pData; const part2: number = out$ref_slice_u8.pStart; const part3: number = out$ref_slice_u8.pLen; if (err === undefined) { - const _2: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(new rs.ByteSlice(part, part2, part3))); + const _2: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(new rs.ByteSlice(part, part2, part3))); if (_2.ok) { return rs.Ok(_2.value); } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index 0bc416c84..783750699 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -114,10 +114,10 @@ export function encodeFailed(out: rs.ByteVec, err: EncodeError.EncodeError): voi } /** An error's thiserror `Display` and derived `Debug`, which callers see. */ -export function putText(out: rs.ByteVec, display: string, debug: string): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(display)); +export function putText(out: rs.ByteVec, display: rs.String, debug: rs.String): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(display.v)); rs.byteVecPush(out, 0); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(debug)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(debug.v)); rs.byteVecPush(out, 0); } @@ -278,9 +278,9 @@ export function decodeStep(r: Decoder.Decoder, step: rs.u8, out: rs.ByteVec): rs return rs.Err(err3 as DecodeError.DecodeError); } } else if (_5 === 6) { - const _49: rs.Result = Decoder.string(r); + const _49: rs.Result = Decoder.string(r); if (_49.ok) { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_49.value)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_49.value.v)); } else { return _49; } @@ -362,9 +362,9 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n const _51: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.u64ToBeBytes(value)), 0, rs.u8Rem(rs.u8Div(step, 10), 9) as rs.usize); result = Encoder.bytes(w, _51); } else if (_33 === 6) { - const _60: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rs.byteSliceFrom(rs.u64ToBeBytes(value)))); + const _60: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rs.byteSliceFrom(rs.u64ToBeBytes(value)))); if (_60.ok) { - result = Encoder.string(w, _60.value); + result = Encoder.string(w, _60.value.v); } else { result = Encoder.string(w, "not utf-8"); } @@ -574,7 +574,7 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, } else if (_10 === 3) { err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError } as DecodeError.DecodeError; } else if (_10 === 4) { - const _20: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data2)); + const _20: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data2)); if (_20.ok) { err = { tag: "Missing" } as DecodeError.DecodeError; } else { @@ -585,7 +585,7 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, } else { if (_10 === 6) { const arg = {}; - const _26: string = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); + const _26: rs.String = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); const arg2 = {}; const args7 = [(f: rs.Formatter) => BoundsExceeded.fmt$fmt_Debug(arg2, f)]; putText(out, _26, rs.fmtFormat([args7[0], " ", rs.fmtSpec({ alternate: true }, args7[0])])); diff --git a/ts/fixtures/codec/src/bench.rs b/ts/fixtures/codec/src/bench.rs index c1b2b2843..bbaa6f09d 100644 --- a/ts/fixtures/codec/src/bench.rs +++ b/ts/fixtures/codec/src/bench.rs @@ -6,8 +6,10 @@ //! keeps a `BTreeMap`, as moq-net's model keeps its state, op 9 converts timestamps //! between timescales, ops 10 and 11 add and order them as moq-net's `Timestamp` does, //! op 12 orders integers by std's own `Ord`, op 13 pushes onto vectors, op 14 keeps a -//! `HashMap`, op 15 numbers TS packets as moq-mux does, op 16 formats log lines, and op 17 -//! writes through the mutable parts of a slice of integers. +//! `HashMap`, op 15 numbers TS packets as moq-mux does, op 16 formats log lines, op 17 +//! writes through the mutable parts of a slice of integers, ops 18 and 19 code strings as +//! moq-net codes a path, op 20 joins and strips paths, and op 21 keeps a `HashMap` keyed +//! by `String`. use std::cmp::Ordering; use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, VecDeque}; @@ -45,6 +47,10 @@ pub fn run(input: &[u8]) -> Vec { 15 => packets(selector, data, &mut out), 16 => format(data, &mut out), 17 => parts(selector, data, &mut out), + 18 => encoded(encode_strings(selector, data, &mut out), &mut out), + 19 => decoded(decode_strings(data, &mut out), &mut out), + 20 => join(selector, data, &mut out), + 21 => keyed(selector, data, &mut out), _ => decoded(decode_group(data, lite_version(selector), &mut out), &mut out), } out @@ -337,6 +343,90 @@ fn format(data: &[u8], out: &mut Vec) { put_u64(out, s.bytes().map(u64::from).sum()); } +/// Broadcast paths as moq names them: one ASCII, and one with chars of two, three, and four +/// bytes. +const NAMES: [&str; 2] = ["demo/room-42/alice/camera", "démo/salle-42/アリス/📷"]; + +/// The tracks `join` appends to a broadcast's path. +const TRACKS: [&str; 4] = ["video", "audio", "catalog.json", "字幕"]; + +/// The `selector`th name of [`NAMES`], `count` times, each size-prefixed, as moq-net's +/// `Encoder::string` writes a path. +fn encode_strings(selector: u8, data: &[u8], out: &mut Vec) -> Result<(), EncodeError> { + let (count, _) = take_u64(data); + let name = NAMES[selector as usize % NAMES.len()]; + let mut w = Encoder::new(out, Form::Quic); + for _ in 0..count as usize { + w.string(name)?; + } + Ok(()) +} + +/// Every string on the wire, each an owned `String`, as moq-net decodes a path: how many, +/// their total length, and the last one's. +fn decode_strings(wire: &[u8], out: &mut Vec) -> Result<(), DecodeError> { + let mut r = Decoder::new(wire, Form::Quic); + let mut count = 0; + let mut total = 0; + let mut last = String::new(); + while !r.is_empty() { + last = r.string()?; + total += last.len(); + count += 1; + } + put_usize(out, count); + put_usize(out, total); + put_usize(out, last.len()); + Ok(()) +} + +/// `count` paths, each the `selector`th name of [`NAMES`] and a track joined into a +/// `String` sized up front, as moq-net's `Path::concat` builds one, then stripped of the +/// name at a segment boundary, as `Path::strip_prefix` is: their total length, and the +/// stripped tracks'. +fn join(selector: u8, data: &[u8], out: &mut Vec) { + let (count, _) = take_u64(data); + let name = NAMES[selector as usize % NAMES.len()]; + let mut total = 0; + let mut stripped = 0; + for i in 0..count.min(1 << 16) as usize { + let track = TRACKS[i % TRACKS.len()]; + let mut path = String::with_capacity(name.len() + 1 + track.len()); + path.push_str(name); + path.push('/'); + path.push_str(track); + total += path.len(); + if let Some(rest) = path.strip_prefix(name) + && let Some(rest) = rest.strip_prefix('/') + { + stripped += rest.len(); + } + } + put_usize(out, total); + put_usize(out, stripped); +} + +/// `count` paths, the `selector`th name of [`NAMES`] and a number, each a key of a +/// `HashMap` and looked up by its `&str` four times, as moq-net finds a broadcast by its +/// path: the sum of what the lookups found. +fn keyed(selector: u8, data: &[u8], out: &mut Vec) { + let (count, _) = take_u64(data); + let name = NAMES[selector as usize % NAMES.len()]; + let keys: Vec = (0..count.min(1 << 16) as u32).map(|i| format!("{name}/{i}")).collect(); + let mut map = HashMap::new(); + for (i, key) in keys.iter().enumerate() { + map.insert(key.clone(), i as u64); + } + let mut sum = 0u64; + for _ in 0..4 { + for key in &keys { + sum += map.get(key.as_str()).copied().unwrap_or(0); + } + } + put_u64(out, sum); + put_usize(out, map.len()); +} + /// A pair `format` writes with its derived `Debug`. #[derive(Debug)] struct Point { diff --git a/ts/fixtures/crates/dep/Cargo.toml b/ts/fixtures/crates/dep/Cargo.toml index 1885525be..f715c28b6 100644 --- a/ts/fixtures/crates/dep/Cargo.toml +++ b/ts/fixtures/crates/dep/Cargo.toml @@ -6,8 +6,5 @@ edition.workspace = true license.workspace = true publish = false -[dependencies] -bytes = "1.12.1" - [lints] workspace = true diff --git a/ts/fixtures/crates/dep/src/lib.rs b/ts/fixtures/crates/dep/src/lib.rs index 893c10b74..9bfac05e4 100644 --- a/ts/fixtures/crates/dep/src/lib.rs +++ b/ts/fixtures/crates/dep/src/lib.rs @@ -1,7 +1,6 @@ //! The dependency `crates-fixture` translates with: a type the package copies, which only //! this crate writes into, a generic function over the package's type, drops, an iterator, -//! `unsafe` with a safe twin where it translates and without one, a trait for objects, and -//! a `Bytes` of a `String`'s bytes. +//! `unsafe` with a safe twin where it translates and without one, and a trait for objects. use std::sync::{Arc, Mutex}; @@ -171,9 +170,3 @@ pub fn tally(tallies: &mut [&mut dyn Tally], by: u8) -> u32 { } sum } - -/// A `String`'s bytes, in storage of its capacity, which JS keeps none of, so the package's -/// reads of a `Bytes`' capacity are refused too. -pub fn string_bytes(text: String) -> bytes::Bytes { - bytes::Bytes::from(text) -} diff --git a/ts/fixtures/crates/src/lib.rs b/ts/fixtures/crates/src/lib.rs index bb760c241..84d42731e 100644 --- a/ts/fixtures/crates/src/lib.rs +++ b/ts/fixtures/crates/src/lib.rs @@ -20,11 +20,6 @@ pub fn alike() -> u8 { } one(fmt::Error) + one(std::fmt::Error) } -/// Whether the dependency's `Bytes` of a `String`'s bytes is the one handle of its storage, -/// which the `String`'s capacity decides: translation refuses it, as the bytes cross crates. -pub fn unique(text: String) -> bool { - ::crates_dep::string_bytes(text).is_unique() -} #[cfg(target_arch = "wasm32")] #[path = "../../wasm.rs"] diff --git a/ts/fixtures/crates/strings.toml b/ts/fixtures/crates/strings.toml deleted file mode 100644 index 6e0d17dac..000000000 --- a/ts/fixtures/crates/strings.toml +++ /dev/null @@ -1,4 +0,0 @@ -# A `Bytes` of a `String`'s bytes that the dependency makes, and the package's read of its -# capacity: `strings.txt` holds the error. -package = "crates-fixture" -roots = ["unique"] diff --git a/ts/fixtures/crates/strings.txt b/ts/fixtures/crates/strings.txt deleted file mode 100644 index 465023241..000000000 --- a/ts/fixtures/crates/strings.txt +++ /dev/null @@ -1 +0,0 @@ -fixtures/crates/src/lib.rs:unique+1:35: `Bytes::is_unique` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index 54a89a3d9..5f6dccd39 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -10,7 +10,7 @@ import { isSomeAnd$1s2u5lz, unwrapOr$0yvilko as option_unwrapOr$0yvilko, unwrapO /** Each byte an operation, its value the operand; each puts what it read. */ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { - let s!: string; + let s!: rs.String; for (const op of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(op, 5); if (_10 === 0) { @@ -59,18 +59,18 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { s = rs.fmtFormat([args20[0], " ", args20[1]]); } else if (_10 === 2) { const captured = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u8Display(op, f)]); - const words: string[] = rs.arrayFromFn(3, (i2: rs.usize): string => { - const args18 = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.usizeDisplay(i2, f)]; + const words: rs.String[] = rs.arrayFromFn(3, (i2: rs.usize): rs.String => { + const args18 = [(f: rs.Formatter) => rs.fmtPad(f, captured.v), (f: rs.Formatter) => rs.usizeDisplay(i2, f)]; return rs.fmtFormat([args18[0], args18[1]]); }); - const _79: string[] = rs.arrayFromFn(0, (i3: rs.usize): string => { - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(i3, f)); + const _79: rs.String[] = rs.arrayFromFn(0, (i3: rs.usize): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(i3, f), 0); }); - const _83: rs.Slice = rs.sliceFrom(words); - [_83, rs.sliceFrom(_79)] as [rs.Slice, rs.Slice]; - const _86: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_83), f, rs.fmtStr); + const _83: rs.Slice = rs.sliceFrom(words); + [_83, rs.sliceFrom(_79)] as [rs.Slice, rs.Slice]; + const _86: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_83), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)); const arg2 = rs.sliceFrom(_79); - const args19 = [_86, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, rs.fmtStr)]; + const args19 = [_86, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; s = rs.fmtFormat([args19[0], " ", args19[1]]); } else if (_10 === 3) { const grid: Uint8Array[] = rs.arrayFromFn(3, (i: rs.usize): Uint8Array => { @@ -91,7 +91,7 @@ export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { const args13 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(_107), f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_109), f, rs.usizeDebug)]; s = rs.fmtFormat([args13[0], " ", args13[1]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); rs.byteVecPush(out, 10); } } @@ -121,7 +121,7 @@ export function counted$5(op: rs.u8): rs.usize[] { * and of arrays, each element the closure's own to change. */ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { - let s!: string; + let s!: rs.String; for (const op of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(op, 5); if (_10 === 0) { @@ -159,29 +159,29 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const _47: Uint8Array = rs.bytesMap([], (w2: rs.u16): rs.u8 => { return w2 & 0xff; }); - const _48: string[] = rs.arrayMap([], (n: rs.u32): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(n, f)); + const _48: rs.String[] = rs.arrayMap([], (n: rs.u32): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(n, f), 0); }); const _52: rs.Slice = rs.sliceFrom(_46); - [_52, rs.byteSliceFrom(_47), rs.sliceFrom(_48)] as [rs.Slice, rs.ByteSlice, rs.Slice]; + [_52, rs.byteSliceFrom(_47), rs.sliceFrom(_48)] as [rs.Slice, rs.ByteSlice, rs.Slice]; const _56: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_52), f, rs.u16Debug); const arg4 = rs.byteSliceFrom(_47); const _57: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg4), f, rs.u8Debug); const arg5 = rs.sliceFrom(_48); - const args23 = [_56, _57, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg5), f, rs.fmtStr)]; + const args23 = [_56, _57, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg5), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; s = rs.fmtFormat([args23[0], " ", args23[1], " ", args23[2]]); } else if (_10 === 2) { const captured = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u8Display(op, f)]); - const words2: string[] = rs.arrayMap(Uint8Array.of(1, 2, 3), (i: rs.u8): string => { - const args20 = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.u8Display(i, f)]; + const words2: rs.String[] = rs.arrayMap(Uint8Array.of(1, 2, 3), (i: rs.u8): rs.String => { + const args20 = [(f: rs.Formatter) => rs.fmtPad(f, captured.v), (f: rs.Formatter) => rs.u8Display(i, f)]; return rs.fmtFormat([args20[0], args20[1]]); }); const arg3 = rs.sliceFrom(words2); - const shown: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.fmtStr)]); - const _89: rs.ByteSlice = rs.byteSliceFrom(rs.bytesMap(words2, (w: string): rs.u8 => { - return rs.u8Add(rs.stringLen(w) & 0xff, rs.u8Rem(op, 3)); + const shown: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]); + const _89: rs.ByteSlice = rs.byteSliceFrom(rs.bytesMap(words2, (w: rs.String): rs.u8 => { + return rs.u8Add(w.len & 0xff, rs.u8Rem(op, 3)); })); - const args22 = [(f: rs.Formatter) => rs.fmtPad(f, shown), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_89), f, rs.u8Debug)]; + const args22 = [(f: rs.Formatter) => rs.fmtPad(f, shown.v), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_89), f, rs.u8Debug)]; s = rs.fmtFormat([args22[0], " ", args22[1]]); } else if (_10 === 3) { const options: Array = [op, undefined, rs.u8WrappingAdd(op, 60)]; @@ -239,7 +239,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const args15 = [_140, _141, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_138), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_133), f, rs.u64Debug)]; s = rs.fmtFormat([args15[0], " ", args15[1], " ", args15[2], " ", args15[3], " ", args15[4]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); rs.byteVecPush(out, 10); } } @@ -261,7 +261,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return 0; }); - const words: string[] = ["", ""]; + const words: rs.String[] = [rs.stringNew(), rs.stringNew()]; const item = copy$array_u8(rs.bytes(2)); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); @@ -297,12 +297,12 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { _40[0].v = _40[1].v; _40[1].v = swapped; } else if (_21 === 2) { - const _49: rs.Place[] = rs.slicePlaces(rs.sliceFrom(words)); + const _49: rs.String[] = rs.arrayFrom(words); const _51: rs.usize = rs.usizeRem(i, 2); if (!(_51 < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _51); } - _49[_51].v = _49[_51].v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + rs.stringPush(_49[_51], rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_21 === 3) { const rows: rs.ByteSlice[] = rs.arrayMap(grid, rs.byteSliceFrom); const _61: rs.usize = rs.usizeRem(i, 2); @@ -338,8 +338,8 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { } _99.v = op; } - const lens: Uint8Array = rs.bytesMap(rs.arrayFrom(words), (w: string): rs.u8 => { - return rs.stringLen(w) & 0xff; + const lens: Uint8Array = rs.bytesMap(rs.arrayFrom(words), (w: rs.String): rs.u8 => { + return w.len & 0xff; }); const rows2: Uint8Array = rs.bytesMap(rs.arrayMap(grid, rs.byteSliceFrom), (row: rs.ByteSlice): rs.u8 => { return row.data[row.start] ^ row.data[row.start + 1]; @@ -363,21 +363,21 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { const _140: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_137), f, rs.u8Debug); const arg = rs.sliceFrom(wides); const args5 = [_140, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_134), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2]]).v)); } } - [rs.byteSliceFrom(bytes), rs.sliceFrom(wide), rs.sliceFrom(words), rs.sliceFrom(grid), rs.sliceFrom(pairs)] as [rs.ByteSlice, rs.Slice, rs.Slice, rs.Slice, rs.Slice]; + [rs.byteSliceFrom(bytes), rs.sliceFrom(wide), rs.sliceFrom(words), rs.sliceFrom(grid), rs.sliceFrom(pairs)] as [rs.ByteSlice, rs.Slice, rs.Slice, rs.Slice, rs.Slice]; const arg2 = rs.byteSliceFrom(bytes); const _158: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); const arg3 = rs.sliceFrom(wide); const _159: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg3), f, rs.u16Debug); const arg4 = rs.sliceFrom(words); - const _160: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg4), f, rs.fmtStr); + const _160: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg4), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)); const arg5 = rs.sliceFrom(grid); const _161: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg5), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); const arg6 = rs.sliceFrom(pairs); const args6 = [_158, _159, _160, _161, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg6), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4]]).v)); } /** @@ -389,7 +389,7 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.u16[] = Array.from({ length: 3 }, (): rs.u16 => { return 0; }); - const words: string[] = ["", ""]; + const words: rs.String[] = [rs.stringNew(), rs.stringNew()]; const item = copy$array_u8(rs.bytes(2)); const grid: Uint8Array[] = Array.from({ length: 3 }, (): Uint8Array => { return copy$array_u8(item); @@ -417,10 +417,10 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { _35.data[_35.start + _37] = (_32 << 7) & 0xffff; rs.sliceRotateRight(rs.sliceFrom(wide), 1); } else if (_22 === 2) { - const _46: rs.Slice = rs.sliceFrom(words); + const _46: rs.Slice = rs.sliceFrom(words); const _48: rs.usize = rs.usizeRem(i, 2); rs.idx(_46, _48); - _46.data[_46.start + _48] = _46.data[_46.start + _48] + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + rs.stringPush(_46.data[_46.start + _48], rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_22 === 3) { const _59: rs.Slice = rs.sliceFrom(grid); const _61: rs.usize = rs.usizeRem(i, 3); @@ -460,13 +460,13 @@ export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { } const _143: rs.ByteSlice = rs.byteSliceFrom(bytes); const _146: rs.Slice = rs.sliceFrom(wide); - const _149: rs.Slice = rs.sliceFrom(words); + const _149: rs.Slice = rs.sliceFrom(words); const _152: rs.Slice = rs.sliceFrom(grid); const _155: rs.Slice = rs.sliceFrom(pairs); const _158: rs.Slice = rs.sliceFrom([]); const _161: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of()); - const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " ", args3[5], " ", args3[6]]))); + const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_146), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_149), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_152), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_155), f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_158), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " ", args3[5], " ", args3[6]]).v)); } /** Arrays lent by `&mut`, written through their slices. */ @@ -748,7 +748,7 @@ export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -863,7 +863,7 @@ export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -978,7 +978,7 @@ export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -1093,7 +1093,7 @@ export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Slice = rs.sliceFrom([rs.byteSliceView(rs.byteSliceFrom(b))]); const _192: rs.ByteSlice = rs.byteSliceFrom(a); const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_190), f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { return rs.u8Rem(d2, 3) === 0; })) { @@ -1128,12 +1128,12 @@ export function fields(data: rs.ByteSlice, out: rs.ByteVec): void { held.bytes[0] = held.bytes[0] ^ 16; put$3(out, rs.sliceFrom([copy$array_u8(a), old, copy$array_u8(held.bytes)])); const part = { _0: copy$array_u8(held.bytes) }; - const shown: string = rs.fmtFormat([(f: rs.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]); + const shown: rs.String = rs.fmtFormat([(f: rs.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]); const _41: rs.ByteSlice = rs.byteSliceFrom(held.bytes); const taken2 = rs.byteSliceToArray(_41); _41.data.set(rs.bytes(3), _41.start); put$3(out, rs.sliceFrom([taken2, copy$array_u8(held.bytes)])); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown.v)); if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d: rs.u8): boolean => { return rs.u8Rem(d, 3) === 1; })) { @@ -1232,7 +1232,7 @@ export function flattened(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi flattenedN$5(data, out); } const part = rs.sliceFrom([{ _0: bytesAt$3(data, 1) }, { _0: undefined }]); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: Listed.Listed, f: rs.Formatter) => Listed.fmt$fmt_Debug(value, f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: Listed.Listed, f: rs.Formatter) => Listed.fmt$fmt_Debug(value, f))]).v)); } /** [`flattened`] of `N` bytes. */ diff --git a/ts/fixtures/lang/ascii/expected/ascii.Held.ts b/ts/fixtures/lang/ascii/expected/ascii.Held.ts index c5f7fcf96..e438ea48a 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.Held.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.Held.ts @@ -5,7 +5,7 @@ import * as rs from "./rs.ts"; /** A struct whose fields change case where they are. */ export interface Held { n: rs.u8; - text: string; + text: rs.String; } //# sourceMappingURL=ascii.Held.ts.map diff --git a/ts/fixtures/lang/ascii/expected/ascii.ts b/ts/fixtures/lang/ascii/expected/ascii.ts index 7f8db8d59..afe435ca6 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.ts @@ -2,7 +2,7 @@ import * as rs from "./rs.ts"; import type * as Held from "./ascii.Held.ts"; -import { isSomeAnd$1s2u5lz, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0p20wlb as option_mapOr$0p20wlb, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i } from "./core/option.ts"; +import { isSomeAnd$1s2u5lz, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0p20wlb as option_mapOr$0p20wlb, mapOr$188iunt as option_mapOr$188iunt, asDeref$0wpj87j as option_asDeref$0wpj87j } from "./core/option.ts"; import { put } from "./harness.ts"; /** Each test of `b`, a bit apiece. */ @@ -27,8 +27,9 @@ export function lowerChar(c: rs.Place): void { c.v = rs.toAsciiLowercase(c.v); } -export function upperText(s: rs.Place): void { - s.v = rs.strToAsciiUppercase(s.v); +export function upperText(s: rs.String): void { + const _3: rs.Place = s; + _3.v = rs.strToAsciiUppercase(_3.v); } /** @@ -57,12 +58,10 @@ export function steps$ascii_EscapeDefault(e: rs.Iter, data: rs.ByteSlice, } if (next !== undefined) { rs.byteVecPush(out, next); - let shown: string = ""; + const shown: rs.String = rs.stringNew(); const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f)]; - const written = rs.fmtWriteString(shown, [args3[0]]); - shown = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug); - put(out, shown); + rs.resultUnwrap(rs.fmtWriteString(shown, [args3[0]]), rs.fmtErrorDebug); + put(out, shown.v); i = rs.usizeAdd(i, 1); } else { return; @@ -139,18 +138,16 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } const b3: rs.u8 = _101; const e: rs.Iter = rs.escapeAscii(b3); - let shown: string = ""; + const shown: rs.String = rs.stringNew(); const _113: rs.Iter = rs.escapeAscii(b3); const _115: rs.usize = rs.iterCount(e.clone()); const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.fmtEscapeAscii(_113, f), (f: rs.Formatter) => rs.usizeDisplay(_115, f)]; - const written = rs.fmtWriteString(shown, [args3[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args3[1]), "|", args3[2]]); - shown = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug); - put(out, shown); + rs.resultUnwrap(rs.fmtWriteString(shown, [args3[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args3[1]), "|", args3[2]]), rs.fmtErrorDebug); + put(out, shown.v); rs.iterExtendBytes(out, e.clone(), "next"); rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); rs.byteVecPush(out, rs.optionUnwrap(rs.iterLast(e.clone()))); - rs.byteVecPush(out, rs.stringLen(rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f))) & 0xff); + rs.byteVecPush(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f)).len & 0xff); } } const iter6: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); @@ -252,48 +249,52 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceMakeAsciiUppercase(rs.byteSliceFrom(array)); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(array)); } else if (_10 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const _95 of rs.byteSliceView(data)) { const _103: rs.usize = rs.usizeRem(_95 as rs.usize, rs.sliceFrom([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111]).length); if (!(_103 < 41)) { rs.panic("index out of bounds: the len is " + 41 + " but the index is " + _103); } - s = s + String.fromCodePoint([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111][_103]); + rs.stringPush(s, [0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111][_103]); } - const mid: rs.usize = option_unwrapOr$05jq4mv(rs.iterFind(rs.iterRev(new rs.RangeInclusive(0, rs.usizeDiv(rs.stringLen(s), 2), rs.usizeStep)), (_2: rs.usize): boolean => { - return rs.strIsCharBoundary(s, _2); + const mid: rs.usize = option_unwrapOr$05jq4mv(rs.iterFind(rs.iterRev(new rs.RangeInclusive(0, rs.usizeDiv(s.len, 2), rs.usizeStep)), (_2: rs.usize): boolean => { + return rs.strIsCharBoundary(s.v, _2); }), 0); - const _124: string = rs.strSlice(s, 0, mid); - const _127: string = rs.strSlice(s, mid); - rs.byteVecPush(out, rs.strIsAscii(s) ? 1 : 0); + const _124: string = rs.strSlice(s.v, 0, mid); + const _127: string = rs.strSlice(s.v, mid); + rs.byteVecPush(out, rs.strIsAscii(s.v) ? 1 : 0); rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, _127) ? 1 : 0); - rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, rs.strToAsciiUppercase(_127)) ? 1 : 0); - put(out, rs.strToAsciiUppercase(s)); - put(out, rs.stringExtendChars("", rs.iterFilter(rs.strChars(s), (a0: rs.char): boolean => { + rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, rs.stringFrom(rs.strToAsciiUppercase(_127)).v) ? 1 : 0); + put(out, rs.stringFrom(rs.strToAsciiUppercase(s.v)).v); + const _154: rs.Iter = rs.iterFilter(rs.strChars(s.v), (a0: rs.char): boolean => { return rs.isAsciiAlphanumeric(a0); - }))); - put(out, rs.strToAsciiLowercase(s)); - put(out, rs.strTrimAsciiStart(s)); - put(out, rs.strTrimAsciiEnd(s)); - put(out, rs.strTrimAscii(s)); - let t: string = s; - t = rs.strToAsciiUppercase(t); - put(out, t); - t = rs.strToAsciiLowercase(t); - put(out, t); + }); + put(out, rs.stringExtendChars(rs.stringNew(), _154).v); + put(out, rs.stringFrom(rs.strToAsciiLowercase(s.v)).v); + put(out, rs.strTrimAsciiStart(s.v)); + put(out, rs.strTrimAsciiEnd(s.v)); + put(out, rs.strTrimAscii(s.v)); + const t: rs.String = rs.stringClone(s); + const _179: rs.Place = t; + _179.v = rs.strToAsciiUppercase(_179.v); + put(out, t.v); + const _186: rs.Place = t; + _186.v = rs.strToAsciiLowercase(_186.v); + put(out, t.v); const held: Held.Held = { n: 0, text: t }; - upperText(rs.place(() => held.text, (value) => held.text = value)); - put(out, held.text); - held.text = rs.strToAsciiLowercase(held.text); - put(out, held.text); + upperText(held.text); + put(out, held.text.v); + const _198: rs.Place = held.text; + _198.v = rs.strToAsciiLowercase(_198.v); + put(out, held.text.v); held.n = rs.toAsciiUppercase(held.n); rs.byteVecPush(out, held.n); } else if (_10 === 2) { const e: rs.Iter = rs.byteSliceEscapeAscii(data); - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f)).v); const _221: rs.usize = rs.iterCount(e.clone()); const args3 = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.usizeDisplay(_221, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 40 }, args3[0]), "|", args3[1]])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 40 }, args3[0]), "|", args3[1]]).v); rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(e.clone()), 255)); } else { @@ -316,7 +317,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } if (next !== undefined) { rs.byteVecPush(out, next); - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e2, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e2, f)).v); rs.iterExtendBytes(out, e2.clone(), "next"); i = rs.usizeAdd(i, 1); } else { @@ -368,50 +369,52 @@ export function parts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _10: [rs.usize, rs.usize] = [at(0), at(1)]; const a: rs.usize = _10[0]; const b: rs.usize = _10[1]; - let s: string = text; - const pair: [rs.u8, string] = [7, text]; - const array: string[] = ["q", text]; - const v: rs.Vec = rs.vecFrom([text, text]); + const s: rs.String = rs.stringFrom(text); + const pair: [rs.u8, rs.String] = [7, rs.stringFrom(text)]; + const array: rs.String[] = [rs.stringFrom("q"), rs.stringFrom(text)]; + const v: rs.Vec = rs.vecFrom([rs.stringFrom(text), rs.stringFrom(text)]); const _32: rs.u8 = rs.u8Rem(kind, 8); if (_32 === 0) { - s = rs.strToAsciiUppercase(s); - put(out, s); - const _41: rs.Place = rs.strPart(rs.place(() => s, (value15) => s = value15), a, b); + const _35: rs.Place = s; + _35.v = rs.strToAsciiUppercase(_35.v); + put(out, s.v); + const _41: rs.Place = rs.strPart(s, a, b); _41.v = rs.strToAsciiLowercase(_41.v); - put(out, s); + put(out, s.v); } else if (_32 === 1) { - pair[1] = rs.strToAsciiUppercase(pair[1]); - put(out, pair[1]); - const _54: rs.Place = rs.strPart(rs.place(() => pair[1], (value14) => pair[1] = value14), a); + const _48: rs.Place = pair[1]; + _48.v = rs.strToAsciiUppercase(_48.v); + put(out, pair[1].v); + const _54: rs.Place = rs.strPart(pair[1], a); _54.v = rs.strToAsciiLowercase(_54.v); - put(out, pair[1]); + put(out, pair[1].v); rs.byteVecPush(out, pair[0]); } else if (_32 === 2) { - array[1] = rs.strToAsciiUppercase(array[1]); - put(out, array[1]); - const _73: rs.Place = rs.strPart(rs.place(() => array[1], (value13) => array[1] = value13), 0, b); + const _63: rs.Place = array[1]; + _63.v = rs.strToAsciiUppercase(_63.v); + put(out, array[1].v); + const _73: rs.Place = rs.strPart(array[1], 0, b); _73.v = rs.strToAsciiLowercase(_73.v); - put(out, array[1]); - put(out, array[0]); + put(out, array[1].v); + put(out, array[0].v); } else if (_32 === 3) { - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(v.items)); + const iter: rs.Iter = rs.iterSlice(v.items); while (true) { - const _93: rs.Place | rs.Done = iter.next(); + const _93: rs.String | rs.Done = iter.next(); if (_93 === rs.DONE) { break; } - _93.v = rs.strToAsciiUppercase(_93.v); + const _98: rs.Place = _93; + _98.v = rs.strToAsciiUppercase(_98.v); } - const at6 = rs.idx(v.items, 0); - const _100: rs.Place = rs.strPart(rs.place(() => v.items[at6], (value11) => v.items[at6] = value11), 0); + const _100: rs.Place = rs.strPart(v.items[rs.idx(v.items, 0)], 0); _100.v = rs.strToAsciiLowercase(_100.v); - const at7 = rs.idx(v.items, 1); - const _105: rs.Place = rs.strPart(rs.place(() => v.items[at7], (value12) => v.items[at7] = value12), a, b); + const _105: rs.Place = rs.strPart(v.items[rs.idx(v.items, 1)], a, b); _105.v = rs.strToAsciiLowercase(_105.v); - put(out, v.items[rs.idx(v.items, 0)]); - put(out, v.items[rs.idx(v.items, 1)]); + put(out, v.items[rs.idx(v.items, 0)].v); + put(out, v.items[rs.idx(v.items, 1)].v); } else if (_32 === 4) { - const _119: [rs.Place, rs.Place] = rs.strSplitAtMut(rs.place(() => s, (value10) => s = value10), a); + const _119: [rs.Place, rs.Place] = rs.strSplitAtMut(s, a); _119[0].v = rs.strToAsciiUppercase(_119[0].v); _119[1].v = rs.strToAsciiUppercase(_119[1].v); _119[0].v = rs.strToAsciiLowercase(_119[0].v); @@ -421,38 +424,37 @@ export function parts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { _131[1].v = rs.strToAsciiLowercase(_131[1].v); put(out, _131[0].v); put(out, _131[1].v); - put(out, s); + put(out, s.v); } else if (_32 === 5) { - putUpper(out, rs.strGetMut(rs.place(() => s, (value7) => s = value7), a, b)); - putUpper(out, rs.strGetMut(rs.place(() => pair[1], (value8) => pair[1] = value8), a)); - const at4 = rs.idx(v.items, 1); - putUpper(out, rs.strGetMut(rs.place(() => v.items[at4], (value9) => v.items[at4] = value9), 0, b)); - put(out, s); - put(out, pair[1]); - put(out, v.items[rs.idx(v.items, 1)]); + putUpper(out, rs.strGetMut(s, a, b)); + putUpper(out, rs.strGetMut(pair[1], a)); + putUpper(out, rs.strGetMut(v.items[rs.idx(v.items, 1)], 0, b)); + put(out, s.v); + put(out, pair[1].v); + put(out, v.items[rs.idx(v.items, 1)].v); } else if (_32 === 6) { - const _168: [rs.Place, rs.Place] | undefined = rs.strSplitAtMutChecked(rs.place(() => array[1], (value5) => array[1] = value5), a); + const _168: [rs.Place, rs.Place] | undefined = rs.strSplitAtMutChecked(array[1], a); if (_168 === undefined) { rs.byteVecPush(out, 253); } else { _168[1].v = rs.strToAsciiUppercase(_168[1].v); putUpper(out, rs.strGetMut(_168[0], rs.min(b, rs.stringLen(_168[0].v)))); } - put(out, array[1]); - let held: string | undefined = text; - const _191: rs.Place | undefined = held === undefined ? undefined : rs.place(() => held as string, (value6) => held = value6); + put(out, array[1].v); + const held: rs.String | undefined = rs.stringFrom(text); + const _191: rs.String | undefined = held; if (_191 !== undefined) { - _191.v = rs.strToAsciiUppercase(_191.v); + const _196: rs.Place = _191; + _196.v = rs.strToAsciiUppercase(_196.v); } - put(out, option_unwrapOr$1iemzn8(option_asDeref$0w8at8i(held), "-")); + put(out, option_unwrapOr$1iemzn8(option_asDeref$0wpj87j(held), "-")); } else { - const at2 = rs.idx(v.items, 1); - upperPart(rs.strPart(rs.place(() => v.items[at2], (value) => v.items[at2] = value), a), 0, rs.usizeSaturatingSub(b, a)); - put(out, v.items[rs.idx(v.items, 1)]); - upperPart(rs.place(() => s, (value2) => s = value2), a, b); - put(out, rs.strPart(rs.place(() => s, (value3) => s = value3), 0, a).v); - put(out, rs.strPart(rs.place(() => s, (value4) => s = value4), a).v); - const leaked: rs.Place = { v: pair[1] }; + upperPart(rs.strPart(v.items[rs.idx(v.items, 1)], a), 0, rs.usizeSaturatingSub(b, a)); + put(out, v.items[rs.idx(v.items, 1)].v); + upperPart(s, a, b); + put(out, rs.stringFrom(rs.strPart(s, 0, a).v).v); + put(out, rs.stringFrom(rs.strPart(s, a).v).v); + const leaked: rs.Place = pair[1]; const _234: rs.Place = rs.strPart(leaked, rs.min(b, a)); _234.v = rs.strToAsciiUppercase(_234.v); put(out, leaked.v); diff --git a/ts/fixtures/lang/ascii/expected/core/option.ts b/ts/fixtures/lang/ascii/expected/core/option.ts index 40c09ab17..d7d77c238 100644 --- a/ts/fixtures/lang/ascii/expected/core/option.ts +++ b/ts/fixtures/lang/ascii/expected/core/option.ts @@ -30,11 +30,11 @@ export function unwrapOr$05jq4mv(self: rs.usize | undefined, default_: rs.usize) return self; } -export function map$1uo1d4o(self: string | undefined, _: (a0: string) => string): string | undefined { +export function map$06og5bz(self: rs.String | undefined, _: (a0: rs.String) => string): string | undefined { if (self === undefined) { return undefined; } - return self; + return self.v; } export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { @@ -58,9 +58,9 @@ export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a return f(self); } -export function asDeref$0w8at8i(self: string | undefined): string | undefined { - return map$1uo1d4o(self, (a0: string): string => { - return a0; +export function asDeref$0wpj87j(self: rs.String | undefined): string | undefined { + return map$06og5bz(self, (a0: rs.String): string => { + return a0.v; }); } diff --git a/ts/fixtures/lang/borrows/expected/borrows.Parts.ts b/ts/fixtures/lang/borrows/expected/borrows.Parts.ts index b39700456..dceb6dadf 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Parts.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Parts.ts @@ -9,13 +9,13 @@ import type * as Tagged from "./borrows.Tagged.ts"; */ export class Parts { n: rs.u32; - text: string; + text: rs.String; bytes: rs.ByteVec; tagged: Tagged.Tagged; maybe: rs.u16 | undefined; quad: Uint8Array; - constructor(n: rs.u32, text: string, bytes: rs.ByteVec, tagged: Tagged.Tagged, maybe: rs.u16 | undefined, quad: Uint8Array) { + constructor(n: rs.u32, text: rs.String, bytes: rs.ByteVec, tagged: Tagged.Tagged, maybe: rs.u16 | undefined, quad: Uint8Array) { this.n = n; this.text = text; this.bytes = bytes; diff --git a/ts/fixtures/lang/borrows/expected/borrows.ts b/ts/fixtures/lang/borrows/expected/borrows.ts index 4f3760045..cf5bfa9ec 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.ts @@ -178,7 +178,7 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const part3 = new rs.BorrowMutError(); const args5 = [(f: rs.Formatter) => rs.borrowMutErrorDisplay(part3, f), (f: rs.Formatter) => rs.borrowMutErrorDebug(part3, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); } if (_116.ok) { drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_116); @@ -192,7 +192,7 @@ export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const part4 = new rs.BorrowError(); const args6 = [(f: rs.Formatter) => rs.borrowErrorDisplay(part4, f), (f: rs.Formatter) => rs.borrowErrorDebug(part4, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v)); } if (_141.ok) { drop$Result_cell_Ref_Vec_u8_cell_BorrowError(_141); @@ -313,7 +313,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const tag: (a0: rs.u8) => Tagged.Tagged = (id: rs.u8): Tagged.Tagged => { return new Tagged.Tagged(id, 0, rs.arcClone(log)); }; - const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, "", new rs.ByteVec(), tag(1), undefined, rs.bytes(4))); + const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, rs.stringNew(), new rs.ByteVec(), tag(1), undefined, rs.bytes(4))); const number: rs.RefCell = new rs.RefCell(0); const bytes4: rs.RefCell = new rs.RefCell(Uint8Array.of(1, 2, 3, 4)); const slot: rs.RefCell = new rs.RefCell(undefined as Tagged.Tagged | undefined); @@ -322,7 +322,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { if (_29 === 0) { const _32: rs.RefCell = rs.refCellBorrowMut(parts); const n: rs.RefCell = rs.refMutMap(_32, ((p16: Parts.Parts): rs.Place => { - return rs.place(() => p16.n, (value8) => p16.n = value8); + return rs.place(() => p16.n, (value6) => p16.n = value6); })(_32.value)); n.value = rs.u32Add(n.value, op as rs.u32); rs.byteVecPush(out, borrowed$borrows_Parts(parts)); @@ -348,17 +348,18 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.refRelease(_78); } else if (_29 === 1) { const _81: rs.RefCell = rs.refCellBorrowMut(parts); - const text: rs.RefCell = rs.refMutMap(_81, ((p15: Parts.Parts): rs.Place => { - return rs.place(() => p15.text, (value7) => p15.text = value7); - })(_81.value)); - text.value = text.value + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + const text: rs.RefCell = rs.refMutMap(_81, rs.partPlace(((p15: Parts.Parts): rs.String => { + return p15.text; + })(_81.value))); + rs.stringPush(text.value, rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); if ((op >> 4) === 15) { - text.value = "z"; + const _95: rs.String = rs.stringFrom("z"); + text.value = _95; } - rs.byteVecPush(out, rs.stringLen(text.value) & 0xff); + rs.byteVecPush(out, text.value.len & 0xff); rs.refMutRelease(text); const _110: rs.RefCell = rs.refCellBorrow(parts); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_110.value.text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_110.value.text.v)); rs.refRelease(_110); } else if (_29 === 2) { const _113: rs.RefCell = rs.refCellBorrowMut(parts); @@ -395,7 +396,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_29 === 3) { const _170: rs.RefCell = rs.refCellBorrowMut(parts); const _169: rs.Result, rs.RefCell> = rs.refMutFilterMap(_170, ((p11: Parts.Parts): rs.Place | undefined => { - return p11.maybe === undefined ? undefined : rs.place(() => p11.maybe as rs.u16, (value6) => p11.maybe = value6); + return p11.maybe === undefined ? undefined : rs.place(() => p11.maybe as rs.u16, (value5) => p11.maybe = value5); })(_170.value)); if (_169.ok) { const m: rs.RefCell = _169.value; @@ -461,13 +462,14 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } else if (_29 === 5) { const _274: rs.RefCell = rs.refCellBorrowMut(parts); - const _273: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_274, ((p8: Parts.Parts): [rs.Place, rs.Place] => { - return [rs.place(() => p8.n, (value4) => p8.n = value4), rs.place(() => p8.text, (value5) => p8.text = value5)] as [rs.Place, rs.Place]; - })(_274.value)); + const parts3 = ((p8: Parts.Parts): [rs.Place, rs.String] => { + return [rs.place(() => p8.n, (value4) => p8.n = value4), p8.text] as [rs.Place, rs.String]; + })(_274.value); + const _273: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_274, [parts3[0], rs.partPlace(parts3[1])]); const n3: rs.RefCell = _273[0]; - const text2: rs.RefCell = _273[1]; + const text2: rs.RefCell = _273[1]; n3.value = rs.u32Add(n3.value, 1); - text2.value = text2.value + "s"; + rs.stringPush(text2.value, 115); rs.byteVecPush(out, borrowed$borrows_Parts(parts)); if (!((op & 16) === 0)) { rs.refMutRelease(text2); @@ -483,11 +485,11 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_305, _311.value.n & 0xff))); rs.refRelease(_311); const _316: rs.RefCell = rs.refCellBorrowMut(parts); - const parts3 = ((p9: Parts.Parts): [rs.ByteSlice, rs.ByteSlice] => { + const parts4 = ((p9: Parts.Parts): [rs.ByteSlice, rs.ByteSlice] => { const half: rs.usize = rs.usizeDiv(p9.bytes.length, 2); return rs.byteSliceSplitAt(rs.byteVecSlice(p9.bytes), half); })(_316.value); - const _315: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_316, [rs.partPlace(parts3[0]), rs.partPlace(parts3[1])]); + const _315: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_316, [rs.partPlace(parts4[0]), rs.partPlace(parts4[1])]); const low: rs.RefCell = _315[0]; const high: rs.RefCell = _315[1]; const _318: rs.Place | undefined = rs.sliceFirstMut(low.value); @@ -531,8 +533,8 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { drop$Result_cell_Ref_u32_cell_Ref_borrows_Parts(_f); } else if (_341 === 15) { const _365: rs.RefCell = rs.refCellBorrow(parts); - const _364: [rs.RefCell, rs.RefCell] = rs.refMapSplit(_365, ((p4: Parts.Parts): [rs.u32, string] => { - return [p4.n, p4.text] as [rs.u32, string]; + const _364: [rs.RefCell, rs.RefCell] = rs.refMapSplit(_365, ((p4: Parts.Parts): [rs.u32, rs.String] => { + return [p4.n, p4.text] as [rs.u32, rs.String]; })(_365.value)); const _a: rs.RefCell = _364[0]; rs.refRelease(_364[1]); @@ -544,7 +546,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { } else { const _373: rs.RefCell = rs.refCellBorrow(parts); const text3: rs.RefCell = rs.refMap(_373, ((p: Parts.Parts): string => { - return p.text; + return p.text.v; })(_373.value)); const _376: rs.RefCell = rs.refCellBorrowMut(number); const n4: rs.RefCell = rs.refMutMap(_376, ((n5: rs.Place): rs.Place => { @@ -553,7 +555,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { const _387: string = text3.value; const _390: rs.u32 = rs.u32Add(n4.value, 1); const args3 = [(f: rs.Formatter) => rs.fmtPad(f, _387), (f: rs.Formatter) => rs.u32Display(_390, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1]]).v)); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(borrowed$borrows_Parts(parts), borrowed$u32(number)))); drop$tuple2_cell_Ref_str_cell_RefMut_u32([text3, n4] as [rs.RefCell, rs.RefCell]); const _411: rs.RefCell = rs.refCellBorrowMut(parts); @@ -611,7 +613,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(last2.n & 0xff, last2.tagged.id, option_mapOr$031uhqp(last2.maybe, 253, (m2: rs.u16): rs.u8 => { return m2 & 0xff; })))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text.v)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last2.bytes)); last2[Symbol.dispose](); slot[Symbol.dispose](); @@ -627,7 +629,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { */ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); - const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, "", new rs.ByteVec(), new Tagged.Tagged(1, 0, rs.arcClone(log)), undefined, Uint8Array.of(1, 2, 3, 4))); + const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, rs.stringNew(), new rs.ByteVec(), new Tagged.Tagged(1, 0, rs.arcClone(log)), undefined, Uint8Array.of(1, 2, 3, 4))); const number: rs.RefCell = new rs.RefCell(0); for (const op of rs.byteSliceView(data)) { const _23: rs.u8 = rs.u8Rem(op, 4); @@ -729,10 +731,10 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } else if (_23 === 2) { const _175: rs.RefCell = rs.refCellBorrowMut(parts); - _175.value.text = _175.value.text + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + rs.stringPush(_175.value.text, rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); rs.refMutRelease(_175); const _183: rs.RefCell = rs.refCellBorrow(parts); - const text: rs.RefCell = rs.refMap(_183, ((p3: Parts.Parts): string => { + const text: rs.RefCell = rs.refMap(_183, ((p3: Parts.Parts): rs.String => { return p3.text; })(_183.value)); const _186: rs.RefCell = rs.refCellBorrow(parts); @@ -740,15 +742,15 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.byteSliceFrom(p4.quad); })(_186.value))); const n2: rs.RefCell = rs.refCellBorrow(number); - const args13 = [(f: rs.Formatter) => rs.fmtPad(f, text.value), (f: rs.Formatter) => rs.fmtStr(text.value, f), (f: rs.Formatter) => rs.fmtList(quad.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(n2.value, f), (f: rs.Formatter) => rs.u32Display(n2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args13[0], " ", args13[1], " [", rs.fmtSpec({ align: ">", width: 4 }, args13[0]), "] ", args13[2], " ", rs.fmtSpec({ alternate: true }, args13[3]), " ", args13[3], " ", rs.fmtSpec({ align: ">", width: 5 }, args13[4])]))); - drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32([text, quad, n2] as [rs.RefCell, rs.RefCell, rs.RefCell]); + const args13 = [(f: rs.Formatter) => rs.fmtPad(f, text.value.v), (f: rs.Formatter) => rs.fmtStr(text.value.v, f), (f: rs.Formatter) => rs.fmtList(quad.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(n2.value, f), (f: rs.Formatter) => rs.u32Display(n2.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args13[0], " ", args13[1], " [", rs.fmtSpec({ align: ">", width: 4 }, args13[0]), "] ", args13[2], " ", rs.fmtSpec({ alternate: true }, args13[3]), " ", args13[3], " ", rs.fmtSpec({ align: ">", width: 5 }, args13[4])]).v)); + drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32([text, quad, n2] as [rs.RefCell, rs.RefCell, rs.RefCell]); const _211: rs.RefCell = rs.refCellBorrowMut(parts); const maybe: rs.RefCell = rs.refMutMap(_211, ((p5: Parts.Parts): rs.Place => { return rs.place(() => p5.maybe, (value2) => p5.maybe = value2); })(_211.value)); const args14 = [(f: rs.Formatter) => rs.fmtOption(maybe.value, f, rs.u16Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0])]).v)); rs.refMutRelease(maybe); const _227: rs.RefCell = rs.refCellBorrowMut(parts); const bytes2: rs.RefCell = rs.refMutMap(_227, rs.partPlace(((p6: Parts.Parts): rs.ByteVec => { @@ -756,19 +758,19 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { })(_227.value))); const _237: rs.RefCell = rs.refCellBorrowMut(number); const args15 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(_237.value, f)]; - const _233: string = rs.fmtFormat([args15[0], " ", args15[1]]); + const _233: rs.String = rs.fmtFormat([args15[0], " ", args15[1]]); rs.refMutRelease(_237); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_233)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_233.v)); rs.refMutRelease(bytes2); const pair: rs.RefCell<[rs.u8, string]> = new rs.RefCell([op, "pair"] as [rs.u8, string]); const _256: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); - const _252: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_256.value[0], f), (f: rs.Formatter) => rs.fmtStr(_256.value[1], f)], f), " "]); + const _252: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_256.value[0], f), (f: rs.Formatter) => rs.fmtStr(_256.value[1], f)], f), " "]); rs.refRelease(_256); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_252)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_252.v)); const _270: rs.RefCell<[rs.u8, string]> = rs.refCellBorrowMut(pair); - const _266: string = rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_270.value[0], f), (f: rs.Formatter) => rs.fmtStr(_270.value[1], f)], f))]); + const _266: rs.String = rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_270.value[0], f), (f: rs.Formatter) => rs.fmtStr(_270.value[1], f)], f))]); rs.refMutRelease(_270); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_266)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_266.v)); const _277: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); const tried4: rs.Result, [rs.RefCell<[rs.u8, string]>, rs.u8]> = rs.refTryMap(_277, ((p7: [rs.u8, string]): rs.Result => { if (!((p7[0] & 1) === 0)) { @@ -776,7 +778,7 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { } return rs.Ok(p7[1]); })(_277.value)); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried4, f, (value: rs.RefCell, f: rs.Formatter) => rs.fmtStr(value.value, f), (value: [rs.RefCell<[rs.u8, string]>, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0].value[0], f), (f: rs.Formatter) => rs.fmtStr(value[0].value[1], f)], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried4, f, (value: rs.RefCell, f: rs.Formatter) => rs.fmtStr(value.value, f), (value: [rs.RefCell<[rs.u8, string]>, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0].value[0], f), (f: rs.Formatter) => rs.fmtStr(value[0].value[1], f)], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]).v)); drop$Result_cell_Ref_ref_str_tuple2_cell_Ref_tuple2_u8_ref_str_u8(tried4); } else { const _291: rs.u8 = op >> 4; @@ -811,7 +813,7 @@ export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(last2.n & 0xff, option_mapOr$031uhqp(last2.maybe, 253, (m3: rs.u16): rs.u8 => { return m3 & 0xff; })))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text.v)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last2.bytes)); last2[Symbol.dispose](); flush(log.value, out); @@ -1075,7 +1077,7 @@ export function flush(log: rs.Mutex, out: rs.ByteVec): void { * write the cell they lend; and `Cell`s of `Copy` values and an `UnsafeCell`. */ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; const number: rs.RefCell = new rs.RefCell(0); const nested: rs.RefCell>> = new rs.RefCell(rs.vecFrom([new rs.RefCell(0)])); const pair: rs.Cell<[rs.u8, rs.char]> = new rs.Cell([0, 97] as [rs.u8, rs.char]); @@ -1089,13 +1091,13 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { _30.value = rs.u32Add(_30.value, _27); rs.refMutRelease(_30); const args40 = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; - const free: string = rs.fmtFormat([args40[0], " ", rs.fmtSpec({ alternate: true }, args40[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args40[0])]); + const free: rs.String = rs.fmtFormat([args40[0], " ", rs.fmtSpec({ alternate: true }, args40[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args40[0])]); const shared: rs.RefCell = rs.refCellBorrow(number); - const read: string = rs.fmtFormat([(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]); + const read: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]); rs.refRelease(shared); const _held: rs.RefCell = rs.refCellBorrowMut(number); const dynamic: rs.Fmt = (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug); - const args42 = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, read), (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug), (f: rs.Formatter) => dynamic(f)]; + const args42 = [(f: rs.Formatter) => rs.fmtPad(f, free.v), (f: rs.Formatter) => rs.fmtPad(f, read.v), (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug), (f: rs.Formatter) => dynamic(f)]; text = rs.fmtFormat([args42[0], " ", args42[1], " ", args42[2], " ", rs.fmtSpec({ alternate: true }, args42[2]), " ", rs.fmtSpec({ align: ">", width: 16 }, args42[2]), " ", args42[3]]); rs.refMutRelease(_held); } else if (_25 === 1) { @@ -1104,11 +1106,11 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { _75.value.items.push(_77); rs.refMutRelease(_75); const args38 = [(f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; - const free2: string = rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0])]); + const free2: rs.String = rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0])]); const cells: rs.RefCell>> = rs.refCellBorrow(nested); const _95: rs.Vec> = cells.value; const _inner: rs.RefCell = rs.refCellBorrowMut(_95.items[rs.idx(_95.items, rs.usizeSub(cells.value.items.length, 1))]); - const args39 = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, free2.v), (f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; text = rs.fmtFormat([args39[0], " ", args39[1], " ", rs.fmtSpec({ alternate: true }, args39[1])]); rs.refMutRelease(_inner); rs.refRelease(cells); @@ -1116,18 +1118,18 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { const outer: rs.RefCell> = new rs.RefCell(new rs.RefCell(v)); const shared2: rs.RefCell> = rs.refCellBorrow(outer); const args35 = [(f: rs.Formatter) => rs.refCellDebug(shared2.value, f, rs.u8Debug)]; - const free3: string = rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0])]); + const free3: rs.String = rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0])]); rs.refRelease(shared2); const exclusive: rs.RefCell> = rs.refCellBorrowMut(outer); const inner: rs.RefCell = rs.refCellBorrowMut(exclusive.value); const args36 = [(f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(outer, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.u8Debug(inner.value, f)]; - const held: string = rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0]), " ", args36[1], " ", args36[2]]); + const held: rs.String = rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0]), " ", args36[1], " ", args36[2]]); rs.refMutRelease(inner); const _146: rs.RefCell>> = rs.refCellBorrow(nested); const last: rs.RefCell> = rs.refMap(_146, ((n: rs.Vec>): rs.RefCell => { return n.items[rs.idx(n.items, 0)]; })(_146.value)); - const args37 = [(f: rs.Formatter) => rs.fmtPad(f, free3), (f: rs.Formatter) => rs.fmtPad(f, held), (f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(last.value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + const args37 = [(f: rs.Formatter) => rs.fmtPad(f, free3.v), (f: rs.Formatter) => rs.fmtPad(f, held.v), (f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(last.value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; text = rs.fmtFormat([args37[0], " ", args37[1], " ", args37[2], " ", args37[3]]); rs.refRelease(last); rs.refMutRelease(exclusive); @@ -1145,9 +1147,9 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(_204.value, v); rs.refMutRelease(_204); const args32 = [(f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; - const free4: string = rs.fmtFormat([args32[0], " ", rs.fmtSpec({ alternate: true }, args32[0])]); + const free4: rs.String = rs.fmtFormat([args32[0], " ", rs.fmtSpec({ alternate: true }, args32[0])]); const _held2: rs.RefCell = rs.refCellBorrowMut(shown.refcell); - const args33 = [(f: rs.Formatter) => rs.fmtPad(f, free4), (f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; + const args33 = [(f: rs.Formatter) => rs.fmtPad(f, free4.v), (f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; text = rs.fmtFormat([args33[0], " ", args33[1], " ", rs.fmtSpec({ alternate: true }, args33[1])]); rs.refMutRelease(_held2); } else if (_25 === 5) { @@ -1163,12 +1165,12 @@ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { text = rs.fmtFormat([args30[0], " ", rs.fmtSpec({ alternate: true }, args30[0])]); probe[Symbol.dispose](); } else { - const _253: rs.RefCell = new rs.RefCell("s"); + const _253: rs.RefCell = new rs.RefCell(rs.stringFrom("s")); const _256: rs.RefCell = new rs.RefCell(rs.bytes(2).fill(v)); - const args29 = [(f: rs.Formatter) => rs.refCellDebug(_253, f, rs.fmtStr), (f: rs.Formatter) => rs.refCellDebug(_256, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + const args29 = [(f: rs.Formatter) => rs.refCellDebug(_253, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.refCellDebug(_256, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; text = rs.fmtFormat([args29[0], " ", args29[1]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } } diff --git a/ts/fixtures/lang/borrows/expected/lib.ts b/ts/fixtures/lang/borrows/expected/lib.ts index 54bc53e1b..44b4c6b14 100644 --- a/ts/fixtures/lang/borrows/expected/lib.ts +++ b/ts/fixtures/lang/borrows/expected/lib.ts @@ -173,7 +173,7 @@ export function drop$tuple2_cell_Ref_tuple2_u8_ref_str_u8(_1: [rs.RefCell<[rs.u8 rs.refRelease(_1[0]); } -export function drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32(_1: [rs.RefCell, rs.RefCell, rs.RefCell]): void { +export function drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32(_1: [rs.RefCell, rs.RefCell, rs.RefCell]): void { rs.refRelease(_1[0]); rs.refRelease(_1[1]); rs.refRelease(_1[2]); diff --git a/ts/fixtures/lang/boxes/expected/boxes.Owner.ts b/ts/fixtures/lang/boxes/expected/boxes.Owner.ts index 456b3d3e6..35253a420 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.Owner.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.Owner.ts @@ -5,7 +5,7 @@ import * as rs from "./rs.ts"; /** Boxes of values JS copies, held in a struct a `&mut` reaches. */ export interface Owner { n: rs.u32; - s: string; + s: rs.String; nested: rs.u32; } diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index 67f0459c4..e85443637 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -221,7 +221,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceFirst(a), 170)); const _261: rs.ByteSlice = rs.byteSliceFrom(new Uint8Array(0)); const args9 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_261), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args9[0], "|", args9[1], "|", args9[2]])); + put(out, rs.fmtFormat([args9[0], "|", args9[1], "|", args9[2]]).v); } else if (_15 === 2) { const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_24: rs.u8): rs.u16 => { return rs.u16Mul(_24 as rs.u16, 257); @@ -261,7 +261,7 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.eqSlice(rs.same)(collected2, cloned2) ? 1 : 0); rs.byteVecPush(out, rs.cmpSlice(rs.cmp)(collected2, cloned2) & 0xff); rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_slice_u16(collected2), hash$slice_u16(collected2)) ? 1 : 0); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected2), f, rs.u16Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected2), f, rs.u16Debug)]).v); const v3: rs.Vec = rs.vecFrom(rs.sliceItems(fromVec2)); v3.items.push(5); wides(rs.sliceFrom(v3.items), out); @@ -409,11 +409,12 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_634[1]).reverse()), undefined, true); } } else { - const s: string = text(data2); - const fromRef4: string = s; - const fromString: string = s; - const into2: string = s; - const collected4: string = rs.stringExtendChars("", rs.iterRev(rs.strChars(s))); + const s: rs.String = text(data2); + const fromRef4: string = s.v; + const fromString: string = rs.stringClone(s).v; + const into2: string = rs.stringClone(s).v; + const _655: rs.Iter = rs.iterRev(rs.strChars(s.v)); + const collected4: string = rs.stringExtendChars(rs.stringNew(), _655).v; const empty4: string = ""; put(out, fromRef4); put(out, fromString); @@ -422,13 +423,13 @@ export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, empty4); rs.byteVecPush(out, fromRef4 === into2 ? 1 : 0); rs.byteVecPush(out, rs.cmpStr(collected4, fromRef4) & 0xff); - rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_str(fromRef4), hash$str(s)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_str(fromRef4), hash$str(s.v)) ? 1 : 0); const args7 = [(f: rs.Formatter) => rs.fmtPad(f, fromRef4), (f: rs.Formatter) => rs.fmtStr(collected4, f)]; - put(out, rs.fmtFormat([args7[0], "|", args7[1]])); - let back2: string = into2; - back2 = back2 + "!"; - put(out, back2); - put(out, collected4); + put(out, rs.fmtFormat([args7[0], "|", args7[1]]).v); + const back2: rs.String = rs.stringFrom(into2); + rs.stringPush(back2, 33); + put(out, back2.v); + put(out, rs.stringFrom(collected4).v); } } @@ -483,7 +484,7 @@ export function reach(b: Owner.Owner, by: rs.u8): void { } else if (_3 === 2) { bump(rs.place(() => b.nested, (value) => b.nested = value), by); } else { - b.s = b.s + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); + rs.stringPush(b.s, rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } } @@ -496,15 +497,15 @@ export function reach(b: Owner.Owner, by: rs.u8): void { export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let n: rs.u32 = 7; const pair: Uint8Array = Uint8Array.of(1, 2); - let s: string = "b"; + const s: rs.String = rs.stringFrom("b"); let t: string = "aBc/D"; let nested: rs.u32 = 3; let maybe: rs.u32 | undefined = undefined as rs.u32 | undefined; - const held: Owner.Owner = { n: 5, s: "", nested: 9 }; + const held: Owner.Owner = { n: 5, s: rs.stringNew(), nested: 9 }; const v: rs.Vec = rs.vecFrom([1, 2]); let o: rs.u32 | undefined = 4; let res: rs.Result = rs.Ok(2); - let said: rs.Result = rs.Ok("r"); + let said: rs.Result = rs.Ok(rs.stringFrom("r")); const words: rs.Slice = rs.sliceFrom([6, 8]); const someWords: rs.Slice | undefined = rs.sliceFrom([3, 5]); let named: string | undefined = "xY/z"; @@ -547,11 +548,11 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } r2.data[r2.start + _76] = r2.data[r2.start + _76] ^ by; } else if (_58 === 8) { - s = s + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); + rs.stringPush(s, rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } else if (_58 === 9) { - s = s + "!?"; + rs.stringPushStr(s, "!?"); } else if (_58 === 10) { - s = rs.stringInsertStr(s, 0, "<"); + rs.stringInsertStr(s, 0, "<"); } else if (_58 === 11) { shout(rs.place(() => t, (value20) => t = value20), by); } else if (_58 === 12) { @@ -561,7 +562,7 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _94: rs.Place = rs.place(() => t, (value17) => t = value17); _94.v = rs.strToAsciiLowercase(_94.v); } else if (_58 === 14) { - t = rs.strSlice(s, 0); + t = rs.strSlice(s.v, 0); } else if (_58 === 15) { bump(rs.place(() => nested, (value16) => nested = value16), by); } else if (_58 === 16) { @@ -614,9 +615,9 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (res.ok) { res = { ok: true, value: rs.u32WrappingMul(res.value, by as rs.u32) }; } - const _165: rs.Place> = rs.place(() => said, (value12) => said = value12); + const _165: rs.Place> = rs.place(() => said, (value12) => said = value12); if (_165.v.ok) { - _165.v = { ok: true, value: _165.v.value + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char) }; + rs.stringPush(_165.v.value, rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } if (rs.usizeRem(i, 5) === 4) { said = rs.Err(by); @@ -679,21 +680,21 @@ export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(n).reverse()), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pair)); - put(out, s); + put(out, s.v); put(out, t); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(nested).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(maybe, 238)).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(held.n).reverse()), undefined, true); - put(out, held.s); + put(out, held.s.v); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(held.nested).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v.items), (b: rs.u32): Uint8Array => { return rs.u32ToBeBytes(b).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(option_asDeref$13yyv6y(o), 238)).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(result_unwrapOr$1n4fvf5(copied$1m63478(result_asDeref$1qd1pp0(res)), 238)).reverse()), undefined, true); - const _298: rs.Result = said; + const _298: rs.Result = said; if (_298.ok) { - put(out, _298.value); + put(out, _298.value.v); } else { rs.byteVecPush(out, _298.error); } @@ -853,25 +854,27 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _113[0]); rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_113[1]).reverse()), undefined, true); } - let s: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_222: rs.u8): string => { + let s: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_222: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_222))); }), undefined, 12, true).items); - const t: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))), (_223: rs.u8): string => { + const t: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))), (_223: rs.u8): rs.String => { const x11: rs.u8 = _223; return text(rs.byteSliceFrom(Uint8Array.of(x11, x11))); }), undefined, 12, true).items); - s = rs.boxSliceCloneFrom(s, t); - const _138: rs.Place | undefined = rs.sliceFirstMut(s); + s = rs.boxSliceCloneFrom(s, t, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }, undefined, rs.stringCloneFromFn()); + const _138: rs.String | undefined = rs.sliceFirst(s); if (_138 !== undefined) { - _138.v = _138.v + "!"; + rs.stringPush(_138, 33); } - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(s)), rs.iterSlice(rs.sliceItems(t))); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(s)), rs.iterSlice(rs.sliceItems(t))); while (true) { - const _150: string | rs.Done = iter2.next(); + const _150: rs.String | rs.Done = iter2.next(); if (_150 === rs.DONE) { break; } - put(out, _150); + put(out, _150.v); } let l: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_224: rs.u8): Logged.Logged => { return logged(_224 & 126); @@ -909,7 +912,7 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.dropAll(m); flush(log.value, out); let t2: string = "ab"; - t2 = text(data2); + t2 = text(data2).v; put(out, t2); } else if (_23 === 1) { let a2: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); @@ -941,9 +944,9 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const v3: rs.ByteVec = rs.byteSliceToByteVec(data2); rs.byteVecPush(v3, 102); bytes(rs.byteVecSlice(v3), out); - let s2: string = text(data2); - s2 = s2 + "#"; - put(out, s2); + const s2: rs.String = text(data2); + rs.stringPush(s2, 35); + put(out, s2.v); const w2: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_28: rs.u8): rs.u16 => { return rs.u16Add(_28 as rs.u16, 1); }), undefined, 2, true).items); @@ -1016,7 +1019,7 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.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 = text(data2).v; const a6: rs.ByteSlice = rs.stringAsBytes(s3); rs.byteSliceView(a6).reverse(); bytes(a6, out); diff --git a/ts/fixtures/lang/boxes/expected/harness.ts b/ts/fixtures/lang/boxes/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/boxes/expected/harness.ts +++ b/ts/fixtures/lang/boxes/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/capacity/caller.ts b/ts/fixtures/lang/capacity/caller.ts index c62893815..922ae7b2f 100644 --- a/ts/fixtures/lang/capacity/caller.ts +++ b/ts/fixtures/lang/capacity/caller.ts @@ -12,7 +12,9 @@ export { ops, run } from "./lang.ts"; * that a `reserve` gave room past its length, remade from its `Vec` and cleared, which * keeps that room; pushes past pops, a truncate, and a clear of a vector and a heap, * which grow only past the most each held; each way `collects` makes one, of each length - * it tries; and each splice of a vector a run of pushes grew. + * it tries; each splice of a vector a run of pushes grew; and each step of a string, of a + * char and a text of each width, by a few, past what it may hold, and within eight of + * `usize::MAX`, from each way it is made, once pushes grew it. */ const capacityCases = [ ...[["capacity::vecs", 41], ["capacity::deques", 28], ["capacity::heaps", 15]].flatMap(([name, steps]) => @@ -33,6 +35,10 @@ const capacityCases = [ ), ...Array.from({ length: 5 * 2 * 256 }, (_, i) => Uint8Array.of(...op("capacity::vecs"), i % 5, (Math.floor(i / 5) % 2) * 0x11, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 35, Math.floor(i / 10))), ...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)), + ...Array.from({ length: 48 * 4 * 4 }, (_, i) => { + const [step, first, arg] = [i % 48, [0, 0x29, 0x0e, 0x0f][Math.floor(i / 48) % 4], [1, 6, 0xc3, 0xe2][Math.floor(i / 192)]]; + return Uint8Array.of(...op("capacity::strings"), first, 1, 3, 0, 2, 1, 1, step, arg, step, arg ^ 3, 0, 1); + }), ]; export const cases: Uint8Array[] = [...capacityCases]; diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index d9a28c9d8..653b24bd7 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { copy$array_u64, copy$array_usize, copy$tuple2_u64_u8 } from "./lib.ts"; +import { copy$array_ref_str, copy$array_u64, copy$array_usize, copy$tuple2_u64_u8 } from "./lib.ts"; import * as Holds from "./capacity.Holds.ts"; import { then$1b5wr43, then$0tujtct, then$0svbdod, then$17csa2h, then$0g2g1ls } from "./core/bool.ts"; -import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$0avqj0t as option_unwrapOrDefault$0avqj0t, map$1n6i7tn as option_map$1n6i7tn, map$12r4ivp as option_map$12r4ivp, map$03x2fqt as option_map$03x2fqt, map$1o9z3sm as option_map$1o9z3sm, map$1d4d0v7 as option_map$1d4d0v7, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, unwrapOrDefault$0avqj0t as option_unwrapOrDefault$0avqj0t, map$1n6i7tn as option_map$1n6i7tn, map$12r4ivp as option_map$12r4ivp, map$03x2fqt as option_map$03x2fqt, map$1o9z3sm as option_map$1o9z3sm, map$1d4d0v7 as option_map$1d4d0v7, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; import { unwrapOrElse$128e309 as result_unwrapOrElse$128e309, unwrapOrElse$02f6iwg as result_unwrapOrElse$02f6iwg, unwrapOrElse$05mb9nr as result_unwrapOrElse$05mb9nr, unwrapOrElse$0pqj9wx as result_unwrapOrElse$0pqj9wx, unwrapOrElse$01ys8fc as result_unwrapOrElse$01ys8fc } from "./core/result.ts"; /** A length or capacity, as four bytes. */ @@ -314,7 +314,7 @@ export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, d } else { tried = rs.vecTryReserveExact(v, additional2, 1280); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 1280)); } @@ -555,7 +555,7 @@ export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } else { tried = rs.vecTryReserveExact(v, additional2, 16); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 16)); } @@ -796,7 +796,7 @@ export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: n } else { tried = rs.vecTryReserveExact(v, additional2, 2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 2)); } @@ -1035,7 +1035,7 @@ export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: nu } else { tried = rs.byteVecTryReserveExact(v, additional2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, v.length, v.data.length); } @@ -1285,7 +1285,7 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.vecTryReserveExact(v, additional2, 0); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, v.items.length, rs.vecCapacity(v, 0)); } @@ -2466,7 +2466,7 @@ export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, } else { tried = rs.dequeTryReserveExact(q, additional2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2600,7 +2600,7 @@ export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number } else { tried = rs.dequeTryReserveExact(q, additional2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2734,7 +2734,7 @@ export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.dequeTryReserveExact(q, additional2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -2868,7 +2868,7 @@ export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.dequeTryReserveExact(q, additional2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -3014,7 +3014,7 @@ export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen } else { tried = rs.dequeTryReserveExact(q, additional2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } put(out, q.n); put(out, rs.dequeCapacity(q)); @@ -3120,7 +3120,7 @@ export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, } else { tried = rs.vecTryReserveExact(h, additional2, 1280); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 1280)); } @@ -3202,7 +3202,7 @@ export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, } else { tried = rs.vecTryReserveExact(h, additional2, 16); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 16)); } @@ -3284,7 +3284,7 @@ export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.vecTryReserveExact(h, additional2, 2); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 2)); } @@ -3366,7 +3366,7 @@ export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: n } else { tried = rs.vecTryReserveExact(h, additional2, 1); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 1)); } @@ -3450,7 +3450,7 @@ export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: } else { tried = rs.vecTryReserveExact(h, additional2, 0); } - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); } sized(out, h.items.length, rs.vecCapacity(h, 0)); } @@ -3666,7 +3666,7 @@ export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const i: rs.usize = _180[0]; const tried: rs.Result = _180[1][0]; const n: rs.usize = _180[1][1]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]).v), undefined, true); if (!tried.ok) { if (!(i < 2)) { rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i); @@ -3695,4 +3695,252 @@ export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } +/** The char boundary at or before byte `arg` of `s`, modulo its length and one. */ +export function boundary(s: string, arg: rs.u8): rs.usize { + let i: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(rs.stringLen(s), 1)); + while (true) { + if (!rs.strIsCharBoundary(s, i)) { + i = rs.usizeSub(i, 1); + } else { + return i; + } + } +} + +/** + * A `String` that `first` makes, by `new`, `with_capacity`, `to_owned`, or `format!`, and + * each pair of `steps` changes, its length and capacity after each, then its bytes: each + * step std's capacity follows, of growth, of shrinking, and of each way std makes one. + */ +export function strings(first: rs.u8, steps: rs.ByteSlice, out: rs.ByteVec): void { + let s!: rs.String; + let _318!: rs.String; + let _350!: rs.String; + let _421!: rs.String; + const _4: (a0: rs.u8) => string = (arg2: rs.u8): string => { + const _42: rs.usize = rs.usizeRem(arg2 as rs.usize, rs.sliceFrom(["", "ab", "démo", "アリス📷, and more text past sixteen bytes"]).length); + if (!(_42 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _42); + } + return ["", "ab", "démo", "アリス📷, and more text past sixteen bytes"][_42]; + }; + const _6: rs.u8 = rs.u8Rem(first, 4); + if (_6 === 0) { + s = rs.stringNew(); + } else if (_6 === 1) { + s = rs.stringWithCapacity(first >> 2 as rs.usize); + } else if (_6 === 2) { + s = rs.stringFrom(_4(first >> 2)); + } else { + const _23: string = _4(first >> 2); + const args13 = [(f: rs.Formatter) => rs.u8Display(first, f), (f: rs.Formatter) => rs.fmtPad(f, _23)]; + s = rs.fmtFormat([args13[0], args13[1]]); + } + put(out, s.cap); + const iter: rs.Iter = rs.byteSliceChunks(steps, 2); + while (true) { + const _40: rs.ByteSlice | rs.Done = iter.next(); + if (_40 === rs.DONE) { + break; + } + rs.idx(_40, 0); + const _46: [rs.u8, rs.u8] = [_40.data[_40.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_40, 1), 0)]; + const op: rs.u8 = _46[0]; + const arg: rs.u8 = _46[1]; + const _56: rs.usize = rs.usizeRem(arg as rs.usize, rs.sliceFrom([97, 233, 20013, 128512]).length); + if (!(_56 < 4)) { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _56); + } + const c: rs.char = [97, 233, 20013, 128512][_56]; + const _64: rs.u8 = rs.u8Rem(op, 48); + if (_64 === 0) { + rs.stringPush(s, c); + } else if (_64 === 1) { + rs.stringPushStr(s, _4(arg)); + } else if (_64 === 2) { + rs.stringReserve(s, amount(arg, s.len, 1)); + } else if (_64 === 3) { + rs.stringReserveExact(s, amount(arg, s.len, 1)); + } else if (_64 === 4) { + put(out, rs.stringTryReserve(s, amount(arg, s.len, 1)).ok ? 1 : 0); + } else if (_64 === 5) { + put(out, rs.stringTryReserveExact(s, amount(arg, s.len, 1)).ok ? 1 : 0); + } else if (_64 === 6) { + rs.stringShrinkTo(s, rs.u8Rem(arg, 40) as rs.usize); + } else if (_64 === 7) { + rs.stringShrinkTo(s, 0); + } else if (_64 === 8) { + rs.stringTruncate(s, boundary(s.v, arg)); + } else if (_64 === 9) { + rs.stringInsertStr(s, boundary(s.v, arg), String.fromCodePoint(c)); + } else if (_64 === 10) { + rs.stringInsertStr(s, boundary(s.v, arg), _4(arg >> 2)); + } else if (_64 === 11) { + rs.stringClear(s); + } else if (_64 === 12) { + const keep: () => boolean = alternate(); + rs.stringRetain(s, (_22: rs.char): boolean => { + return keep(); + }); + } else if (_64 === 13) { + const _126: [rs.usize, rs.usize] = [boundary(s.v, arg), boundary(s.v, arg >> 1)]; + const a: rs.usize = _126[0]; + const b: rs.usize = _126[1]; + rs.stringReplaceRange(s, new rs.Range(rs.min(a, b), rs.max(a, b)), _4(arg >> 2)); + } else if (_64 === 14) { + rs.stringExtendFromWithin(s, { end: boundary(s.v, arg) }); + } else if (_64 === 15) { + put(out, option_mapOr$0yzb10z(rs.stringPop(s), 0, (a0: rs.char): rs.u32 => { + return a0 as rs.u32; + }) as rs.usize); + } else if (_64 === 16) { + if (!(s.len === 0)) { + const _169: rs.Iter = rs.iterRev(new rs.RangeInclusive(0, rs.min(boundary(s.v, arg), rs.usizeSub(s.len, 1)), rs.usizeStep)); + const _172: rs.String = s; + const i2: rs.usize = option_unwrapOr$05jq4mv(rs.iterFind(_169, (_2: rs.usize): boolean => { + return rs.strIsCharBoundary(_172.v, _2); + }), 0); + put(out, (rs.stringRemove(s, i2) as rs.u32) as rs.usize); + } + } else if (_64 === 17) { + const rest: rs.String = rs.stringSplitOff(s, boundary(s.v, arg)); + sized(out, rest.len, rest.cap); + } else if (_64 === 18) { + rs.drop(rs.stringDrain(s, { end: boundary(s.v, arg) })); + } else if (_64 === 19) { + const copy: rs.String = rs.stringClone(s); + const _198: string = _4(arg); + rs.stringPushStr(copy, _198); + sized(out, copy.len, copy.cap); + s = rs.stringClone(s); + } else if (_64 === 20) { + let over: rs.String = rs.stringWithCapacity(rs.u8Rem(arg, 24) as rs.usize); + const _214: string = _4(arg >> 2); + rs.stringPushStr(over, _214); + if ((arg & 128) === 0) { + over = rs.stringCloneFrom(over, s); + } else { + over = rs.stringCloneFrom(over, s.v); + } + s = over; + } else if (_64 === 21) { + rs.stringExtendChars(s, rs.iterFilter(rs.strChars(_4(arg)), (c3: rs.char): boolean => { + return c3 !== 101; + })); + } else if (_64 === 22) { + rs.stringExtendArray(s, rs.iterSlice(copy$array_ref_str([_4(arg), _4(arg >> 2)]))); + } else if (_64 === 23) { + rs.stringExtend(s, rs.vecIntoIter(rs.vecFrom([_4(arg), _4(arg >> 2)]))); + } else if (_64 === 24) { + s = rs.stringAdd(s, _4(arg)); + } else if (_64 === 25) { + rs.stringPushStr(s, _4(arg)); + } else if (_64 === 26) { + const _268: rs.String = s; + const _272: string = _4(arg >> 2); + const args18 = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, _272)]; + rs.resultUnwrap(rs.fmtWriteString(_268, [args18[0], "-", args18[1]]), rs.fmtErrorDebug); + } else if (_64 === 27) { + const args17 = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.u8Display(arg, f)]; + s = rs.fmtFormat([args17[0], args17[1]]); + } else if (_64 === 28) { + const args16 = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.u8Display(arg, f)]; + s = rs.fmtFormat([args16[0], " and then some text ", args16[1]]); + } else if (_64 === 29) { + s = rs.fmtFormat(["[", (f: rs.Formatter) => rs.fmtPad(f, s.v), "]"]); + } else if (_64 === 30) { + s = rs.fmtFormat(["text alone"]); + } else if (_64 === 31) { + const _319: rs.u8 = rs.u8Rem(arg, 6); + if (_319 === 0) { + const _322: rs.i8 = (arg << 24) >> 24; + _318 = rs.fmtToString((f: rs.Formatter) => rs.i8Display(_322, f), 3); + } else if (_319 === 1) { + const _324: rs.i32 = rs.i32Sub(arg as rs.i32, 128); + _318 = rs.fmtToString((f: rs.Formatter) => rs.i32Display(_324, f), 10); + } else if (_319 === 2) { + _318 = rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0); + } else if (_319 === 3) { + _318 = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(c, f), 0); + } else if (_319 === 4) { + const _330: boolean = rs.u8Rem(arg, 2) === 0; + _318 = rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_330, f), 0); + } else { + _318 = rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f)]); + } + s = _318; + } else if (_64 === 32) { + s = rs.strToLowercase(s.v); + } else if (_64 === 33) { + s = rs.strToUppercase(s.v); + } else if (_64 === 34) { + s = rs.stringFrom(rs.strToAsciiUppercase(s.v)); + } else if (_64 === 35) { + const _351: rs.u8 = rs.u8Rem(arg, 5); + if (_351 === 0) { + _350 = rs.strReplace(s.v, "a", "b", true); + } else if (_351 === 1) { + _350 = rs.strReplace(s.v, "a", "xyz", true); + } else if (_351 === 2) { + _350 = rs.strReplace(s.v, String.fromCodePoint(c), "", true); + } else if (_351 === 3) { + _350 = rs.strReplace(s.v, (c2: rs.char): boolean => { + return rs.charIsAlphabetic(c2); + }, "-", false); + } else { + _350 = rs.strReplace(s.v, rs.stringFrom("é").v, "e", true); + } + s = _350; + } else if (_64 === 36) { + s = rs.strReplacen(s.v, "a", "bc", rs.u8Rem(arg, 3) as rs.usize); + } else if (_64 === 37) { + const bytes: rs.ByteVec = rs.stringIntoBytes(s); + sized(out, bytes.length, bytes.data.length); + s = rs.resultUnwrap(rs.stringFromUtf8(bytes), rs.fmtFromUtf8ErrorDebug); + } else if (_64 === 38) { + const bytes2: rs.ByteVec = rs.strToBytes(s.v); + sized(out, bytes2.length, bytes2.data.length); + const bytes3: rs.ByteVec = rs.stringIntoBytes(s); + sized(out, bytes3.length, bytes3.data.length); + s = rs.resultUnwrap(rs.stringFromUtf8(bytes3), rs.fmtFromUtf8ErrorDebug); + } else if (_64 === 39) { + const _404: rs.Iter = rs.iterRev(rs.strChars(s.v)); + s = rs.stringExtendChars(rs.stringNew(), _404); + } else if (_64 === 40) { + s = rs.stringFromStrings(rs.vecIntoIter(rs.vecFrom([s, rs.stringFrom(_4(arg))]))); + } else if (_64 === 41) { + const units: rs.Vec = rs.iterToVec(rs.strEncodeUtf16(s.v), "next", 2); + if (rs.u8Rem(arg, 2) === 0) { + _421 = rs.resultUnwrap(rs.stringFromUtf16(rs.sliceFrom(units.items)), rs.fmtFromUtf16ErrorDebug); + } else { + _421 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); + } + s = _421; + } else if (_64 === 42) { + const bytes4: rs.ByteVec = rs.stringIntoBytes(s); + rs.byteVecPush(bytes4, 255); + s = rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteVecSlice(bytes4))); + } else if (_64 === 43) { + const _438: rs.Slice = rs.sliceFrom([s.v, _4(arg)]); + const _446: string = _4(arg >> 2); + s = rs.strsJoin(rs.sliceItems(_438), _446); + } else if (_64 === 44) { + s = rs.stringFrom(s.v); + } else if (_64 === 45) { + let cow: rs.StrCow = new rs.Borrowed(_4(arg)); + cow = rs.strCowAdd(cow, new rs.Borrowed(s.v)); + const _465: string = _4(arg >> 2); + cow = rs.strCowAdd(cow, new rs.Borrowed(_465)); + s = rs.strCowIntoOwned(cow); + } else if (_64 === 46) { + const _474: string[] = [_4(arg), _4(arg >> 2)]; + s = rs.stringExtendArray(rs.stringNew(), rs.iterSlice(_474)); + } else if (_64 === 47) { + s = rs.stringAdd(rs.replaceIn(s, rs.stringNew()), _4(arg)); + } + sized(out, s.len, s.cap); + } + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); +} + //# sourceMappingURL=capacity.ts.map diff --git a/ts/fixtures/lang/capacity/expected/core/option.ts b/ts/fixtures/lang/capacity/expected/core/option.ts index 781b780a5..4d25274b9 100644 --- a/ts/fixtures/lang/capacity/expected/core/option.ts +++ b/ts/fixtures/lang/capacity/expected/core/option.ts @@ -9,6 +9,13 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } +export function unwrapOr$05jq4mv(self: rs.usize | undefined, default_: rs.usize): rs.usize { + if (self === undefined) { + return default_; + } + return self; +} + export function unwrapOrDefault$0avqj0t(self: rs.ByteSlice | undefined): rs.ByteSlice { if (self === undefined) { return rs.byteSliceFrom(new Uint8Array(0)); @@ -51,6 +58,13 @@ export function map$1d4d0v7(self: rs.Vec[] | undefined, f: (a0: rs.Ve return f(self); } +export function mapOr$0yzb10z(self: rs.char | undefined, default_: rs.u32, _: (a0: rs.char) => rs.u32): rs.u32 { + if (self === undefined) { + return default_; + } + return self as rs.u32; +} + export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/capacity/expected/lib.ts b/ts/fixtures/lang/capacity/expected/lib.ts index 4c151945f..8a874da31 100644 --- a/ts/fixtures/lang/capacity/expected/lib.ts +++ b/ts/fixtures/lang/capacity/expected/lib.ts @@ -1,7 +1,11 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { vecs, cloneFroms, deques, heaps, collects, maps } from "./capacity.ts"; +import { vecs, cloneFroms, deques, heaps, collects, maps, strings } from "./capacity.ts"; + +export function copy$array_ref_str(v: string[]): string[] { + return v.slice(); +} export function copy$array_u64(v: rs.u64[]): rs.u64[] { return v.slice(); @@ -26,7 +30,7 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By deques(a02, a12.data, a12.start, a12.length, a22); }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::heaps", (a03: rs.u8, a13: rs.ByteSlice, a23: rs.ByteVec): undefined => { heaps(a03, a13.data, a13.start, a13.length, a23); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::collects", collects as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::maps", maps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::clone_froms", cloneFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::collects", collects as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::maps", maps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::clone_froms", cloneFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::strings", strings as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/capacity/src/capacity.rs b/ts/fixtures/lang/capacity/src/capacity.rs index 9ed6af89a..61a5ba27b 100644 --- a/ts/fixtures/lang/capacity/src/capacity.rs +++ b/ts/fixtures/lang/capacity/src/capacity.rs @@ -646,3 +646,165 @@ pub fn maps(kind: u8, data: &[u8], out: &mut Vec) { put(out, huge.len()); } } + +/// Text of each width a char's UTF-8 takes, and of format's thresholds: none, short, and +/// past 16 bytes. +const TEXTS: [&str; 4] = ["", "ab", "démo", "アリス📷, and more text past sixteen bytes"]; + +/// A char of each UTF-8 width. +const CHARS: [char; 4] = ['a', 'é', '中', '😀']; + +/// The char boundary at or before byte `arg` of `s`, modulo its length and one. +fn boundary(s: &str, arg: u8) -> usize { + let mut i = usize::from(arg) % (s.len() + 1); + while !s.is_char_boundary(i) { + i -= 1; + } + i +} + +/// A `String` that `first` makes, by `new`, `with_capacity`, `to_owned`, or `format!`, and +/// each pair of `steps` changes, its length and capacity after each, then its bytes: each +/// step std's capacity follows, of growth, of shrinking, and of each way std makes one. +pub fn strings(first: u8, steps: &[u8], out: &mut Vec) { + let text = |arg: u8| TEXTS[usize::from(arg) % TEXTS.len()]; + let mut s = match first % 4 { + 0 => String::new(), + 1 => String::with_capacity(usize::from(first >> 2)), + 2 => text(first >> 2).to_owned(), + _ => format!("{}{}", first, text(first >> 2)), + }; + put(out, s.capacity()); + for step in steps.chunks(2) { + let (op, arg) = (step[0], step.get(1).copied().unwrap_or(0)); + let c = CHARS[usize::from(arg) % CHARS.len()]; + match op % 48 { + 0 => s.push(c), + 1 => s.push_str(text(arg)), + 2 => s.reserve(amount(arg, s.len(), 1)), + 3 => s.reserve_exact(amount(arg, s.len(), 1)), + 4 => put(out, usize::from(s.try_reserve(amount(arg, s.len(), 1)).is_ok())), + 5 => put(out, usize::from(s.try_reserve_exact(amount(arg, s.len(), 1)).is_ok())), + 6 => s.shrink_to(usize::from(arg % 40)), + 7 => s.shrink_to_fit(), + 8 => s.truncate(boundary(&s, arg)), + 9 => s.insert(boundary(&s, arg), c), + 10 => s.insert_str(boundary(&s, arg), text(arg >> 2)), + 11 => s.clear(), + 12 => { + let mut keep = alternate(); + s.retain(|_| keep()); + } + 13 => { + let (a, b) = (boundary(&s, arg), boundary(&s, arg >> 1)); + s.replace_range(a.min(b)..a.max(b), text(arg >> 2)); + } + 14 => s.extend_from_within(..boundary(&s, arg)), + 15 => put(out, s.pop().map_or(0, u32::from) as usize), + 16 if !s.is_empty() => { + let i = boundary(&s, arg).min(s.len() - 1); + let i = (0..=i).rev().find(|&i| s.is_char_boundary(i)).unwrap_or(0); + put(out, u32::from(s.remove(i)) as usize); + } + 17 => { + let rest = s.split_off(boundary(&s, arg)); + sized(out, rest.len(), rest.capacity()); + } + 18 => drop(s.drain(..boundary(&s, arg))), + // A clone, and a `String::from` of a reference's, which leaves the original as it was. + 19 => { + let mut copy = String::from(&s); + copy.push_str(text(arg)); + sized(out, copy.len(), copy.capacity()); + s = s.clone(); + } + // Grown from `with_capacity` only where it holds fewer, by a `String`'s or a `str`'s. + 20 => { + let mut over = String::with_capacity(usize::from(arg % 24)); + over.push_str(text(arg >> 2)); + match arg & 0x80 { + 0 => over.clone_from(&s), + _ => s.as_str().clone_into(&mut over), + } + s = over; + } + 21 => s.extend(text(arg).chars().filter(|c| *c != 'e')), + 22 => s.extend([text(arg), text(arg >> 2)]), + 23 => s.extend(vec![text(arg), text(arg >> 2)]), + 24 => s = s + text(arg), + 25 => s += text(arg), + 26 => { + use std::fmt::Write; + write!(s, "{arg}-{}", text(arg >> 2)).unwrap(); + } + // Each of `format!`'s estimates: none past a placeholder first, twice its text + // if 16 bytes or more or a placeholder is after it, and its text alone. + 27 => s = format!("{s}{arg}"), + 28 => s = format!("{s} and then some text {arg}"), + 29 => s = format!("[{s}]"), + 30 => s = format!("text alone"), + 31 => { + s = match arg % 6 { + 0 => (arg as i8).to_string(), + 1 => (i32::from(arg) - 128).to_string(), + 2 => arg.to_string(), + 3 => c.to_string(), + 4 => (arg % 2 == 0).to_string(), + _ => format_args!("{arg}").to_string(), + } + } + 32 => s = s.to_lowercase(), + 33 => s = s.to_uppercase(), + 34 => s = s.to_ascii_uppercase(), + 35 => { + s = match arg % 5 { + 0 => s.replace('a', "b"), + 1 => s.replace("a", "xyz"), + 2 => s.replace(c, ""), + 3 => s.replace(|c: char| c.is_alphabetic(), "-"), + _ => s.replace(&String::from("é"), "e"), + } + } + 36 => s = s.replacen('a', "bc", usize::from(arg % 3)), + 37 => { + let bytes = s.into_bytes(); + sized(out, bytes.len(), bytes.capacity()); + s = String::from_utf8(bytes).unwrap(); + } + 38 => { + let bytes = Vec::from(s.as_str()); + sized(out, bytes.len(), bytes.capacity()); + let bytes = Vec::from(s); + sized(out, bytes.len(), bytes.capacity()); + s = String::from_utf8(bytes).unwrap(); + } + 39 => s = s.chars().rev().collect(), + 40 => s = vec![s, text(arg).to_owned()].into_iter().collect(), + 41 => { + let units: Vec = s.encode_utf16().collect(); + s = match arg % 2 { + 0 => String::from_utf16(&units).unwrap(), + _ => String::from_utf16_lossy(&units), + } + } + 42 => { + let mut bytes = s.into_bytes(); + bytes.push(0xff); + s = String::from_utf8_lossy(&bytes).into_owned(); + } + 43 => s = [s.as_str(), text(arg)].join(text(arg >> 2)), + 44 => s = s.into_boxed_str().into_string(), + 45 => { + let mut cow = std::borrow::Cow::Borrowed(text(arg)); + cow += s.as_str(); + cow += text(arg >> 2); + s = cow.into_owned(); + } + 46 => s = String::from_iter([text(arg), text(arg >> 2)]), + 47 => s = mem::take(&mut s) + text(arg), + _ => {} + } + sized(out, s.len(), s.capacity()); + } + out.extend_from_slice(s.as_bytes()); +} diff --git a/ts/fixtures/lang/capacity/src/lib.rs b/ts/fixtures/lang/capacity/src/lib.rs index 1f56103f4..a5278f1a6 100644 --- a/ts/fixtures/lang/capacity/src/lib.rs +++ b/ts/fixtures/lang/capacity/src/lib.rs @@ -22,5 +22,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("capacity::collects", capacity::collects), ("capacity::maps", capacity::maps), ("capacity::clone_froms", capacity::clone_froms), + ("capacity::strings", capacity::strings), ] } diff --git a/ts/fixtures/lang/cells/expected/cells.ts b/ts/fixtures/lang/cells/expected/cells.ts index c995eff90..f24cad0e7 100644 --- a/ts/fixtures/lang/cells/expected/cells.ts +++ b/ts/fixtures/lang/cells/expected/cells.ts @@ -4,11 +4,11 @@ import * as rs from "./rs.ts"; import { out$Option_u8, out$u64, out$u8 } from "./lib.ts"; import { thenSome$0quywni } from "./core/bool.ts"; import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; -import { err$1yr5s3w, map$0vjzmou as result_map$0vjzmou, map$0ac8dwe as result_map$0ac8dwe, map$0zkrphe as result_map$0zkrphe, map$0w147c6 as result_map$0w147c6, map$1gelxzx as result_map$1gelxzx, map$0vfooax as result_map$0vfooax } from "./core/result.ts"; +import { err$1yr5s3w, map$0vjzmou as result_map$0vjzmou, map$1kzzqt5 as result_map$1kzzqt5, map$0zkrphe as result_map$0zkrphe, map$0w147c6 as result_map$0w147c6, map$1gelxzx as result_map$1gelxzx, map$0vfooax as result_map$0vfooax } from "./core/result.ts"; /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 | undefined = maybe; const put: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = putMaybe as (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined; @@ -122,7 +122,7 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]); @@ -130,13 +130,13 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num }, undefined, rs.None); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell, rs.None); if (_155 === undefined) { @@ -190,15 +190,15 @@ export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; - let result!: rs.Result; - const make: (a0: rs.u8) => string = (v3: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f)); + let text!: rs.String; + let result!: rs.Result; + const make: (a0: rs.u8) => rs.String = (v3: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f), 0); }; - const put: (a0: rs.ByteVec, a1: string) => undefined = (out2: rs.ByteVec, t10: string): undefined => { - rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10)); + const put: (a0: rs.ByteVec, a1: rs.String) => undefined = (out2: rs.ByteVec, t10: rs.String): undefined => { + rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10.v)); }; - let cell: rs.OnceCell = new rs.OnceCell(undefined); + let cell: rs.OnceCell = new rs.OnceCell(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; @@ -215,7 +215,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num const v2: rs.u8 = v; const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: string | undefined = cell.v; + const _20: rs.String | undefined = cell.v; if (_20 === undefined) { rs.byteVecPush(out, 0); } else { @@ -223,49 +223,49 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, _20); } } else if (_18 === 1) { - const _26: rs.Result = rs.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { rs.byteVecPush(out, 1); } else { - const t: string = _26.error; + const t: rs.String = _26.error; rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: string = rs.onceGetOrInit(cell, (): string => { + const _34: rs.String = rs.onceGetOrInit(cell, (): rs.String => { return make(v2); }); put(out, _34); } else if (_18 === 3) { let seen: rs.u8 = 2; - const _44: rs.OnceCell = cell; - const t2: string = rs.onceGetOrInit(cell, (): string => { + const _44: rs.OnceCell = cell; + const t2: rs.String = rs.onceGetOrInit(cell, (): rs.String => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: string | undefined = rs.onceTake(cell); + const _50: rs.String | undefined = rs.onceTake(cell); if (_50 === undefined) { rs.byteVecPush(out, 0); } else { - const t3: string = _50; + const t3: rs.String = _50; rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rs.OnceCell = cell; - const _57: string = rs.onceGetOrInit(cell, (): string => { + const _60: rs.OnceCell = cell; + const _57: rs.String = rs.onceGetOrInit(cell, (): rs.String => { rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { const inner: rs.ByteVec = new rs.ByteVec(); - const _69: rs.OnceCell = cell; - const t4: string = rs.onceGetOrInit(cell, (): string => { - put(inner, rs.onceGetOrInit(_69, (): string => { + const _69: rs.OnceCell = cell; + const t4: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + put(inner, rs.onceGetOrInit(_69, (): rs.String => { return make(v2 ^ 1); })); return make(v2); @@ -273,7 +273,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, t4); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: string = rs.onceGetOrInit(cell, (): string => { + const _76: rs.String = rs.onceGetOrInit(cell, (): rs.String => { rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); @@ -284,23 +284,27 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num cell = new rs.OnceCell(undefined); } } else if (_18 === 9) { - const alias: rs.OnceCell = twin$ref_cell_OnceCell_String(cell); - const copy: rs.OnceCell = rs.onceClone(cell, undefined); - let inner2 = undefined as rs.OnceCell | undefined; - const _95: rs.OnceCell = cell; - const t5: string = rs.onceGetOrInit(cell, (): string => { - inner2 = rs.onceClone(_95, undefined); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_String(cell); + const copy: rs.OnceCell = rs.onceClone(cell, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t5: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + inner2 = rs.onceClone(_95, (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); return make(v2); }); put(out, t5); rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rs.OnceCell | rs.Done = iter.next(); + const _112: rs.OnceCell | rs.Done = iter.next(); if (_112 === rs.DONE) { break; } - const _116: string | undefined = _112.v; + const _116: rs.String | undefined = _112.v; if (_116 === undefined) { rs.byteVecPush(out, 238); } else { @@ -308,53 +312,53 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; - const _125: rs.OnceCell = cell; - const t7: string = rs.onceGetOrInit(cell, (): string => { - inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtStr)]); + let inner3: rs.String = rs.stringNew(); + const _125: rs.OnceCell = cell; + const t7: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { - const _155: rs.Place | undefined = rs.optionAsMut(cell); + const _155: rs.String | undefined = cell.v; if (_155 === undefined) { rs.byteVecPush(out, 0); } else { - _155.v = make(v2); + Object.assign(_155, make(v2)); rs.byteVecPush(out, 1); - const _162: string = rs.optionUnwrap(cell.v); + const _162: rs.String = rs.optionUnwrap(cell.v); put(out, _162); } } else { const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$String(make, v2); }); } else if (_166 === 2) { - const _174: rs.OnceCell = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { rs.onceSet(_174, make(v2 ^ 1)); return made$String(make, v2); }); } else { - const _179: rs.OnceCell = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { - return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0ac8dwe(rs.onceGetOrTryInit(_179, (): rs.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$1kzzqt5(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$String(make, v2 ^ 1); - }), (_22: string): undefined => {})), v2)); + }), (_22: rs.String): undefined => {})), v2)); }); } if (result.ok) { - const t8: string = result.value; + const t8: rs.String = result.value; rs.byteVecPush(out, 1); put(out, t8); } else { @@ -362,7 +366,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num } } } - const _190: string | undefined = cell.v; + const _190: rs.String | undefined = cell.v; if (_190 === undefined) { rs.byteVecPush(out, 238); } else { @@ -372,7 +376,7 @@ export function cellString(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u64 = wide; const put: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, t10: rs.u64): undefined => { @@ -488,7 +492,7 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u64Debug)]); @@ -496,13 +500,13 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -556,7 +560,7 @@ export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 = (v3: rs.u8): rs.u8 => { return v3; @@ -674,7 +678,7 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u8Debug)]); @@ -682,13 +686,13 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -742,7 +746,7 @@ export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => undefined = (_2: rs.u8): undefined => {}; const put: (a0: rs.ByteVec, a1: undefined) => undefined = (out2: rs.ByteVec, _3: undefined): undefined => { @@ -857,7 +861,7 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtUnit, rs.None)]); @@ -865,13 +869,13 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe }, undefined, rs.None); put(out, t4); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { if (rs.optionAsMut(cell, rs.None) === undefined) { rs.byteVecPush(out, 0); @@ -920,7 +924,7 @@ export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe /** Steps of an operation and an operand on one cell, each putting what it read. */ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.ByteVec = (v3: rs.u8): rs.ByteVec => { return rs.byteVecOf(v3, rs.u8Rem(v3, 4) as rs.usize); @@ -1042,7 +1046,7 @@ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceCell = cell; const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); @@ -1050,13 +1054,13 @@ export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.ByteVec | undefined = cell.v; if (_155 === undefined) { @@ -1136,7 +1140,7 @@ export function cells(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 | undefined = maybe; const put: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = putMaybe as (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined; @@ -1250,7 +1254,7 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]); @@ -1258,13 +1262,13 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num }, undefined, rs.None); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell, rs.None); if (_155 === undefined) { @@ -1318,15 +1322,15 @@ export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; - let result!: rs.Result; - const make: (a0: rs.u8) => string = (v3: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f)); + let text!: rs.String; + let result!: rs.Result; + const make: (a0: rs.u8) => rs.String = (v3: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f), 0); }; - const put: (a0: rs.ByteVec, a1: string) => undefined = (out2: rs.ByteVec, t10: string): undefined => { - rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10)); + const put: (a0: rs.ByteVec, a1: rs.String) => undefined = (out2: rs.ByteVec, t10: rs.String): undefined => { + rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10.v)); }; - let cell: rs.OnceLock = new rs.OnceLock(undefined); + let cell: rs.OnceLock = new rs.OnceLock(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; @@ -1343,7 +1347,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num const v2: rs.u8 = v; const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: string | undefined = cell.v; + const _20: rs.String | undefined = cell.v; if (_20 === undefined) { rs.byteVecPush(out, 0); } else { @@ -1351,49 +1355,49 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, _20); } } else if (_18 === 1) { - const _26: rs.Result = rs.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { rs.byteVecPush(out, 1); } else { - const t: string = _26.error; + const t: rs.String = _26.error; rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: string = rs.onceGetOrInit(cell, (): string => { + const _34: rs.String = rs.onceGetOrInit(cell, (): rs.String => { return make(v2); }); put(out, _34); } else if (_18 === 3) { let seen: rs.u8 = 2; - const _44: rs.OnceLock = cell; - const t2: string = rs.onceGetOrInit(cell, (): string => { + const _44: rs.OnceLock = cell; + const t2: rs.String = rs.onceGetOrInit(cell, (): rs.String => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: string | undefined = rs.onceTake(cell); + const _50: rs.String | undefined = rs.onceTake(cell); if (_50 === undefined) { rs.byteVecPush(out, 0); } else { - const t3: string = _50; + const t3: rs.String = _50; rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rs.OnceLock = cell; - const _57: string = rs.onceGetOrInit(cell, (): string => { + const _60: rs.OnceLock = cell; + const _57: rs.String = rs.onceGetOrInit(cell, (): rs.String => { rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { const inner: rs.ByteVec = new rs.ByteVec(); - const _69: rs.OnceLock = cell; - const t4: string = rs.onceGetOrInit(cell, (): string => { - put(inner, rs.onceGetOrInit(_69, (): string => { + const _69: rs.OnceLock = cell; + const t4: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + put(inner, rs.onceGetOrInit(_69, (): rs.String => { return make(v2 ^ 1); })); return make(v2); @@ -1401,7 +1405,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num put(out, t4); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: string = rs.onceGetOrInit(cell, (): string => { + const _76: rs.String = rs.onceGetOrInit(cell, (): rs.String => { rs.panicFmt(["init ", (f: rs.Formatter) => rs.u8Display(v2, f)]); }); put(out, _76); @@ -1412,23 +1416,27 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num cell = new rs.OnceLock(undefined); } } else if (_18 === 9) { - const alias: rs.OnceLock = twin$ref_sync_OnceLock_String(cell); - const copy: rs.OnceLock = rs.onceClone(cell, undefined); - let inner2 = undefined as rs.OnceLock | undefined; - const _95: rs.OnceLock = cell; - const t5: string = rs.onceGetOrInit(cell, (): string => { - inner2 = rs.onceClone(_95, undefined); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_String(cell); + const copy: rs.OnceLock = rs.onceClone(cell, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t5: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + inner2 = rs.onceClone(_95, (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); return make(v2); }); put(out, t5); rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rs.OnceLock | rs.Done = iter.next(); + const _112: rs.OnceLock | rs.Done = iter.next(); if (_112 === rs.DONE) { break; } - const _116: string | undefined = _112.v; + const _116: rs.String | undefined = _112.v; if (_116 === undefined) { rs.byteVecPush(out, 238); } else { @@ -1436,53 +1444,53 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num } } } else if (_18 === 10) { - let inner3: string = ""; - const _125: rs.OnceLock = cell; - const t7: string = rs.onceGetOrInit(cell, (): string => { - inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtStr)]); + let inner3: rs.String = rs.stringNew(); + const _125: rs.OnceLock = cell; + const t7: rs.String = rs.onceGetOrInit(cell, (): rs.String => { + inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]); return make(v2); }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { - const _155: rs.Place | undefined = rs.optionAsMut(cell); + const _155: rs.String | undefined = cell.v; if (_155 === undefined) { rs.byteVecPush(out, 0); } else { - _155.v = make(v2); + Object.assign(_155, make(v2)); rs.byteVecPush(out, 1); - const _162: string = rs.optionUnwrap(cell.v); + const _162: rs.String = rs.optionUnwrap(cell.v); put(out, _162); } } else { const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$String(make, v2); }); } else if (_166 === 2) { - const _174: rs.OnceLock = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { rs.onceSet(_174, make(v2 ^ 1)); return made$String(make, v2); }); } else { - const _179: rs.OnceLock = cell; - result = rs.onceGetOrTryInit(cell, (): rs.Result => { - return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0ac8dwe(rs.onceGetOrTryInit(_179, (): rs.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$1kzzqt5(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$String(make, v2 ^ 1); - }), (_22: string): undefined => {})), v2)); + }), (_22: rs.String): undefined => {})), v2)); }); } if (result.ok) { - const t8: string = result.value; + const t8: rs.String = result.value; rs.byteVecPush(out, 1); put(out, t8); } else { @@ -1490,7 +1498,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num } } } - const _190: string | undefined = cell.v; + const _190: rs.String | undefined = cell.v; if (_190 === undefined) { rs.byteVecPush(out, 238); } else { @@ -1500,7 +1508,7 @@ export function lockString(dataData: Uint8Array, dataStart: number, dataLen: num /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u64 = wide; const put: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, t10: rs.u64): undefined => { @@ -1616,7 +1624,7 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u64Debug)]); @@ -1624,13 +1632,13 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -1684,7 +1692,7 @@ export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.u8 = (v3: rs.u8): rs.u8 => { return v3; @@ -1802,7 +1810,7 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u8Debug)]); @@ -1810,13 +1818,13 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { @@ -1870,7 +1878,7 @@ export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => undefined = (_2: rs.u8): undefined => {}; const put: (a0: rs.ByteVec, a1: undefined) => undefined = (out2: rs.ByteVec, _3: undefined): undefined => { @@ -1985,7 +1993,7 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtUnit, rs.None)]); @@ -1993,13 +2001,13 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe }, undefined, rs.None); put(out, t4); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { if (rs.optionAsMut(cell, rs.None) === undefined) { rs.byteVecPush(out, 0); @@ -2048,7 +2056,7 @@ export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: numbe /** Steps of an operation and an operand on one cell, each putting what it read. */ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; let result!: rs.Result; const make: (a0: rs.u8) => rs.ByteVec = (v3: rs.u8): rs.ByteVec => { return rs.byteVecOf(v3, rs.u8Rem(v3, 4) as rs.usize); @@ -2170,7 +2178,7 @@ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number } } } else if (_18 === 10) { - let inner3: string = ""; + let inner3: rs.String = rs.stringNew(); const _125: rs.OnceLock = cell; const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { inner3 = rs.fmtFormat([(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]); @@ -2178,13 +2186,13 @@ export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number }); put(out, t7); if (rs.u8Rem(v2, 2) === 0) { - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args9[0], " ", args9[1]]); } else { - const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + const args8 = [(f: rs.Formatter) => rs.fmtPad(f, inner3.v), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; text = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1])]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } else if (_18 === 11) { const _155: rs.ByteVec | undefined = cell.v; if (_155 === undefined) { @@ -2238,7 +2246,7 @@ export function twin$ref_cell_OnceCell_Option_u8(t: rs.OnceCell): rs.OnceCell { +export function twin$ref_cell_OnceCell_String(t: rs.OnceCell): rs.OnceCell { return t; } @@ -2268,7 +2276,7 @@ export function twin$ref_sync_OnceLock_Option_u8(t: rs.OnceLock): rs.OnceLock { +export function twin$ref_sync_OnceLock_String(t: rs.OnceLock): rs.OnceLock { return t; } @@ -2302,7 +2310,7 @@ export function made$Option_u8(make: (a0: rs.u8) => rs.u8 | undefined, v: rs.u8) } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$String(make: (a0: rs.u8) => string, v: rs.u8): rs.Result { +export function made$String(make: (a0: rs.u8) => rs.String, v: rs.u8): rs.Result { if (rs.u8Rem(v, 3) === 0) { return rs.Err(v); } diff --git a/ts/fixtures/lang/cells/expected/core/result.ts b/ts/fixtures/lang/cells/expected/core/result.ts index b4dbe26e3..d09746c0b 100644 --- a/ts/fixtures/lang/cells/expected/core/result.ts +++ b/ts/fixtures/lang/cells/expected/core/result.ts @@ -17,7 +17,7 @@ export function map$0vjzmou(self: rs.Result, op: (a0: return self as rs.Result; } -export function map$0ac8dwe(self: rs.Result, op: (a0: string) => undefined): rs.Result { +export function map$1kzzqt5(self: rs.Result, op: (a0: rs.String) => undefined): rs.Result { if (self.ok) { op(self.value); return rs.OK; diff --git a/ts/fixtures/lang/chars/expected/chars.ts b/ts/fixtures/lang/chars/expected/chars.ts index a31f6de8a..451ad57ce 100644 --- a/ts/fixtures/lang/chars/expected/chars.ts +++ b/ts/fixtures/lang/chars/expected/chars.ts @@ -128,7 +128,7 @@ export function chars(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _144: rs.char | undefined = rs.charFromU32(_140); if (_144 !== undefined) { const args5 = [(f: rs.Formatter) => rs.fmtCharDisplay(_144, f)]; - put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 3 }, args5[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 4 }, args5[0]), "|", rs.fmtSpec({ align: "<", width: 2 }, args5[0])])); + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 3 }, args5[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 4 }, args5[0]), "|", rs.fmtSpec({ align: "<", width: 2 }, args5[0])]).v); } } const iter6: rs.Iter = rs.iterSlice([97, 39, 34, 92, 10, 0, 127, 233, 769, 173, 57344, 128512, 65438, 65439, 4447, 4448, 12644, 65440]); @@ -138,7 +138,7 @@ export function chars(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { break; } const args6 = [(f: rs.Formatter) => rs.fmtCharDebug(_161, f), (f: rs.Formatter) => rs.fmtCharDisplay(_161, f)]; - put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", args6[1]])); + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", args6[1]]).v); } } } @@ -196,7 +196,7 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug")]; - put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -207,21 +207,22 @@ export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): vo const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); - const rest: string = rs.stringExtendChars("", it); - const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1]])); + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault")]; - put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -232,21 +233,22 @@ export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); - const rest: string = rs.stringExtendChars("", it); - const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1]])); + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode")]; - put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -257,21 +259,22 @@ export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); - const rest: string = rs.stringExtendChars("", it); - const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1]])); + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): void { const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase")]; - put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -282,21 +285,22 @@ export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): vo const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); - const rest: string = rs.stringExtendChars("", it); - const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1]])); + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } /** What each iterator does from either end, sized, cloned, and printed partway. */ export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): void { const args9 = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase")]; - put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])])); + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[1])]).v); const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); const low: rs.usize = _18[0]; const high: rs.usize | undefined = _18[1]; @@ -307,15 +311,16 @@ export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): vo const first: rs.char | undefined = rs.iterToOption(it.next()); const _39: rs.usize = it.len(); const args10 = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]])); + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", args10[3], "|", args10[4]]).v); const _60: rs.char | undefined = rs.iterLast(copy.clone()); const _64: rs.usize = rs.iterCount(copy.clone()); const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); const args11 = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); - const rest: string = rs.stringExtendChars("", it); - const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1]])); + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); + const _79: rs.Iter = it; + const rest: rs.String = rs.stringExtendChars(rs.stringNew(), _79); + const args12 = [(f: rs.Formatter) => rs.fmtPad(f, rest.v), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } /** @@ -335,7 +340,8 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _15: rs.u8 = rs.u8Rem(kind, 5); if (_15 === 0) { walk$char_ToLowercase(out, rs.charToLowercase(c)); - put(out, rs.stringExtendChars("", rs.iterRev(rs.charToLowercase(c)))); + const _23: rs.Iter = rs.iterRev(rs.charToLowercase(c)); + put(out, rs.stringExtendChars(rs.stringNew(), _23).v); } else if (_15 === 1) { walk$char_ToUppercase(out, rs.charToUppercase(c)); const up: rs.Iter = rs.charToUppercase(c); @@ -343,7 +349,7 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _39: rs.char | undefined = rs.iterToOption(up.next()); const _42: rs.usize = up.len(); const args3 = [(f: rs.Formatter) => rs.fmtOption(_36, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtOption(_39, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(up, f), (f: rs.Formatter) => rs.fmtCharsDebug(up, f, "ToUppercase"), (f: rs.Formatter) => rs.usizeDisplay(_42, f)]; - put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3], "|", args3[4]])); + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3], "|", args3[4]]).v); } else if (_15 === 2) { walk$char_EscapeUnicode(out, rs.charEscapeUnicode(c)); } else if (_15 === 3) { @@ -375,7 +381,7 @@ export function encodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const s: rs.Place = rs.charEncodeUtf8(c, rs.byteSliceFrom(bytes)); const _34: rs.usize = rs.stringLen(s.v); const args3 = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.usizeDisplay(_34, f), (f: rs.Formatter) => rs.fmtStr(s.v, f)]; - put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2]])); + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2]]).v); s.v = rs.strToAsciiUppercase(s.v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); const units: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { @@ -446,7 +452,7 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else { const e: rs.DecodeUtf16Error = r.error; const args5 = [(f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtDecodeUtf16ErrorDebug)]; - put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", args5[2]])); + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", args5[2]]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(e.code))); const _79: rs.DecodeUtf16Error | undefined = last; const _82: rs.DecodeUtf16Error | undefined = e; @@ -457,14 +463,16 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void break; } } - const s: string = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.iterSlice([55357, 56832])), (r2: rs.Result): rs.char => { + const _94: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.iterSlice([55357, 56832])), (r2: rs.Result): rs.char => { return result_unwrapOr$1yj84xe(r2, 65533); - })); - const lossy: string = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _94); + const _97: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { return result_unwrapOr$1yj84xe(r3, 63); - })); - const args6 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, lossy)]; - put(out, rs.fmtFormat([args6[0], "|", args6[1]])); + }); + const lossy: rs.String = rs.stringExtendChars(rs.stringNew(), _97); + const args6 = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.fmtPad(f, lossy.v)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1]]).v); } /** @@ -484,7 +492,7 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void break; } const part3 = rs.charFromDigit(_11, radix); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtCharDebug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtCharDebug)]).v); } } else if (_6 === 1) { const iter2: rs.Iter = rs.iterSlice([48, 57, 97, 122, 65, 90, 47, 58, 64, 91, 96, 123, 1635, 65345]); @@ -498,11 +506,11 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else { for (const n2 of scalars(data).items) { const r: rs.Result = rs.charTryFrom(n2); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtCharTryFromErrorDebug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtCharTryFromErrorDebug)]).v); if (!r.ok) { const part = new rs.CharTryFromError(); const args12 = [(f: rs.Formatter) => rs.fmtCharTryFromErrorDisplay(part, f), (f: rs.Formatter) => rs.fmtCharTryFromErrorDebug(part, f)]; - put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args12[0]), "|", args12[1], "|", rs.fmtSpec({ alternate: true }, args12[1])])); + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args12[0]), "|", args12[1], "|", rs.fmtSpec({ alternate: true }, args12[1])]).v); const _78: rs.CharTryFromError = new rs.CharTryFromError(); rs.byteVecPush(out, convert_eq$1efmo6b(new rs.CharTryFromError(), _78) ? 1 : 0); } @@ -515,14 +523,14 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _96: rs.u64 = c2 as rs.u64; const _98: rs.u128 = c2 as rs.u128; const args13 = [(f: rs.Formatter) => rs.fmtResult(b, f, rs.u8Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.fmtResult(w, f, rs.u16Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.u64Display(_96, f), (f: rs.Formatter) => rs.u128Display(_98, f)]; - put(out, rs.fmtFormat([args13[0], "|", args13[1], "|", args13[2], "|", args13[3]])); + put(out, rs.fmtFormat([args13[0], "|", args13[1], "|", args13[2], "|", args13[3]]).v); const _109: rs.Result = result_map$1q32zo4(b, (a0: rs.u8): rs.u16 => { return a0 as rs.u16; }); if (!result_and$02o4suw(w, _109).ok) { const part2 = new rs.TryFromCharError(); const args14 = [(f: rs.Formatter) => rs.fmtTryFromCharErrorDisplay(part2, f), (f: rs.Formatter) => rs.fmtTryFromCharErrorDebug(part2, f)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[1])])); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[1])]).v); const _130: rs.TryFromCharError = new rs.TryFromCharError(); rs.byteVecPush(out, char_eq$1g188ap(new rs.TryFromCharError(), _130) ? 1 : 0); } @@ -536,9 +544,9 @@ export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void * harness's alphabet and the special chars. */ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - let s: string = text(data); - s = rs.stringExtendChars(s, rs.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); - const s2: string = s; + const s: rs.String = text(data); + rs.stringExtendChars(s, rs.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); + const s2: string = s.v; const _9: rs.u8 = rs.u8Rem(kind, 3); if (_9 === 0) { const parts: rs.Vec = rs.iterToVec(rs.strSplit(s2, (a011: rs.char): boolean => { @@ -548,15 +556,15 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.charIsNumeric(a012); }); const args13 = [(f: rs.Formatter) => rs.fmtList(parts.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(_21, f)]; - put(out, rs.fmtFormat([args13[0], "|", args13[1]])); + put(out, rs.fmtFormat([args13[0], "|", args13[1]]).v); const part = rs.strFind(s2, (a013: rs.char): boolean => { return rs.charIsUppercase(a013); }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.usizeDebug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.usizeDebug)]).v); const part2 = rs.strRfind(s2, (a014: rs.char): boolean => { return rs.charIsControl(a014); }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, rs.usizeDebug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, rs.usizeDebug)]).v); } else if (_9 === 1) { const lens: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a07: rs.char): rs.usize => { return rs.charLenUtf8(a07); @@ -564,21 +572,24 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const units: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a08: rs.char): rs.usize => { return rs.charLenUtf16(a08); }), rs.usizeAdd, 0); - const upper: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a09: rs.char): rs.Iter => { + const _61: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a09: rs.char): rs.Iter => { return rs.charToUppercase(a09); - }, undefined, true)); - const lower: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { + }, undefined, true); + const upper: rs.String = rs.stringExtendChars(rs.stringNew(), _61); + const _64: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { return rs.charToLowercase(a010); - }, undefined, true)); - const args12 = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper), (f: rs.Formatter) => rs.fmtPad(f, lower)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", args12[3]])); + }, undefined, true); + const lower: rs.String = rs.stringExtendChars(rs.stringNew(), _64); + const args12 = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper.v), (f: rs.Formatter) => rs.fmtPad(f, lower.v)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", args12[3]]).v); } else { - const escaped: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { + const _85: rs.Iter = rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { return rs.charEscapeDefault(a0); - }, undefined, true)); - const debug: string = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.strChars(s2), (a02: rs.char): rs.Iter => { + }, undefined, true); + const escaped: rs.String = rs.stringExtendChars(rs.stringNew(), _85); + const debug: rs.String = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.strChars(s2), (a02: rs.char): rs.Iter => { return rs.charEscapeDebug(a02); - }), (e: rs.Iter): string => { + }), (e: rs.Iter): rs.String => { return rs.fmtToString((f: rs.Formatter) => rs.fmtCharsDisplay(e, f)); })); const unicode: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.strChars(s2), (a03: rs.char): rs.Iter => { @@ -586,8 +597,8 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), (e2: rs.Iter): rs.usize => { return e2.len(); }), "next", 4); - const args11 = [(f: rs.Formatter) => rs.fmtPad(f, escaped), (f: rs.Formatter) => rs.fmtPad(f, debug), (f: rs.Formatter) => rs.fmtList(unicode.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]])); + const args11 = [(f: rs.Formatter) => rs.fmtPad(f, escaped.v), (f: rs.Formatter) => rs.fmtPad(f, debug.v), (f: rs.Formatter) => rs.fmtList(unicode.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1], "|", args11[2]]).v); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterAll(rs.strChars(s2), (a04: rs.char): boolean => { return rs.charIsAlphanumeric(a04); }), rs.iterAny(rs.strChars(s2), (a05: rs.char): boolean => { diff --git a/ts/fixtures/lang/chars/expected/harness.ts b/ts/fixtures/lang/chars/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/chars/expected/harness.ts +++ b/ts/fixtures/lang/chars/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/chunks/expected/chunks.ts b/ts/fixtures/lang/chunks/expected/chunks.ts index 33392c25d..5158e6f29 100644 --- a/ts/fixtures/lang/chunks/expected/chunks.ts +++ b/ts/fixtures/lang/chunks/expected/chunks.ts @@ -149,11 +149,11 @@ export function chunks(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, chosen2); rs.byteVecPush(out, chosen2.data[chosen2.start + 1]); const args5 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chosen2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(lit), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); if (data.length >= 3) { const chunk2: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, 3); const args6 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v)); } } else if (_4 === 4) { const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Uint8Array => { diff --git a/ts/fixtures/lang/clones/expected/clones.Pair.ts b/ts/fixtures/lang/clones/expected/clones.Pair.ts index a87524e42..b7e29d6e3 100644 --- a/ts/fixtures/lang/clones/expected/clones.Pair.ts +++ b/ts/fixtures/lang/clones/expected/clones.Pair.ts @@ -4,15 +4,15 @@ import * as rs from "./rs.ts"; import * as Logged from "./clones.Logged.ts"; export function clone$Clone(self: Pair): Pair { - return new Pair(self.left.map(Logged.clone$Clone), self.tag); + return new Pair(self.left.map(Logged.clone$Clone), rs.stringClone(self.tag)); } /** A derived `Clone`, which clones each field in order. */ export class Pair { left: Logged.Logged[]; - tag: string; + tag: rs.String; - constructor(left: Logged.Logged[], tag: string) { + constructor(left: Logged.Logged[], tag: rs.String) { this.left = left; this.tag = tag; } diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index bddd7d194..aef9b0caf 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -6737,34 +6737,35 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return x67; }, out); } else if (_9 === 3) { - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_273: rs.u8): rs.char => { + const _111: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_273: rs.u8): rs.char => { const _518: rs.usize = rs.u8Rem(_273, 4) as rs.usize; if (!(_518 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _518); } return [97, 233, 20013, 129408][_518]; - })); - turns$str_Chars_clones_iters_closure53_clones_iters_closure54(rs.strChars(text), (it53: rs.Iter): rs.char | undefined => { + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _111); + turns$str_Chars_clones_iters_closure53_clones_iters_closure54(rs.strChars(text.v), (it53: rs.Iter): rs.char | undefined => { return rs.iterToOption(it53.nextBack()); }, plan, (c4: rs.char): rs.u8 => { return rs.u32Rem(c4 as rs.u32, 251) & 0xff; }, out); - turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(rs.strBytes(text), (it54: rs.Iter): rs.u8 | undefined => { + turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(rs.strBytes(text.v), (it54: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it54.nextBack()); }, plan, (b15: rs.u8): rs.u8 => { return b15; }, out); - turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(rs.strSplit(text, "é"), (it55: rs.Iter): string | undefined => { + turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(rs.strSplit(text.v, "é"), (it55: rs.Iter): string | undefined => { return rs.iterToOption(it55.nextBack()); }, plan, (s: string): rs.u8 => { return rs.stringLen(s) & 0xff; }, out); - turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(rs.strSplit(text, "中"), (it56: rs.Iter): string | undefined => { + turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(rs.strSplit(text.v, "中"), (it56: rs.Iter): string | undefined => { return rs.iterToOption(it56.next()); }, plan, (s2: string): rs.u8 => { return rs.stringLen(s2) & 0xff; }, out); - const _135: string = text; + const _135: string = text.v; const make6 = (captured7: rs.u8): (a0: rs.char) => boolean => { return rs.cloning((c5: rs.char): boolean => { captured7 = rs.u8WrappingAdd(captured7, 1); @@ -6779,7 +6780,7 @@ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }, plan, (s3: string): rs.u8 => { return rs.stringLen(s3) & 0xff; }, out); - turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(rs.strMatchIndices(text, rs.patternChars([97, 129408])), (it58: rs.Iter<[rs.usize, string]>): [rs.usize, string] | undefined => { + turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(rs.strMatchIndices(text.v, rs.patternChars([97, 129408])), (it58: rs.Iter<[rs.usize, string]>): [rs.usize, string] | undefined => { return rs.iterToOption(it58.nextBack()); }, plan, (_283: [rs.usize, string]): rs.u8 => { return (_283[0] & 0xff) ^ (rs.stringLen(_283[1]) & 0xff); @@ -7585,28 +7586,30 @@ export function closures(data: rs.ByteSlice, plan: Plan.Plan, out: rs.ByteVec): flush(log.value, out); rs.drop(copy); flush(log.value, out); - const text: string = "ab"; + const text: rs.String = rs.stringFrom("ab"); const tag2: Logged.Logged = logged(7); - const make6 = (captured9: string, captured10: Logged.Logged): () => [string, Logged.Logged] => { - return rs.closure(rs.cloning((): [string, Logged.Logged] => { - captured9 = captured9 + "c"; - return [captured9, captured10] as [string, Logged.Logged]; - }, () => make6(captured9, Logged.clone$Clone(captured10))), (): void => { + const make6 = (captured9: rs.String, captured10: Logged.Logged): () => [rs.String, Logged.Logged] => { + return rs.closure(rs.cloning((): [rs.String, Logged.Logged] => { + rs.stringPush(captured9, 99); + return [captured9, captured10] as [rs.String, Logged.Logged]; + }, () => make6(((a0: rs.String): rs.String => { + return rs.stringClone(a0); + })(captured9), Logged.clone$Clone(captured10))), (): void => { captured10[Symbol.dispose](); }); }; - const once: () => [string, Logged.Logged] = make6(text, tag2); - const twice: () => [string, Logged.Logged] = rs.closureClone(once); + const once: () => [rs.String, Logged.Logged] = make6(text, tag2); + const twice: () => [rs.String, Logged.Logged] = rs.closureClone(once); flush(log.value, out); - const _127: [string, Logged.Logged] = once(); - const text2: string = _127[0]; + const _127: [rs.String, Logged.Logged] = once(); + const text2: rs.String = _127[0]; const tag3: Logged.Logged = _127[1]; - rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text2), rs.iterSlice(Uint8Array.of(Logged.id(tag3)))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text2.v), rs.iterSlice(Uint8Array.of(Logged.id(tag3)))), undefined, true); tag3[Symbol.dispose](); - const _139: [string, Logged.Logged] = twice(); - const text3: string = _139[0]; + const _139: [rs.String, Logged.Logged] = twice(); + const text3: rs.String = _139[0]; const tag4: Logged.Logged = _139[1]; - rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text3), rs.iterSlice(Uint8Array.of(Logged.id(tag4)))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text3.v), rs.iterSlice(Uint8Array.of(Logged.id(tag4)))), undefined, true); tag4[Symbol.dispose](); flush(log.value, out); const captured11 = data.length & 0xff; @@ -7713,10 +7716,12 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _166: Logged.Logged = logged(part13); const part14 = at(1); const _165: Logged.Logged[] = [_166, logged(part14)]; - const _178: string = "t"; + const _178: rs.String = rs.stringFrom("t"); const part15 = at(2); - const tuple: [Logged.Logged[], string, Logged.Logged] = [_165, _178, logged(part15)]; - const copy: [Logged.Logged[], string, Logged.Logged] = rs.tupleClone(tuple, [(a: Logged.Logged[]) => a.map(Logged.clone$Clone), undefined, Logged.clone$Clone]); + const tuple: [Logged.Logged[], rs.String, Logged.Logged] = [_165, _178, logged(part15)]; + const copy: [Logged.Logged[], rs.String, Logged.Logged] = rs.tupleClone(tuple, [(a: Logged.Logged[]) => a.map(Logged.clone$Clone), (a04: rs.String): rs.String => { + return rs.stringClone(a04); + }, Logged.clone$Clone]); flush(log.value, out); const part16 = rs.sliceFrom(copy[0]); _13(part16, out); @@ -7732,8 +7737,8 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { flush(log.value, out); const part20 = rs.sliceFrom(other.left); _13(part20, out); - rs.iterExtendBytes(out, rs.strBytes(other.tag), undefined, true); - drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair([copy, pair] as [[Logged.Logged[], string, Logged.Logged], Pair.Pair]); + rs.iterExtendBytes(out, rs.strBytes(other.tag.v), undefined, true); + drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair([copy, pair] as [[Logged.Logged[], rs.String, Logged.Logged], Pair.Pair]); flush(log.value, out); other[Symbol.dispose](); flush(log.value, out); @@ -7753,15 +7758,17 @@ export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const part12 = rs.sliceFrom(copy2[1]); _13(part12, out); const _295: rs.u8 = at(4); - const words: string[] = ["a", rs.fmtToString((f: rs.Formatter) => rs.u8Display(_295, f)), ""]; + const words: rs.String[] = [rs.stringFrom("a"), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_295, f), 0), rs.stringNew()]; const vecs: rs.ByteVec[] = [rs.byteSliceToByteVec(data), rs.byteVecFrom(Uint8Array.of(at(5)))]; - const _308: [string[], rs.ByteVec[]] = [words.slice(), vecs.map((a02: rs.ByteVec): rs.ByteVec => { - return rs.byteVecFrom(rs.byteVecView(a02)); + const _308: [rs.String[], rs.ByteVec[]] = [words.map((a02: rs.String): rs.String => { + return rs.stringClone(a02); + }), vecs.map((a03: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a03)); })]; - const words2: string[] = _308[0]; + const words2: rs.String[] = _308[0]; const vecs2: rs.ByteVec[] = _308[1]; rs.byteVecPush(vecs2[0], 1); - rs.iterExtendBytes(out, rs.strBytes(rs.strsJoin(words2, "")), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.strsJoin(words2, "").v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatten(rs.iterChain(rs.iterSlice(vecs), rs.iterSlice(vecs2)), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); rs.dropAll(copy2, drop$array2_clones_Logged); flush(log.value, out); @@ -8118,8 +8125,8 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return logged(at(rs.usizeAdd(2, i3))); }); rs.iterExtend(row, _43, undefined, 8, true); - const v2: rs.Vec> = rs.vecFromElem(row, n(0), (a03: rs.Vec): rs.Vec => { - return rs.vecFrom(a03.items.map(Logged.clone$Clone)); + const v2: rs.Vec> = rs.vecFromElem(row, n(0), (a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged); flush(log.value, out); for (const _62 of v2.items) { @@ -8170,14 +8177,16 @@ export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, none.items.length & 0xff); const part11 = at(3); const _194: rs.u8 = at(4); - const pairs: rs.Vec<[Logged.Logged, string]> = rs.vecFromElem([logged(part11), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_194, f))] as [Logged.Logged, string], n(5), (a02: [Logged.Logged, string]): [Logged.Logged, string] => { - return rs.tupleClone(a02, [Logged.clone$Clone, undefined]); + const pairs: rs.Vec<[Logged.Logged, rs.String]> = rs.vecFromElem([logged(part11), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_194, f), 0)] as [Logged.Logged, rs.String], n(5), (a02: [Logged.Logged, rs.String]): [Logged.Logged, rs.String] => { + return rs.tupleClone(a02, [Logged.clone$Clone, (a03: rs.String): rs.String => { + return rs.stringClone(a03); + }]); }, drop$tuple2_clones_Logged_String); flush(log.value, out); - rs.iterForEach(rs.iterSlice(pairs.items), (_2: [Logged.Logged, string]): undefined => { - rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(_2[1]), rs.iterSlice(Uint8Array.of(Logged.id(_2[0])))), undefined, true); + rs.iterForEach(rs.iterSlice(pairs.items), (_2: [Logged.Logged, rs.String]): undefined => { + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(_2[1].v), rs.iterSlice(Uint8Array.of(Logged.id(_2[0])))), undefined, true); }); - drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String([some, none, pairs] as [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, string]>]); + drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String([some, none, pairs] as [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, rs.String]>]); flush(log.value, out); } else if (_12 === 5) { const part8 = at(0); diff --git a/ts/fixtures/lang/clones/expected/lib.ts b/ts/fixtures/lang/clones/expected/lib.ts index a72fcbbc4..017f79ec3 100644 --- a/ts/fixtures/lang/clones/expected/lib.ts +++ b/ts/fixtures/lang/clones/expected/lib.ts @@ -54,11 +54,11 @@ export function drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Log rs.dropAll(_1[1], drop$array2_clones_Logged); } -export function drop$tuple2_clones_Logged_String(_1: [Logged.Logged, string]): void { +export function drop$tuple2_clones_Logged_String(_1: [Logged.Logged, rs.String]): void { _1[0][Symbol.dispose](); } -export function drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair(_1: [[Logged.Logged[], string, Logged.Logged], Pair.Pair]): void { +export function drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair(_1: [[Logged.Logged[], rs.String, Logged.Logged], Pair.Pair]): void { drop$tuple3_array2_clones_Logged_String_clones_Logged(_1[0]); _1[1][Symbol.dispose](); } @@ -69,7 +69,7 @@ export function drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Log rs.dropAll(_1[2]); } -export function drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String(_1: [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, string]>]): void { +export function drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String(_1: [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, rs.String]>]): void { rs.dropVec(_1[0]); rs.dropVec(_1[1]); rs.dropVec(_1[2], drop$tuple2_clones_Logged_String); @@ -97,7 +97,7 @@ export function drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clo rs.dropAll(_1[2]); } -export function drop$tuple3_array2_clones_Logged_String_clones_Logged(_1: [Logged.Logged[], string, Logged.Logged]): void { +export function drop$tuple3_array2_clones_Logged_String_clones_Logged(_1: [Logged.Logged[], rs.String, Logged.Logged]): void { rs.dropAll(_1[0]); _1[2][Symbol.dispose](); } diff --git a/ts/fixtures/lang/collections/expected/collections.Cloned.ts b/ts/fixtures/lang/collections/expected/collections.Cloned.ts index 6312a4353..c236b49ee 100644 --- a/ts/fixtures/lang/collections/expected/collections.Cloned.ts +++ b/ts/fixtures/lang/collections/expected/collections.Cloned.ts @@ -8,11 +8,11 @@ import * as rs from "./rs.ts"; */ export interface Cloned { depth: rs.u8; - name: string; + name: rs.String; } export function clone$Clone(self: Cloned): Cloned { - return { depth: rs.u8Add(self.depth, 1), name: self.name }; + return { depth: rs.u8Add(self.depth, 1), name: rs.stringClone(self.name) }; } //# sourceMappingURL=collections.Cloned.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index 2b0fbf77c..e3efad8a5 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -27,7 +27,7 @@ import * as Tally from "./collections.Tally.ts"; import * as Window from "./collections.Window.ts"; import * as Wrap from "./collections.Wrap.ts"; import { thenSome$0quywni } from "./core/bool.ts"; -import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pdxnel as option_map$1pdxnel, map$093awy8 as option_map$093awy8, map$0aug5m6 as option_map$0aug5m6, map$16w3l9s as option_map$16w3l9s, map$1y26nmr as option_map$1y26nmr, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$0tj0y3q as option_mapOr$0tj0y3q, mapOr$0f7cus0 as option_mapOr$0f7cus0, mapOr$0vkblkh as option_mapOr$0vkblkh, mapOr$07jk2xl as option_mapOr$07jk2xl, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0pgapuk as option_mapOr$0pgapuk, mapOr$13kt6x8 as option_mapOr$13kt6x8, mapOr$1wei0sy as option_mapOr$1wei0sy, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$18dcmgz as option_mapOr$18dcmgz, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt, mapOr$1f8lrju as option_mapOr$1f8lrju, mapOr$05q90i2 as option_mapOr$05q90i2, mapOr$0955beb as option_mapOr$0955beb, mapOr$1h9hu6n as option_mapOr$1h9hu6n, clone$14nprly as option_clone$14nprly, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; +import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pdxnel as option_map$1pdxnel, map$093awy8 as option_map$093awy8, map$0aug5m6 as option_map$0aug5m6, map$16w3l9s as option_map$16w3l9s, map$0n6ziv9 as option_map$0n6ziv9, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$0tj0y3q as option_mapOr$0tj0y3q, mapOr$0f7cus0 as option_mapOr$0f7cus0, mapOr$0vkblkh as option_mapOr$0vkblkh, mapOr$07jk2xl as option_mapOr$07jk2xl, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0pgapuk as option_mapOr$0pgapuk, mapOr$13kt6x8 as option_mapOr$13kt6x8, mapOr$1wei0sy as option_mapOr$1wei0sy, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$18dcmgz as option_mapOr$18dcmgz, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt, mapOr$1f8lrju as option_mapOr$1f8lrju, mapOr$05q90i2 as option_mapOr$05q90i2, mapOr$0955beb as option_mapOr$0955beb, mapOr$1h9hu6n as option_mapOr$1h9hu6n, clone$0dg4ec5 as option_clone$0dg4ec5, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; import { eq$1a91ieh as result_eq$1a91ieh, eq$122baxc as result_eq$122baxc } from "./core/result.ts"; import { put } from "./harness.ts"; @@ -365,35 +365,37 @@ export function hashMaps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } rs.byteVecPush(out, rs.hashLen(tuples) & 0xff); } else { - const words: rs.HashMap = rs.hashNew() as rs.HashMap; + const words: rs.HashMap = rs.hashNew(rs.HASH_TEXT) as rs.HashMap; for (const b6 of rs.byteSliceView(data)) { const _515: rs.usize = rs.usizeRem(b6 as rs.usize, rs.sliceFrom(["", "a", "ab", "b", "é", "", "￿", "𐀀"]).length); if (!(_515 < 8)) { rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _515); } - rs.byteVecPush(rs.entryOrInsertWith(rs.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_515]), (): rs.ByteVec => { + const word: rs.String = rs.stringFrom(["", "a", "ab", "b", "é", "", "￿", "𐀀"][_515]); + rs.byteVecPush(rs.entryOrInsertWith(rs.entry(words, word), (): rs.ByteVec => { return new rs.ByteVec(); }), b6); } - const lens: rs.BTreeMap = rs.btreeNew(rs.cmpStr) as rs.BTreeMap; - const iter16: rs.Iter<[string, rs.ByteVec]> = rs.hashIter(words); + const lens: rs.BTreeMap = rs.btreeNew(rs.cmpStr) as rs.BTreeMap; + const iter16: rs.Iter<[rs.String, rs.ByteVec]> = rs.hashIter(words); while (true) { - const _530: [string, rs.ByteVec] | rs.Done = iter16.next(); + const _530: [rs.String, rs.ByteVec] | rs.Done = iter16.next(); if (_530 === rs.DONE) { break; } - rs.btreeInsert(lens, _530[0], _530[1].length); + const _537: rs.String = rs.stringClone(_530[0]); + rs.btreeInsert(lens, _537, _530[1].length); } - const iter17: rs.Iter<[string, rs.usize]> = rs.btreeIter(lens); + const iter17: rs.Iter<[rs.String, rs.usize]> = rs.btreeIter(lens); while (true) { - const _542: [string, rs.usize] | rs.Done = iter17.next(); + const _542: [rs.String, rs.usize] | rs.Done = iter17.next(); if (_542 === rs.DONE) { break; } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_542[0])); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_542[0].v)); rs.byteVecPush(out, _542[1] & 0xff); } - rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.hashDrain(words), (_2: [string, rs.ByteVec]): rs.usize => { + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.hashDrain(words), (_2: [rs.String, rs.ByteVec]): rs.usize => { return _2[1].length; }), rs.usizeAdd, 0) & 0xff); rs.byteVecPush(out, rs.hashLen(words) === 0 ? 1 : 0); @@ -1107,7 +1109,7 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v it = rs.dequeRange(q, new rs.Range(a, a)); } rs.byteVecPush(out, it.len() & 0xff); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]).v)); let i2: rs.i32 = 0; while (true) { if ((rs.u8Shr(kind, rs.i32Add(5, rs.i32Rem(i2, 3))) & 1) === 1) { @@ -1117,7 +1119,7 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v } if (item !== undefined) { rs.byteVecPush(out, item); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]).v)); if (i2 === 1) { rs.iterExtendBytes(out, rs.iterRev(it.clone()), undefined, true); } @@ -1133,15 +1135,15 @@ export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): v /** `vec![a, b]` and `vec![x; n]`, of bytes, numbers, `Copy` tuples, and types that clone. */ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { - let name!: string; + let name!: rs.String; const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); const n: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 2), 0) as rs.usize, 5); - const _16: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); + const _16: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_16.ok) { name = _16.value; } else { - name = "?"; + name = rs.stringFrom("?"); } const bytes: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(a, b, 66)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); @@ -1152,9 +1154,9 @@ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { for (const _39 of pairs.items) { rs.byteVecPush(out, _39[0] ^ (_39[1] & 0xff)); } - const names: rs.Vec = rs.vecFrom([name, "x", name]); + const names: rs.Vec = rs.vecFrom([rs.stringClone(name), rs.stringFrom("x"), rs.stringClone(name)]); rs.byteVecPush(out, names.items.length & 0xff); - const one: rs.Vec = rs.vecFrom([{ depth: a, name: name }]); + const one: rs.Vec = rs.vecFrom([{ depth: a, name: rs.stringClone(name) }]); rs.byteVecPush(out, one.items[rs.idx(one.items, 0)].depth); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteVecOf(b, n))); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecFromElem(rs.u16Mul(a as rs.u16, 257), n, undefined).items), (w: rs.u16): rs.u8 => { @@ -1167,13 +1169,15 @@ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(tuples.items), (t: [rs.u8, rs.u8]): rs.u8 => { return t[0] ^ t[1]; }), undefined, true); - rs.byteVecPush(out, rs.vecFromElem(name, n, undefined).items.length & 0xff); + rs.byteVecPush(out, rs.vecFromElem(rs.stringClone(name), n, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }).items.length & 0xff); const cloned: rs.Vec = rs.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(cloned.items), (c: Cloned.Cloned): rs.u8 => { return c.depth; }), undefined, true); rs.byteVecPush(out, rs.iterAll(rs.iterSlice(cloned.items), (c2: Cloned.Cloned): boolean => { - return rs.stringLen(c2.name) === data.length; + return c2.name.len === data.length; }) ? 1 : 0); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecFromElem({ _0: b }, n, Bumped.clone$Clone).items), (o: Bumped.Bumped): rs.u8 => { return o._0; @@ -1220,8 +1224,8 @@ export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(wrapped.items), (w2: Wrap.Wrap): rs.u8 => { return w2.value ^ w2.count; }), undefined, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(names.items), (s2: string): rs.u8 => { - return rs.stringLen(s2) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(names.items), (s2: rs.String): rs.u8 => { + return s2.len & 0xff; }), undefined, true); } @@ -1347,7 +1351,7 @@ export function stores(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); } -export function get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): string | undefined | rs.None { +export function get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.String | undefined | rs.None { return rs.hashGet(self, k, rs.None); } @@ -1359,7 +1363,7 @@ export function get$collections_OptionMap_unit_collections_HashMap_u8_unit(self: return rs.hashGet(self, k, rs.None); } -export function insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8, v: string | undefined): string | undefined | rs.None { +export function insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8, v: rs.String | undefined): rs.String | undefined | rs.None { return rs.hashInsert(self, k, v, undefined, rs.None); } @@ -1371,7 +1375,7 @@ export function insert$collections_OptionMap_unit_collections_HashMap_u8_unit(se return rs.hashInsert(self, k, undefined, undefined, rs.None); } -export function remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): string | undefined | rs.None { +export function remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.String | undefined | rs.None { return rs.hashRemove(self, k, undefined, rs.None); } @@ -1383,7 +1387,7 @@ export function remove$collections_OptionMap_unit_collections_HashMap_u8_unit(se return rs.hashRemove(self, k, undefined, rs.None); } -export function getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.Place | undefined { +export function getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.Place | undefined { return rs.hashGetMut(self, k); } @@ -1395,11 +1399,11 @@ export function getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(se return rs.hashGetMut(self, k); } -export function sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap): rs.Vec<[rs.u8, string | undefined]> { - const all: rs.Vec<[rs.u8, string | undefined]> = rs.iterToVec(rs.iterMap(rs.hashIter(self), (_2: [rs.u8, string | undefined]): [rs.u8, string | undefined] => { - return [_2[0], option_clone$14nprly(_2[1])] as [rs.u8, string | undefined]; +export function sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap): rs.Vec<[rs.u8, rs.String | undefined]> { + const all: rs.Vec<[rs.u8, rs.String | undefined]> = rs.iterToVec(rs.iterMap(rs.hashIter(self), (_2: [rs.u8, rs.String | undefined]): [rs.u8, rs.String | undefined] => { + return [_2[0], option_clone$0dg4ec5(_2[1])] as [rs.u8, rs.String | undefined]; }), "next", 16); - rs.sliceSort(rs.sliceFrom(all.items), rs.keyLt((_22: [rs.u8, string | undefined]): rs.u8 => { + rs.sliceSort(rs.sliceFrom(all.items), rs.keyLt((_22: [rs.u8, rs.String | undefined]): rs.u8 => { return _22[0]; }, rs.lt), 16, true); return all; @@ -1477,36 +1481,36 @@ export function sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(s * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_String_collections_HashMap_u8_Option_String(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => string | undefined, out: rs.ByteVec): void { - let read!: string; +export function optional$Option_String_collections_HashMap_u8_Option_String(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.String | undefined, out: rs.ByteVec): void { + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); if (_14 === 0) { - const _24: string | undefined = value(b); + const _24: rs.String | undefined = value(b); const part3 = insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k, _24); - read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None), " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.String | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), rs.None), " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None), " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.String | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), rs.None), " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None), " "]); + read = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.String | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), rs.None), " "]); } else { - const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); + const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { - const v: rs.Place = _49; - const _53: string | undefined = value(rs.u8Div(b, 2)); + const v: rs.Place = _49; + const _53: rs.String | undefined = value(rs.u8Div(b, 2)); v.v = _53; - read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtOption(v.v, f, rs.fmtStr), " "]); + read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtOption(v.v, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, string | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.fmtStr)], f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.String | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))], f))]).v)); } /** @@ -1514,7 +1518,7 @@ export function optional$Option_String_collections_HashMap_u8_Option_String(map: * `value` making what `insert` and `get_mut` put. */ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.u8 | undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1531,7 +1535,7 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); @@ -1539,10 +1543,10 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug), " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]).v)); } /** @@ -1550,7 +1554,7 @@ export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTr * `value` making what `insert` and `get_mut` put. */ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.u8 | undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1567,7 +1571,7 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash } else { const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); @@ -1575,10 +1579,10 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash read = rs.fmtFormat(["=", (f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug), " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]).v)); } /** @@ -1586,7 +1590,7 @@ export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.Hash * `value` making what `insert` and `get_mut` put. */ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1603,7 +1607,7 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap | undefined = getMut$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; value(rs.u8Div(b, 2)); @@ -1611,10 +1615,10 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap rs.fmtUnit(v.v, f), " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]).v)); } /** @@ -1622,7 +1626,7 @@ export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => undefined, out: rs.ByteVec): void { - let read!: string; + let read!: rs.String; for (const b of rs.byteSliceView(data)) { const k: rs.u8 = rs.u8Rem(b, 8); const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); @@ -1639,7 +1643,7 @@ export function optional$unit_collections_HashMap_u8_unit(map: rs.HashMap | undefined = getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); if (_49 === undefined) { - read = "- "; + read = rs.stringFrom("- "); } else { const v: rs.Place = _49; value(rs.u8Div(b, 2)); @@ -1647,10 +1651,10 @@ export function optional$unit_collections_HashMap_u8_unit(map: rs.HashMap rs.fmtUnit(v.v, f), " "]); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read.v)); } const part4 = sorted$collections_OptionMap_unit_collections_HashMap_u8_unit(map); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]).v)); } /** `b`, unless a multiple of 3. */ @@ -1664,8 +1668,8 @@ export function made$collections_BTreeMap_u8_Option_u8(): rs.BTreeMap::default` makes its map. */ -export function made$collections_HashMap_u8_Option_String(): rs.HashMap { - return rs.hashNew() as rs.HashMap; +export function made$collections_HashMap_u8_Option_String(): rs.HashMap { + return rs.hashNew() as rs.HashMap; } /** @@ -1684,9 +1688,9 @@ export function optionals(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else if (_4 === 3) { optional$unit_collections_BTreeMap_u8_unit(rs.btreeNew(rs.cmp) as rs.BTreeMap, data, (_2: rs.u8): undefined => {}, out); } else if (_4 === 4) { - optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), data, (b2: rs.u8): string | undefined => { - return option_map$1y26nmr(some(b2), (b3: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b3, f)); + optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), data, (b2: rs.u8): rs.String | undefined => { + return option_map$0n6ziv9(some(b2), (b3: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b3, f), 0); }); }, out); } else { @@ -1708,11 +1712,11 @@ export function optionals(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const _53: boolean = rs.hashContains(map, k); const _56: rs.u8 | undefined | rs.None = read; const args5 = [(f: rs.Formatter) => rs.fmtOption(_56, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_53, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " "]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " "]).v)); } const all: rs.Vec<[[rs.u8, boolean], rs.u8 | undefined]> = rs.iterToVec(rs.hashIter(map), "next", 4); rs.sliceSort(rs.sliceFrom(all.items), rs.cmpLt(rs.cmpTuple<[[rs.u8, boolean], rs.u8 | undefined], rs.Ordering | undefined>([rs.cmpTuple<[rs.u8, boolean], rs.Ordering | undefined>([rs.cmp, rs.cmp]), rs.cmpOption(rs.cmp)])), 4, true); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [[rs.u8, boolean], rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0][0], f), (f: rs.Formatter) => rs.fmtBool(value[0][1], f)], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [[rs.u8, boolean], rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0][0], f), (f: rs.Formatter) => rs.fmtBool(value[0][1], f)], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]).v)); } } @@ -4390,11 +4394,11 @@ export function cellEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putCmp(rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob), log, out); const _261: rs.u16 = at(0); const _267: rs.u16 = at(1); - const _257: [rs.RefCell, rs.RefCell] = [new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_261, f))), new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_267, f)))]; - const sa: rs.RefCell = _257[0]; - const sb: rs.RefCell = _257[1]; - putEq(rs.refCellBy(rs.same)(sa, sb), log, out); - putEq(!rs.refCellBy(rs.same)(sa, sb), log, out); + const _257: [rs.RefCell, rs.RefCell] = [new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_261, f), 0)), new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_267, f), 0))]; + const sa: rs.RefCell = _257[0]; + const sb: rs.RefCell = _257[1]; + putEq(rs.refCellBy(rs.eqStr)(sa, sb), log, out); + putEq(!rs.refCellBy(rs.eqStr)(sa, sb), log, out); putEq(rs.refCellBy(rs.cmpStr)(sa, sb) === -1, log, out); const order5 = rs.refCellBy(rs.cmpStr)(sa, sb); putEq(order5 !== undefined && order5 <= 0, log, out); @@ -5846,27 +5850,27 @@ export function btreeExtracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): }); const _62: [rs.usize, rs.usize | undefined] = it.sizeHint(); const args26 = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_62[0], f), (f: rs.Formatter) => rs.fmtOption(_62[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1]])); + put(out, rs.fmtFormat([args26[0], " ", args26[1]]).v); const _72: rs.Iter<[rs.u16, rs.u16]> = it; const _74: rs.usize = limit as rs.usize; const taken: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterTake(rs.iterBorrow(_72), _74), "next", 4); const _83: [rs.usize, rs.usize | undefined] = it.sizeHint(); const args27 = [(f: rs.Formatter) => rs.fmtList(taken.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_83[0], f), (f: rs.Formatter) => rs.fmtOption(_83[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2]])); + put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2]]).v); if (rs.u8Rem(limit, 2) === 0) { const _104: [rs.u16, rs.u16] | undefined = rs.iterToOption(it.next()); const args28 = [(f: rs.Formatter) => rs.fmtOption(_104, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug)]; - put(out, rs.fmtFormat([args28[0], " ", rs.fmtSpec({ alternate: true }, args28[1])])); + put(out, rs.fmtFormat([args28[0], " ", rs.fmtSpec({ alternate: true }, args28[1])]).v); } const _122: rs.usize = rs.btreeLen(map); const _125: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterStepBy(rs.btreeIter(map), 7), "next", 8); const args29 = [(f: rs.Formatter) => rs.usizeDisplay(_122, f), (f: rs.Formatter) => rs.fmtList(_125.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args29[0], " ", args29[1]])); + put(out, rs.fmtFormat([args29[0], " ", args29[1]]).v); const taken2: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.btreeExtractIfMut(map, undefined, (_217: rs.u16, v3: rs.Place): boolean => { return rs.u16Rem(v3.v, 3) === 0; }), "next", 4); const args30 = [(f: rs.Formatter) => rs.fmtList(taken2.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u16Debug, rs.u16Debug)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1]])); + put(out, rs.fmtFormat([args30[0], " ", args30[1]]).v); } else if (_44 === 1) { const _152: rs.Iter = rs.iterMap(new rs.Range(0, n), (k5: rs.u16): rs.u16 => { return rs.u16Rem(rs.u16Mul(k5, 3), rs.u16Add(n, 1)); @@ -5875,23 +5879,23 @@ export function btreeExtracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): const it2: rs.Iter = rs.btreeExtractKeysIf(set, range, (k6: rs.u16): boolean => { return rs.u16Rem(k6, every) !== 0; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug)]).v); const _174: rs.Iter = it2; const _176: rs.usize = limit as rs.usize; const taken3: rs.Vec = rs.iterToVec(rs.iterTake(rs.iterBorrow(_174), _176), "next", 2); const _185: [rs.usize, rs.usize | undefined] = it2.sizeHint(); const args22 = [(f: rs.Formatter) => rs.fmtList(taken3.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_185[0], f), (f: rs.Formatter) => rs.fmtOption(_185[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2]])); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u16Debug)])); + put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2]]).v); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u16Debug)]).v); const part3 = rs.btreeExtractKeysIf(rs.btreeNew(rs.cmp) as rs.BTreeSet, range, (_212: rs.u16): boolean => { return true; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(part3, f, rs.u16Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(part3, f, rs.u16Debug)]).v); rs.btreeClear(set); const part4 = rs.btreeExtractKeysIf(set, undefined, (_216: rs.u16): boolean => { return true; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(part4, f, rs.u16Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBTreeExtractIf(part4, f, rs.u16Debug)]).v); } else { const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); const _243: rs.Iter<[Logged.Logged, Logged.Logged]> = rs.iterMap(new rs.Range(0, rs.u16Div(n, 2)), (k: rs.u16): [Logged.Logged, Logged.Logged] => { diff --git a/ts/fixtures/lang/collections/expected/core/option.ts b/ts/fixtures/lang/collections/expected/core/option.ts index 6af90f86a..7a570f447 100644 --- a/ts/fixtures/lang/collections/expected/core/option.ts +++ b/ts/fixtures/lang/collections/expected/core/option.ts @@ -53,7 +53,7 @@ export function map$16w3l9s(self: Nibble.Nibble | undefined, f: (a0: Nibble.Nibb return f(self); } -export function map$1y26nmr(self: rs.u8 | undefined, f: (a0: rs.u8) => string): string | undefined { +export function map$0n6ziv9(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.String): rs.String | undefined { if (self === undefined) { return undefined; } @@ -200,11 +200,11 @@ export function mapOr$1h9hu6n(self: [rs.u8, rs.u8] | undefined, default_: rs.u8, return f(self); } -export function clone$14nprly(self: string | undefined): string | undefined { +export function clone$0dg4ec5(self: rs.String | undefined): rs.String | undefined { if (self === undefined) { return undefined; } - return self; + return rs.stringClone(self); } export function flatten$0ux6gqw(self: rs.u8 | undefined | rs.None): rs.u8 | undefined { diff --git a/ts/fixtures/lang/collects/expected/collects.Bag.ts b/ts/fixtures/lang/collects/expected/collects.Bag.ts index 22a74de35..605b22068 100644 --- a/ts/fixtures/lang/collects/expected/collects.Bag.ts +++ b/ts/fixtures/lang/collects/expected/collects.Bag.ts @@ -38,9 +38,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_iter_Filter_it } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -66,9 +66,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_iter_Rev_slice } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -94,9 +94,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_iter_Skip_slic } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -122,9 +122,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_iter_Take_slic } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -150,9 +150,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_slice_Iter_u8_ } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -178,9 +178,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_slice_Iter_u8_ } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -206,9 +206,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_slice_Iter_u8_ } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -234,9 +234,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_slice_Iter_u8_ } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -262,9 +262,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Map_slice_Iter_u8_ } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -290,9 +290,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_Skip_vec_IntoIter_ } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -320,9 +320,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_adapters_GenericSh } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } @@ -348,9 +348,9 @@ export function fromIter$iter_FromIterator_collects_Item_iter_adapters_GenericSh } const _17: Item.Item | undefined = rs.sliceFirst(rs.sliceFrom(items.items)); if (_17 !== undefined) { - const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); + const _25: rs.RefCell> = rs.refCellBorrowMut(_17.log); const part = items.items.length; - const _26: string = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _26: rs.String = rs.fmtFormat(["bag of ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); _25.value.items.push(_26); rs.refMutRelease(_25); } diff --git a/ts/fixtures/lang/collects/expected/collects.Count.ts b/ts/fixtures/lang/collects/expected/collects.Count.ts index de9bd14c4..b03fdaf65 100644 --- a/ts/fixtures/lang/collects/expected/collects.Count.ts +++ b/ts/fixtures/lang/collects/expected/collects.Count.ts @@ -6,13 +6,13 @@ import * as Down from "./collects.Down.ts"; /** What counts down from `n`, by the crate's own iterator. */ export interface Count { n: rs.u8; - log: rs.RefCell>; + log: rs.RefCell>; } export function intoIter$iter_IntoIterator(self: Count): Down.Down { - const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); + const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); const arg = self.n; - const _6: string = rs.fmtFormat(["count ", (f: rs.Formatter) => rs.u8Display(arg, f)]); + const _6: rs.String = rs.fmtFormat(["count ", (f: rs.Formatter) => rs.u8Display(arg, f)]); _5.value.items.push(_6); rs.refMutRelease(_5); return new Down.Down(self.n, self.log); diff --git a/ts/fixtures/lang/collects/expected/collects.Down.ts b/ts/fixtures/lang/collects/expected/collects.Down.ts index 7274f72f7..c52aa95bc 100644 --- a/ts/fixtures/lang/collects/expected/collects.Down.ts +++ b/ts/fixtures/lang/collects/expected/collects.Down.ts @@ -5,9 +5,9 @@ import * as rs from "./rs.ts"; /** The crate's own iterator, which logs each read and its drop. */ export class Down { n: rs.u8; - log: rs.RefCell>; + log: rs.RefCell>; - constructor(n: rs.u8, log: rs.RefCell>) { + constructor(n: rs.u8, log: rs.RefCell>) { this.n = n; this.log = log; } @@ -18,9 +18,9 @@ export class Down { } export function next$iter_Iterator(self: Down): rs.u8 | rs.Done { - const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); + const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); const arg = self.n; - const _6: string = rs.fmtFormat(["next ", (f: rs.Formatter) => rs.u8Display(arg, f)]); + const _6: rs.String = rs.fmtFormat(["next ", (f: rs.Formatter) => rs.u8Display(arg, f)]); _5.value.items.push(_6); rs.refMutRelease(_5); const _15: rs.u8 | undefined = rs.u8CheckedSub(self.n, 1); @@ -32,9 +32,9 @@ export function next$iter_Iterator(self: Down): rs.u8 | rs.Done { } export function drop$ops_Drop(self: Down): void { - const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); + const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); const arg = self.n; - const _6: string = rs.fmtFormat(["down dropped at ", (f: rs.Formatter) => rs.u8Display(arg, f)]); + const _6: rs.String = rs.fmtFormat(["down dropped at ", (f: rs.Formatter) => rs.u8Display(arg, f)]); _5.value.items.push(_6); rs.refMutRelease(_5); } diff --git a/ts/fixtures/lang/collects/expected/collects.Item.ts b/ts/fixtures/lang/collects/expected/collects.Item.ts index b60b3d9d8..17043cc0f 100644 --- a/ts/fixtures/lang/collects/expected/collects.Item.ts +++ b/ts/fixtures/lang/collects/expected/collects.Item.ts @@ -5,9 +5,9 @@ import * as rs from "./rs.ts"; /** Logs its byte as it drops. */ export class Item { v: rs.u8; - log: rs.RefCell>; + log: rs.RefCell>; - constructor(v: rs.u8, log: rs.RefCell>) { + constructor(v: rs.u8, log: rs.RefCell>) { this.v = v; this.log = log; } @@ -18,9 +18,9 @@ export class Item { } export function drop$ops_Drop(self: Item): void { - const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); + const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); const arg = self.v; - const _6: string = rs.fmtFormat(["drop ", (f: rs.Formatter) => rs.u8Display(arg, f)]); + const _6: rs.String = rs.fmtFormat(["drop ", (f: rs.Formatter) => rs.u8Display(arg, f)]); _5.value.items.push(_6); rs.refMutRelease(_5); } diff --git a/ts/fixtures/lang/collects/expected/collects.ts b/ts/fixtures/lang/collects/expected/collects.ts index 770453d88..71a3943d9 100644 --- a/ts/fixtures/lang/collects/expected/collects.ts +++ b/ts/fixtures/lang/collects/expected/collects.ts @@ -12,101 +12,101 @@ import { map$1hm93qk as option_map$1hm93qk, map$1yttib1 as option_map$1yttib1, m import { put } from "./harness.ts"; /** What `values` reads, each at most `limit`, and the log. */ -export function write$Option_ref_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: Item.Item | undefined): void { +export function write$Option_ref_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: Item.Item | undefined): void { const part = rs.iterToByteVec(rs.iterMap(rs.iterOption(values), (item: Item.Item): rs.u8 => { return item.v; }), undefined, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$array0_ref_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: Item.Item[]): void { +export function write$array0_ref_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: Item.Item[]): void { const part = rs.iterToByteVec(rs.iterMap(rs.iterSlice(values), (item: Item.Item): rs.u8 => { return item.v; }), undefined, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$iter_Chain_slice_Iter_collects_Item_slice_Iter_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { +export function write$iter_Chain_slice_Iter_collects_Item_slice_Iter_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { const part = rs.iterToByteVec(rs.iterMap(values, (item: Item.Item): rs.u8 => { return item.v; }), undefined, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$iter_Flatten_option_Iter_collects_Bag(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { +export function write$iter_Flatten_option_Iter_collects_Bag(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { const part = rs.iterToByteVec(rs.iterMap(values, (item: Item.Item): rs.u8 => { return item.v; }), "next"); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$iter_Skip_iter_Flatten_slice_Iter_collects_Bag(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { +export function write$iter_Skip_iter_Flatten_slice_Iter_collects_Bag(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { const part = rs.iterToByteVec(rs.iterMap(values, (item: Item.Item): rs.u8 => { return item.v; }), "next"); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$iter_StepBy_iter_FlatMap_iter_Rev_ops_Range_usize_ref_collects_Bag_collects_flattens_closure5(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { +export function write$iter_StepBy_iter_FlatMap_iter_Rev_ops_Range_usize_ref_collects_Bag_collects_flattens_closure5(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { const part = rs.iterToByteVec(rs.iterMap(values, (item: Item.Item): rs.u8 => { return item.v; }), "next"); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$iter_Take_slice_Iter_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { +export function write$iter_Take_slice_Iter_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: rs.Iter): void { const part = rs.iterToByteVec(rs.iterMap(values, (item: Item.Item): rs.u8 => { return item.v; }), undefined, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$ref_Vec_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: rs.Vec): void { +export function write$ref_Vec_collects_Item(out: rs.ByteVec, log: rs.RefCell>, values: rs.Vec): void { const part = rs.iterToByteVec(rs.iterMap(rs.iterSlice(values.items), (item: Item.Item): rs.u8 => { return item.v; }), undefined, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } /** What `values` reads, each at most `limit`, and the log. */ -export function write$ref_collects_Bag(out: rs.ByteVec, log: rs.RefCell>, values: Bag.Bag): void { +export function write$ref_collects_Bag(out: rs.ByteVec, log: rs.RefCell>, values: Bag.Bag): void { const part = rs.iterToByteVec(rs.iterMap(Bag.intoIter$iter_IntoIterator_ref(values), (item: Item.Item): rs.u8 => { return item.v; }), undefined, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)])); - const _29: rs.RefCell> = rs.refCellBorrowMut(log); - put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ")); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]).v); + const _29: rs.RefCell> = rs.refCellBorrowMut(log); + put(out, rs.strsJoin(rs.iterToVec(rs.vecDrain(_29.value, undefined), "fold", 12, true).items, ", ").v); rs.refMutRelease(_29); } @@ -115,10 +115,10 @@ export function write$ref_collects_Bag(out: rs.ByteVec, log: rs.RefCell> = new rs.RefCell(new rs.Vec()); + const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); const item: (a0: rs.u8) => Item.Item = (v: rs.u8): Item.Item => { - const _6: rs.RefCell> = rs.refCellBorrowMut(log); - const _7: string = rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u8Display(v, f)]); + const _6: rs.RefCell> = rs.refCellBorrowMut(log); + const _7: rs.String = rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u8Display(v, f)]); _6.value.items.push(_7); rs.refMutRelease(_6); return new Item.Item(v, log); @@ -160,7 +160,7 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void bag5[Symbol.dispose](); } else { const arg5 = bag4.error; - put(out, rs.fmtFormat(["err ", (f: rs.Formatter) => rs.u8Display(arg5, f)])); + put(out, rs.fmtFormat(["err ", (f: rs.Formatter) => rs.u8Display(arg5, f)]).v); } } else if (_12 === 4) { const bag6: Bag.Bag | undefined = rs.iterCollectOption(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): Item.Item | undefined => { @@ -172,7 +172,7 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part6 = option_map$0a0rmxp(bag6, (bag7: Bag.Bag): rs.usize => { return bag7.items.items.length; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, rs.usizeDebug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, rs.usizeDebug)]).v); const _89: rs.Iter = rs.iterFlatten(rs.iterOption(bag6), (value: Bag.Bag) => Bag.intoIter$iter_IntoIterator_ref(value), true); write$iter_Flatten_option_Iter_collects_Bag(out, log, _89); rs.drop(bag6); @@ -184,7 +184,7 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _105: rs.Fmt = (f: rs.Formatter) => rs.fmtList(part5.items, f, rs.u16Debug); const arg4 = stack.count; const args25 = [_105, (f: rs.Formatter) => rs.usizeDisplay(arg4, f)]; - put(out, rs.fmtFormat([args25[0], " ", args25[1]])); + put(out, rs.fmtFormat([args25[0], " ", args25[1]]).v); const stack2: Stack.Stack = Stack.fromIter$iter_FromIterator_collects_Item_collects_Item_iter_Map_iter_Take_slice_Iter_u8_collects_collects_closure8(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), k), (_211: rs.u8): Item.Item => { return item(_211); })); @@ -199,7 +199,7 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _133: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(part3), f, rs.u8Debug); const arg2 = stack3.count; const args23 = [_133, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; - put(out, rs.fmtFormat([args23[0], " ", args23[1]])); + put(out, rs.fmtFormat([args23[0], " ", args23[1]]).v); const down: Down.Down = new Down.Down(n, log); const stack4: Stack.Stack = Stack.fromIter$iter_FromIterator_u8_u8_iter_Take_mut_collects_Down(rs.iterTake(rs.iterFrom(down, Down.next$iter_Iterator), k)); const _153: rs.u8 | undefined = rs.iterToOption(Down.next$iter_Iterator(down)); @@ -207,7 +207,7 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _156: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(part4), f, rs.u8Debug); const arg3 = stack4.count; const args24 = [_156, (f: rs.Formatter) => rs.usizeDisplay(arg3, f), (f: rs.Formatter) => rs.fmtOption(_153, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2]])); + put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2]]).v); down[Symbol.dispose](); } else { const tries: rs.Result, Item.Item> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result => { @@ -219,11 +219,11 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }), (values: rs.Iter) => Tries.fromIter$iter_FromIterator_u8_u8_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_collects_collects_closure10_Result_never_collects_Item(values), undefined, rs.drop); if (tries.ok) { const part = tries.value._0; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part.items, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part.items, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]).v); } else { const e2: Item.Item = tries.error; const arg = e2.v; - put(out, rs.fmtFormat(["err ", (f: rs.Formatter) => rs.u8Display(arg, f)])); + put(out, rs.fmtFormat(["err ", (f: rs.Formatter) => rs.u8Display(arg, f)]).v); e2[Symbol.dispose](); } const part2 = option_map$1yttib1(rs.iterCollectOption(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): Item.Item | undefined => { @@ -241,7 +241,7 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.dropVec(values3); return _05; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))]).v); } write$array0_ref_collects_Item(out, log, []); } @@ -251,10 +251,10 @@ export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void * over one whose iterator is the crate's own, read only so far. */ export function flattens(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); + const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); const item: (a0: rs.u8) => Item.Item = (v: rs.u8): Item.Item => { - const _6: rs.RefCell> = rs.refCellBorrowMut(log); - const _7: string = rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u8Display(v, f)]); + const _6: rs.RefCell> = rs.refCellBorrowMut(log); + const _7: rs.String = rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u8Display(v, f)]); _6.value.items.push(_7); rs.refMutRelease(_6); return new Item.Item(v, log); @@ -273,8 +273,8 @@ export function flattens(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void item3[Symbol.dispose](); return _013; }); - const _27: rs.RefCell> = rs.refCellBorrowMut(log); - const _29: string = rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(back, f, rs.u8Debug)]); + const _27: rs.RefCell> = rs.refCellBorrowMut(log); + const _29: rs.String = rs.fmtFormat(["back ", (f: rs.Formatter) => rs.fmtOption(back, f, rs.u8Debug)]); _27.value.items.push(_29); rs.refMutRelease(_27); rs.drop(it); @@ -310,24 +310,24 @@ export function flattens(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part2 = rs.iterToByteVec(rs.iterTake(rs.iterFlatMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): Count.Count => { return { n: rs.u8Rem(_23, 5), log }; }, (value: Count.Count) => rs.iterFrom(Count.intoIter$iter_IntoIterator(value), Down.next$iter_Iterator, rs.drop), true), k), "next"); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part2), f, rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part2), f, rs.u8Debug)]).v); } else if (_11 === 4) { const part = rs.iterFold(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Count.Count => { return { n: rs.u8Rem(_2, 4), log }; }), (value: Count.Count) => rs.iterFrom(Count.intoIter$iter_IntoIterator(value), Down.next$iter_Iterator, rs.drop), true), 0, (sum2: rs.u32, v3: rs.u8): rs.u32 => { return rs.u32Add(sum2, v3 as rs.u32); }, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part, f)]).v); } write$array0_ref_collects_Item(out, log, []); } /** `chain`, `zip`, and `extend` of the crate's collections. */ export function chains(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); + const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); const item: (a0: rs.u8) => Item.Item = (v: rs.u8): Item.Item => { - const _6: rs.RefCell> = rs.refCellBorrowMut(log); - const _7: string = rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u8Display(v, f)]); + const _6: rs.RefCell> = rs.refCellBorrowMut(log); + const _7: rs.String = rs.fmtFormat(["make ", (f: rs.Formatter) => rs.u8Display(v, f)]); _6.value.items.push(_7); rs.refMutRelease(_6); return new Item.Item(v, log); @@ -356,14 +356,14 @@ export function chains(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const part = rs.iterToVec(rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterFrom(Count.intoIter$iter_IntoIterator({ n: 4, log }), Down.next$iter_Iterator, rs.drop)), (_24: [rs.u8, rs.u8]): [rs.u8, rs.u8] => { return [_24[0], _24[1]] as [rs.u8, rs.u8]; }), "next", 2); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]).v); const part2 = rs.iterToByteVec(rs.iterMap(rs.iterZip(new rs.Range(0, k), Bag.intoIter$iter_IntoIterator(bag2), "len", undefined, rs.drop), (_25: [rs.usize, Item.Item]): rs.u8 => { const item2: Item.Item = _25[1]; const _04: rs.u8 = item2.v; item2[Symbol.dispose](); return _04; }), "fold", true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part2), f, rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part2), f, rs.u8Debug)]).v); } write$array0_ref_collects_Item(out, log, []); } diff --git a/ts/fixtures/lang/combinators/expected/combinators.ts b/ts/fixtures/lang/combinators/expected/combinators.ts index bd9b0a83c..0c3ee50d6 100644 --- a/ts/fixtures/lang/combinators/expected/combinators.ts +++ b/ts/fixtures/lang/combinators/expected/combinators.ts @@ -2,8 +2,8 @@ import * as rs from "./rs.ts"; import { copy$Result_array2_u32_u16, copy$array_u32 } from "./lib.ts"; -import { isSomeAnd$1s2u5lz, isNoneOr$0xn3i4j, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrElse$1badkpb as option_unwrapOrElse$1badkpb, unwrapOrElse$0wd124z as option_unwrapOrElse$0wd124z, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, unwrapOrDefault$03apme8 as option_unwrapOrDefault$03apme8, map$1y26nmr as option_map$1y26nmr, map$1px2rk4 as option_map$1px2rk4, map$1ek423e as option_map$1ek423e, map$1yjmt5m as option_map$1yjmt5m, inspect$1sa9a1m as option_inspect$1sa9a1m, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOrElse$0moj49b as option_mapOrElse$0moj49b, okOr$12zia2c as option_okOr$12zia2c, okOr$19jxvkb as option_okOr$19jxvkb, okOr$1j8owgb as option_okOr$1j8owgb, okOrElse$1usib9z as option_okOrElse$1usib9z, okOrElse$0cs4x8k as option_okOrElse$0cs4x8k, and$02hlbkj as option_and$02hlbkj, andThen$195hx6l as option_andThen$195hx6l, filter$1855tjj, filter$0hq86nl, or$0ar58vy as option_or$0ar58vy, orElse$05gzawv as option_orElse$05gzawv, orElse$1xazu5k as option_orElse$1xazu5k, xor$0x5qjg4, zip$0p00b0o, clone$14nprly as option_clone$14nprly } from "./core/option.ts"; -import { isOkAnd$1poqzjs, isErrAnd$0ecrrmy, ok$08qo4au, err$0zs6b4d, asRef$0qzh9or, map$0jdlh8o as result_map$0jdlh8o, map$044vsgj as result_map$044vsgj, mapOr$1yz3viz as result_mapOr$1yz3viz, mapOrElse$0eu5k5b as result_mapOrElse$0eu5k5b, mapErr$12sqndm as result_mapErr$12sqndm, mapErr$16o3r40 as result_mapErr$16o3r40, inspect$1lvk7wu as result_inspect$1lvk7wu, inspectErr$0nqm52c, unwrapOrDefault$0ysbycw as result_unwrapOrDefault$0ysbycw, and$1cozx1j as result_and$1cozx1j, andThen$19hld68 as result_andThen$19hld68, or$1sapa01 as result_or$1sapa01, orElse$009jxpk as result_orElse$009jxpk, unwrapOr$137i3aj as result_unwrapOr$137i3aj, unwrapOrElse$1d4fano as result_unwrapOrElse$1d4fano, unwrapOrElse$1iet7cd as result_unwrapOrElse$1iet7cd, copied$10r3llp, clone$1dcpug1 as result_clone$1dcpug1 } from "./core/result.ts"; +import { isSomeAnd$1s2u5lz, isNoneOr$0xn3i4j, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrElse$1va5cjo as option_unwrapOrElse$1va5cjo, unwrapOrElse$0wd124z as option_unwrapOrElse$0wd124z, unwrapOrDefault$1exlfpa as option_unwrapOrDefault$1exlfpa, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, unwrapOrDefault$03apme8 as option_unwrapOrDefault$03apme8, map$0n6ziv9 as option_map$0n6ziv9, map$1px2rk4 as option_map$1px2rk4, map$1ek423e as option_map$1ek423e, map$1yjmt5m as option_map$1yjmt5m, inspect$1sa9a1m as option_inspect$1sa9a1m, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOrElse$0moj49b as option_mapOrElse$0moj49b, okOr$12zia2c as option_okOr$12zia2c, okOr$19jxvkb as option_okOr$19jxvkb, okOr$1j8owgb as option_okOr$1j8owgb, okOrElse$1xtou7y as option_okOrElse$1xtou7y, okOrElse$0cs4x8k as option_okOrElse$0cs4x8k, and$02hlbkj as option_and$02hlbkj, andThen$195hx6l as option_andThen$195hx6l, filter$0hpv4s6, filter$0hq86nl, or$0ar58vy as option_or$0ar58vy, orElse$12s7nhv as option_orElse$12s7nhv, orElse$1xazu5k as option_orElse$1xazu5k, xor$0x5qjg4, zip$0p00b0o, clone$0dg4ec5 as option_clone$0dg4ec5 } from "./core/option.ts"; +import { isOkAnd$1poqzjs, isErrAnd$0ecrrmy, ok$08qo4au, err$0zs6b4d, asRef$0qzh9or, map$022lpi2 as result_map$022lpi2, map$044vsgj as result_map$044vsgj, mapOr$1yz3viz as result_mapOr$1yz3viz, mapOrElse$0eu5k5b as result_mapOrElse$0eu5k5b, mapErr$12sqndm as result_mapErr$12sqndm, mapErr$16o3r40 as result_mapErr$16o3r40, inspect$1lvk7wu as result_inspect$1lvk7wu, inspectErr$0nqm52c, unwrapOrDefault$0ysbycw as result_unwrapOrDefault$0ysbycw, and$1cozx1j as result_and$1cozx1j, andThen$19hld68 as result_andThen$19hld68, or$1sapa01 as result_or$1sapa01, orElse$009jxpk as result_orElse$009jxpk, unwrapOr$137i3aj as result_unwrapOr$137i3aj, unwrapOrElse$1d4fano as result_unwrapOrElse$1d4fano, unwrapOrElse$1iet7cd as result_unwrapOrElse$1iet7cd, copied$10r3llp, clone$1mincpv as result_clone$1mincpv } from "./core/result.ts"; /** Run case `kind % 4` over `data`, whose bytes pick each `Some` or `None`, `Ok` or `Err`. */ export function combinators(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { @@ -135,45 +135,45 @@ export function results(a: rs.u8 | undefined, b: rs.u8 | undefined, limit: rs.u8 /** Values JS shares where Rust clones or moves them. */ export function owned(a: rs.u8 | undefined, b: rs.u8 | undefined, out: rs.ByteVec): void { let matched!: rs.Result; - const s: string | undefined = option_map$1y26nmr(a, (x2: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(x2, f)); + const s: rs.String | undefined = option_map$0n6ziv9(a, (x2: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(x2, f), 0); }); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$165pyh5(filter$1855tjj(option_clone$14nprly(s), (s2: string): boolean => { - return rs.stringLen(s2) > 1; - })))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$1exlfpa(filter$0hpv4s6(option_clone$0dg4ec5(s), (s2: rs.String): boolean => { + return s2.len > 1; + })).v)); rs.byteVecPush(out, 124); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrElse$1badkpb(option_orElse$05gzawv(s, (): string | undefined => { - return option_map$1y26nmr(b, (y2: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(y2, f)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrElse$1va5cjo(option_orElse$12s7nhv(s, (): rs.String | undefined => { + return option_map$0n6ziv9(b, (y2: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(y2, f), 0); }); - }), (): string => { - return "-"; - }))); + }), (): rs.String => { + return rs.stringFrom("-"); + }).v)); rs.byteVecPush(out, 124); - const v: rs.Result = option_okOrElse$1usib9z(option_map$1px2rk4(a, (x3: rs.u8): rs.ByteVec => { + const v: rs.Result = option_okOrElse$1xtou7y(option_map$1px2rk4(a, (x3: rs.u8): rs.ByteVec => { return rs.byteVecOf(x3, 2); - }), (): string => { - return "none"; + }), (): rs.String => { + return rs.stringFrom("none"); }); - const copy: rs.Result = result_clone$1dcpug1(v); + const copy: rs.Result = result_clone$1mincpv(v); if (copy.ok) { rs.byteVecPush(copy.value, 7); } - const grown: rs.Result = result_map$0jdlh8o(result_clone$1dcpug1(v), (v3: rs.ByteVec): rs.ByteVec => { + const grown: rs.Result = result_map$022lpi2(result_clone$1mincpv(v), (v3: rs.ByteVec): rs.ByteVec => { rs.byteVecPush(v3, 9); return v3; }); - const iter: rs.Iter> = rs.iterSlice([v, copy, grown]); + const iter: rs.Iter> = rs.iterSlice([v, copy, grown]); while (true) { - const _36: rs.Result | rs.Done = iter.next(); + const _36: rs.Result | rs.Done = iter.next(); if (_36 === rs.DONE) { break; } - const r: rs.Result = _36; + const r: rs.Result = _36; if (r.ok) { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(r.value)); } else { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(r.error)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(r.error.v)); } rs.byteVecPush(out, 124); } diff --git a/ts/fixtures/lang/combinators/expected/core/option.ts b/ts/fixtures/lang/combinators/expected/core/option.ts index 70968496d..1348d46c9 100644 --- a/ts/fixtures/lang/combinators/expected/core/option.ts +++ b/ts/fixtures/lang/combinators/expected/core/option.ts @@ -23,7 +23,7 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function unwrapOrElse$1badkpb(self: string | undefined, f: () => string): string { +export function unwrapOrElse$1va5cjo(self: rs.String | undefined, f: () => rs.String): rs.String { if (self === undefined) { return f(); } @@ -37,9 +37,9 @@ export function unwrapOrElse$0wd124z(self: rs.u8 | undefined, f: () => rs.u8): r return self; } -export function unwrapOrDefault$165pyh5(self: string | undefined): string { +export function unwrapOrDefault$1exlfpa(self: rs.String | undefined): rs.String { if (self === undefined) { - return ""; + return rs.stringNew(); } return self; } @@ -58,7 +58,7 @@ export function unwrapOrDefault$03apme8(self: rs.u8 | undefined): rs.u8 { return self; } -export function map$1y26nmr(self: rs.u8 | undefined, f: (a0: rs.u8) => string): string | undefined { +export function map$0n6ziv9(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.String): rs.String | undefined { if (self === undefined) { return undefined; } @@ -142,7 +142,7 @@ export function okOr$1j8owgb(self: rs.u8 | undefined, err: rs.u8): rs.Result string): rs.Result { +export function okOrElse$1xtou7y(self: rs.ByteVec | undefined, err: () => rs.String): rs.Result { if (self === undefined) { return rs.Err(err()); } @@ -170,9 +170,9 @@ export function andThen$195hx6l(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 return f(self); } -export function filter$1855tjj(self: string | undefined, predicate: (a0: string) => boolean): string | undefined { +export function filter$0hpv4s6(self: rs.String | undefined, predicate: (a0: rs.String) => boolean): rs.String | undefined { if (self !== undefined) { - const x: string = self; + const x: rs.String = self; if (predicate(x)) { return x; } @@ -197,7 +197,7 @@ export function or$0ar58vy(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs return self; } -export function orElse$05gzawv(self: string | undefined, f: () => string | undefined): string | undefined { +export function orElse$12s7nhv(self: rs.String | undefined, f: () => rs.String | undefined): rs.String | undefined { if (self === undefined) { return f(); } @@ -242,11 +242,11 @@ export function zip$0p00b0o(self: rs.u8 | undefined, other: rs.u8 | undefined): return _0; } -export function clone$14nprly(self: string | undefined): string | undefined { +export function clone$0dg4ec5(self: rs.String | undefined): rs.String | undefined { if (self === undefined) { return undefined; } - return self; + return rs.stringClone(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/combinators/expected/core/result.ts b/ts/fixtures/lang/combinators/expected/core/result.ts index e76381103..64c33aae2 100644 --- a/ts/fixtures/lang/combinators/expected/core/result.ts +++ b/ts/fixtures/lang/combinators/expected/core/result.ts @@ -37,7 +37,7 @@ export function asRef$0qzh9or(self: rs.Result): rs.Result, op: (a0: rs.ByteVec) => rs.ByteVec): rs.Result { +export function map$022lpi2(self: rs.Result, op: (a0: rs.ByteVec) => rs.ByteVec): rs.Result { if (self.ok) { return rs.Ok(op(self.value)); } @@ -156,11 +156,11 @@ export function copied$10r3llp(self: rs.Result): rs.Result): rs.Result { +export function clone$1mincpv(self: rs.Result): rs.Result { if (self.ok) { return rs.Ok(rs.byteVecFrom(rs.byteVecView(self.value))); } - return rs.Err(self.error); + return rs.Err(rs.stringClone(self.error)); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/conversions/expected/conversions.Named.ts b/ts/fixtures/lang/conversions/expected/conversions.Named.ts index dbfac878f..1827e32fb 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.Named.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.Named.ts @@ -4,14 +4,14 @@ import * as rs from "./rs.ts"; import { byte, make$conversions_Value_String, put$conversions_Value_String as conversions_put$conversions_Value_String } from "./conversions.ts"; export function clone$Clone(self: Named): Named { - return { id: self.id, name: self.name }; + return { id: self.id, name: rs.stringClone(self.name) }; } export function eq$cmp_PartialEq(self: Named, other: Named): boolean { if (!(self.id === other.id)) { return false; } - return self.name === other.name; + return rs.eqStr(self.name, other.name); } export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Ordering | undefined { @@ -29,7 +29,7 @@ export function cmp$cmp_Ord(self: Named, other: Named): rs.Ordering { /** A struct, which JS holds as an object. */ export interface Named { id: rs.u16; - name: string; + name: rs.String; } /** The value `data` makes from `at`. */ diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index 6059901f0..0988e8a82 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -7,7 +7,7 @@ import * as Kept from "./conversions.Kept.ts"; import * as Logged from "./conversions.Logged.ts"; import * as Named from "./conversions.Named.ts"; import { thenSome$1gvhopg } from "./core/bool.ts"; -import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, clone$0wpatp7 as option_clone$0wpatp7, clone$14nprly as option_clone$14nprly, clone$13oewp0 as option_clone$13oewp0, clone$0xr8mw0 as option_clone$0xr8mw0, clone$17fv6u9 as option_clone$17fv6u9, clone$0fp7wpk as option_clone$0fp7wpk, clone$1lfse5o as option_clone$1lfse5o, clone$08wmfj8 as option_clone$08wmfj8, clone$1aebjgp as option_clone$1aebjgp } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, clone$0wpatp7 as option_clone$0wpatp7, clone$13oewp0 as option_clone$13oewp0, clone$0xr8mw0 as option_clone$0xr8mw0, clone$17fv6u9 as option_clone$17fv6u9, clone$0fp7wpk as option_clone$0fp7wpk, clone$1lfse5o as option_clone$1lfse5o, clone$08wmfj8 as option_clone$08wmfj8, clone$1aebjgp as option_clone$1aebjgp } from "./core/option.ts"; /** The byte at `at`, past `data`'s end its index. */ export function byte(data: rs.ByteSlice, at: rs.usize): rs.u8 { @@ -45,14 +45,14 @@ export function put$conversions_Value_u64(self: rs.u64, out: rs.ByteVec): void { } /** The value `data` makes from `at`. */ -export function make$conversions_Value_String(data: rs.ByteSlice, at: rs.usize): string { +export function make$conversions_Value_String(data: rs.ByteSlice, at: rs.usize): rs.String { const part = rs.u8Rem(byte(data, at), 16); return rs.fmtFormat(["s", (f: rs.Formatter) => rs.u8Display(part, f)]); } /** Its bytes. */ -export function put$conversions_Value_String(self: string, out: rs.ByteVec): void { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(self))), undefined, true); +export function put$conversions_Value_String(self: rs.String, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(self.v))), undefined, true); rs.byteVecPush(out, 255); } @@ -336,8 +336,8 @@ export function cloneFromParam$Option_u16(to: rs.Place, from } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$String(to: rs.Place, from: string): void { - to.v = from; +export function cloneFromParam$String(to: rs.String, from: rs.String): void { + Object.assign(to, rs.stringCloneFrom(to, from)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ @@ -406,8 +406,8 @@ export function cloneIntoParam$Option_u16(from: rs.u16 | undefined, to: rs.Place } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$String(from: string, to: rs.Place): void { - to.v = from; +export function cloneIntoParam$String(from: rs.String, to: rs.String): void { + Object.assign(to, rs.stringCloneFrom(to, from)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ @@ -484,13 +484,11 @@ export function writeFirst$Option_u16(s: rs.Slice, value: rs } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$String(s: rs.Slice, value: string): string { +export function writeFirst$String(s: rs.Slice, value: rs.String): rs.String { rs.idx(s, 0); - const _8: string = value; - const old2 = s.data[s.start]; - s.data[s.start] = _8; - const old: string = old2; - const _10: string = value; + const _8: rs.String = rs.stringClone(value); + const old: rs.String = rs.sliceReplace(s.data, s.start, _8); + const _10: rs.String = value; rs.idx(s, 0); s.data[s.start] = _10; return old; @@ -644,9 +642,9 @@ export function replaceFirst$Option_u16(s: rs.Slice>, } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$String(s: rs.Slice, value: string[]): string[] { +export function replaceFirst$String(s: rs.Slice, value: rs.String[]): rs.String[] { rs.idx(s, 0); - return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value); + return rs.replaceIn(rs.sliceView(rs.sliceFrom(s.data[s.start])), value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ @@ -795,31 +793,23 @@ export function lentParam$Option_u16(to: rs.Place, data: rs. * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceOfPlace(to); +export function lentParam$String(to: rs.String, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.Slice = rs.sliceIn(to); put$conversions_Value_String(writeFirst$String(s, make$conversions_Value_String(data, 18)), out); - let other: string = make$conversions_Value_String(data, 19); + let other: rs.String = make$conversions_Value_String(data, 19); rs.idx(s, 0); - const swapped = s.data[s.start]; - s.data[s.start] = other; - other = swapped; + other = rs.sliceReplace(s.data, s.start, other); put$conversions_Value_String(other, out); rs.idx(s, 0); - const swapped2 = other; - other = s.data[s.start]; - s.data[s.start] = swapped2; + other = rs.sliceReplace(s.data, s.start, other); put$conversions_Value_String(other, out); - const t: rs.Slice = rs.sliceFrom(rs.vecFrom([make$conversions_Value_String(data, 20), make$conversions_Value_String(data, 21)]).items); + const t: rs.Slice = rs.sliceFrom(rs.vecFrom([make$conversions_Value_String(data, 20), make$conversions_Value_String(data, 21)]).items); rs.idx(s, 0); rs.idx(t, 1); - const swapped3 = s.data[s.start]; - s.data[s.start] = t.data[t.start + 1]; - t.data[t.start + 1] = swapped3; + rs.sliceSwapAcross(s.data, s.start, t.data, t.start + 1); rs.idx(t, 0); rs.idx(s, 0); - const swapped4 = t.data[t.start]; - t.data[t.start] = s.data[s.start]; - s.data[s.start] = swapped4; + rs.sliceSwapAcross(t.data, t.start, s.data, s.start); rs.idx(t, 0); put$conversions_Value_String(t.data[t.start], out); rs.idx(t, 1); @@ -827,37 +817,34 @@ export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.idx(s, 0); const borrowed = s.data; const borrowed2 = s.start; - const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); - const _77: string[] = [make$conversions_Value_String(data, 22)]; - put$conversions_Value_String(rs.replaceIn(rs.sliceView(a), _77)[0], out); - let by: string = make$conversions_Value_String(data, 23); - rs.idx(s, 0); - const borrowed3 = s.start; - let r: rs.Place = rs.place(() => s.data[borrowed3], (value2) => s.data[borrowed3] = value2); - const _89: rs.Slice> = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); - const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; - rs.replaceIn(rs.sliceView(_89), _91)[0].v = make$conversions_Value_String(data, 24); - put$conversions_Value_String(r.v, out); + const a: rs.Slice = rs.sliceOfPlace(rs.place(() => borrowed[borrowed2], (value) => borrowed[borrowed2] = value)); + const _77: rs.String[] = [make$conversions_Value_String(data, 22)]; + put$conversions_Value_String(rs.replaceIn(rs.sliceView(a), _77, 1)[0], out); + const by: rs.String = make$conversions_Value_String(data, 23); + rs.idx(s, 0); + let r: rs.String = s.data[s.start]; + const _89: rs.Slice = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); + const _91: rs.String[] = [by]; + Object.assign(rs.replaceIn(rs.sliceView(_89), _91)[0], make$conversions_Value_String(data, 24)); + put$conversions_Value_String(r, out); rs.idx(s, 0); put$conversions_Value_String(s.data[s.start], out); rs.idx(s, 0); - const borrowed4 = s.data; - const borrowed5 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellOfPlace(rs.place(() => borrowed4[borrowed5], (value5) => borrowed4[borrowed5] = value5)), make$conversions_Value_String(data, 25)), out); + put$conversions_Value_String(rs.cellReplace(rs.cellIn(s.data[s.start]), make$conversions_Value_String(data, 25)), out); rs.idx(s, 0); - const borrowed6 = s.data; - const borrowed7 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed6[borrowed7], (value6) => borrowed6[borrowed7] = value6)))), [make$conversions_Value_String(data, 26)])[0], out); + const borrowed3 = s.data; + const borrowed4 = s.start; + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed3[borrowed4], (value3) => borrowed3[borrowed4] = value3))), 1), [make$conversions_Value_String(data, 26)])[0], out); rs.idx(s, 0); - const borrowed8 = s.data; - const borrowed9 = s.start; - put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed8[borrowed9], (value7) => borrowed8[borrowed9] = value7)))), [make$conversions_Value_String(data, 27)])[0], out); + const borrowed5 = s.data; + const borrowed6 = s.start; + put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed5[borrowed6], (value4) => borrowed5[borrowed6] = value4)))), [make$conversions_Value_String(data, 27)])[0], out); rs.idx(s, 0); - const borrowed10 = s.data; - const borrowed11 = s.start; - put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed10[borrowed11], (value8) => borrowed10[borrowed11] = value8))))), 1), [[make$conversions_Value_String(data, 28)]])[0][0], out); + const borrowed7 = s.data; + const borrowed8 = s.start; + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceView(rs.sliceIn(rs.sliceView(rs.sliceOfPlace(rs.place(() => borrowed7[borrowed8], (value5) => borrowed7[borrowed8] = value5))))), 2), [[make$conversions_Value_String(data, 28)]])[0][0], out); rs.idx(s, 0); - s.data[s.start] = other; + s.data[s.start] = rs.stringCloneFrom(s.data[s.start], other); rs.idx(s, 0); put$conversions_Value_String(s.data[s.start], out); } @@ -1651,16 +1638,14 @@ export function lentThrough$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): voi * read after. */ export function lentThrough$String(data: rs.ByteSlice, out: rs.ByteVec): void { - let a: string = make$conversions_Value_String(data, 0); - const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - lentParam$String(rs.place(() => a, (value) => a = value), data, out); - lentParam$String(rs.place(() => held.value, (value2) => held.value = value2), data, out); - const at = rs.idx(v.items, 1); - lentParam$String(rs.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); - const at2 = rs.idx(v.items, 0); - let _19: rs.Place = rs.place(() => v.items[at2], (value4) => v.items[at2] = value4); - lentNested$String(rs.place(() => _19, (value5) => _19 = value5), data, out); + const a: rs.String = make$conversions_Value_String(data, 0); + const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + lentParam$String(a, data, out); + lentParam$String(held.value, data, out); + lentParam$String(v.items[rs.idx(v.items, 1)], data, out); + let _19: rs.String = v.items[rs.idx(v.items, 0)]; + lentNested$String(rs.place(() => _19, (value) => _19 = value), data, out); put$conversions_Value_String(a, out); put$conversions_Value_String(held.value, out); put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); @@ -1889,7 +1874,7 @@ export function lentNested$Option_u16(to: rs.Place> } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$String(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { +export function lentNested$String(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$String(to.v, data, out); } @@ -1954,8 +1939,8 @@ export function setThrough$Option_u16(to: rs.Place, value: r } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$String(to: rs.Place, value: string): string { - return rs.cellReplace(rs.cellOfPlace(to), value); +export function setThrough$String(to: rs.String, value: rs.String): rs.String { + return rs.cellReplace(rs.cellIn(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ @@ -2107,80 +2092,83 @@ export function converted$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void /** Each conversion of a `T`, its copies put after a write to what they copied. */ export function converted$String(data: rs.ByteSlice, out: rs.ByteVec): void { - let a: string = make$conversions_Value_String(data, 0); - const b: string = make$conversions_Value_String(data, 3); - const owned: string = a; - a = b; + let a: rs.String = make$conversions_Value_String(data, 0); + const b: rs.String = make$conversions_Value_String(data, 3); + const owned: rs.String = rs.stringClone(a); + a = rs.stringCloneFrom(a, b); put$conversions_Value_String(owned, out); put$conversions_Value_String(a, out); - let c: string = make$conversions_Value_String(data, 6); - c = owned; + let c: rs.String = make$conversions_Value_String(data, 6); + c = rs.stringCloneFrom(c, owned); put$conversions_Value_String(c, out); - cloneFromParam$String(rs.place(() => c, (value) => c = value), b); - cloneIntoParam$String(owned, rs.place(() => a, (value2) => a = value2)); + cloneFromParam$String(c, b); + cloneIntoParam$String(owned, a); put$conversions_Value_String(c, out); put$conversions_Value_String(a, out); - const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - held.value = c; - const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - v.items[rs.idx(v.items, 1)] = held.value; - v.items[rs.idx(v.items, 0)] = b; + const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); + held.value = rs.stringCloneFrom(held.value, c); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + const at = rs.idx(v.items, 1); + v.items[at] = rs.stringCloneFrom(v.items[at], held.value); + const at2 = rs.idx(v.items, 0); + v.items[at2] = rs.stringCloneFrom(v.items[at2], b); put$conversions_Value_String(held.value, out); put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); - const one: rs.Slice = rs.sliceFrom([b]); + const one: rs.Slice = rs.sliceFrom([b]); rs.byteVecPush(out, one.length & 0xff); - const copied: string = one.data[one.start]; + const copied: rs.String = rs.stringClone(one.data[one.start]); put$conversions_Value_String(one.data[one.start], out); - a = copied; + a = rs.stringCloneFrom(a, copied); put$conversions_Value_String(copied, out); put$conversions_Value_String(a, out); - const cell: rs.Cell = rs.cellOfPlace(rs.place(() => c, (value3) => c = value3)); - const old: string = rs.cellReplace(cell, make$conversions_Value_String(data, 10)); + const cell: rs.Cell = rs.cellIn(c); + const old: rs.String = rs.cellReplace(cell, make$conversions_Value_String(data, 10)); rs.cellSet(cell, make$conversions_Value_String(data, 11)); put$conversions_Value_String(old, out); put$conversions_Value_String(c, out); const at5 = rs.idx(v.items, 0); - const _91: string = make$conversions_Value_String(data, 12); - put$conversions_Value_String(setThrough$String(rs.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); + const _91: rs.String = make$conversions_Value_String(data, 12); + put$conversions_Value_String(setThrough$String(v.items[at5], _91), out); put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); - const borrowed = held; - rs.cellSet(rs.cellOfPlace(rs.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_String(data, 17)); + rs.cellSet(rs.cellIn(held.value), make$conversions_Value_String(data, 17)); put$conversions_Value_String(held.value, out); - const array: string[] = [make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14), make$conversions_Value_String(data, 15)]; + const array: rs.String[] = [make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14), make$conversions_Value_String(data, 15)]; rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(array).length, rs.sliceFrom(array).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: string = b; - const _116: rs.Slice = rs.sliceFrom(array); + const _114: rs.String = rs.stringClone(b); + const _116: rs.Slice = rs.sliceFrom(array); rs.idx(_116, 0); _116.data[_116.start] = _114; - const _124: rs.Slice = rs.sliceFrom(array); + const _124: rs.Slice = rs.sliceFrom(array); rs.idx(_124, 2); - _124.data[_124.start + 2] = c; + _124.data[_124.start + 2] = rs.stringCloneFrom(_124.data[_124.start + 2], c); for (const _134 of array) { put$conversions_Value_String(_134, out); } - const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14)]); - const none: rs.Vec = new rs.Vec(); + const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14)]); + const none: rs.Vec = new rs.Vec(); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceFrom(list.items).length, list.items.length, rs.sliceFrom(none.items).length, rs.sliceFrom(none.items).length, rs.sliceFrom(list.items).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: string = b; - const _165: rs.Slice = rs.sliceFrom(list.items); + const _163: rs.String = rs.stringClone(b); + const _165: rs.Slice = rs.sliceFrom(list.items); rs.idx(_165, 0); _165.data[_165.start] = _163; - const _173: rs.Slice = rs.sliceFrom(list.items); + const _173: rs.Slice = rs.sliceFrom(list.items); rs.idx(_173, 1); - _173.data[_173.start + 1] = c; + _173.data[_173.start + 1] = rs.stringCloneFrom(_173.data[_173.start + 1], c); rs.sliceSwap(rs.sliceFrom(list.items), 0, 1); - const _184: rs.Vec = list; - const _186: string = make$conversions_Value_String(data, 15); + const _184: rs.Vec = list; + const _186: rs.String = make$conversions_Value_String(data, 15); _184.items.push(_186); - none.items.push(a); - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); + const _188: rs.Vec = none; + const _190: rs.String = rs.stringClone(a); + _188.items.push(_190); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: string | rs.Done = iter2.next(); + const _199: rs.String | rs.Done = iter2.next(); if (_199 === rs.DONE) { break; } @@ -3431,45 +3419,69 @@ export function boxed$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { * `Option`, and in a slice, and a boxed slice by `clone_into`. */ export function boxed$String(data: rs.ByteSlice, out: rs.ByteVec): void { - let boxed: string = make$conversions_Value_String(data, 19); - boxed = make$conversions_Value_String(data, 3); + let boxed: rs.String = make$conversions_Value_String(data, 19); + const _8: rs.String = make$conversions_Value_String(data, 3); + boxed = rs.stringCloneFrom(boxed, _8); put$conversions_Value_String(boxed, out); - const source: string = make$conversions_Value_String(data, 20); - boxed = source; + const source: rs.String = make$conversions_Value_String(data, 20); + boxed = rs.stringCloneFrom(boxed, source); put$conversions_Value_String(boxed, out); put$conversions_Value_String(source, out); - let nested: string = make$conversions_Value_String(data, 21); - nested = ((a0: string): string => { - return a0; + let nested: rs.String = make$conversions_Value_String(data, 21); + const _27: rs.String = ((a0: rs.String): rs.String => { + return rs.stringClone(a0); })(source); + nested = rs.stringCloneFrom(nested, _27); put$conversions_Value_String(nested, out); - let maybe: string | undefined = make$conversions_Value_String(data, 22); - maybe = option_clone$14nprly(boxed); - maybe = option_clone$14nprly(undefined); + let maybe: rs.String | undefined = make$conversions_Value_String(data, 22); + const _38: rs.String | undefined = ((a02: rs.String): rs.String => { + return rs.stringClone(a02); + })(boxed); + maybe = rs.optionCloneFrom(maybe, _38, (a03: rs.String): rs.String => { + return ((a04: rs.String): rs.String => { + return rs.stringClone(a04); + })(a03); + }, undefined, rs.stringCloneFromFn()); + maybe = rs.optionCloneFrom(maybe, undefined, (a05: rs.String): rs.String => { + return ((a06: rs.String): rs.String => { + return rs.stringClone(a06); + })(a05); + }, undefined, rs.stringCloneFromFn()); rs.byteVecPush(out, maybe === undefined ? 1 : 0); - maybe = option_clone$14nprly(source); - rs.iterForEach(rs.iterOption(maybe), (x: string): undefined => { + const _51: rs.String | undefined = ((a07: rs.String): rs.String => { + return rs.stringClone(a07); + })(source); + maybe = rs.optionCloneFrom(maybe, _51, (a08: rs.String): rs.String => { + return ((a09: rs.String): rs.String => { + return rs.stringClone(a09); + })(a08); + }, undefined, rs.stringCloneFromFn()); + rs.iterForEach(rs.iterOption(maybe), (x: rs.String): undefined => { put$conversions_Value_String(x, out); }); - const slots: string[] = [make$conversions_Value_String(data, 23), make$conversions_Value_String(data, 24)]; - rs.sliceCloneFromSlice(rs.sliceFrom(slots), rs.sliceFrom([source, boxed]), (a02: string): string => { - return a02; - }); + const slots: rs.String[] = [make$conversions_Value_String(data, 23), make$conversions_Value_String(data, 24)]; + rs.sliceCloneFromSlice(rs.sliceFrom(slots), rs.sliceFrom([source, boxed]), (a010: rs.String): rs.String => { + return ((a011: rs.String): rs.String => { + return rs.stringClone(a011); + })(a010); + }, undefined, rs.stringCloneFromFn()); for (const _73 of slots) { put$conversions_Value_String(_73, out); } const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; - const whole: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): string => { + const whole: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.String => { return make$conversions_Value_String(data, rs.usizeAdd(26, i)); }), undefined, 12, true).items); - let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): string => { + let into: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.String => { return make$conversions_Value_String(data, rs.usizeAdd(29, i2)); }), undefined, 12, true).items); - into = rs.boxSliceCloneFrom(into, whole); + into = rs.boxSliceCloneFrom(into, whole, (a012: rs.String): rs.String => { + return rs.stringClone(a012); + }, undefined, rs.stringCloneFromFn()); rs.byteVecPush(out, into.length & 0xff); - const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(into)), rs.iterSlice(rs.sliceItems(whole))); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.sliceItems(into)), rs.iterSlice(rs.sliceItems(whole))); while (true) { - const _108: string | rs.Done = iter2.next(); + const _108: rs.String | rs.Done = iter2.next(); if (_108 === rs.DONE) { break; } @@ -4236,19 +4248,17 @@ export function lentOne$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { * a whole, the old value read out, and through std's slice methods. */ export function lentOne$String(data: rs.ByteSlice, out: rs.ByteVec): void { - const _6: [string, string, string] = [make$conversions_Value_String(data, 0), make$conversions_Value_String(data, 3), make$conversions_Value_String(data, 6)]; - let a: string = _6[0]; - const b: string = _6[1]; - let c: string = _6[2]; - const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - const s: rs.Slice = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + const _6: [rs.String, rs.String, rs.String] = [make$conversions_Value_String(data, 0), make$conversions_Value_String(data, 3), make$conversions_Value_String(data, 6)]; + let a: rs.String = _6[0]; + const b: rs.String = _6[1]; + let c: rs.String = _6[2]; + const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + const s: rs.Slice = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); rs.byteVecPush(out, s.length & 0xff); rs.idx(s, 0); - const _28: string = make$conversions_Value_String(data, 5); - const old4 = s.data[s.start]; - s.data[s.start] = _28; - put$conversions_Value_String(old4, out); + const _28: rs.String = make$conversions_Value_String(data, 5); + put$conversions_Value_String(rs.sliceReplace(s.data, s.start, _28), out); put$conversions_Value_String(a, out); const borrowed = held; put$conversions_Value_String(writeFirst$String(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_String(data, 7)), out); @@ -4258,14 +4268,11 @@ export function lentOne$String(data: rs.ByteSlice, out: rs.ByteVec): void { const borrowed3 = at; put$conversions_Value_String(writeFirst$String(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_String(data, 8)), out); put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); - rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), b, undefined); - const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); - while (true) { - const _61: rs.Place | rs.Done = iter.next(); - if (_61 === rs.DONE) { - break; - } - _61.v = make$conversions_Value_String(data, 9); + rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), rs.stringClone(b), (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }, undefined, rs.stringCloneFromFn()); + for (const _61 of rs.sliceItems(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5)))) { + Object.assign(_61, make$conversions_Value_String(data, 9)); } put$conversions_Value_String(c, out); put$conversions_Value_String(a, out); @@ -4745,11 +4752,13 @@ export function searched$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { export function searched$String(data: rs.ByteSlice, out: rs.ByteVec): void { let _45!: rs.usize; let _75!: [rs.u8, rs.usize]; - const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): string => { + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.String => { return make$conversions_Value_String(data, i2); }), undefined, 12, true); rs.sliceSort(rs.sliceFrom(v.items), rs.cmpLt(rs.cmpStr), 12, true); - const tagged: rs.Vec<[string, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterCloned(rs.iterSlice(v.items)), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); + const tagged: rs.Vec<[rs.String, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { const _24: rs.usize | rs.Done = iter.next(); @@ -4757,8 +4766,8 @@ export function searched$String(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const part = rs.min(_24, v.items.length); - const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); - const t: rs.Slice<[string, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); + const s: rs.Slice = rs.sliceRange(rs.sliceFrom(v.items), 0, part); + const t: rs.Slice<[rs.String, rs.u8]> = rs.sliceRange(rs.sliceFrom(tagged.items), 0, s.length); const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); let iterStart: rs.usize = 0; const iterEnd: rs.usize = _40; @@ -4766,14 +4775,14 @@ export function searched$String(data: rs.ByteSlice, out: rs.ByteVec): void { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: string = make$conversions_Value_String(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); - const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpStr), rs.sliceBinarySearchBy(s, (e: string): rs.Ordering => { + const x: rs.String = make$conversions_Value_String(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpStr), rs.sliceBinarySearchBy(s, (e: rs.String): rs.Ordering => { put$conversions_Value_String(e, out); return rs.cmpStr(e, x); - }), rs.sliceBinarySearchByKey(t, x, (_2: [string, rs.u8]): string => { + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.String, rs.u8]): rs.String => { rs.byteVecPush(out, _2[1]); - return _2[0]; - }, rs.cmpStr), rs.Ok(rs.slicePartitionPoint(s, (e2: string): boolean => { + return rs.stringClone(_2[0]); + }, rs.cmpStr), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.String): boolean => { put$conversions_Value_String(e2, out); return rs.cmpStr(e2, x) === -1; }))]); @@ -5516,9 +5525,10 @@ export function measured(data: rs.ByteSlice, out: rs.ByteVec): void { const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u64 => { return _2 as rs.u64; }), undefined, 8, true); - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.char => { + const _8: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.char => { return _25 as rs.char; - })); + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _8); Named.make$conversions_Value(data, 0); const _13: rs.usize = rs.byteSliceRange(data, 0, 0).length; rs.byteSliceRange(data, 0, 0); @@ -5527,7 +5537,7 @@ export function measured(data: rs.ByteSlice, out: rs.ByteVec): void { const _23: rs.usize = rs.sliceFrom(wide.items).length * 8; rs.sliceFrom(wide.items); const _22: [rs.usize, rs.usize] = [_23, 8]; - const _29: [rs.usize, rs.usize] = [rs.stringLen(text), 1]; + const _29: [rs.usize, rs.usize] = [rs.stringLen(text.v), 1]; const _36: [rs.usize, rs.usize] = [4, 4]; const _41: [rs.usize, rs.usize] = [16, 16]; [n & 0xff, n & 0xffff] as [rs.u8, rs.u16]; @@ -5640,8 +5650,8 @@ export function referenced$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void * `&mut`, which lend what it points at; and the comparisons of references to elements and to slices. */ export function referenced$String(data: rs.ByteSlice, out: rs.ByteVec): void { - const array: string[] = [make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14), make$conversions_Value_String(data, 15)]; - const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 16), make$conversions_Value_String(data, 17)]); + const array: rs.String[] = [make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14), make$conversions_Value_String(data, 15)]; + const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 16), make$conversions_Value_String(data, 17)]); readAs$String_ref_slice_String(rs.sliceFrom(array), out); readAs$String_ref_ref_slice_String(rs.sliceRange(rs.sliceFrom(array), 1), out); readAs$String_ref_array3_String(rs.sliceFrom(array), out); @@ -5650,41 +5660,40 @@ export function referenced$String(data: rs.ByteSlice, out: rs.ByteVec): void { readAs$String_ref_mut_Vec_String(list, out); writeAs$String_mut_slice_String(rs.sliceFrom(array), make$conversions_Value_String(data, 18)); writeAs$String_mut_array3_String(rs.sliceFrom(array), make$conversions_Value_String(data, 19)); - const _38: string = make$conversions_Value_String(data, 20); + const _38: rs.String = make$conversions_Value_String(data, 20); writeAs$String_mut_Vec_String(list, _38); - let _41: rs.Vec = list; - const _42: string = make$conversions_Value_String(data, 21); + let _41: rs.Vec = list; + const _42: rs.String = make$conversions_Value_String(data, 21); writeAs$String_mut_mut_Vec_String(rs.place(() => _41, (value) => _41 = value), _42); derefPut$String_ref_String(array[0], out); - const at = rs.idx(list.items, 0); - derefPut$String_mut_String(rs.place(() => list.items[at], (value2) => list.items[at] = value2), out); + derefPut$String_mut_String(list.items[rs.idx(list.items, 0)], out); borrowPut$String_ref_String(array[1], out); - const at2 = rs.idx(list.items, 1); - borrowPut$String_mut_String(rs.place(() => list.items[at2], (value3) => list.items[at2] = value3), out); + borrowPut$String_mut_String(list.items[rs.idx(list.items, 1)], out); const at3 = rs.idx(list.items, 1); - const _60: string = make$conversions_Value_String(data, 24); - borrowWrite$String_mut_String(rs.place(() => list.items[at3], (value4) => list.items[at3] = value4), _60); - const _65: string = make$conversions_Value_String(data, 25); - borrowWrite$String_mut_String(rs.place(() => array[1], (value5) => array[1] = value5), _65); - let whole: string = make$conversions_Value_String(data, 26); - whole = make$conversions_Value_String(data, 27); + const _60: rs.String = make$conversions_Value_String(data, 24); + borrowWrite$String_mut_String(list.items[at3], _60); + const _65: rs.String = make$conversions_Value_String(data, 25); + borrowWrite$String_mut_String(array[1], _65); + const whole: rs.String = make$conversions_Value_String(data, 26); + const _67: rs.String = make$conversions_Value_String(data, 27); + Object.assign(whole, _67); put$conversions_Value_String(whole, out); - const _74: rs.Vec = list; - const _77: string = make$conversions_Value_String(data, 28); + const _74: rs.Vec = list; + const _77: rs.String = make$conversions_Value_String(data, 28); _74.items.push(_77); - const other: string = make$conversions_Value_String(data, 29); - let r: string = whole; + const other: rs.String = make$conversions_Value_String(data, 29); + let r: rs.String = whole; r = other; put$conversions_Value_String(r, out); put$conversions_Value_String(compared$ref_String(array[0], array[1], out), out); put$conversions_Value_String(compared$ref_ref_String(list.items[rs.idx(list.items, 1)], array[2], out), out); - let _107: string = make$conversions_Value_String(data, 22); - let _109: string = make$conversions_Value_String(data, 23); - put$conversions_Value_String(compared$mut_String(rs.place(() => _107, (value9) => _107 = value9), rs.place(() => _109, (value10) => _109 = value10), out).v, out); + const _107: rs.String = make$conversions_Value_String(data, 22); + const _109: rs.String = make$conversions_Value_String(data, 23); + put$conversions_Value_String(compared$mut_String(_107, _109, out), out); rs.byteVecPush(out, compared$ref_slice_String(rs.sliceFrom(array), rs.sliceFrom(list.items), out).length & 0xff); - const iter: rs.Iter = rs.iterChain(rs.iterSlice(array), rs.iterSlice(list.items)); + const iter: rs.Iter = rs.iterChain(rs.iterSlice(array), rs.iterSlice(list.items)); while (true) { - const _125: string | rs.Done = iter.next(); + const _125: rs.String | rs.Done = iter.next(); if (_125 === rs.DONE) { break; } @@ -6108,21 +6117,22 @@ export function referenced$u8(data: rs.ByteSlice, out: rs.ByteVec): void { * `Vec`s behind `&`, `&mut`, and a reference to one, as moq's buffers reach them. */ export function referencedBytes(data: rs.ByteSlice, out: rs.ByteVec): void { - let text: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): rs.char => { + const _4: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): rs.char => { return _2 as rs.char; - })); + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _4); const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); - readBytes$ref_str(text, out); + readBytes$ref_str(text.v, out); readBytes$ref_String(text, out); - readBytes$mut_String(rs.place(() => text, (value) => text = value), out); - readBytes$ref_ref_str(text, out); + readBytes$mut_String(text, out); + readBytes$ref_ref_str(text.v, out); readBytes$ref_slice_u8(data, out); readBytes$ref_ref_slice_u8(data, out); readBytes$ref_Vec_u8(bytes, out); readBytes$mut_Vec_u8(bytes, out); - readStr$ref_str(text, out); + readStr$ref_str(text.v, out); readStr$ref_String(text, out); - readStr$ref_mut_String(rs.place(() => text, (value2) => text = value2), out); + readStr$ref_mut_String(text, out); } /** What `b` reads as a slice: its length, then each element. */ @@ -6180,8 +6190,8 @@ export function readAs$Option_u16_ref_slice_Option_u16(b: rs.Slice, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b.items); +export function readAs$String_mut_Vec_String(b: rs.Vec, out: rs.ByteVec): void { + const s: rs.Slice = rs.sliceFrom(b.items); rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_String(_10, out); @@ -6189,8 +6199,8 @@ export function readAs$String_mut_Vec_String(b: rs.Vec, out: rs.ByteVec) } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$String_ref_Vec_String(b: rs.Vec, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b.items); +export function readAs$String_ref_Vec_String(b: rs.Vec, out: rs.ByteVec): void { + const s: rs.Slice = rs.sliceFrom(b.items); rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_String(_10, out); @@ -6198,8 +6208,8 @@ export function readAs$String_ref_Vec_String(b: rs.Vec, out: rs.ByteVec) } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$String_ref_array3_String(b: rs.Slice, out: rs.ByteVec): void { - const s: rs.Slice = b; +export function readAs$String_ref_array3_String(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_String(_10, out); @@ -6207,8 +6217,8 @@ export function readAs$String_ref_array3_String(b: rs.Slice, out: rs.Byt } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$String_ref_mut_Vec_String(b: rs.Vec, out: rs.ByteVec): void { - const s: rs.Slice = rs.sliceFrom(b.items); +export function readAs$String_ref_mut_Vec_String(b: rs.Vec, out: rs.ByteVec): void { + const s: rs.Slice = rs.sliceFrom(b.items); rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_String(_10, out); @@ -6216,8 +6226,8 @@ export function readAs$String_ref_mut_Vec_String(b: rs.Vec, out: rs.Byte } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$String_ref_ref_slice_String(b: rs.Slice, out: rs.ByteVec): void { - const s: rs.Slice = b; +export function readAs$String_ref_ref_slice_String(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_String(_10, out); @@ -6225,8 +6235,8 @@ export function readAs$String_ref_ref_slice_String(b: rs.Slice, out: rs. } /** What `b` reads as a slice: its length, then each element. */ -export function readAs$String_ref_slice_String(b: rs.Slice, out: rs.ByteVec): void { - const s: rs.Slice = b; +export function readAs$String_ref_slice_String(b: rs.Slice, out: rs.ByteVec): void { + const s: rs.Slice = b; rs.byteVecPush(out, s.length & 0xff); for (const _10 of rs.sliceItems(s)) { put$conversions_Value_String(_10, out); @@ -6674,34 +6684,34 @@ export function writeAs$Option_u16_mut_slice_Option_u16(b: rs.Slice, value: string): void { - const _3: rs.Place | undefined = rs.sliceLastMut(rs.sliceFrom(b.items)); +export function writeAs$String_mut_Vec_String(b: rs.Vec, value: rs.String): void { + const _3: rs.String | undefined = rs.sliceLast(rs.sliceFrom(b.items)); if (_3 !== undefined) { - _3.v = value; + Object.assign(_3, value); } } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$String_mut_array3_String(b: rs.Slice, value: string): void { - const _3: rs.Place | undefined = rs.sliceLastMut(b); +export function writeAs$String_mut_array3_String(b: rs.Slice, value: rs.String): void { + const _3: rs.String | undefined = rs.sliceLast(b); if (_3 !== undefined) { - _3.v = value; + Object.assign(_3, value); } } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$String_mut_mut_Vec_String(b: rs.Place>, value: string): void { - const _3: rs.Place | undefined = rs.sliceLastMut(rs.sliceFrom(b.v.items)); +export function writeAs$String_mut_mut_Vec_String(b: rs.Place>, value: rs.String): void { + const _3: rs.String | undefined = rs.sliceLast(rs.sliceFrom(b.v.items)); if (_3 !== undefined) { - _3.v = value; + Object.assign(_3, value); } } /** Writes `value` over the last element of what `b` lends as a slice. */ -export function writeAs$String_mut_slice_String(b: rs.Slice, value: string): void { - const _3: rs.Place | undefined = rs.sliceLastMut(b); +export function writeAs$String_mut_slice_String(b: rs.Slice, value: rs.String): void { + const _3: rs.String | undefined = rs.sliceLast(b); if (_3 !== undefined) { - _3.v = value; + Object.assign(_3, value); } } @@ -6974,13 +6984,13 @@ export function derefPut$Option_u16_ref_Option_u16(b: rs.u16 | undefined, out: r } /** What `b` derefs to, by `deref` and by `*`. */ -export function derefPut$String_mut_String(b: rs.Place, out: rs.ByteVec): void { - put$conversions_Value_String(b.v, out); - put$conversions_Value_String(b.v, out); +export function derefPut$String_mut_String(b: rs.String, out: rs.ByteVec): void { + put$conversions_Value_String(b, out); + put$conversions_Value_String(b, out); } /** What `b` derefs to, by `deref` and by `*`. */ -export function derefPut$String_ref_String(b: string, out: rs.ByteVec): void { +export function derefPut$String_ref_String(b: rs.String, out: rs.ByteVec): void { put$conversions_Value_String(b, out); put$conversions_Value_String(b, out); } @@ -7080,12 +7090,12 @@ export function borrowPut$Option_u16_ref_Option_u16(b: rs.u16 | undefined, out: } /** What `b` lends by `borrow`. */ -export function borrowPut$String_mut_String(b: rs.Place, out: rs.ByteVec): void { - put$conversions_Value_String(b.v, out); +export function borrowPut$String_mut_String(b: rs.String, out: rs.ByteVec): void { + put$conversions_Value_String(b, out); } /** What `b` lends by `borrow`. */ -export function borrowPut$String_ref_String(b: string, out: rs.ByteVec): void { +export function borrowPut$String_ref_String(b: rs.String, out: rs.ByteVec): void { put$conversions_Value_String(b, out); } @@ -7165,8 +7175,8 @@ export function borrowWrite$Option_u16_mut_Option_u16(b: rs.Place, value: string): void { - b.v = value; +export function borrowWrite$String_mut_String(b: rs.String, value: rs.String): void { + Object.assign(b, value); } /** Writes `value` over what `b` lends by `borrow_mut`. */ @@ -7227,22 +7237,22 @@ export function compared$mut_Option_u16(a: rs.Place, b: rs.P } /** Each comparison of `a` with `b`, and the greater. */ -export function compared$mut_String(a: rs.Place, b: rs.Place, out: rs.ByteVec): rs.Place { - const _5: boolean = a.v === b.v; - const _8: boolean = a.v !== b.v; - const _11: boolean = rs.cmpStr(a.v, b.v) === -1; - const order2 = rs.cmpStr(a.v, b.v); +export function compared$mut_String(a: rs.String, b: rs.String, out: rs.ByteVec): rs.String { + const _5: boolean = rs.eqStr(a, b); + const _8: boolean = !rs.eqStr(a, b); + const _11: boolean = rs.cmpStr(a, b) === -1; + const order2 = rs.cmpStr(a, b); const _14: boolean = order2 !== undefined && order2 <= 0; - const _17: boolean = rs.cmpStr(a.v, b.v) === 1; - const order3 = rs.cmpStr(a.v, b.v); + const _17: boolean = rs.cmpStr(a, b) === 1; + const order3 = rs.cmpStr(a, b); rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_5, _8, _11, _14, _17, order3 !== undefined && order3 >= 0], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rs.byteVecPush(out, rs.cmpStr(a.v, b.v) & 0xff); - rs.byteVecPush(out, option_mapOr$14runhi(rs.cmpStr(a.v, b.v), 9, (o: rs.Ordering): rs.u8 => { + rs.byteVecPush(out, rs.cmpStr(a, b) & 0xff); + rs.byteVecPush(out, option_mapOr$14runhi(rs.cmpStr(a, b), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); - return rs.ordMax(a, b, rs.cellBy(rs.cmpLt(rs.cmpStr))); + return rs.ordMax(a, b, rs.cmpLt(rs.cmpStr)); } /** Each comparison of `a` with `b`, and the greater. */ @@ -7377,9 +7387,9 @@ export function compared$ref_Option_u16(a: rs.u16 | undefined, b: rs.u16 | undef } /** Each comparison of `a` with `b`, and the greater. */ -export function compared$ref_String(a: string, b: string, out: rs.ByteVec): string { - const _5: boolean = a === b; - const _8: boolean = a !== b; +export function compared$ref_String(a: rs.String, b: rs.String, out: rs.ByteVec): rs.String { + const _5: boolean = rs.eqStr(a, b); + const _8: boolean = !rs.eqStr(a, b); const _11: boolean = rs.cmpStr(a, b) === -1; const order2 = rs.cmpStr(a, b); const _14: boolean = order2 !== undefined && order2 <= 0; @@ -7491,9 +7501,9 @@ export function compared$ref_ref_Option_u16(a: rs.u16 | undefined, b: rs.u16 | u } /** Each comparison of `a` with `b`, and the greater. */ -export function compared$ref_ref_String(a: string, b: string, out: rs.ByteVec): string { - const _5: boolean = a === b; - const _8: boolean = a !== b; +export function compared$ref_ref_String(a: rs.String, b: rs.String, out: rs.ByteVec): rs.String { + const _5: boolean = rs.eqStr(a, b); + const _8: boolean = !rs.eqStr(a, b); const _11: boolean = rs.cmpStr(a, b) === -1; const order2 = rs.cmpStr(a, b); const _14: boolean = order2 !== undefined && order2 <= 0; @@ -7641,9 +7651,9 @@ export function compared$ref_slice_Option_u16(a: rs.Slice, b } /** Each comparison of `a` with `b`, and the greater. */ -export function compared$ref_slice_String(a: rs.Slice, b: rs.Slice, out: rs.ByteVec): rs.Slice { - const _5: boolean = rs.eqSlice(rs.same)(a, b); - const _8: boolean = !rs.eqSlice(rs.same)(a, b); +export function compared$ref_slice_String(a: rs.Slice, b: rs.Slice, out: rs.ByteVec): rs.Slice { + const _5: boolean = rs.eqSlice(rs.eqStr)(a, b); + const _8: boolean = !rs.eqSlice(rs.eqStr)(a, b); const _11: boolean = rs.cmpSlice(rs.cmpStr)(a, b) === -1; const order2 = rs.cmpSlice(rs.cmpStr)(a, b); const _14: boolean = order2 !== undefined && order2 <= 0; @@ -7829,7 +7839,7 @@ export function compared$ref_u8(a: rs.u8, b: rs.u8, out: rs.ByteVec): rs.u8 { } /** The bytes `b` reads as. */ -export function readBytes$mut_String(b: rs.Place, out: rs.ByteVec): void { +export function readBytes$mut_String(b: rs.String, out: rs.ByteVec): void { rs.byteVecPush(out, rs.stringAsBytes(b.v).length & 0xff); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(b.v)); } @@ -7841,9 +7851,9 @@ export function readBytes$mut_Vec_u8(b: rs.ByteVec, out: rs.ByteVec): void { } /** The bytes `b` reads as. */ -export function readBytes$ref_String(b: string, out: rs.ByteVec): void { - rs.byteVecPush(out, rs.stringAsBytes(b).length & 0xff); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(b)); +export function readBytes$ref_String(b: rs.String, out: rs.ByteVec): void { + rs.byteVecPush(out, rs.stringAsBytes(b.v).length & 0xff); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(b.v)); } /** The bytes `b` reads as. */ @@ -7877,13 +7887,13 @@ export function readBytes$ref_str(b: string, out: rs.ByteVec): void { } /** The text `s` reads as, as bytes. */ -export function readStr$ref_String(s: string, out: rs.ByteVec): void { - rs.byteVecPush(out, rs.stringLen(s) & 0xff); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); +export function readStr$ref_String(s: rs.String, out: rs.ByteVec): void { + rs.byteVecPush(out, rs.stringLen(s.v) & 0xff); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } /** The text `s` reads as, as bytes. */ -export function readStr$ref_mut_String(s: rs.Place, out: rs.ByteVec): void { +export function readStr$ref_mut_String(s: rs.String, out: rs.ByteVec): void { rs.byteVecPush(out, rs.stringLen(s.v) & 0xff); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } diff --git a/ts/fixtures/lang/conversions/expected/core/option.ts b/ts/fixtures/lang/conversions/expected/core/option.ts index b3ab45d2f..69fbdba55 100644 --- a/ts/fixtures/lang/conversions/expected/core/option.ts +++ b/ts/fixtures/lang/conversions/expected/core/option.ts @@ -26,13 +26,6 @@ export function clone$0wpatp7(self: rs.u16 | undefined | rs.None): rs.u16 | unde return self; } -export function clone$14nprly(self: string | undefined): string | undefined { - if (self === undefined) { - return undefined; - } - return self; -} - export function clone$13oewp0(self: Uint8Array | undefined): Uint8Array | undefined { if (self === undefined) { return undefined; diff --git a/ts/fixtures/lang/cows/expected/core/option.ts b/ts/fixtures/lang/cows/expected/core/option.ts index 5bd9ecef4..51528100b 100644 --- a/ts/fixtures/lang/cows/expected/core/option.ts +++ b/ts/fixtures/lang/cows/expected/core/option.ts @@ -31,11 +31,11 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function map$167hjon(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => string): string | undefined { +export function map$0bka7d0(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => rs.String): rs.String | undefined { if (self === undefined) { return undefined; } - return rs.strCowStr(self); + return rs.strCowIntoOwned(self); } export function map$1g811lq(self: string | undefined, _: (a0: string) => rs.StrCow): rs.StrCow | undefined { @@ -45,7 +45,7 @@ export function map$1g811lq(self: string | undefined, _: (a0: string) => rs.StrC return new rs.Borrowed(self); } -export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { +export function mapOr$1fzqoua(self: rs.String | undefined, default_: rs.u8, f: (a0: rs.String) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/cows/expected/cows.Named.ts b/ts/fixtures/lang/cows/expected/cows.Named.ts index 4b3e279d3..30cf096c6 100644 --- a/ts/fixtures/lang/cows/expected/cows.Named.ts +++ b/ts/fixtures/lang/cows/expected/cows.Named.ts @@ -16,7 +16,7 @@ export function fmt$fmt_Debug(self: Named, f: rs.Formatter): rs.Result): rs.Result { if (r.ok) { - r = { ok: true, value: rs.strCowStr(r.value) }; - return { ok: true, value: r.value + "!" }; + r = { ok: true, value: rs.strCowIntoOwned(r.value) }; + rs.stringPush(r.value as rs.String, 33); + return r; } return r; } @@ -20,54 +21,55 @@ export function cow(s: string, owned: boolean): rs.StrCow { if (!owned) { return new rs.Borrowed(s); } - return s; + return rs.stringFrom(s); } export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let r!: rs.Result; - const s: string = text(data); + const s: rs.String = text(data); const owned: boolean = (kind & 128) !== 0; - const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").next()), ""); + const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, "/").next()), ""); const _14: rs.u8 = rs.u8Rem(kind, 6); if (_14 === 0) { - const c: rs.StrCow = cow(s, owned); + const c: rs.StrCow = cow(s.v, owned); rs.byteVecPush(out, rs.stringLen(rs.strCowStr(c)) & 0xff); rs.byteVecPush(out, rs.strCowStr(c).length === 0 ? 1 : 0); rs.byteVecPush(out, rs.iterCount(rs.strChars(rs.strCowStr(c))) & 0xff); put(out, rs.strCowStr(c)); put(out, rs.strCowStr(c)); put(out, rs.strCowStr(rs.strCowClone(c))); - put(out, rs.strCowStr(c)); - put(out, rs.strCowStr(c)); - put(out, rs.strCowStr("")); + put(out, rs.stringFrom(rs.strCowStr(c)).v); + put(out, rs.strCowIntoOwned(c).v); + put(out, rs.strCowStr(rs.stringNew())); put(out, rs.strCowStr(new rs.Borrowed("fallback"))); - put(out, rs.strCowStr(s)); - const shared: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s))); + put(out, rs.strCowIntoOwned(rs.stringClone(s)).v); + const shared: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s.v))); put(out, shared.value); - put(out, rs.strCowStr(option_unwrapOr$0jw3da9(option_map$1g811lq(rs.iterNth(rs.strSplit(s, "\\"), 1), (a0: string): rs.StrCow => { + put(out, rs.strCowStr(option_unwrapOr$0jw3da9(option_map$1g811lq(rs.iterNth(rs.strSplit(s.v, "\\"), 1), (a0: string): rs.StrCow => { return new rs.Borrowed(a0); }), new rs.Borrowed("fallback")))); - put(out, rs.strCowStr(cow(first, owned))); - put(out, first); + put(out, rs.strCowIntoOwned(cow(first, owned)).v); + put(out, rs.stringFrom(first).v); shared[Symbol.dispose](); } else if (_14 === 1) { - let c2: rs.StrCow = cow(s, owned); - c2 = rs.strCowStr(c2); - c2 = c2 + "!"; - c2 = rs.strCowStr(c2); - c2 = c2 + "?"; - c2 = c2 + "𐀀"; + let c2: rs.StrCow = cow(s.v, owned); + c2 = rs.strCowIntoOwned(c2); + rs.stringPush(c2 as rs.String, 33); + c2 = rs.strCowIntoOwned(c2); + const m: rs.String = c2 as rs.String; + rs.stringPush(m, 63); + rs.stringPush(m, 65536); put(out, rs.strCowStr(c2)); - put(out, s); - const v: rs.Vec = rs.vecFrom([cow(first, owned), cow(s, !owned)]); + put(out, s.v); + const v: rs.Vec = rs.vecFrom([cow(first, owned), cow(s.v, !owned)]); const at = rs.idx(v.items, 1); - v.items[at] = rs.strCowStr(v.items[at]); - v.items[at] = v.items[at] + "v"; + v.items[at] = rs.strCowIntoOwned(v.items[at]); + rs.stringPush(v.items[at] as rs.String, 118); for (const _124 of v.items) { put(out, rs.strCowStr(_124)); } - put(out, rs.strCowStr(c2)); - let joined: rs.StrCow = rs.strCowAdd(rs.strCowAdd(cow("", owned), new rs.Borrowed(first)), cow(s, !owned)); + put(out, rs.strCowIntoOwned(c2).v); + let joined: rs.StrCow = rs.strCowAdd(rs.strCowAdd(cow("", owned), new rs.Borrowed(first)), cow(s.v, !owned)); const _145: rs.StrCow = cow("", !owned); joined = rs.strCowAdd(joined, _145); joined = rs.strCowAdd(joined, new rs.Borrowed("+")); @@ -84,9 +86,9 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, _156.error); } } else if (_14 === 2) { - const a: rs.StrCow = cow(s, owned); + const a: rs.StrCow = cow(s.v, owned); const b: rs.StrCow = cow(first, !owned); - const iter2: rs.Iter = rs.iterSlice([rs.strCowStr(a) === first, rs.strCowStr(a) === first, rs.strCowStr(a) === s, first === rs.strCowStr(a), s === rs.strCowStr(a), rs.strCowStr(a) === rs.strCowStr(b), rs.strCowStr(a) !== rs.strCowStr(b), rs.cowBy(rs.cmpStr)(a, b) < 0, rs.cowBy(rs.cmpStr)(a, b) >= 0, rs.cowBy(rs.cmpStr)(a, b) === 1]); + const iter2: rs.Iter = rs.iterSlice([rs.strCowStr(a) === first, rs.strCowStr(a) === first, rs.eqStr(rs.strCowStr(a), s), first === rs.strCowStr(a), rs.eqStr(s, rs.strCowStr(a)), rs.strCowStr(a) === rs.strCowStr(b), rs.strCowStr(a) !== rs.strCowStr(b), rs.cowBy(rs.cmpStr)(a, b) < 0, rs.cowBy(rs.cmpStr)(a, b) >= 0, rs.cowBy(rs.cmpStr)(a, b) === 1]); while (true) { const _205: boolean | rs.Done = iter2.next(); if (_205 === rs.DONE) { @@ -101,7 +103,7 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const m2: Named.Named = Named.clone$Clone(n); Named.tag(n, 120); const args11 = [(f: rs.Formatter) => Named.fmt$fmt_Debug(n, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(m2, f)]; - put(out, rs.fmtFormat([args11[0], " ", args11[1]])); + put(out, rs.fmtFormat([args11[0], " ", args11[1]]).v); rs.byteVecPush(out, Named.eq$cmp_PartialEq(n, m2) ? 1 : 0); rs.byteVecPush(out, Named.cmp$cmp_Ord(n, m2) > 0 ? 1 : 0); rs.byteVecPush(out, Named.partialCmp$cmp_PartialOrd(n, m2) === -1 ? 1 : 0); @@ -109,10 +111,10 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _270: Named.Named = Named.default$Default(); const _272: Named.Named = Named.new("", kind); const args12 = [(f: rs.Formatter) => Named.fmt$fmt_Debug(_270, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(_272, f)]; - put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + put(out, rs.fmtFormat([args12[0], " ", args12[1]]).v); } else if (_14 === 4) { const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; - const iter3: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.strSplit(s, "/")); + const iter3: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.strSplit(s.v, "/")); while (true) { const _286: [rs.usize, string] | rs.Done = iter3.next(); if (_286 === rs.DONE) { @@ -131,9 +133,9 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, rs.strCowStr(_303[0])); rs.byteVecPush(out, _303[1]); } - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(counts, first), 255)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(counts, (first as unknown) as rs.StrCow), 255)); const names: rs.HashSet = rs.hashNew(rs.hashing(Named.hash$Hash_hash_DefaultHasher as (a0: Named.Named, a1: rs.Hasher) => undefined, Named.eq$cmp_PartialEq)) as rs.HashSet; - const iter5: rs.Iter = rs.strSplit(s, "/"); + const iter5: rs.Iter = rs.strSplit(s.v, "/"); while (true) { const _323: string | rs.Done = iter5.next(); if (_323 === rs.DONE) { @@ -146,11 +148,11 @@ export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _339: Named.Named = Named.new(first, 0); rs.byteVecPush(out, rs.hashContains(names, _339) ? 1 : 0); } else { - const c4: rs.StrCow = cow(s, owned); + const c4: rs.StrCow = cow(s.v, owned); const args9 = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(c4)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(c4), f)]; - put(out, rs.fmtFormat(["[", args9[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args9[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args9[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args9[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 3 }, args9[0]), "|", args9[1], "]"])); + put(out, rs.fmtFormat(["[", args9[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args9[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args9[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args9[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 3 }, args9[0]), "|", args9[1], "]"]).v); const part2 = cow(first, owned); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.StrCow, f: rs.Formatter) => rs.fmtStr(rs.strCowStr(value), f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.StrCow, f: rs.Formatter) => rs.fmtStr(rs.strCowStr(value), f))]).v); } } @@ -178,32 +180,33 @@ export function cloned$borrow_Cow_str(t: rs.StrCow): rs.StrCow { * held in collections and fields. */ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - let made2!: string; + let made2!: rs.String; let _184!: rs.StrCow; - const s: string = text(data); + const s: rs.String = text(data); const owned: boolean = (kind & 128) !== 0; - const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").next()), ""); - const rest: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").nextBack()), ""); + const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, "/").next()), ""); + const rest: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, "/").nextBack()), ""); const _21: rs.u8 = rs.u8Rem(kind, 3); if (_21 === 0) { - const c: rs.StrCow = cow(s, owned); + const c: rs.StrCow = cow(s.v, owned); const _27: rs.StrCow = rs.strCowClone(c); const _29: rs.StrCow = cloned$borrow_Cow_str(c); const _31: rs.StrCow = new rs.Borrowed(first); - const _32: rs.StrCow = s; - const _35: rs.StrCow = new rs.Borrowed(s); + const _32: rs.StrCow = rs.stringClone(s); + const _35: rs.StrCow = new rs.Borrowed(s.v); const _37: rs.StrCow = new rs.Borrowed(first); - const _38: rs.StrCow = ""; - const _39: rs.StrCow = rs.stringExtendChars("", rs.iterRev(rs.strChars(first))); + const _38: rs.StrCow = rs.stringNew(); + const _40: rs.Iter = rs.iterRev(rs.strChars(first)); + const _39: rs.StrCow = rs.stringExtendChars(rs.stringNew(), _40); const iterS: rs.StrCow[] = [_27, _29, _31, _32, _35, _37, _38, new rs.Borrowed("fallback"), _39]; for (const _45 of iterS) { rs.byteVecPush(out, borrows(_45)); put(out, rs.strCowStr(_45)); } let m: rs.StrCow = cow(first, owned); - m = rs.strCowStr(m); + m = rs.strCowIntoOwned(m); rs.byteVecPush(out, borrows(m)); - put(out, rs.strCowStr(cow(rest, owned))); + put(out, rs.strCowIntoOwned(cow(rest, owned)).v); const iter2: rs.Iter<[string, string]> = rs.iterSlice([["", rest] as [string, string], [first, ""] as [string, string], [first, rest] as [string, string], ["", ""] as [string, string]]); while (true) { const _74: [string, string] | rs.Done = iter2.next(); @@ -228,15 +231,15 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } } } else if (_21 === 1) { - let c2: rs.StrCow = cow(s, owned); + let c2: rs.StrCow = cow(s.v, owned); if (c2 instanceof rs.Borrowed) { put(out, (c2 as rs.Borrowed).slice); } else { rs.byteVecPush(out, 238); - put(out, c2 as string); + put(out, (c2 as rs.String).v); } if (!(c2 instanceof rs.Borrowed)) { - (c2 as string) = (c2 as string) + "!"; + rs.stringPush(c2 as rs.String, 33); } put(out, rs.strCowStr(c2)); const kept: rs.StrCow = rs.strCowClone(c2); @@ -244,13 +247,14 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void (c2 as rs.Borrowed).slice = first; } if (!(c2 instanceof rs.Borrowed)) { - const _137: string = rs.stringExtendChars("", rs.iterRev(rs.strChars(first))); - (c2 as string) = _137; + const _138: rs.Iter = rs.iterRev(rs.strChars(first)); + const _137: rs.String = rs.stringExtendChars(rs.stringNew(), _138); + (c2 as rs.String) = _137; } put(out, rs.strCowStr(c2)); put(out, rs.strCowStr(kept)); rs.byteVecPush(out, borrows(kept)); - let e: rs.StrCow = cow(s, !owned); + const e: rs.StrCow = cow(s.v, !owned); const kept2: rs.StrCow = rs.strCowClone(e); if (e instanceof rs.Borrowed) { const borrowed = e as rs.Borrowed; @@ -258,25 +262,26 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void put(out, borrowed.slice); borrowed.slice = first; } else { - const _162: rs.usize = option_mapOr$1je44uu(rs.iterToOption(rs.strChars(e as string).next()), 0, (a05: rs.char): rs.usize => { + const _162: rs.usize = option_mapOr$1je44uu(rs.iterToOption(rs.strChars((e as rs.String).v).next()), 0, (a05: rs.char): rs.usize => { return rs.charLenUtf8(a05); }); - (e as string) = rs.stringTruncate(e as string, _162); - (e as string) = (e as string) + "?"; + rs.stringTruncate(e as rs.String, _162); + rs.stringPush(e as rs.String, 63); } put(out, rs.strCowStr(e)); put(out, rs.strCowStr(kept2)); if (c2 instanceof rs.Borrowed) { made2 = rs.strToUppercase((c2 as rs.Borrowed).slice); } else { - made2 = c2 as string; + made2 = c2 as rs.String; } - put(out, made2); + put(out, made2.v); let d: rs.StrCow = cow(first, !owned); b18: { if (d instanceof rs.Borrowed) { if (!((d as rs.Borrowed).slice.length === 0)) { - _184 = rs.stringExtendChars("", rs.iterSkip(rs.strChars((d as rs.Borrowed).slice), 1)); + const _190: rs.Iter = rs.iterSkip(rs.strChars((d as rs.Borrowed).slice), 1); + _184 = rs.stringExtendChars(rs.stringNew(), _190); break b18; } } @@ -292,30 +297,30 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } } } else { - const parts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.strSplit(s, "/")), (_2: [rs.usize, string]): rs.StrCow => { + const parts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.strSplit(s.v, "/")), (_2: [rs.usize, string]): rs.StrCow => { return cow(_2[1], rs.usizeRem(_2[0], 2) === 1 === owned); }), "next", 12); for (const _216 of parts.items) { rs.byteVecPush(out, borrows(_216)); } - put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "+")); - put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "")); - const collected: string = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.iterRev(rs.iterSlice(parts.items)), (a0: rs.StrCow): rs.StrCow => { + put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "+").v); + put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "").v); + const collected: rs.String = rs.stringFromStrings(rs.iterMap(rs.iterRev(rs.iterSlice(parts.items)), (a0: rs.StrCow): rs.StrCow => { return rs.strCowClone(a0); - }), rs.strCowStr)); - let extended: string = rest; + })); + const extended: rs.String = rs.stringFrom(rest); const _244: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (a02: rs.StrCow): rs.StrCow => { return rs.strCowClone(a02); }); - extended = rs.stringExtend(extended, rs.iterMap(_244, rs.strCowStr)); + rs.stringExtend(extended, _244); const _251: rs.Iter<[rs.StrCow, rs.usize]> = rs.iterMap(rs.iterSlice(parts.items), (p: rs.StrCow): [rs.StrCow, rs.usize] => { return [rs.strCowClone(p), rs.stringLen(rs.strCowStr(p))] as [rs.StrCow, rs.usize]; }); - const _250: [string, rs.Vec] = rs.tupleExtend(["", new rs.Vec()] as [string, rs.Vec], _251, [rs.STRING_COW_PART, rs.vecPart(4)]); - const texts: string = _250[0]; + const _250: [rs.String, rs.Vec] = rs.tupleExtend([rs.stringNew(), new rs.Vec()] as [rs.String, rs.Vec], _251, [rs.STRING_COW_PART, rs.vecPart(4)]); + const texts: rs.String = _250[0]; const lens: rs.Vec = _250[1]; - const args3 = [(f: rs.Formatter) => rs.fmtPad(f, collected), (f: rs.Formatter) => rs.fmtPad(f, extended), (f: rs.Formatter) => rs.fmtPad(f, texts), (f: rs.Formatter) => rs.fmtList(lens.items, f, rs.usizeDebug)]; - put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3]])); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, collected.v), (f: rs.Formatter) => rs.fmtPad(f, extended.v), (f: rs.Formatter) => rs.fmtPad(f, texts.v), (f: rs.Formatter) => rs.fmtList(lens.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3]]).v); const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; const iter5: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); while (true) { @@ -336,7 +341,7 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, borrows(_292[0])); rs.byteVecPush(out, _292[1]); } - const _301: [rs.StrCow, rs.u8] | undefined = rs.btreeGetKeyValue(counts, first); + const _301: [rs.StrCow, rs.u8] | undefined = rs.btreeGetKeyValue(counts, (first as unknown) as rs.StrCow); if (_301 !== undefined) { rs.byteVecPush(out, borrows(_301[0])); } @@ -362,10 +367,10 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeSet, _336, true, undefined, undefined, 12, true), [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rest } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]), borrows), "next"); const _347: rs.Iter<[rs.StrCow, rs.u8]> = rs.btreeIter(counts); - const hashed: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.cowBy(rs.same), true)) as rs.HashMap, _347, undefined, undefined, undefined, 58720256); - rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(hashed, first), 255)); - rs.byteVecPush(out, rs.hashContains(hashed, rest) ? 1 : 0); - const both: rs.HashSet = rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.cowBy(rs.same), true)) as rs.HashSet; + const hashed: rs.HashMap = rs.hashExtend(rs.hashNew(rs.HASH_TEXT) as rs.HashMap, _347, undefined, undefined, undefined, 58720256); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(hashed, (first as unknown) as rs.StrCow), 255)); + rs.byteVecPush(out, rs.hashContains(hashed, (rest as unknown) as rs.StrCow) ? 1 : 0); + const both: rs.HashSet = rs.hashNew(rs.HASH_TEXT) as rs.HashSet; const _361: rs.StrCow = cow(first, owned); rs.hashAdd(both, _361); const _366: rs.StrCow = cow(first, !owned); @@ -377,10 +382,10 @@ export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, borrows(named.name)); const o2: rs.StrCow | undefined = rs.iterNth(rs.vecIntoIter(parts), 1); rs.byteVecPush(out, option_mapOr$03q317x(o2, 2, borrows)); - rs.byteVecPush(out, option_mapOr$1nyk1yj(option_map$167hjon(o2, (a04: rs.StrCow): string => { - return rs.strCowStr(a04); - }), 0, (t: string): rs.u8 => { - return rs.stringLen(t) & 0xff; + rs.byteVecPush(out, option_mapOr$1fzqoua(option_map$0bka7d0(o2, (a04: rs.StrCow): rs.String => { + return rs.strCowIntoOwned(a04); + }), 0, (t: rs.String): rs.u8 => { + return t.len & 0xff; })); } } @@ -461,7 +466,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putWords(out, rs.cowSlice(c)); putWords(out, rs.cowSlice(c)); putWords(out, rs.cowSlice(rs.cowClone(c))); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(c)), f, rs.u16Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(rs.cowSlice(c)), f, rs.u16Debug)]).v); putWords(out, rs.sliceFrom(rs.cowIntoOwned(c).items)); putWords(out, rs.cowSlice(new rs.Vec())); const iter: rs.Iter> = rs.iterSlice([new rs.Borrowed(half), rs.vecFrom(v.items.slice()), new rs.Borrowed(rs.sliceFrom(v.items)), new rs.Borrowed(rs.sliceFrom([3, 1, 4])), rs.iterToVec(rs.iterRev(rs.iterSlice(v.items)), undefined, 2, true)]); @@ -500,7 +505,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const before: Run.Run = Run.clone$Clone(run); Run.bump(run); const args8 = [(f: rs.Formatter) => Run.fmt$fmt_Debug(run, f), (f: rs.Formatter) => Run.fmt$fmt_Debug(before, f)]; - put(out, rs.fmtFormat([args8[0], " ", args8[1]])); + put(out, rs.fmtFormat([args8[0], " ", args8[1]]).v); putWords(out, half); putWords(out, rs.sliceFrom(rs.cowIntoOwned(c2).items)); } else if (_15 === 2) { @@ -639,7 +644,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _435: Run.Run = { words: cowOf(rs.sliceRange(rs.sliceFrom(v.items), 0, part3), !owned) }; rs.byteVecPush(out, rs.hashContains(runs, _435) ? 1 : 0); const part4 = Run.default$Default(); - put(out, rs.fmtFormat([(f: rs.Formatter) => Run.fmt$fmt_Debug(part4, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => Run.fmt$fmt_Debug(part4, f)]).v); } else { const log: rs.Cell = new rs.Cell(0); const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Tally.Tally => { @@ -725,7 +730,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteCowSlice(c), 0, rs.min(rs.byteCowSlice(c).length, 3))); const _35: rs.ByteCow = made(half, !owned); const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(c)), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(_35)), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1]]).v); const _47: rs.ByteCow = made(half, !owned); const _44: boolean = rs.eqBytes(c, _47); const _49: boolean = rs.eqBytes(c, data); @@ -939,11 +944,12 @@ export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_167.length & 0xff, _167.data.length & 0xff)), undefined, true); } } else { - const _179: [string, string] = [text(left), text(right)]; - const to: string = _179[0]; - const from4: string = _179[1]; - let c5: rs.StrCow = cow(to, intoOwned); - c5 = rs.strCowClone(cow(from4, fromOwned)); + const _179: [rs.String, rs.String] = [text(left), text(right)]; + const to: rs.String = _179[0]; + const from4: rs.String = _179[1]; + let c5: rs.StrCow = cow(to.v, intoOwned); + const _188: rs.StrCow = cow(from4.v, fromOwned); + c5 = rs.strCowCloneFrom(c5, _188); put(out, rs.strCowStr(c5)); } } diff --git a/ts/fixtures/lang/cows/expected/harness.ts b/ts/fixtures/lang/cows/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/cows/expected/harness.ts +++ b/ts/fixtures/lang/cows/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/defaults/expected/defaults.Made.ts b/ts/fixtures/lang/defaults/expected/defaults.Made.ts index d85d379b0..5997e68ec 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.Made.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.Made.ts @@ -7,18 +7,18 @@ export function fmt$fmt_Debug(self: Made, f: rs.Formatter): rs.Result rs.u64Debug(self.n, f); const _7: string = "tag"; - const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.tag, f); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.tag.v, f); return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** A type of the crate's own, whose `Default` impl is no zero value. */ export interface Made { n: rs.u64; - tag: string; + tag: rs.String; } export function default$Default(): Made { - return { n: 3, tag: "made" }; + return { n: 3, tag: rs.stringFrom("made") }; } //# sourceMappingURL=defaults.Made.ts.map diff --git a/ts/fixtures/lang/defaults/expected/defaults.ts b/ts/fixtures/lang/defaults/expected/defaults.ts index 4d6dae998..d2a57343e 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.ts @@ -42,7 +42,7 @@ export function made$unit(): void { /** Each byte an operation, its value the operand; each puts what it read. */ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { - let s!: string; + let s!: rs.String; for (const op of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(op, 9); if (_10 === 0) { @@ -113,7 +113,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _142: rs.Arc | undefined = rs.weakUpgrade(live); const _140: boolean = _142 !== undefined; const args22 = [(f: rs.Formatter) => rs.fmtBool(_115, f), (f: rs.Formatter) => rs.usizeDisplay(_120, f), (f: rs.Formatter) => rs.fmtBool(_123, f), (f: rs.Formatter) => rs.fmtBool(_127, f), (f: rs.Formatter) => rs.fmtBool(_131, f), (f: rs.Formatter) => rs.fmtBool(_135, f), (f: rs.Formatter) => rs.fmtBool(_140, f)]; - const _111: string = rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3], " ", args22[4], " ", args22[5], " ", args22[6]]); + const _111: rs.String = rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3], " ", args22[4], " ", args22[5], " ", args22[6]]); rs.drop(_142); rs.drop(_137); rs.drop(_117); @@ -175,10 +175,10 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _218: rs.u64 = rs.u64Add(made2.n, op as rs.u64); const _224: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_218, f); const arg = made2.tag; - const args19 = [_224, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + const args19 = [_224, (f: rs.Formatter) => rs.fmtPad(f, arg.v)]; s = rs.fmtFormat([args19[0], " ", args19[1]]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); rs.byteVecPush(out, 10); } } diff --git a/ts/fixtures/lang/durations/expected/durations.ts b/ts/fixtures/lang/durations/expected/durations.ts index f49047250..d80cae815 100644 --- a/ts/fixtures/lang/durations/expected/durations.ts +++ b/ts/fixtures/lang/durations/expected/durations.ts @@ -154,11 +154,11 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const c: rs.Duration = rs.durationNew(0, rs.durationSubsecNanos(b)); const d2: rs.Duration = rs.durationFromNanos(rs.u32Rem(n, 1000000) as rs.u64); const args10 = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), (f: rs.Formatter) => rs.fmtOption(b, f, rs.durationDebug)]; - put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", rs.fmtSpec({ align: ">", width: 16 }, args10[1]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 14 }, args10[2]), "|", rs.fmtSpec({ align: "<", width: 12 }, args10[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args10[0]), "|", args10[3]])); + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2], "|", rs.fmtSpec({ align: ">", width: 16 }, args10[1]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 14 }, args10[2]), "|", rs.fmtSpec({ align: "<", width: 12 }, args10[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args10[0]), "|", args10[3]]).v); const p: rs.usize = rs.u32Rem(n, 13) as rs.usize; const _234: rs.Duration | undefined = b; const args11 = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtOption(_234, f, rs.durationDebug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args11[0]), "|", rs.fmtSpec({ precision: 3 }, args11[0]), "|", rs.fmtSpec({ precision: 1 }, args11[1]), "|", rs.fmtSpec({ precision: 12 }, args11[2]), "|", rs.fmtSpec({ plus: true }, args11[0]), "|", rs.fmtSpec({ plus: true, width: 12, precision: 2 }, args11[1]), "|", rs.fmtSpec({ align: "<", width: 10, precision: 1 }, args11[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args11[3]) }, args11[0]), "|", rs.fmtSpec({ precision: 1 }, args11[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args11[0]), "|", rs.fmtSpec({ precision: 3 }, args11[0]), "|", rs.fmtSpec({ precision: 1 }, args11[1]), "|", rs.fmtSpec({ precision: 12 }, args11[2]), "|", rs.fmtSpec({ plus: true }, args11[0]), "|", rs.fmtSpec({ plus: true, width: 12, precision: 2 }, args11[1]), "|", rs.fmtSpec({ align: "<", width: 10, precision: 1 }, args11[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args11[3]) }, args11[0]), "|", rs.fmtSpec({ precision: 1 }, args11[4])]).v); const iter4: rs.Iter = rs.iterSlice([1500000000, 2500000000, 1250000, 1350000, 999500, 1999999999]); while (true) { const _250: rs.u64 | rs.Done = iter4.next(); @@ -167,7 +167,7 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } const part = rs.durationFromNanos(_250); const args12 = [(f: rs.Formatter) => rs.durationDebug(part, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args12[0]), " ", rs.fmtSpec({ precision: 1 }, args12[0]), " ", rs.fmtSpec({ precision: 2 }, args12[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args12[0]), " ", rs.fmtSpec({ precision: 1 }, args12[0]), " ", rs.fmtSpec({ precision: 2 }, args12[0])]).v); } } else if (_24 === 10) { let c2: rs.Duration = a; @@ -236,7 +236,7 @@ export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Window.hash$Hash_hash_DefaultHasher as (a0: Window.Window, a1: rs.Hasher) => undefined, Window.eq$cmp_PartialEq)) as rs.HashSet, _398, undefined, undefined, 29360128)) & 0xff); const _413: Window.Window = Window.default$Default(); const args9 = [(f: rs.Formatter) => Window.fmt$fmt_Debug(w2, f), (f: rs.Formatter) => Window.fmt$fmt_Debug(_413, f)]; - put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ alternate: true }, args9[1])])); + put(out, rs.fmtFormat([args9[0], "|", rs.fmtSpec({ alternate: true }, args9[1])]).v); } } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Named.ts b/ts/fixtures/lang/dyns/expected/dyns.Named.ts index bce537b7b..0999b0c74 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Named.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Named.ts @@ -3,6 +3,6 @@ import * as rs from "./rs.ts"; export type Named = - | { label$Named: () => string; fmt$Debug: (a0: rs.Formatter) => rs.Result; area$Shape: () => rs.u32; grow$Shape: (a0: rs.u8) => void; sides$Shape: () => rs.u8; intoArea$Shape: () => rs.u32; larger$Shape: (a0: rs.u32) => rs.u32; tally$Shape: (a0: rs.Place) => void }; + | { label$Named: () => rs.String; fmt$Debug: (a0: rs.Formatter) => rs.Result; area$Shape: () => rs.u32; grow$Shape: (a0: rs.u8) => void; sides$Shape: () => rs.u8; intoArea$Shape: () => rs.u32; larger$Shape: (a0: rs.u32) => rs.u32; tally$Shape: (a0: rs.Place) => void }; //# sourceMappingURL=dyns.Named.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Over.ts b/ts/fixtures/lang/dyns/expected/dyns.Over.ts index bea23cc06..60a234260 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Over.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Over.ts @@ -20,12 +20,12 @@ export class Over { } } -export function run$String(self: Over): string | undefined { - const _3: string | undefined = self.source.take$Source(); +export function run$String(self: Over): rs.String | undefined { + const _3: rs.String | undefined = self.source.take$Source(); if (_3 !== undefined) { - const next: string = _3; - const other: string = self.scale.scale$Scaled(next); - return self.scale.pick$Scaled(next as rs.Ptr, other as rs.Ptr) as string; + const next: rs.String = _3; + const other: rs.String = self.scale.scale$Scaled(rs.stringClone(next)); + return rs.stringClone(self.scale.pick$Scaled(next as rs.Ptr, other as rs.Ptr) as rs.String); } return undefined; } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Square.ts b/ts/fixtures/lang/dyns/expected/dyns.Square.ts index 33e6e1c70..2915dffea 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Square.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Square.ts @@ -42,7 +42,7 @@ export function grow$dyns_Shape(self: Square, by: rs.u8): void { self.side = rs.u16WrappingAdd(self.side, by as rs.u16); } -export function label$dyns_Named(self: Square): string { +export function label$dyns_Named(self: Square): rs.String { const arg = self.side; return rs.fmtFormat(["square ", (f: rs.Formatter) => rs.u16Display(arg, f)]); } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts index 5ac62fbb3..0ddb30274 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts @@ -56,7 +56,7 @@ export function intoArea$dyns_Shape(self: Tri): rs.u32 { return rs.u32WrappingMul(area$dyns_Shape(self), 2); } -export function label$dyns_Named(self: Tri): string { +export function label$dyns_Named(self: Tri): rs.String { return rs.fmtFormat(["tri ", (f: rs.Formatter) => fmt$fmt_Debug(self, f)]); } @@ -72,28 +72,27 @@ export function asAnyMut$dyns_Erased(self: rs.Place): Any.Any { * Provided, taking a function of a reference to the argument, which the trait's type * takes in each form a reference may be. */ -export function apply$dyns_Scaled_String(self: Tri, f: (a0: string) => string, x: string): string { +export function apply$dyns_Scaled_String(self: Tri, f: (a0: rs.String) => rs.String, x: rs.String): rs.String { return f(scale$dyns_Scaled_String(self, x)); } -export function scale$dyns_Scaled_String(self: Tri, by: string): string { - const args3 = [(f: rs.Formatter) => rs.fmtPad(f, by), (f: rs.Formatter) => fmt$fmt_Debug(self, f)]; +export function scale$dyns_Scaled_String(self: Tri, by: rs.String): rs.String { + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, by.v), (f: rs.Formatter) => fmt$fmt_Debug(self, f)]; return rs.fmtFormat([args3[0], args3[1]]); } /** Writes through a `&mut` to the argument, an `rs.Place` for a number. */ -export function bump$dyns_Scaled_String(self: Tri, at: rs.Place): void { +export function bump$dyns_Scaled_String(self: Tri, at: rs.String): void { const _8: rs.u32 = area$dyns_Shape(self); - const _4: string = rs.fmtToString((f: rs.Formatter) => rs.u32Display(_8, f)); - at.v = at.v + _4; + rs.stringPushStr(at, rs.fmtToString((f: rs.Formatter) => rs.u32Display(_8, f), 0).v); } /** * Takes and returns references to the argument, which the trait's type has in each * form a reference may be. */ -export function pick$dyns_Scaled_String(_self: Tri, a: string, b: string): string { - if (!(rs.stringLen(a) >= rs.stringLen(b))) { +export function pick$dyns_Scaled_String(_self: Tri, a: rs.String, b: rs.String): rs.String { + if (!(a.len >= b.len)) { return b; } return a; diff --git a/ts/fixtures/lang/dyns/expected/dyns.ts b/ts/fixtures/lang/dyns/expected/dyns.ts index 114003c7e..59513f8cf 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.ts @@ -119,17 +119,17 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o } let n: rs.u32 = c as rs.u32; const part = total(rs.sliceFrom([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)])); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part, f), " "]).v); growTwice(new of$dyns_Square(sq), b); growTwice(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), c); growTwice(new ofPlace$u32(rs.place(() => n, (value2) => n = value2)), a); const arg = sq.side; const args14 = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(tri, f), (f: rs.Formatter) => rs.u32Display(n, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "]).v); const _78: rs.u8 = sidesOf$dyn_dyns_Shape(new of$dyns_Tri(tri)); const _82: rs.u8 = sidesOf$dyns_Square(sq); const args15 = [(f: rs.Formatter) => rs.u8Display(_78, f), (f: rs.Formatter) => rs.u8Display(_82, f)]; - put(out, rs.fmtFormat([args15[0], " ", args15[1], " "])); + put(out, rs.fmtFormat([args15[0], " ", args15[1], " "]).v); const shapes: rs.Vec = new rs.Vec(); const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 3, dataLen - 3)))); while (true) { @@ -152,11 +152,11 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o if (rs.usizeRem(i2, 2) === 0) { s.v.grow$Shape(a); } - const _129: string = s.v.label$Named(); + const _129: rs.String = s.v.label$Named(); const _132: rs.u32 = s.v.area$Shape(); const _135: rs.u8 = sidesOf$dyn_dyns_Shape(upcast(s.v)); - const args16 = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => rs.u32Display(_132, f), (f: rs.Formatter) => rs.u8Display(_135, f), (f: rs.Formatter) => s.v.fmt$Debug(f)]; - put(out, rs.fmtFormat([args16[0], ":", args16[1], ":", args16[2], ":", args16[3], " "])); + const args16 = [(f: rs.Formatter) => rs.fmtPad(f, _129.v), (f: rs.Formatter) => rs.u32Display(_132, f), (f: rs.Formatter) => rs.u8Display(_135, f), (f: rs.Formatter) => s.v.fmt$Debug(f)]; + put(out, rs.fmtFormat([args16[0], ":", args16[1], ":", args16[2], ":", args16[3], " "]).v); } let sum: rs.u32 = 0; for (const _150 of shapes.items) { @@ -168,42 +168,42 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o const _169: rs.u32 = shapes.items[at2].larger$Shape(b as rs.u32); const _175: rs.u32 = sum; const args17 = [(f: rs.Formatter) => rs.u32Display(_175, f), (f: rs.Formatter) => Shown.fmt$fmt_Debug(_165, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; - put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " "])); + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " "]).v); for (const s2 of shapes.items) { sum = rs.u32WrappingAdd(sum, s2.intoArea$Shape()); } const _203: rs.u32 = new of$u32(n).intoArea$Shape(); const _204: rs.u32 = sum; const args18 = [(f: rs.Formatter) => rs.u32Display(_204, f), (f: rs.Formatter) => rs.u32Display(_203, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1]])); + put(out, rs.fmtFormat([args18[0], " ", args18[1]]).v); } } -export function counts$dyn_dyns_Named(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyn_dyns_Named(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } -export function counts$dyn_dyns_Shape(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyn_dyns_Shape(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } -export function counts$dyns_Hits(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyns_Hits(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } -export function counts$dyns_Square(arcs: rs.Slice>): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): string => { +export function counts$dyns_Square(arcs: rs.Slice>): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(arcs)), (a: rs.Arc): rs.String => { const _42: rs.usize = a.strong; - return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f), 0); }), undefined, 12, true).items, ","); } @@ -217,13 +217,13 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const shape: rs.Arc = rs.arcClone(named); const up: rs.Arc = rs.arcClone(again); const part = counts$dyns_Square(rs.sliceFrom([sq])); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " "])); - const _49: string = named.value.label$Named(); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part.v), " "]).v); + const _49: rs.String = named.value.label$Named(); const _53: rs.u32 = shape.value.area$Shape(); const _57: rs.u8 = sidesOf$dyn_dyns_Shape(up.value); const _62: Named.Named = named.value; - const args26 = [(f: rs.Formatter) => rs.fmtPad(f, _49), (f: rs.Formatter) => rs.u32Display(_53, f), (f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => _62.fmt$Debug(f)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " ", args26[3], " "])); + const args26 = [(f: rs.Formatter) => rs.fmtPad(f, _49.v), (f: rs.Formatter) => rs.u32Display(_53, f), (f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => _62.fmt$Debug(f)]; + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " ", args26[3], " "]).v); const _73: [rs.Weak, rs.Weak] = [new rs.Weak(shape), new rs.Weak(up)]; const weak: rs.Weak = _73[0]; const other: rs.Weak = _73[1]; @@ -231,13 +231,13 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const _90: boolean = rs.arcPtrEq(shape, up); const _94: boolean = rs.arcPtrEq(weak.arc, other.arc); const args27 = [(f: rs.Formatter) => rs.fmtBool(_86, f), (f: rs.Formatter) => rs.fmtBool(_90, f), (f: rs.Formatter) => rs.fmtBool(_94, f)]; - put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2], " "])); + put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2], " "]).v); sq[Symbol.dispose](); named[Symbol.dispose](); - const _113: string = counts$dyn_dyns_Named(rs.sliceFrom([again])); + const _113: rs.String = counts$dyn_dyns_Named(rs.sliceFrom([again])); const _119: rs.usize = weak.arc.strong; - const args28 = [(f: rs.Formatter) => rs.fmtPad(f, _113), (f: rs.Formatter) => rs.usizeDisplay(_119, f)]; - put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + const args28 = [(f: rs.Formatter) => rs.fmtPad(f, _113.v), (f: rs.Formatter) => rs.usizeDisplay(_119, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " "]).v); const upgraded: rs.u32 | undefined = option_map$1mach0o(rs.weakUpgrade(weak), (s: rs.Arc): rs.u32 => { const _0: rs.u32 = s.value.area$Shape(); s[Symbol.dispose](); @@ -245,23 +245,23 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, }); again[Symbol.dispose](); const part2 = counts$dyn_dyns_Shape(rs.sliceFrom([up])); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part2), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part2.v), " "]).v); up[Symbol.dispose](); - const _156: string = counts$dyn_dyns_Shape(rs.sliceFrom([shape])); + const _156: rs.String = counts$dyn_dyns_Shape(rs.sliceFrom([shape])); const _164: rs.Arc | undefined = rs.weakUpgrade(weak); const _162: boolean = _164 !== undefined; - const args30 = [(f: rs.Formatter) => rs.fmtPad(f, _156), (f: rs.Formatter) => rs.fmtBool(_162, f), (f: rs.Formatter) => rs.fmtOption(upgraded, f, rs.u32Debug)]; - const _152: string = rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); + const args30 = [(f: rs.Formatter) => rs.fmtPad(f, _156.v), (f: rs.Formatter) => rs.fmtBool(_162, f), (f: rs.Formatter) => rs.fmtOption(upgraded, f, rs.u32Debug)]; + const _152: rs.String = rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); rs.drop(_164); - put(out, _152); + put(out, _152.v); shape[Symbol.dispose](); const _184: rs.Arc | undefined = rs.weakUpgrade(weak); const _182: boolean = _184 === undefined; const _187: rs.usize = other.arc.strong; const args31 = [(f: rs.Formatter) => rs.fmtBool(_182, f), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; - const _178: string = rs.fmtFormat([args31[0], " ", args31[1], " "]); + const _178: rs.String = rs.fmtFormat([args31[0], " ", args31[1], " "]); rs.drop(_184); - put(out, _178); + put(out, _178.v); const hits: rs.Arc = new rs.Arc({ _0: new rs.Atomic(dataData[dataStart + 1] as rs.u32) }); const objects: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (_2: rs.i32): rs.Arc => { const _36: rs.Arc = rs.arcClone(hits); @@ -271,12 +271,12 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, return rs.u32WrappingAdd(sum2, s2.value.area$Shape()); }); const _216: rs.u32 = rs.atomicLoad(hits.value._0, 0); - const _222: string = counts$dyns_Hits(rs.sliceFrom([hits])); - const args32 = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.u32Display(_216, f), (f: rs.Formatter) => rs.fmtPad(f, _222)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "])); + const _222: rs.String = counts$dyns_Hits(rs.sliceFrom([hits])); + const args32 = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.u32Display(_216, f), (f: rs.Formatter) => rs.fmtPad(f, _222.v)]; + put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]).v); rs.dropVec(objects); const part3 = counts$dyns_Hits(rs.sliceFrom([hits])); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part3), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part3.v), " "]).v); const _253: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); const n: rs.Arc = new rs.ArcDyn(_253, new of$u32(_253.value)); const _257: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); @@ -284,7 +284,7 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, const _268: rs.u32 = n.value.area$Shape(); const _272: boolean = rs.arcPtrEq(n, m); const args34 = [(f: rs.Formatter) => rs.u32Display(_268, f), (f: rs.Formatter) => rs.fmtBool(_272, f)]; - put(out, rs.fmtFormat([args34[0], " ", args34[1], " "])); + put(out, rs.fmtFormat([args34[0], " ", args34[1], " "]).v); const tris: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_23: rs.u8): rs.Arc => { const x: rs.u8 = _23; const _43: rs.u8 = rs.u8Rem(x, 3); @@ -303,20 +303,20 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, return rs.arcClone(a0); }), undefined, 8, true); for (const _292 of tris.items) { - const _304: string = _292.value.label$Named(); + const _304: rs.String = _292.value.label$Named(); const _307: rs.u32 = _292.value.area$Shape(); const _310: rs.usize = _292.strong; - const args35 = [(f: rs.Formatter) => rs.fmtPad(f, _304), (f: rs.Formatter) => rs.u32Display(_307, f), (f: rs.Formatter) => rs.usizeDisplay(_310, f)]; - put(out, rs.fmtFormat([args35[0], ":", args35[1], ":", args35[2], " "])); + const args35 = [(f: rs.Formatter) => rs.fmtPad(f, _304.v), (f: rs.Formatter) => rs.u32Display(_307, f), (f: rs.Formatter) => rs.usizeDisplay(_310, f)]; + put(out, rs.fmtFormat([args35[0], ":", args35[1], ":", args35[2], " "]).v); } rs.dropVec(tris); let total: rs.u32 = 0; for (const _322 of kept.items) { _322.value.tally$Shape(rs.place(() => total, (value) => total = value)); } - const _337: string = counts$dyn_dyns_Named(rs.sliceFrom(rs.iterToVec(rs.iterSlice(kept.items), undefined, 4, true).items)); - const args36 = [(f: rs.Formatter) => rs.u32Display(total, f), (f: rs.Formatter) => rs.fmtPad(f, _337)]; - put(out, rs.fmtFormat([args36[0], " ", args36[1]])); + const _337: rs.String = counts$dyn_dyns_Named(rs.sliceFrom(rs.iterToVec(rs.iterSlice(kept.items), undefined, 4, true).items)); + const args36 = [(f: rs.Formatter) => rs.u32Display(total, f), (f: rs.Formatter) => rs.fmtPad(f, _337.v)]; + put(out, rs.fmtFormat([args36[0], " ", args36[1]]).v); rs.dropVec(kept); m[Symbol.dispose](); n[Symbol.dispose](); @@ -339,7 +339,7 @@ export function key$dyns_Keyed_u32(self: rs.u32): rs.u32 { } /** What `a` holds, by the type it downcasts to. */ -export function kind(a: Any.Any): string { +export function kind(a: Any.Any): rs.String { const _2: Square.Square | undefined = a instanceof of$dyns_Square ? a.v : undefined; if (_2 !== undefined) { const arg = _2.side; @@ -354,9 +354,9 @@ export function kind(a: Any.Any): string { return rs.fmtFormat(["tri ", (f: rs.Formatter) => Tri.fmt$fmt_Debug(_24, f)]); } if (!(a instanceof of$u8 || a instanceof ofPlace$u8)) { - return "other"; + return rs.stringFrom("other"); } - return "u8"; + return rs.stringFrom("u8"); } /** Bumps the number or enum `a` holds where it is. */ @@ -412,7 +412,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o break; } const part = kind(_33); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part.v), " "]).v); } const _51: boolean = bump(new of$dyns_Square(sq), a); const _54: boolean = bump(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), b); @@ -422,7 +422,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _72: Tri.Tri = tri; const arg = sq.side; const args44 = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_72, f), (f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(hit[0], f), (f: rs.Formatter) => rs.fmtBool(hit[1], f), (f: rs.Formatter) => rs.fmtBool(hit[2], f), (f: rs.Formatter) => rs.fmtBool(hit[3], f)], f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " ", args44[3], " "])); + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " ", args44[3], " "]).v); const iter2: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)]); while (true) { const _91: dyns_Erased.Erased | rs.Done = iter2.next(); @@ -431,9 +431,9 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } const _103: boolean = isA$dyns_Square(_91); const _105: boolean = isA$u32(_91); - const _107: string = kind(_91.asAny$Erased()); - const args45 = [(f: rs.Formatter) => rs.fmtBool(_103, f), (f: rs.Formatter) => rs.fmtBool(_105, f), (f: rs.Formatter) => rs.fmtPad(f, _107)]; - put(out, rs.fmtFormat([args45[0], args45[1], args45[2], " "])); + const _107: rs.String = kind(_91.asAny$Erased()); + const args45 = [(f: rs.Formatter) => rs.fmtBool(_103, f), (f: rs.Formatter) => rs.fmtBool(_105, f), (f: rs.Formatter) => rs.fmtPad(f, _107.v)]; + put(out, rs.fmtFormat([args45[0], args45[1], args45[2], " "]).v); } let m: rs.u32 = a as rs.u32; const _119: Any.Any = new ofPlace$u32(rs.place(() => m, (value4) => m = value4)).asAnyMut$Erased(); @@ -441,10 +441,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o if (_118 !== undefined) { _118.v = rs.u32WrappingMul(_118.v, 3); } - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(m, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(m, f), " "]).v); const unit: Any.Any = new of$unit(undefined); const part2 = [unit instanceof of$unit ? unit.v : unit instanceof ofPlace$unit ? unit.v.v : rs.None, unit instanceof of$Option_u8 || unit instanceof ofPlace$Option_u8] as [undefined | rs.None, boolean]; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part2[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtBool(part2[1], f)], f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part2[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtBool(part2[1], f)], f), " "]).v); let some: rs.u8 | undefined = a; let none: rs.u8 | undefined = undefined; const iter3: rs.Iter = rs.iterSlice([new ofPlace$Option_u8(rs.place(() => some, (value5) => some = value5)), new ofPlace$Option_u8(rs.place(() => none, (value6) => none = value6)), new ofPlace$u32(rs.place(() => n, (value7) => n = value7))]); @@ -454,7 +454,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o break; } const part3 = [_167 instanceof of$unit ? _167.v : _167 instanceof ofPlace$unit ? _167.v.v : rs.None, _167 instanceof of$Option_u8 ? _167.v : _167 instanceof ofPlace$Option_u8 ? _167.v.v : rs.None] as [undefined | rs.None, rs.u8 | undefined | rs.None]; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part3[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(part3[1], f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)], f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part3[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(part3[1], f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)], f)]).v); const _189: rs.Place | undefined = _167 instanceof of$Option_u8 ? _167 : _167 instanceof ofPlace$Option_u8 ? _167.v : undefined; if (_189 !== undefined) { _189.v = option_mapOr$19a4gco(_189.v, b, (_2: rs.u8): rs.u8 | undefined => { @@ -462,10 +462,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o }); } const arg2 = (_167 instanceof of$unit ? _167 : _167 instanceof ofPlace$unit ? _167.v : undefined) !== undefined; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(arg2, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(arg2, f), " "]).v); } const args50 = [(f: rs.Formatter) => rs.fmtOption(some, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args50[0], " ", args50[1], " "])); + put(out, rs.fmtFormat([args50[0], " ", args50[1], " "]).v); const boxes: rs.Vec = new rs.Vec(); const iter4: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2)))); while (true) { @@ -499,17 +499,17 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _261: rs.Result = boxed instanceof of$u32 ? rs.Ok(boxed.v) : rs.Err(boxed); if (_261.ok) { const part5 = _261.value; - put(out, rs.fmtFormat(["n", (f: rs.Formatter) => rs.u32Display(part5, f), " "])); + put(out, rs.fmtFormat(["n", (f: rs.Formatter) => rs.u32Display(part5, f), " "]).v); } else if (!(rs.usizeRem(i2, 2) === 0)) { const other2: Any.Any = _261.error; const _282: rs.Result = other2 instanceof of$u8 ? rs.Ok(other2.v) : rs.Err(other2); if (_282.ok) { const arg3 = _282.value; - put(out, rs.fmtFormat(["u8 ", (f: rs.Formatter) => rs.u8Display(arg3, f), " "])); + put(out, rs.fmtFormat(["u8 ", (f: rs.Formatter) => rs.u8Display(arg3, f), " "]).v); } else { const other3: Any.Any = _282.error; const part4 = kind(other3); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part4), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part4.v), " "]).v); rs.drop(other3); } } else { @@ -523,10 +523,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o if (_316 === rs.DONE) { break; } - const _328: string = kind(_316.v); + const _328: rs.String = kind(_316.v); const _331: boolean = bump(_316.v, a); - const args54 = [(f: rs.Formatter) => rs.fmtPad(f, _328), (f: rs.Formatter) => rs.fmtBool(_331, f)]; - put(out, rs.fmtFormat([args54[0], ":", args54[1], " "])); + const args54 = [(f: rs.Formatter) => rs.fmtPad(f, _328.v), (f: rs.Formatter) => rs.fmtBool(_331, f)]; + put(out, rs.fmtFormat([args54[0], ":", args54[1], " "]).v); } const _339: rs.Arc<[rs.u8, rs.u8]> = new rs.Arc([a, b] as [rs.u8, rs.u8]); const hold: rs.Arc = new rs.ArcDyn(_339, new of$tuple2_u8_u8(_339.value)); @@ -535,10 +535,10 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _354: rs.usize = hold.strong; const _357: [rs.u8, rs.u8] | undefined = _358 instanceof of$tuple2_u8_u8 ? _358.v : undefined; const args55 = [(f: rs.Formatter) => rs.usizeDisplay(_354, f), (f: rs.Formatter) => rs.fmtOption(_357, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args55[0], " ", args55[1], " "])); + put(out, rs.fmtFormat([args55[0], " ", args55[1], " "]).v); rs.dropAll(held); const part6 = hold.strong; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part6, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part6, f), " "]).v); const _381: rs.Result, rs.Arc> = rs.arcDowncast(hold, of$u8, (object) => object.v); if (_381.ok) { rs.panic("internal error: entered unreachable code"); @@ -548,7 +548,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o t[Symbol.dispose](); return _02; })); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]).v); let n3: rs.u32 = a as rs.u32; const iter7: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$u32(n3)]); while (true) { @@ -558,18 +558,18 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } const any: Any.Any = _407; const _420: rs.u32 = _407.key$Keyed(); - const _422: string = kind(any); - const args58 = [(f: rs.Formatter) => rs.u32Display(_420, f), (f: rs.Formatter) => rs.fmtPad(f, _422)]; - put(out, rs.fmtFormat([args58[0], args58[1], " "])); + const _422: rs.String = kind(any); + const args58 = [(f: rs.Formatter) => rs.u32Display(_420, f), (f: rs.Formatter) => rs.fmtPad(f, _422.v)]; + put(out, rs.fmtFormat([args58[0], args58[1], " "]).v); } const part8 = bump(new ofPlace$u32(rs.place(() => n3, (value8) => n3 = value8)), b); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part8, f), " "])); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(n3, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part8, f), " "]).v); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(n3, f), " "]).v); const any3: Any.Any = new of$dyns_Square({ side: b as rs.u16 }); const part9 = ok$1wwd922(result_map$0tx2z7o(any3 instanceof of$dyns_Square ? rs.Ok(any3.v) : rs.Err(any3), (sq2: Square.Square): rs.u16 => { return sq2.side; })); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u16Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u16Debug), " "]).v); const _477: rs.Arc = new rs.Arc(n3); const shared: rs.Arc = new rs.ArcDyn(_477, new of$u32(_477.value)); const weak2: rs.Weak = new rs.Weak(shared); @@ -583,7 +583,7 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o }); const _495: rs.u32 | undefined = _496 instanceof of$u32 ? _496.v : _496 instanceof ofPlace$u32 ? _496.v.v : undefined; const args62 = [(f: rs.Formatter) => rs.fmtBool(_491, f), (f: rs.Formatter) => rs.fmtOption(_495, f, rs.u32Debug)]; - put(out, rs.fmtFormat([args62[0], " ", args62[1], " "])); + put(out, rs.fmtFormat([args62[0], " ", args62[1], " "]).v); const typed2: [rs.usize, rs.u32] | undefined = ok$0y6a1w6(result_map$0njbm3o(rs.arcDowncast(any4, of$u32, (object) => object.v), (n4: rs.Arc): [rs.usize, rs.u32] => { const _05: [rs.usize, rs.u32] = [n4.strong, n4.value]; n4[Symbol.dispose](); @@ -592,9 +592,9 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o const _516: rs.Arc | undefined = rs.weakUpgrade(weak2); const _514: boolean = _516 !== undefined; const args63 = [(f: rs.Formatter) => rs.fmtOption(typed2, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_514, f)]; - const _510: string = rs.fmtFormat([args63[0], " ", args63[1]]); + const _510: rs.String = rs.fmtFormat([args63[0], " ", args63[1]]); rs.drop(_516); - put(out, _510); + put(out, _510.v); weak2[Symbol.dispose](); rs.dropVec(kept); } @@ -649,11 +649,11 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const _31: rs.u8 = twice(halve, a); const _35: rs.u8 = twice(ptr, a); const args17 = [(f: rs.Formatter) => rs.u8Display(_27, f), (f: rs.Formatter) => rs.u8Display(_31, f), (f: rs.Formatter) => rs.u8Display(_35, f)]; - put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " "])); + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " "]).v); const part = firstWord((s: string): string => { return option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, " ").next()), ""); }, "ab cd"); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part, f), " "]).v); let sum: rs.u32 = 0; const seen: rs.ByteVec = new rs.ByteVec(); bumpAll((x2: rs.u8): undefined => { @@ -661,7 +661,7 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(seen, x2); }, rs.byteSliceRange(data, 2)); const args19 = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args19[0], " ", args19[1], " "])); + put(out, rs.fmtFormat([args19[0], " ", args19[1], " "]).v); const fs: rs.Vec<(a0: rs.u8) => rs.u8> = rs.vecFrom([adder(a), halve, mul, ptr]); const captured = a; const _94: (a0: rs.u8) => rs.u8 = (x3: rs.u8): rs.u8 => { @@ -685,7 +685,7 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const y: rs.u8 = _115[1](option_unwrapOr$1fr498u(rs.byteSliceGet(rs.byteSliceRange(data, 2), i), b)); const _133: rs.u32 = hook.f(y); const args20 = [(f: rs.Formatter) => rs.u8Display(y, f), (f: rs.Formatter) => rs.u32Display(_133, f)]; - put(out, rs.fmtFormat([args20[0], ":", args20[1], " "])); + put(out, rs.fmtFormat([args20[0], ":", args20[1], " "]).v); } const _142: (a0: rs.u8) => rs.u32 = (x5: rs.u8): rs.u32 => { return x5 as rs.u32; @@ -693,16 +693,16 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { rs.drop(hook.f); hook.f = _142; const part4 = hook.f(a); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part4, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part4, f), " "]).v); const captured3 = rs.byteVecFrom(Uint8Array.of(a)); const part6 = ((x6: rs.u8): rs.ByteVec => { const list2: rs.ByteVec = captured3; rs.byteVecPush(list2, x6); return list2; })(b); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part6), f, rs.u8Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part6), f, rs.u8Debug), " "]).v); const part7 = rs.once(rs.optionUnwrap(rs.vecPop(fs)))(a); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(part7, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(part7, f), " "]).v); const captured4 = b; const _196: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x7: rs.u8): rs.u8 => { return x7 ^ captured4; @@ -713,7 +713,7 @@ export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { const _213: rs.u8 = other.value(b); const _218: rs.usize = other.strong; const args24 = [(f: rs.Formatter) => rs.u8Display(_208, f), (f: rs.Formatter) => rs.u8Display(_213, f), (f: rs.Formatter) => rs.usizeDisplay(_218, f)]; - put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2]])); + put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", args24[2]]).v); other[Symbol.dispose](); shared[Symbol.dispose](); hook[Symbol.dispose](); @@ -732,7 +732,7 @@ export function dropped(out: rs.ByteVec): void { const part = rs.localKeyWithBorrowMut(DROPS, (d: rs.ByteVec): rs.ByteVec => { return rs.replaceIn(d, new rs.ByteVec()); }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug), " "]).v); } /** Each of the vtable's methods, then std's adaptors over the borrow, then by value. */ @@ -745,7 +745,7 @@ export function read(it: rs.Iter, out: rs.ByteVec): void { return a0 as rs.u32; }), rs.u32Add, 0); const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0], f), (f: rs.Formatter) => rs.fmtOption(hint[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Display(rest, f)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " "])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " "]).v); } /** @@ -768,7 +768,7 @@ export function scan$dyns_iters_closure1(map: rs.BTreeMap, from: } /** The length on either side of an item, and an upcast that reads the rest. */ -export function lens(it: rs.Iter): string { +export function lens(it: rs.Iter): rs.String { const before: rs.usize = rs.iterBorrow(it).len(); const first: rs.u8 | undefined = rs.iterToOption(it.next()); const after: rs.usize = rs.iterBorrow(it).len(); @@ -806,9 +806,9 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return thenSome$0quywni(rs.u8Rem(v2, 2) === 1, v2); }); const args43 = [(f: rs.Formatter) => rs.fmtOption(_44, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args43[0], " ", args43[1], " "])); + put(out, rs.fmtFormat([args43[0], " ", args43[1], " "]).v); const part = lens(rs.iterDyn(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2)))))); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part.v), " "]).v); const _79: rs.usize = rs.usizeRem(a as rs.usize, rs.usizeAdd(rs.byteSliceRange(data, 2).length, 1)); const slice: rs.ByteSlice = rs.byteSliceRange(data, 2); if (_79 > slice.length) { @@ -833,7 +833,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args45 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(ends[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtOption(nth, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args45[0], " ", args45[1], " "])); + put(out, rs.fmtFormat([args45[0], " ", args45[1], " "]).v); rs.drop(boxed); dropped(out); const last: rs.u8 | undefined = option_map$11l9b8r(rs.ownedLast(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(front), rs.drop), rs.vecIntoIter(tagged(back), rs.drop)))), rs.drop), (t4: Tagged.Tagged): rs.u8 => { @@ -842,9 +842,9 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return _07; }); dropped(out); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug), " "]).v); const part2 = rs.ownedCount(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(back), rs.drop), rs.vecIntoIter(tagged(front), rs.drop)))), rs.drop); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part2, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part2, f), " "]).v); dropped(out); const own: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 16)), Countdown.next$iter_Iterator, rs.drop)); let sum: rs.u32 = 0; @@ -857,7 +857,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { sum = rs.u32WrappingAdd(sum, _166 as rs.u32); } rs.drop(iter); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(sum, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(sum, f), " "]).v); dropped(out); const nested: rs.Iter = rs.iterDyn(rs.iterBox(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop))); const inner: Countdown.Countdown = new Countdown.Countdown(rs.u8Rem(b, 8)); @@ -874,7 +874,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _235: rs.usize = rs.ownedCount(rs.iterBox(erased)); const _238: rs.usize = rs.ownedCount(rs.iterBox(rs.iterFrom(doubled, Countdown.next$iter_Iterator, rs.drop))); const args49 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_233), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(fourth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(mapped), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_235, f), (f: rs.Formatter) => rs.usizeDisplay(_238, f)]; - put(out, rs.fmtFormat([args49[0], " ", args49[1], " ", args49[2], " ", args49[3], " ", args49[4], " ", args49[5], " ", args49[6], " ", args49[7], " "])); + put(out, rs.fmtFormat([args49[0], " ", args49[1], " ", args49[2], " ", args49[3], " ", args49[4], " ", args49[5], " ", args49[6], " ", args49[7], " "]).v); dropped(out); inner[Symbol.dispose](); dropped(out); @@ -893,7 +893,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { [_301, rs.sliceFrom(hints), fifth, sixth] as [rs.usize, rs.Slice<[rs.usize, rs.usize | undefined]>, rs.u8 | undefined, rs.u8 | undefined]; const arg = rs.sliceFrom(hints); const args50 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), (f: rs.Formatter) => rs.fmtOption(fifth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(sixth, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_301, f)]; - put(out, rs.fmtFormat([args50[0], " ", args50[1], " ", args50[2], " ", args50[3], " "])); + put(out, rs.fmtFormat([args50[0], " ", args50[1], " ", args50[2], " ", args50[3], " "]).v); dropped(out); own2[Symbol.dispose](); dropped(out); @@ -910,25 +910,25 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const lent3: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterBorrow(rs.iterBox(rs.iterBorrow(zipped()))), "next", 2); const _339: rs.RefCell = rs.refCellBorrow(seen2); const args51 = [(f: rs.Formatter) => rs.fmtList(owned.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(lent3.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_339.value), f, rs.u8Debug)]; - const _335: string = rs.fmtFormat([args51[0], " ", args51[1], " ", args51[2], " "]); + const _335: rs.String = rs.fmtFormat([args51[0], " ", args51[1], " ", args51[2], " "]); rs.refRelease(_339); - put(out, _335); + put(out, _335.v); const split: Chunks.Chunks = new of$dyns_Lease({ _0: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)), _1: rs.usizeAdd(rs.u8Rem(b, 4) as rs.usize, 1) }); const lens_: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterBox(split.chunks$Chunks()), (a0: rs.ByteSlice): rs.usize => { return a0.length; }), "next", 4); const _369: rs.usize = rs.ownedCount(rs.iterBox(split.chunks$Chunks())); const args52 = [(f: rs.Formatter) => rs.fmtList(lens_.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_369, f)]; - put(out, rs.fmtFormat([args52[0], " ", args52[1], " "])); + put(out, rs.fmtFormat([args52[0], " ", args52[1], " "]).v); const part3 = drain(rs.iterDyn(rs.iterBorrow(rs.iterFuse(rs.iterFrom({ _0: rs.u8Rem(a, 4) }, Resuming.next$iter_Iterator))))); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part3), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part3.v), " "]).v); const resuming: Resuming.Resuming = { _0: rs.u8Rem(b, 4) }; const up: rs.Iter = rs.iterDyn(rs.iterFrom(resuming, Resuming.next$iter_Iterator)); const part4 = [rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next())] as [rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined]; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[2], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[3], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[4], f, rs.u8Debug)], f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[2], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[3], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[4], f, rs.u8Debug)], f), " "]).v); const boxed3: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop)); const part5 = drain(boxed3); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part5), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part5.v), " "]).v); rs.drop(boxed3); dropped(out); const concrete: rs.Arc> = new rs.Arc(rs.vecIntoIter(tagged(front), rs.drop)); @@ -938,7 +938,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _456: [rs.usize, rs.usize | undefined] = other.value.sizeHint(); const _460: boolean = rs.arcGetMut(shared) === undefined; const args56 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_456[0], f), (f: rs.Formatter) => rs.fmtOption(_456[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_460, f)]; - put(out, rs.fmtFormat([args56[0], " ", args56[1], " "])); + put(out, rs.fmtFormat([args56[0], " ", args56[1], " "]).v); other[Symbol.dispose](); weak[Symbol.dispose](); const taken: rs.u8 | undefined = option_map$11l9b8r(option_andThen$1xlvufy(rs.arcGetMut(shared), (it2: rs.Iter): Tagged.Tagged | undefined => { @@ -949,7 +949,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return _014; }); dropped(out); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(taken, f, rs.u8Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(taken, f, rs.u8Debug), " "]).v); shared[Symbol.dispose](); dropped(out); const _492: rs.Arc> = new rs.Arc(rs.byteVecIntoIter(rs.byteSliceToByteVec(back))); @@ -960,19 +960,19 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.iterToOption(it3.next()); }); const args58 = [(f: rs.Formatter) => rs.usizeDisplay(_506, f), (f: rs.Formatter) => rs.fmtOption(_510, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; - put(out, rs.fmtFormat([args58[0], " ", args58[1], " "])); + put(out, rs.fmtFormat([args58[0], " ", args58[1], " "]).v); exact[Symbol.dispose](); const next: rs.u8 | undefined = option_andThen$0imujmv(rs.arcGetMut(up2), (it4: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it4.next()); }); const _530: [rs.usize, rs.usize | undefined] = up2.value.sizeHint(); const args59 = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_530[0], f), (f: rs.Formatter) => rs.fmtOption(_530[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args59[0], " ", args59[1], " "])); + put(out, rs.fmtFormat([args59[0], " ", args59[1], " "]).v); const fromBox: rs.Arc> = new rs.Arc(rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop))); const part6 = option_andThen$0imujmv(rs.arcGetMut(fromBox), (it5: rs.Iter): rs.u8 | undefined => { return rs.iterToOption(it5.next()); }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u8Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u8Debug), " "]).v); fromBox[Symbol.dispose](); dropped(out); const counted2: rs.Arc = new rs.Arc(new Countdown.Countdown(rs.u8Rem(a, 8))); @@ -984,17 +984,17 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { it6[Symbol.dispose](); return _018; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), " "]).v); counted2[Symbol.dispose](); const _596: rs.Arc> | undefined = rs.weakUpgrade(weak3); const part8 = _596 === undefined; - const _590: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part8, f), " "]); + const _590: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part8, f), " "]); rs.drop(_596); - put(out, _590); + put(out, _590.v); dropped(out); const pinned: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop)); const part9 = rs.iterToOption(pinned.next()); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u8Debug)]).v); rs.drop(pinned); dropped(out); weak3[Symbol.dispose](); @@ -1003,7 +1003,7 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { } /** What `it` yields up to its end and twice past it. */ -export function drain(it: rs.Iter): string { +export function drain(it: rs.Iter): rs.String { const items: rs.ByteVec = rs.iterToByteVec(rs.iterBorrow(it), "next"); const _7: rs.u8 | undefined = rs.iterToOption(it.next()); const _9: rs.u8 | undefined = rs.iterToOption(it.next()); @@ -1029,14 +1029,14 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const named: rs.Arc = new rs.ArcDyn(_19, new of$dyns_Square(_19.value)); const shape: rs.Arc = rs.arcClone(named); const other: rs.Weak = new rs.Weak(shape); - const _34: string = named.value.label$Named(); + const _34: rs.String = named.value.label$Named(); const _38: rs.u32 = shape.value.area$Shape(); const _42: rs.usize = sq.strong; const _45: rs.usize = weak2.arc.strong; const _48: rs.usize = rs.weakWeakCount(weak2); const _51: boolean = rs.arcPtrEq(weak2.arc, other.arc); - const args39 = [(f: rs.Formatter) => rs.fmtPad(f, _34), (f: rs.Formatter) => rs.u32Display(_38, f), (f: rs.Formatter) => rs.usizeDisplay(_42, f), (f: rs.Formatter) => rs.usizeDisplay(_45, f), (f: rs.Formatter) => rs.usizeDisplay(_48, f), (f: rs.Formatter) => rs.fmtBool(_51, f)]; - put(out, rs.fmtFormat([args39[0], " ", args39[1], " ", args39[2], " ", args39[3], " ", args39[4], " ", args39[5], " "])); + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, _34.v), (f: rs.Formatter) => rs.u32Display(_38, f), (f: rs.Formatter) => rs.usizeDisplay(_42, f), (f: rs.Formatter) => rs.usizeDisplay(_45, f), (f: rs.Formatter) => rs.usizeDisplay(_48, f), (f: rs.Formatter) => rs.fmtBool(_51, f)]; + put(out, rs.fmtFormat([args39[0], " ", args39[1], " ", args39[2], " ", args39[3], " ", args39[4], " ", args39[5], " "]).v); const again: rs.Weak = rs.weakClone(weak2); sq[Symbol.dispose](); named[Symbol.dispose](); @@ -1047,7 +1047,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe }); const _79: rs.usize = shape.strong; const args40 = [(f: rs.Formatter) => rs.fmtOption(_75, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); + put(out, rs.fmtFormat([args40[0], " ", args40[1], " "]).v); shape[Symbol.dispose](); const _97: rs.Arc | undefined = rs.weakUpgrade(weak2); const _95: boolean = _97 === undefined; @@ -1055,10 +1055,10 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _100: boolean = _102 === undefined; const _105: rs.usize = weak2.arc.strong; const args41 = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtBool(_100, f), (f: rs.Formatter) => rs.usizeDisplay(_105, f)]; - const _91: string = rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " "]); + const _91: rs.String = rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " "]); rs.drop(_102); rs.drop(_97); - put(out, _91); + put(out, _91.v); const noisy: rs.Arc = new rs.Arc(new Noisy.Noisy(dataData[dataStart + 1], rs.arcClone(log))); const weak4: rs.Weak = rs.weakDyn(new rs.Weak(noisy), (arc2: rs.Arc): rs.Arc => { return new rs.ArcDyn(arc2, new of$dyns_Noisy(arc2.value)); @@ -1068,16 +1068,16 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe s2[Symbol.dispose](); return _02; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug), " "]).v); noisy[Symbol.dispose](); const _147: rs.Arc | undefined = rs.weakUpgrade(weak4); const _145: boolean = _147 === undefined; const _150: rs.RefCell = rs.refCellBorrow(log.value); const args43 = [(f: rs.Formatter) => rs.fmtBool(_145, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_150.value), f, rs.u8Debug)]; - const _141: string = rs.fmtFormat([args43[0], " ", args43[1], " "]); + const _141: rs.String = rs.fmtFormat([args43[0], " ", args43[1], " "]); rs.refRelease(_150); rs.drop(_147); - put(out, _141); + put(out, _141.v); const looped: rs.Arc = rs.arcNewCyclic((me: rs.Weak): Looped.Looped => { return new Looped.Looped(dataData[dataStart], rs.weakDyn(rs.weakClone(me), (arc3: rs.Arc): rs.Arc => { return new rs.ArcDyn(arc3, new of$dyns_Looped(arc3.value)); @@ -1091,7 +1091,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _174: rs.usize = looped.strong; const _177: rs.usize = looped.weak; const args44 = [(f: rs.Formatter) => rs.fmtOption(_168, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_174, f), (f: rs.Formatter) => rs.usizeDisplay(_177, f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "])); + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "]).v); const pinned: Shape.Shape = new of$dyns_Noisy(new Noisy.Noisy(rs.u8WrappingAdd(dataData[dataStart], 1), rs.arcClone(log))); let n: rs.u32 = dataData[dataStart + 1] as rs.u32; const borrowed2: Shape.Shape = new ofPlace$u32(rs.place(() => n, (value) => n = value)); @@ -1099,12 +1099,12 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _209: rs.u8 = pinned.sides$Shape(); const _213: rs.u32 = borrowed2.area$Shape(); const args45 = [(f: rs.Formatter) => rs.u32Display(_205, f), (f: rs.Formatter) => rs.u8Display(_209, f), (f: rs.Formatter) => rs.u32Display(_213, f)]; - put(out, rs.fmtFormat([args45[0], " ", args45[1], " ", args45[2], " "])); + put(out, rs.fmtFormat([args45[0], " ", args45[1], " ", args45[2], " "]).v); rs.drop(pinned); const _230: rs.RefCell = rs.refCellBorrow(log.value); - const _226: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_230.value), f, rs.u8Debug), " "]); + const _226: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_230.value), f, rs.u8Debug), " "]); rs.refRelease(_230); - put(out, _226); + put(out, _226.v); const boxes: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): Shape.Shape => { const x2: rs.u8 = _2; const _43: rs.u8 = rs.u8Rem(x2, 3); @@ -1143,25 +1143,25 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe }), rs.iterMap(rs.iterSlice(arcs.items), (s5: rs.Arc): rs.u32 => { return s5.value.area$Shape(); })), undefined, 4, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug), " "]).v); const _291: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_291.value); rs.refMutRelease(_291); rs.dropVec(arcs); const _304: rs.RefCell = rs.refCellBorrow(log.value); - const _300: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_304.value), f, rs.u8Debug), " "]); + const _300: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_304.value), f, rs.u8Debug), " "]); rs.refRelease(_304); - put(out, _300); + put(out, _300.v); rs.dropVec(rcs); const _321: rs.RefCell = rs.refCellBorrow(log.value); - const _317: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_321.value), f, rs.u8Debug), " "]); + const _317: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_321.value), f, rs.u8Debug), " "]); rs.refRelease(_321); - put(out, _317); + put(out, _317.v); rs.dropVec(kept); const _337: rs.RefCell = rs.refCellBorrow(log.value); - const _333: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_337.value), f, rs.u8Debug), " "]); + const _333: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_337.value), f, rs.u8Debug), " "]); rs.refRelease(_337); - put(out, _333); + put(out, _333.v); const _345: rs.Arc = new rs.Arc({ side: dataData[dataStart + 1] as rs.u16 }); const any: rs.Arc = new rs.ArcDyn(_345, new of$dyns_Square(_345.value)); const _351: rs.Result, rs.Arc> = rs.arcDowncast(rs.arcClone(any), of$dyns_Tri, (object) => object.v); @@ -1175,7 +1175,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _372: rs.Fmt = (f: rs.Formatter) => rs.fmtBool(wrong, f); const arg = _365.side; const args51 = [_372, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; - put(out, rs.fmtFormat([args51[0], " ", args51[1], " ", args51[2], " "])); + put(out, rs.fmtFormat([args51[0], " ", args51[1], " ", args51[2], " "]).v); sq2[Symbol.dispose](); } else { put(out, "none "); @@ -1203,7 +1203,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _424: boolean = rs.arcPtrEq(ex, held); const _428: rs.usize = x.strong; const args52 = [(f: rs.Formatter) => rs.fmtBool(_416, f), (f: rs.Formatter) => rs.fmtBool(_420, f), (f: rs.Formatter) => rs.fmtBool(_424, f), (f: rs.Formatter) => rs.usizeDisplay(_428, f)]; - put(out, rs.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " "])); + put(out, rs.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " "]).v); ey[Symbol.dispose](); ex[Symbol.dispose](); y[Symbol.dispose](); @@ -1232,15 +1232,15 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _458: rs.usize = n2.strong; const arg2 = _455._0; const args53 = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_458, f)]; - put(out, rs.fmtFormat([args53[0], " ", args53[1], " "])); + put(out, rs.fmtFormat([args53[0], " ", args53[1], " "]).v); _595 = false; held[Symbol.dispose](); const _475: rs.usize = n2.strong; const _478: rs.RefCell = rs.refCellBorrow(log.value); const args54 = [(f: rs.Formatter) => rs.usizeDisplay(_475, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_478.value), f, rs.u8Debug)]; - const _471: string = rs.fmtFormat([args54[0], " ", args54[1], " "]); + const _471: rs.String = rs.fmtFormat([args54[0], " ", args54[1], " "]); rs.refRelease(_478); - put(out, _471); + put(out, _471.v); n2[Symbol.dispose](); } else { put(out, "none "); @@ -1249,15 +1249,15 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_444); } const _495: rs.RefCell = rs.refCellBorrow(log.value); - const _491: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_495.value), f, rs.u8Debug), " "]); + const _491: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_495.value), f, rs.u8Debug), " "]); rs.refRelease(_495); - put(out, _491); + put(out, _491.v); const part3 = option_map$1bn5ufk(ok$1oks8md(rs.arcDowncast(new rs.Arc(new of$u32(dataData[dataStart] as rs.u32)), of$u32, (object) => object.v)), (n3: rs.Arc): rs.u32 => { const _09: rs.u32 = n3.value; n3[Symbol.dispose](); return _09; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug), " "]).v); const _523: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x3: rs.u8): rs.u8 => { return rs.u8WrappingAdd(x3, dataData[dataStart]); }); @@ -1268,7 +1268,7 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe const _537: rs.u8 = f.value(dataData[dataStart + 1]); const _543: rs.u8 = g.value(dataData[dataStart]); const args57 = [(f: rs.Formatter) => rs.u8Display(_537, f), (f: rs.Formatter) => rs.u8Display(_543, f)]; - put(out, rs.fmtFormat([args57[0], " ", args57[1]])); + put(out, rs.fmtFormat([args57[0], " ", args57[1]]).v); g[Symbol.dispose](); f[Symbol.dispose](); if (_595) { @@ -1339,16 +1339,16 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const nths: [[rs.u8, rs.u8] | undefined, [rs.u8, rs.u8] | undefined] = [tags(rs.iterNth(rs.iterBox(boxed), 1, drop$tuple2_dyns_Tagged_dyns_Tagged)), tags(rs.iterNthBack(rs.iterBox(boxed), 0, drop$tuple2_dyns_Tagged_dyns_Tagged))]; dropped(out); const args43 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0][0], f), (f: rs.Formatter) => rs.fmtOption(hint[0][1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.usizeDebug(hint[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(ends[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(nths[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(nths[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f)]; - put(out, rs.fmtFormat([args43[0], " ", args43[1], " ", args43[2], " "])); + put(out, rs.fmtFormat([args43[0], " ", args43[1], " ", args43[2], " "]).v); dropped(out); const part = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]).v); dropped(out); const part2 = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]).v); dropped(out); const part3 = rs.ownedCount(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part3, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part3, f), " "]).v); dropped(out); const sum: rs.u32 = rs.iterFold(rs.iterBox(it()), 0, (n3: rs.u32, _3: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x: Tagged.Tagged = _3[0]; @@ -1359,7 +1359,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _02; }); dropped(out); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(sum, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(sum, f), " "]).v); rs.iterForEach(rs.iterBox(it()), (_24: [Tagged.Tagged, Tagged.Tagged]): undefined => { const x2: Tagged.Tagged = _24[0]; const y2: Tagged.Tagged = _24[1]; @@ -1367,7 +1367,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const _142: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg, f); const arg2 = y2._0; const args50 = [_142, (f: rs.Formatter) => rs.u8Display(arg2, f)]; - put(out, rs.fmtFormat([args50[0], " ", args50[1], " "])); + put(out, rs.fmtFormat([args50[0], " ", args50[1], " "]).v); y2[Symbol.dispose](); x2[Symbol.dispose](); }); @@ -1380,7 +1380,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _03; }); dropped(out); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(found, f, rs.usizeDebug), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(found, f, rs.usizeDebug), " "]).v); const found2: [rs.u8, rs.u8] | undefined = tags(rs.iterFind(rs.iterBox(it()), (_26: [Tagged.Tagged, Tagged.Tagged]): boolean => { return rs.u8Rem(_26[1]._0, 3) === 0; }, drop$tuple2_dyns_Tagged_dyns_Tagged)); @@ -1393,12 +1393,12 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _05; }); const args52 = [(f: rs.Formatter) => rs.fmtOption(found2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_148, f)]; - put(out, rs.fmtFormat([args52[0], " ", args52[1], " "])); + put(out, rs.fmtFormat([args52[0], " ", args52[1], " "]).v); dropped(out); const part4 = tags(rs.iterMaxByKey(rs.iterBox(it()), (p: [Tagged.Tagged, Tagged.Tagged]): rs.u8 => { return p[1]._0; }, rs.lt, undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]).v); dropped(out); const all: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterMap(rs.vecIntoIter(rs.iterToVec(rs.iterBox(it()), "next", 2), drop$tuple2_dyns_Tagged_dyns_Tagged), (p2: [Tagged.Tagged, Tagged.Tagged]): [rs.u8, rs.u8] => { const _07: [rs.u8, rs.u8] = [p2[0]._0, p2[1]._0]; @@ -1406,7 +1406,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _07; }), "next", 2, true, 2); dropped(out); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]).v); const back: rs.u32 = rs.iterFold(rs.iterRev(rs.iterBox(it())), 0, (n4: rs.u32, _33: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x5: Tagged.Tagged = _33[0]; const y3: Tagged.Tagged = _33[1]; @@ -1425,22 +1425,22 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { return _09; }), rs.u32Add, 0); const args55 = [(f: rs.Formatter) => rs.u32Display(back, f), (f: rs.Formatter) => rs.u32Display(_208, f)]; - put(out, rs.fmtFormat([args55[0], " ", args55[1], " "])); + put(out, rs.fmtFormat([args55[0], " ", args55[1], " "]).v); dropped(out); const _227: rs.usize = rs.ownedCount(rs.iterSkip(rs.iterBox(it()), 1, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); const _232: rs.usize = rs.ownedCount(rs.iterStepBy(rs.iterBox(it()), 2, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); const args56 = [(f: rs.Formatter) => rs.usizeDisplay(_227, f), (f: rs.Formatter) => rs.usizeDisplay(_232, f)]; - put(out, rs.fmtFormat([args56[0], " ", args56[1], " "])); + put(out, rs.fmtFormat([args56[0], " ", args56[1], " "]).v); dropped(out); const _253: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(it()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part5 = tags(rs.iterNth(_253, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const _246: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part5, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); + const _246: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part5, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); rs.drop(_253); - put(out, _246); + put(out, _246.v); dropped(out); const last: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it()))), drop$tuple2_dyns_Tagged_dyns_Tagged)); dropped(out); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]).v); const boxed3: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); const _285: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const nth: [rs.u8, rs.u8] | undefined = tags(rs.iterNth(_285, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); @@ -1449,7 +1449,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.usize = rs.ownedCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), drop$tuple2_dyns_Tagged_dyns_Tagged); dropped(out); const args59 = [(f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(n, f)]; - put(out, rs.fmtFormat([args59[0], " ", args59[1], " "])); + put(out, rs.fmtFormat([args59[0], " ", args59[1], " "]).v); const boxed4: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); const first: [rs.u8, rs.u8] | undefined = tags(rs.iterToOption(boxed4.next())); const sum2: rs.u32 = rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed4))), 0, (n5: rs.u32, _34: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { @@ -1462,7 +1462,7 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { }); dropped(out); const args60 = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(sum2, f)]; - put(out, rs.fmtFormat([args60[0], " ", args60[1], " "])); + put(out, rs.fmtFormat([args60[0], " ", args60[1], " "]).v); dropped(out); const n2: rs.u8 = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 0, (n6: rs.u8): rs.u8 => { return rs.u8Rem(n6, 4); @@ -1480,35 +1480,35 @@ export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { const _351: [rs.u8, rs.u8] | undefined = rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(logged())))); const _354: rs.RefCell = rs.refCellBorrow(seen); const args61 = [(f: rs.Formatter) => rs.fmtOption(last2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(_351, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; - const _347: string = rs.fmtFormat([args61[0], " ", args61[1], " ", args61[2], " "]); + const _347: rs.String = rs.fmtFormat([args61[0], " ", args61[1], " ", args61[2], " "]); rs.refRelease(_354); - put(out, _347); + put(out, _347.v); const part6 = tags(rs.ownedLast(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part6, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]).v); dropped(out); const part7 = rs.ownedCount(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part7, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(part7, f), " "]).v); dropped(out); const erased: () => rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = (): rs.Iter<[Tagged.Tagged, Tagged.Tagged]> => { return rs.iterDyn(skipped(data)); }; const _410: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(erased()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part8 = tags(rs.iterNth(_410, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const _403: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); + const _403: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); rs.drop(_410); - put(out, _403); + put(out, _403.v); dropped(out); const _427: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged)); const _432: rs.usize = rs.ownedCount(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged); const args65 = [(f: rs.Formatter) => rs.fmtOption(_427, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(_432, f)]; - put(out, rs.fmtFormat([args65[0], " ", args65[1], " "])); + put(out, rs.fmtFormat([args65[0], " ", args65[1], " "]).v); dropped(out); const boxed6: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = erased(); const _455: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(boxed6), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); const part9 = tags(rs.iterNth(_455, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const _448: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); + const _448: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(part9, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), " "]); rs.drop(_455); - put(out, _448); + put(out, _448.v); dropped(out); rs.drop(boxed6); dropped(out); @@ -1566,11 +1566,11 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _93: rs.Fmt = (f: rs.Formatter) => rs.fmtList(areas.items, f, rs.u32Debug); const arg = _78.side; const args61 = [_93, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.u32Display(_84.value, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_88.value, f)]; - const _74: string = rs.fmtFormat([args61[0], " ", args61[1], " ", args61[2], " ", args61[3], " "]); + const _74: rs.String = rs.fmtFormat([args61[0], " ", args61[1], " ", args61[2], " ", args61[3], " "]); rs.refRelease(_88); rs.refRelease(_84); rs.refRelease(_80); - put(out, _74); + put(out, _74.v); const held: rs.RefCell = rs.refCellBorrowMut(n.value); const shared: rs.RefCell = rs.refCellBorrow(shapes.items[rs.idx(shapes.items, 0)].value); const _116: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(shapes.items[rs.idx(shapes.items, 1)].value); @@ -1583,10 +1583,10 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { return _02; }), 0); const args62 = [(f: rs.Formatter) => rs.fmtBool(_114, f), (f: rs.Formatter) => rs.fmtBool(_121, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - const _110: string = rs.fmtFormat([args62[0], " ", args62[1], " ", args62[2], " "]); + const _110: rs.String = rs.fmtFormat([args62[0], " ", args62[1], " ", args62[2], " "]); drop$Result_cell_RefMut_dyns_Square_cell_BorrowMutError(_123); drop$Result_cell_Ref_dyn_dyns_Shape_cell_BorrowError(_116); - put(out, _110); + put(out, _110.v); rs.refMutRelease(held); rs.refRelease(shared); const r: rs.RefCell = rs.refCellBorrow(shapes.items[rs.idx(shapes.items, 2)].value); @@ -1594,14 +1594,14 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _153: boolean = !_155.ok; const _159: rs.u8 = r.value.sides$Shape(); const args63 = [(f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.u8Display(_159, f)]; - const _149: string = rs.fmtFormat([args63[0], " ", args63[1], " "]); + const _149: rs.String = rs.fmtFormat([args63[0], " ", args63[1], " "]); drop$Result_cell_RefMut_dyns_Tri_cell_BorrowMutError(_155); - put(out, _149); + put(out, _149.v); rs.refRelease(r); const _175: rs.usize = sq.strong; const _178: rs.usize = shapes.items[rs.idx(shapes.items, 1)].strong; const args64 = [(f: rs.Formatter) => rs.usizeDisplay(_175, f), (f: rs.Formatter) => rs.usizeDisplay(_178, f)]; - put(out, rs.fmtFormat([args64[0], " ", args64[1], " "])); + put(out, rs.fmtFormat([args64[0], " ", args64[1], " "]).v); const _187: rs.Arc> = new rs.Arc(new rs.RefCell({ tag: "Flat" } as Tri.Tri)); const named: rs.Arc> = new rs.ArcDyn(_187, rs.tailDyn(_187.value, { value: (value5: rs.RefCell) => new ofPlace$dyns_Tri(rs.valuePlace(value5)) })); const _193: rs.RefCell = rs.refCellBorrowMut(named.value); @@ -1613,16 +1613,16 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { _202.value.grow$Shape(a); rs.refMutRelease(_202); const _217: rs.RefCell = rs.refCellBorrow(named.value); - const _214: string = _217.value.label$Named(); + const _214: rs.String = _217.value.label$Named(); const _224: rs.RefCell = rs.refCellBorrow(upcast.value); const _221: rs.u32 = _224.value.area$Shape(); - const args65 = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), (f: rs.Formatter) => rs.fmtPad(f, _214), (f: rs.Formatter) => rs.u32Display(_221, f)]; - const _209: string = rs.fmtFormat([args65[0], " ", args65[1], " ", args65[2], " "]); + const args65 = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), (f: rs.Formatter) => rs.fmtPad(f, _214.v), (f: rs.Formatter) => rs.u32Display(_221, f)]; + const _209: rs.String = rs.fmtFormat([args65[0], " ", args65[1], " ", args65[2], " "]); rs.refRelease(_224); rs.refRelease(_217); - put(out, _209); + put(out, _209.v); const _held: rs.RefCell = rs.refCellBorrowMut(named.value); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), " "]).v); rs.refMutRelease(_held); const noisy: rs.Arc> = new rs.Arc(new rs.RefCell(new Noisy.Noisy(c, rs.arcClone(log)))); const _254: rs.Arc> = rs.arcClone(noisy); @@ -1638,23 +1638,23 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { return _03; }); const args67 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_268.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_272, f, rs.u32Debug)]; - const _264: string = rs.fmtFormat([args67[0], " ", args67[1], " "]); + const _264: rs.String = rs.fmtFormat([args67[0], " ", args67[1], " "]); rs.refRelease(_268); - put(out, _264); + put(out, _264.v); shape[Symbol.dispose](); const _289: rs.RefCell = rs.refCellBorrow(log.value); const _295: rs.Arc> | undefined = rs.weakUpgrade(weak); const _293: boolean = _295 === undefined; const args68 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_289.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_293, f)]; - const _285: string = rs.fmtFormat([args68[0], " ", args68[1], " "]); + const _285: rs.String = rs.fmtFormat([args68[0], " ", args68[1], " "]); rs.drop(_295); rs.refRelease(_289); - put(out, _285); + put(out, _285.v); rs.dropVec(shapes); const _311: rs.RefCell = rs.refCellBorrow(log.value); - const _307: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug), " "]); + const _307: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug), " "]); rs.refRelease(_311); - put(out, _307); + put(out, _307.v); const _321: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_321.value); rs.refMutRelease(_321); @@ -1667,9 +1667,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _guard: rs.Mutex = rs.mutexLock(m.value); const _351: rs.Result, rs.TryLockError>> = rs.mutexTryLock(locked.value); const part = !_351.ok; - const _345: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part, f), " "]); + const _345: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(part, f), " "]); drop$Result_sync_MutexGuard_dyn_dyns_Shape_sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_351); - put(out, _345); + put(out, _345.v); rs.mutexUnlock(_guard); const weak2: rs.Weak> = new rs.Weak(locked); const area: rs.u32 | undefined = option_map$13cu53u(rs.weakUpgrade(weak2), (l: rs.Arc>): rs.u32 => { @@ -1682,9 +1682,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _372: rs.Mutex = rs.mutexLock(m.value); const _377: rs.usize = m.strong; const args71 = [(f: rs.Formatter) => Tri.fmt$fmt_Debug(_372.value, f), (f: rs.Formatter) => rs.fmtOption(area, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_377, f)]; - const _368: string = rs.fmtFormat([args71[0], " ", args71[1], " ", args71[2], " "]); + const _368: rs.String = rs.fmtFormat([args71[0], " ", args71[1], " ", args71[2], " "]); rs.mutexUnlock(_372); - put(out, _368); + put(out, _368.v); const rw: rs.Arc> = new rs.Arc(new rs.RefCell(c as rs.u32)); const _390: rs.Arc> = rs.arcClone(rw); const lock: rs.Arc> = new rs.ArcDyn(_390, rs.tailDyn(_390.value, { value: (value9: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value9)) })); @@ -1697,15 +1697,15 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _420: rs.RefCell = rs.rwLockRead(lock.value); const _417: rs.u32 = _420.value.area$Shape(); const args72 = [(f: rs.Formatter) => rs.fmtBool(_411, f), (f: rs.Formatter) => rs.u32Display(_417, f)]; - const _407: string = rs.fmtFormat([args72[0], " ", args72[1], " "]); + const _407: rs.String = rs.fmtFormat([args72[0], " ", args72[1], " "]); rs.refRelease(_420); drop$Result_sync_RwLockWriteGuard_dyn_dyns_Shape_sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_413); - put(out, _407); + put(out, _407.v); rs.refRelease(_read); const _437: rs.RefCell = rs.rwLockRead(rw.value); - const _433: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_437.value, f), " "]); + const _433: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_437.value, f), " "]); rs.refRelease(_437); - put(out, _433); + put(out, _433.v); const t: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rs.arcClone(log)), c as rs.u32); const area2: rs.u32 = bumpTail(rs.tailDyn(t, { value: (value10: Tail.Tail) => new ofPlace$u32(rs.place(() => value10.value, (value11) => value10.value = value11)) }), b); const shared2: Tail.Tail = rs.tailDyn(t, { value: (value12: Tail.Tail) => new ofPlace$u32(rs.place(() => value12.value, (value13) => value12.value = value13)) }); @@ -1718,7 +1718,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _473: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_465, f); const arg4 = t.value; const args74 = [_470, _471, _472, _473, (f: rs.Formatter) => rs.u32Display(arg4, f)]; - put(out, rs.fmtFormat([args74[0], " ", args74[1], " ", args74[2], " ", args74[3], " ", args74[4], " "])); + put(out, rs.fmtFormat([args74[0], " ", args74[1], " ", args74[2], " ", args74[3], " ", args74[4], " "]).v); const cell: rs.Arc>> = new rs.Arc(new rs.RefCell(new Tail.Tail(b, new Noisy.Noisy(a, rs.arcClone(log)), { side: b as rs.u16 }))); const _486: rs.Arc>> = rs.arcClone(cell); const nested: rs.Arc>> = new rs.ArcDyn(_486, rs.tailDyn(_486.value, { value: (value14: rs.RefCell>) => rs.tailDyn(value14.value, { value: (value15: Tail.Tail) => new of$dyns_Square(value15.value) }) }, rs.drop)); @@ -1734,25 +1734,25 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _516: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg5, f); const arg6 = _508.value.side; const args75 = [_515, _516, (f: rs.Formatter) => rs.u16Display(arg6, f)]; - const _498: string = rs.fmtFormat([args75[0], " ", args75[1], " ", args75[2], " "]); + const _498: rs.String = rs.fmtFormat([args75[0], " ", args75[1], " ", args75[2], " "]); rs.refRelease(_510); rs.refRelease(_504); - put(out, _498); + put(out, _498.v); cell[Symbol.dispose](); t[Symbol.dispose](); const _531: rs.RefCell = rs.refCellBorrow(log.value); - const _527: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_531.value), f, rs.u8Debug), " "]); + const _527: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_531.value), f, rs.u8Debug), " "]); rs.refRelease(_531); - put(out, _527); + put(out, _527.v); nested[Symbol.dispose](); const boxed: Tail.Tail = rs.tailDyn(new Tail.Tail(c, new Noisy.Noisy(c, rs.arcClone(log)), new Noisy.Noisy(rs.u8WrappingAdd(c, 1), rs.arcClone(log))), { value: (value17: Tail.Tail) => new of$dyns_Noisy(value17.value) }, rs.drop); const part2 = boxed.value.area$Shape(); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part2, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part2, f), " "]).v); boxed[Symbol.dispose](); const _572: rs.RefCell = rs.refCellBorrow(log.value); - const _568: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_572.value), f, rs.u8Debug), " "]); + const _568: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_572.value), f, rs.u8Debug), " "]); rs.refRelease(_572); - put(out, _568); + put(out, _568.v); const pinned: Tail.Tail = rs.tailDyn(new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), { tag: "Tall", _0: b } as Tri.Tri), { value: (value19: Tail.Tail) => new ofPlace$dyns_Tri(rs.place(() => value19.value, (value20) => value19.value = value20)) }, rs.drop); const own: rs.Arc> = new rs.Arc(new rs.RefCell(a as rs.u32)); const weak4: rs.Weak> = rs.weakDyn(new rs.Weak(own), (arc: rs.Arc>): rs.Arc> => { @@ -1772,14 +1772,14 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _622: rs.usize = weak4.arc.strong; const arg7 = _610.count; const args79 = [(f: rs.Formatter) => rs.u8Display(arg7, f), (f: rs.Formatter) => rs.u32Display(_613, f), (f: rs.Formatter) => rs.u32Display(_618.value, f), (f: rs.Formatter) => rs.usizeDisplay(_622, f)]; - const _606: string = rs.fmtFormat([args79[0], " ", args79[1], " ", args79[2], " ", args79[3], " "]); + const _606: rs.String = rs.fmtFormat([args79[0], " ", args79[1], " ", args79[2], " ", args79[3], " "]); rs.refRelease(_618); - put(out, _606); + put(out, _606.v); pinned[Symbol.dispose](); const _640: rs.RefCell = rs.refCellBorrow(log.value); - const _636: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_640.value), f, rs.u8Debug), " "]); + const _636: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_640.value), f, rs.u8Debug), " "]); rs.refRelease(_640); - put(out, _636); + put(out, _636.v); const shared3: rs.Arc> = new rs.Arc(rs.tailDyn(new rs.RefCell(new Noisy.Noisy(b, rs.arcClone(log))), { value: (value22: rs.RefCell) => new of$dyns_Noisy(value22.value) }, rs.drop)); const again: rs.Arc> = rs.arcClone(shared3); const _659: rs.RefCell = rs.refCellBorrowMut(again.value); @@ -1790,15 +1790,15 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _671: rs.u32 = _674.value.area$Shape(); const _678: rs.RefCell = rs.refCellBorrow(log.value); const args81 = [(f: rs.Formatter) => rs.u32Display(_671, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_678.value), f, rs.u8Debug)]; - const _667: string = rs.fmtFormat([args81[0], " ", args81[1], " "]); + const _667: rs.String = rs.fmtFormat([args81[0], " ", args81[1], " "]); rs.refRelease(_678); rs.refRelease(_674); - put(out, _667); + put(out, _667.v); again[Symbol.dispose](); const _695: rs.RefCell = rs.refCellBorrow(log.value); - const _691: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_695.value), f, rs.u8Debug), " "]); + const _691: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_695.value), f, rs.u8Debug), " "]); rs.refRelease(_695); - put(out, _691); + put(out, _691.v); const guarded: rs.Vec> = rs.vecFrom([rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(a, rs.arcClone(log)) } as Held.Held), { value: (value23: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value23.value, (value24) => value23.value = value24)) }, drop$dyns_Guarded_dyns_Held), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), new Noisy.Noisy(b, rs.arcClone(log))), { value: (value25: Guarded.Guarded) => new of$dyns_Noisy(value25.value) }, drop$dyns_Guarded_dyns_Noisy), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Empty" } as Held.Held), { value: (value27: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value27.value, (value28) => value27.value = value28)) }, drop$dyns_Guarded_dyns_Held)]); const _728: rs.Arc>> = new rs.Arc(new rs.RefCell(new Guarded.Guarded(rs.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(c, rs.arcClone(log)) } as Held.Held))); const cell2: rs.Arc>> = new rs.ArcDyn(_728, rs.tailDyn(_728.value, { value: (value29: rs.RefCell>) => rs.tailDyn(value29.value, { value: (value30: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value30.value, (value31) => value30.value = value31)) }) }, drop$cell_RefCell_dyns_Guarded_dyns_Held)); @@ -1811,22 +1811,22 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _761: rs.RefCell> = rs.refCellBorrow(cell2.value); const _757: rs.u32 = _761.value.value.area$Shape(); const args83 = [(f: rs.Formatter) => rs.fmtList(areas2.items, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_757, f)]; - const _753: string = rs.fmtFormat([args83[0], " ", args83[1], " "]); + const _753: rs.String = rs.fmtFormat([args83[0], " ", args83[1], " "]); rs.refRelease(_761); - put(out, _753); + put(out, _753.v); const _773: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_773.value); rs.refMutRelease(_773); rs.dropVec(guarded, drop$boxed_Box_dyns_Guarded_dyn_dyns_Shape); const _785: rs.RefCell = rs.refCellBorrow(log.value); - const _781: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_785.value), f, rs.u8Debug), " "]); + const _781: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_785.value), f, rs.u8Debug), " "]); rs.refRelease(_785); - put(out, _781); + put(out, _781.v); rs.arcDrop(cell2, drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape); const _801: rs.RefCell = rs.refCellBorrow(log.value); - const _797: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_801.value), f, rs.u8Debug), " "]); + const _797: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_801.value), f, rs.u8Debug), " "]); rs.refRelease(_801); - put(out, _797); + put(out, _797.v); const t2: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), b as rs.u32); const apart: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rs.arcClone(log)), b as rs.u32); const _822: Tail.Tail = rs.tailDyn(t2, { value: (value32: Tail.Tail) => new ofPlace$u32(rs.place(() => value32.value, (value33) => value32.value = value33)) }); @@ -1850,7 +1850,7 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _871: boolean = rs.arcPtrEq(r2, other); const _875: boolean = rs.arcPtrEq(u.arc, v.arc); const args86 = [(f: rs.Formatter) => rs.fmtBool(_859, f), (f: rs.Formatter) => rs.fmtBool(_863, f), (f: rs.Formatter) => rs.fmtBool(_867, f), (f: rs.Formatter) => rs.fmtBool(_871, f), (f: rs.Formatter) => rs.fmtBool(_875, f)]; - put(out, rs.fmtFormat([args86[0], " ", args86[1], " ", args86[2], " ", args86[3], " ", args86[4], " "])); + put(out, rs.fmtFormat([args86[0], " ", args86[1], " ", args86[2], " ", args86[3], " ", args86[4], " "]).v); v[Symbol.dispose](); u[Symbol.dispose](); other[Symbol.dispose](); @@ -1888,9 +1888,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _952: rs.Mutex> = rs.mutexLock(it.value); const _949: rs.u8 | undefined = rs.iterToOption(_952.value.next()); const args87 = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.refCellDebug(shown, f, (value: rs.Fmt, f: rs.Formatter) => value(f)), (f: rs.Formatter) => rs.fmtOption(_943, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_946, f), (f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_949, f, rs.u8Debug)]; - const _939: string = rs.fmtFormat([args87[0], " ", args87[1], " ", args87[2], " ", args87[3], " ", args87[4], " ", args87[5], " "]); + const _939: rs.String = rs.fmtFormat([args87[0], " ", args87[1], " ", args87[2], " ", args87[3], " ", args87[4], " ", args87[5], " "]); rs.mutexUnlock(_952); - put(out, _939); + put(out, _939.v); const _968: rs.u8 | undefined = option_map$1yjmt5m(rs.byteSliceFirst(rs.byteSliceRange(data, 3)), (x3: rs.u8): rs.u8 => { return rs.u8Rem(x3, 4); }); @@ -1912,9 +1912,9 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const dynamic2: rs.Arc> = new rs.ArcDyn(_984, rs.tailDyn(_984.value, { value: (value46: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value46)) })); const _held2: rs.RefCell = rs.refCellBorrowMut(dynamic2.value); const _997: rs.RefCell = rs.refCellBorrow(n.value); - const _993: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_997.value, f)]); + const _993: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_997.value, f)]); rs.refRelease(_997); - put(out, _993); + put(out, _993.v); rs.refMutRelease(_held2); dynamic2[Symbol.dispose](); break b6; @@ -1923,17 +1923,17 @@ export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { const _guard2: rs.Mutex = rs.mutexLock(m.value); const _1019: rs.Mutex = rs.mutexLock(locked.value); const part3 = _1019.value.area$Shape(); - const _1012: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part3, f)]); + const _1012: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part3, f)]); rs.mutexUnlock(_1019); - put(out, _1012); + put(out, _1012.v); rs.mutexUnlock(_guard2); break b6; } } const _1034: rs.RefCell = rs.refCellBorrow(n.value); - const _1030: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_1034.value, f)]); + const _1030: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(_1034.value, f)]); rs.refRelease(_1034); - put(out, _1030); + put(out, _1030.v); } it[Symbol.dispose](); any[Symbol.dispose](); @@ -2006,7 +2006,7 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _68: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_58, f); const arg = _61.side; const args41 = [_68, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_64, f), (f: rs.Formatter) => rs.u32Display(area, f)]; - put(out, rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " ", args41[3], " "])); + put(out, rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " ", args41[3], " "]).v); const noisy: rs.Arc> = new rs.Arc(new rs.Cell(new Noisy.Noisy(a, rs.arcClone(log)))); const _80: rs.Arc> = rs.arcClone(noisy); const cell: rs.Arc> = new rs.ArcDyn(_80, rs.tailDyn(_80.value, { v: (value5: rs.Cell) => new of$dyns_Noisy(value5.v) }, rs.drop)); @@ -2014,14 +2014,14 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, noisy[Symbol.dispose](); const _95: rs.RefCell = rs.refCellBorrow(log.value); const args42 = [(f: rs.Formatter) => rs.u32Display(area2, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_95.value), f, rs.u8Debug)]; - const _91: string = rs.fmtFormat([args42[0], " ", args42[1], " "]); + const _91: rs.String = rs.fmtFormat([args42[0], " ", args42[1], " "]); rs.refRelease(_95); - put(out, _91); + put(out, _91.v); cell[Symbol.dispose](); const _113: rs.RefCell = rs.refCellBorrow(log.value); - const _109: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_113.value), f, rs.u8Debug), " "]); + const _109: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_113.value), f, rs.u8Debug), " "]); rs.refRelease(_113); - put(out, _109); + put(out, _109.v); const _123: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_123.value); rs.refMutRelease(_123); @@ -2035,12 +2035,12 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _158: Tri.Tri = copy$dyns_Tri(u.value.v); const _163: rs.u32 = boxed.v.area$Shape(); const args44 = [(f: rs.Formatter) => rs.u32Display(area3, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_158, f), (f: rs.Formatter) => rs.u32Display(_163, f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "])); + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "]).v); boxed[Symbol.dispose](); const _183: rs.RefCell = rs.refCellBorrow(log.value); - const _179: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_183.value), f, rs.u8Debug), " "]); + const _179: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_183.value), f, rs.u8Debug), " "]); rs.refRelease(_183); - put(out, _179); + put(out, _179.v); const _193: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_193.value); rs.refMutRelease(_193); @@ -2053,23 +2053,23 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _218: rs.u32 = m.area$Shape(); const _222: rs.u32 = t.area$Shape(); const args46 = [(f: rs.Formatter) => rs.u32Display(_218, f), (f: rs.Formatter) => rs.u32Display(_222, f)]; - put(out, rs.fmtFormat([args46[0], " ", args46[1], " "])); + put(out, rs.fmtFormat([args46[0], " ", args46[1], " "]).v); const _244: rs.u32 = new of$dyns_Noisy(new Noisy.Noisy(b, rs.arcClone(log))).area$Shape(); const _248: Noisy.Noisy = kept; const _250: Tri.Tri = held; const _253: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_244, f); const arg2 = _248._0; const args47 = [_253, (f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_250, f)]; - put(out, rs.fmtFormat([args47[0], " ", args47[1], " ", args47[2], " "])); + put(out, rs.fmtFormat([args47[0], " ", args47[1], " ", args47[2], " "]).v); const _267: rs.RefCell = rs.refCellBorrow(log.value); - const _263: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_267.value), f, rs.u8Debug), " "]); + const _263: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_267.value), f, rs.u8Debug), " "]); rs.refRelease(_267); - put(out, _263); + put(out, _263.v); rs.drop(new of$dyns_Noisy(kept)); const _285: rs.RefCell = rs.refCellBorrow(log.value); - const _281: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_285.value), f, rs.u8Debug), " "]); + const _281: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_285.value), f, rs.u8Debug), " "]); rs.refRelease(_285); - put(out, _281); + put(out, _281.v); const _295: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_295.value); rs.refMutRelease(_295); @@ -2084,14 +2084,14 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, ticks[Symbol.dispose](); const _332: rs.RefCell = rs.refCellBorrow(log.value); const args50 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(first[0], f), (f: rs.Formatter) => rs.fmtOption(first[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Display(polls, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(rest[0], f), (f: rs.Formatter) => rs.fmtOption(rest[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_332.value), f, rs.u8Debug)]; - const _328: string = rs.fmtFormat([args50[0], " ", args50[1], " ", args50[2], " ", args50[3], " "]); + const _328: rs.String = rs.fmtFormat([args50[0], " ", args50[1], " ", args50[2], " ", args50[3], " "]); rs.refRelease(_332); - put(out, _328); + put(out, _328.v); future[Symbol.dispose](); const _354: rs.RefCell = rs.refCellBorrow(log.value); - const _350: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug), " "]); + const _350: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug), " "]); rs.refRelease(_354); - put(out, _350); + put(out, _350.v); const _364: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_364.value); rs.refMutRelease(_364); @@ -2111,14 +2111,14 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, block[Symbol.dispose](); const _398: rs.RefCell = rs.refCellBorrow(log.value); const args52 = [(f: rs.Formatter) => rs.fmtOption(ready, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_398.value), f, rs.u8Debug)]; - const _394: string = rs.fmtFormat([args52[0], " ", args52[1], " "]); + const _394: rs.String = rs.fmtFormat([args52[0], " ", args52[1], " "]); rs.refRelease(_398); - put(out, _394); + put(out, _394.v); erased[Symbol.dispose](); const _416: rs.RefCell = rs.refCellBorrow(log.value); - const _412: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_416.value), f, rs.u8Debug), " "]); + const _412: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_416.value), f, rs.u8Debug), " "]); rs.refRelease(_416); - put(out, _412); + put(out, _412.v); const _426: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_426.value); rs.refMutRelease(_426); @@ -2142,12 +2142,12 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _475: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg4, f); const arg5 = t2.value; const args54 = [_471, _472, _473, _474, _475, (f: rs.Formatter) => Tri.fmt$fmt_Debug(arg5, f)]; - put(out, rs.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "])); + put(out, rs.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "]).v); t2[Symbol.dispose](); const _489: rs.RefCell = rs.refCellBorrow(log.value); - const _485: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_489.value), f, rs.u8Debug), " "]); + const _485: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_489.value), f, rs.u8Debug), " "]); rs.refRelease(_489); - put(out, _485); + put(out, _485.v); let sq2: rs.Cell = new rs.Cell({ side: c as rs.u16 }); let tri2: rs.RefCell = new rs.RefCell({ tag: "Tall", _0: a } as Tri.Tri); const p2: rs.Place> = rs.rawUnsizePlace(rs.place(() => sq2, (value14) => sq2 = value14), (p7) => rs.tailDyn(p7, { v: (value15: rs.Cell) => new of$dyns_Square(value15.v) })); @@ -2165,9 +2165,9 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const _538: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(areas2[0], f), (f: rs.Formatter) => rs.u32Debug(areas2[1], f)], f); const arg6 = _531.side; const args56 = [_538, (f: rs.Formatter) => rs.u16Display(arg6, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_534.value, f)]; - const _527: string = rs.fmtFormat([args56[0], " ", args56[1], " ", args56[2], " "]); + const _527: rs.String = rs.fmtFormat([args56[0], " ", args56[1], " ", args56[2], " "]); rs.refRelease(_534); - put(out, _527); + put(out, _527.v); const _546: [Ticks.Ticks, Noisy.Noisy, Tail.Tail] = [new Ticks.Ticks(rs.u8Rem(b, 3), 0, rs.arcClone(log)), new Noisy.Noisy(a, rs.arcClone(log)), new Tail.Tail(b, new Noisy.Noisy(b, rs.arcClone(log)), new Noisy.Noisy(c, rs.arcClone(log)))]; const ticks2: Ticks.Ticks = _546[0]; const noisy2: Noisy.Noisy = _546[1]; @@ -2183,9 +2183,9 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, tail3[Symbol.dispose](); const _599: rs.RefCell = rs.refCellBorrow(log.value); const args57 = [(f: rs.Formatter) => rs.fmtBool(polled, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_599.value), f, rs.u8Debug)]; - const _595: string = rs.fmtFormat([args57[0], " ", args57[1], " "]); + const _595: rs.String = rs.fmtFormat([args57[0], " ", args57[1], " "]); rs.refRelease(_599); - put(out, _595); + put(out, _595.v); const _611: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_611.value); rs.refMutRelease(_611); @@ -2197,7 +2197,7 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const second: rs.u8 | undefined = rs.iterToOption(_632.value.next()); rs.mutexUnlock(_632); const args58 = [(f: rs.Formatter) => rs.fmtOption(first2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args58[0], " ", args58[1], " "])); + put(out, rs.fmtFormat([args58[0], " ", args58[1], " "]).v); cell2[Symbol.dispose](); dropped(out); locked[Symbol.dispose](); @@ -2211,11 +2211,11 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, const area5: rs.u32 = wide.v.v.area$Shape(); const _677: rs.u32 = slot.v; const args59 = [(f: rs.Formatter) => rs.fmtBool(null_, f), (f: rs.Formatter) => rs.u32Display(area5, f), (f: rs.Formatter) => rs.u32Display(_677, f)]; - put(out, rs.fmtFormat([args59[0], " ", args59[1], " ", args59[2], " "])); + put(out, rs.fmtFormat([args59[0], " ", args59[1], " ", args59[2], " "]).v); const shown: rs.Fmt = rs.rawUnsize(side, (p13) => rs.fmtOwned(p13, (value: Square.Square, f: rs.Formatter) => Square.fmt$fmt_Debug(value, f))); const _703: boolean = rs.rawUnsize(rs.NULL, (p14) => new of$dyns_Square(p14)) === rs.NULL; const args60 = [(f: rs.Formatter) => shown(f), (f: rs.Formatter) => rs.fmtBool(_703, f)]; - put(out, rs.fmtFormat([args60[0], " ", args60[1]])); + put(out, rs.fmtFormat([args60[0], " ", args60[1]]).v); owned[Symbol.dispose](); shape[Symbol.dispose](); u[Symbol.dispose](); @@ -2276,7 +2276,7 @@ export function pick$dyns_Scaled_u16_u16(_self: rs.u16, a: rs.u16, b: rs.u16): r return a; } -export function take$dyns_Source_u8(self: rs.Place): string | undefined { +export function take$dyns_Source_u8(self: rs.Place): rs.String | undefined { const _2: rs.u8 | undefined = rs.u8CheckedSub(self.v, 1); if (_2 !== undefined) { self.v = _2; @@ -2289,12 +2289,12 @@ export function left$dyns_Source_u8(self: rs.u8): rs.usize { return self as rs.usize; } -export function taken$String(s: Source.Source): string { - const taken: rs.Vec = new rs.Vec(); +export function taken$String(s: Source.Source): rs.String { + const taken: rs.Vec = new rs.Vec(); while (true) { - const _3: string | undefined = s.take$Source(); + const _3: rs.String | undefined = s.take$Source(); if (_3 !== undefined) { - const _8: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(_3, f)]); + const _8: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(_3.v, f)]); taken.items.push(_8); } else { break; @@ -2303,12 +2303,12 @@ export function taken$String(s: Source.Source): string { return rs.strsJoin(taken.items, ","); } -export function taken$u32(s: Source.Source): string { - const taken: rs.Vec = new rs.Vec(); +export function taken$u32(s: Source.Source): rs.String { + const taken: rs.Vec = new rs.Vec(); while (true) { const _3: rs.u32 | undefined = s.take$Source(); if (_3 !== undefined) { - const _8: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(_3, f)]); + const _8: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(_3, f)]); taken.items.push(_8); } else { break; @@ -2332,29 +2332,29 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { } else { tri = { tag: "Flat" } as Tri.Tri; } - const named: Scaled.Scaled = new of$dyns_Tri(tri); + const named: Scaled.Scaled = new of$dyns_Tri(tri); const _37: rs.u16 = ((c as rs.u16) << 8) & 0xffff; - const _41: string = "s"; + const _41: rs.String = rs.stringFrom("s"); let n: rs.u8 = b; let w: rs.u16 = _37; - let s: string = _41; + const s: rs.String = _41; narrow.bump$Scaled(rs.place(() => n, (value) => n = value) as rs.Ptr); wide.bump$Scaled(rs.place(() => w, (value2) => w = value2) as rs.Ptr); - named.bump$Scaled(rs.place(() => s, (value3) => s = value3) as rs.Ptr); + named.bump$Scaled(s as rs.Ptr); const _57: rs.u8 = narrow.scale$Scaled(b); const _59: rs.u16 = wide.scale$Scaled(rs.u16Mul(c as rs.u16, 300)); - const _65: string = named.scale$Scaled(rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(a, f)])); - const args34 = [(f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => rs.u16Display(_59, f), (f: rs.Formatter) => rs.fmtPad(f, _65), (f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u16Display(w, f), (f: rs.Formatter) => rs.fmtPad(f, s)]; - put(out, rs.fmtFormat([args34[0], " ", args34[1], " ", args34[2], " ", args34[3], " ", args34[4], " ", args34[5], " "])); - const _90: string = "ab"; - const _89: [string, string] = [_90, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(c, f)])]; - const x: string = _90; - const y: string = _89[1]; + const _65: rs.String = named.scale$Scaled(rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(a, f)])); + const args34 = [(f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => rs.u16Display(_59, f), (f: rs.Formatter) => rs.fmtPad(f, _65.v), (f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u16Display(w, f), (f: rs.Formatter) => rs.fmtPad(f, s.v)]; + put(out, rs.fmtFormat([args34[0], " ", args34[1], " ", args34[2], " ", args34[3], " ", args34[4], " ", args34[5], " "]).v); + const _90: rs.String = rs.stringFrom("ab"); + const _89: [rs.String, rs.String] = [_90, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(c, f)])]; + const x: rs.String = _90; + const y: rs.String = _89[1]; const _108: rs.u8 = narrow.pick$Scaled(b as rs.Ptr, c as rs.Ptr) as rs.u8; const _112: rs.u16 = wide.pick$Scaled((a as rs.u16) as rs.Ptr, w as rs.Ptr) as rs.u16; - const _118: string = named.pick$Scaled(x as rs.Ptr, y as rs.Ptr) as string; - const args36 = [(f: rs.Formatter) => rs.u8Display(_108, f), (f: rs.Formatter) => rs.u16Display(_112, f), (f: rs.Formatter) => rs.fmtPad(f, _118)]; - put(out, rs.fmtFormat([args36[0], " ", args36[1], " ", args36[2], " "])); + const _118: rs.String = named.pick$Scaled(x as rs.Ptr, y as rs.Ptr) as rs.String; + const args36 = [(f: rs.Formatter) => rs.u8Display(_108, f), (f: rs.Formatter) => rs.u16Display(_112, f), (f: rs.Formatter) => rs.fmtPad(f, _118.v)]; + put(out, rs.fmtFormat([args36[0], " ", args36[1], " ", args36[2], " "]).v); const paired: Paired.Paired = new of$dyns_Many({ _0: b }); const up: Scaled.Scaled = paired as Scaled.Scaled; const v: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 3)); @@ -2364,7 +2364,7 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _150: [rs.u8, rs.u8] = paired.pair$Paired(c); const _152: rs.ByteVec = up.scale$Scaled(rs.byteSliceToByteVec(rs.byteSliceRange(data, 3))); const args37 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_150[0], f), (f: rs.Formatter) => rs.u8Debug(_150[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_152), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(picked), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args37[0], " ", args37[1], " ", args37[2], " ", args37[3], " "])); + put(out, rs.fmtFormat([args37[0], " ", args37[1], " ", args37[2], " ", args37[3], " "]).v); const _164: rs.Arc = new rs.Arc({ _0: c }); const shared: rs.Arc> = new rs.ArcDyn(_164, new of$dyns_Many(_164.value)); const up2: rs.Arc> = rs.arcClone(shared) as rs.Arc>; @@ -2373,7 +2373,7 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _183: [rs.u8, rs.u8] = shared.value.pair$Paired(b); const _187: rs.usize = up2.strong; const args38 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_183[0], f), (f: rs.Formatter) => rs.u8Debug(_183[1], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(v2), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "])); + put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "]).v); const weak2: rs.Weak> = new rs.Weak(shared) as rs.Weak>; up2[Symbol.dispose](); const scaled: rs.ByteVec | undefined = option_map$00ac22d(rs.weakUpgrade(weak2), (s2: rs.Arc>): rs.ByteVec => { @@ -2385,15 +2385,15 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _217: rs.Arc> | undefined = rs.weakUpgrade(weak2); const _215: boolean = _217 === undefined; const args39 = [(f: rs.Formatter) => rs.fmtOption(scaled, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtBool(_215, f)]; - const _211: string = rs.fmtFormat([args39[0], " ", args39[1], " "]); + const _211: rs.String = rs.fmtFormat([args39[0], " ", args39[1], " "]); rs.drop(_217); - put(out, _211); + put(out, _211.v); const nest: Nest.Nest = new of$dyns_Leaf({ _0: c }); const _236: boolean = (nest.next$Nest() as Nest.Nest | undefined) === undefined; const _240: rs.u8 = nest.depth$Nest(); const _242: rs.u8 = narrow.apply$Scaled(doubled as (a0: rs.Ptr) => rs.u8, c); const args40 = [(f: rs.Formatter) => rs.fmtBool(_236, f), (f: rs.Formatter) => rs.u8Display(_240, f), (f: rs.Formatter) => rs.u8Display(_242, f)]; - put(out, rs.fmtFormat([args40[0], " ", args40[1], " ", args40[2], " "])); + put(out, rs.fmtFormat([args40[0], " ", args40[1], " ", args40[2], " "]).v); const owned: Source.Source = new of$dyns_Drained(new Drained.Drained(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_2: rs.u8): Noisy.Noisy => { return new Noisy.Noisy(_2, rs.arcClone(log)); }), undefined, 8, true))); @@ -2401,38 +2401,38 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { const _268: rs.usize = owned.left$Source(); const _271: rs.RefCell = rs.refCellBorrow(log.value); const args41 = [(f: rs.Formatter) => rs.usizeDisplay(_268, f), (f: rs.Formatter) => rs.fmtOption(first, f, (value: Noisy.Noisy, f: rs.Formatter) => Noisy.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_271.value), f, rs.u8Debug)]; - const _264: string = rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " "]); + const _264: rs.String = rs.fmtFormat([args41[0], " ", args41[1], " ", args41[2], " "]); rs.refRelease(_271); - put(out, _264); + put(out, _264.v); rs.drop(first); const _290: rs.RefCell = rs.refCellBorrow(log.value); - const _286: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_290.value), f, rs.u8Debug), " "]); + const _286: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_290.value), f, rs.u8Debug), " "]); rs.refRelease(_290); - put(out, _286); + put(out, _286.v); if (rs.u8Rem(a, 2) === 0) { rs.drop(owned.take$Source()); } rs.drop(owned); const _311: rs.RefCell = rs.refCellBorrow(log.value); - const _307: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug), " "]); + const _307: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug), " "]); rs.refRelease(_311); - put(out, _307); + put(out, _307.v); const steps: Steps.Steps = { _0: rs.u8Rem(a, 6) as rs.u32, _1: b as rs.u32 }; const counted: Counted.Counted = new of$dyns_Steps(steps); const next: rs.u32 | undefined = counted.take$Source(); const _334: rs.usize = counted.left$Source(); const _337: rs.u32 = counted.total$Counted(); const args44 = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; - put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "])); - const _354: string = taken$u32(counted as Source.Source); - const _358: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, _354); + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", args44[2], " "]).v); + const _354: rs.String = taken$u32(counted as Source.Source); + const _358: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, _354.v); const arg = steps._1; const args45 = [_358, (f: rs.Formatter) => rs.u32Display(arg, f)]; - put(out, rs.fmtFormat([args45[0], " ", args45[1], " "])); + put(out, rs.fmtFormat([args45[0], " ", args45[1], " "]).v); let left: rs.u8 = rs.u8Rem(c, 5); - const _372: string = taken$String(new ofPlace$u8(rs.place(() => left, (value4) => left = value4))); - const args46 = [(f: rs.Formatter) => rs.fmtPad(f, _372), (f: rs.Formatter) => rs.u8Display(left, f)]; - put(out, rs.fmtFormat([args46[0], " ", args46[1], " "])); + const _372: rs.String = taken$String(new ofPlace$u8(rs.place(() => left, (value3) => left = value3))); + const args46 = [(f: rs.Formatter) => rs.fmtPad(f, _372.v), (f: rs.Formatter) => rs.u8Display(left, f)]; + put(out, rs.fmtFormat([args46[0], " ", args46[1], " "]).v); const tasks: rs.Vec> = rs.vecFrom([new of$dyns_Steps({ _0: 1, _1: a as rs.u32 })]); const square: Task.Task = new of$dyns_Square({ side: c as rs.u16 }); tasks.items[rs.idx(tasks.items, 0)].run$Task(); @@ -2441,11 +2441,11 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { })); const _408: rs.u32 = square.run$Task(); const args47 = [(f: rs.Formatter) => rs.usizeDisplay(ran, f), (f: rs.Formatter) => rs.u32Display(_408, f)]; - put(out, rs.fmtFormat([args47[0], " ", args47[1], " "])); - const over: Over.Over = new Over.Over(new of$dyns_Tri(copy$dyns_Tri(tri)), new of$u8(rs.u8Rem(a, 4))); - const runs: rs.Vec = new rs.Vec(); + put(out, rs.fmtFormat([args47[0], " ", args47[1], " "]).v); + const over: Over.Over = new Over.Over(new of$dyns_Tri(copy$dyns_Tri(tri)), new of$u8(rs.u8Rem(a, 4))); + const runs: rs.Vec = new rs.Vec(); while (true) { - const _425: string | undefined = Over.run$String(over); + const _425: rs.String | undefined = Over.run$String(over); if (_425 !== undefined) { runs.items.push(_425); } else { @@ -2453,8 +2453,8 @@ export function generics(data: rs.ByteSlice, out: rs.ByteVec): void { } } const _439: rs.usize = over.source.left$Source(); - const args48 = [(f: rs.Formatter) => rs.fmtList(runs.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(_439, f)]; - put(out, rs.fmtFormat([args48[0], " ", args48[1]])); + const args48 = [(f: rs.Formatter) => rs.fmtList(runs.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.usizeDisplay(_439, f)]; + put(out, rs.fmtFormat([args48[0], " ", args48[1]]).v); over[Symbol.dispose](); rs.drop(square); rs.dropVec(tasks); diff --git a/ts/fixtures/lang/dyns/expected/lib.ts b/ts/fixtures/lang/dyns/expected/lib.ts index 62a9c5b58..9c6e2ec2c 100644 --- a/ts/fixtures/lang/dyns/expected/lib.ts +++ b/ts/fixtures/lang/dyns/expected/lib.ts @@ -332,6 +332,28 @@ export class of$Option_u8 { } } +export class of$String { + v: rs.String; + + constructor(v: rs.String) { + this.v = v; + } + + writeChar$Write(a: rs.char): rs.Result { + rs.stringPush(this.v, a); + return rs.OK; + } + + writeFmt$Write(a: rs.Arguments): rs.Result { + return rs.fmtWriteString(this.v, a); + } + + writeStr$Write(a: string): rs.Result { + rs.stringPushStr(this.v, a); + return rs.OK; + } +} + export class of$dyns_By { v: By.By; @@ -571,7 +593,7 @@ export class of$dyns_Square { return Square.key$dyns_Keyed(this.v); } - label$Named(): string { + label$Named(): rs.String { return Square.label$dyns_Named(this.v); } @@ -623,8 +645,8 @@ export class of$dyns_Tri { this.v = v; } - apply$Scaled(a: (a0: rs.Ptr) => string, a2: string): string { - return Tri.apply$dyns_Scaled_String(this.v, a as (a0: string) => string, a2); + apply$Scaled(a: (a0: rs.Ptr) => rs.String, a2: rs.String): rs.String { + return Tri.apply$dyns_Scaled_String(this.v, a as (a0: rs.String) => rs.String, a2); } area$Shape(): rs.u32 { @@ -639,8 +661,8 @@ export class of$dyns_Tri { return Tri.asAnyMut$dyns_Erased(this); } - bump$Scaled(a: rs.Ptr): void { - return Tri.bump$dyns_Scaled_String(this.v, a as rs.Place); + bump$Scaled(a: rs.Ptr): void { + return Tri.bump$dyns_Scaled_String(this.v, a as rs.String); } fmt$Debug(a: rs.Formatter): rs.Result { @@ -655,7 +677,7 @@ export class of$dyns_Tri { return Tri.intoArea$dyns_Shape(this.v); } - label$Named(): string { + label$Named(): rs.String { return Tri.label$dyns_Named(this.v); } @@ -663,11 +685,11 @@ export class of$dyns_Tri { return Tri.larger$dyns_Shape(this.v, a); } - pick$Scaled(a: rs.Ptr, a2: rs.Ptr): rs.Ptr { - return Tri.pick$dyns_Scaled_String(this.v, a as string, a2 as string) as rs.Ptr; + pick$Scaled(a: rs.Ptr, a2: rs.Ptr): rs.Ptr { + return Tri.pick$dyns_Scaled_String(this.v, a as rs.String, a2 as rs.String) as rs.Ptr; } - scale$Scaled(a: string): string { + scale$Scaled(a: rs.String): rs.String { return Tri.scale$dyns_Scaled_String(this.v, a); } @@ -1105,7 +1127,7 @@ export class of$u8 { return left$dyns_Source_u8(this.v); } - take$Source(): string | undefined { + take$Source(): rs.String | undefined { return dyns_take$dyns_Source_u8(this); } } @@ -1126,30 +1148,6 @@ export class ofPlace$Option_u8 { } } -export class ofPlace$String { - v: rs.Place; - - constructor(v: rs.Place) { - this.v = v; - } - - writeChar$Write(a: rs.char): rs.Result { - this.v.v = this.v.v + String.fromCodePoint(a); - return rs.OK; - } - - writeFmt$Write(a: rs.Arguments): rs.Result { - const written = rs.fmtWriteString(this.v.v, a); - this.v.v = written.s; - return written.result; - } - - writeStr$Write(a: string): rs.Result { - this.v.v = this.v.v + a; - return rs.OK; - } -} - export class ofPlace$dyns_Held { v: rs.Place; @@ -1209,7 +1207,7 @@ export class ofPlace$dyns_Tri { return Tri.intoArea$dyns_Shape(this.v.v); } - label$Named(): string { + label$Named(): rs.String { return Tri.label$dyns_Named(this.v.v); } @@ -1227,25 +1225,23 @@ export class ofPlace$dyns_Tri { } export class ofPlace$mut_String { - v: rs.Place>; + v: rs.Place; - constructor(v: rs.Place>) { + constructor(v: rs.Place) { this.v = v; } writeChar$Write(a: rs.char): rs.Result { - this.v.v.v = this.v.v.v + String.fromCodePoint(a); + rs.stringPush(this.v.v, a); return rs.OK; } writeFmt$Write(a: rs.Arguments): rs.Result { - const written = rs.fmtWriteString(this.v.v.v, a); - this.v.v.v = written.s; - return written.result; + return rs.fmtWriteString(this.v.v, a); } writeStr$Write(a: string): rs.Result { - this.v.v.v = this.v.v.v + a; + rs.stringPushStr(this.v.v, a); return rs.OK; } } @@ -1305,7 +1301,7 @@ export class ofPlace$u8 { return left$dyns_Source_u8(this.v.v); } - take$Source(): string | undefined { + take$Source(): rs.String | undefined { return dyns_take$dyns_Source_u8(this.v); } } diff --git a/ts/fixtures/lang/dyns/expected/stds.Key.ts b/ts/fixtures/lang/dyns/expected/stds.Key.ts index f1be7faf5..10accdfab 100644 --- a/ts/fixtures/lang/dyns/expected/stds.Key.ts +++ b/ts/fixtures/lang/dyns/expected/stds.Key.ts @@ -26,7 +26,7 @@ export function hash$Hash_mut_stds_Sum(self: Key, state: rs.Place) /** A key of the crate's own, which hashes its fields into whichever hasher it is given. */ export interface Key { id: rs.u16; - name: string; + name: rs.String; tags: rs.ByteVec; } diff --git a/ts/fixtures/lang/dyns/expected/stds.Upper.ts b/ts/fixtures/lang/dyns/expected/stds.Upper.ts index 40a473101..3e315459b 100644 --- a/ts/fixtures/lang/dyns/expected/stds.Upper.ts +++ b/ts/fixtures/lang/dyns/expected/stds.Upper.ts @@ -7,11 +7,11 @@ import * as rs from "./rs.ts"; * `limit` bytes, logs each char `write_char` writes itself, and logs as it drops. */ export class Upper { - s: string; + s: rs.String; limit: rs.usize; log: rs.Arc>; - constructor(s: string, limit: rs.usize, log: rs.Arc>) { + constructor(s: rs.String, limit: rs.usize, log: rs.Arc>) { this.s = s; this.limit = limit; this.log = log; @@ -24,9 +24,9 @@ export class Upper { } export function writeStr$fmt_Write(self: Upper, s: string): rs.Result { - if (!(rs.usizeAdd(rs.stringLen(self.s), rs.stringLen(s)) > self.limit)) { - const _12: string = rs.strToUppercase(s); - self.s = self.s + _12; + if (!(rs.usizeAdd(self.s.len, rs.stringLen(s)) > self.limit)) { + const _12: string = rs.strToUppercase(s).v; + rs.stringPushStr(self.s, _12); return rs.OK; } return rs.Err(new rs.FmtError()); diff --git a/ts/fixtures/lang/dyns/expected/stds.ts b/ts/fixtures/lang/dyns/expected/stds.ts index f3563010f..840a2c78a 100644 --- a/ts/fixtures/lang/dyns/expected/stds.ts +++ b/ts/fixtures/lang/dyns/expected/stds.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { hasher$mut_dyn_hash_Hasher, hasher$mut_hash_DefaultHasher, of$hash_DefaultHasher, of$ref_str, of$stds_Counter, of$stds_Fnv, of$stds_Key, of$stds_Sum, of$stds_Upper, of$u8, ofPlace$String, ofPlace$mut_String } from "./lib.ts"; +import { hasher$mut_dyn_hash_Hasher, hasher$mut_hash_DefaultHasher, of$String, of$hash_DefaultHasher, of$ref_str, of$stds_Counter, of$stds_Fnv, of$stds_Key, of$stds_Sum, of$stds_Upper, of$u8, ofPlace$mut_String } from "./lib.ts"; import type * as fmt_Write from "./core/fmt.Write.ts"; import type * as Hasher from "./core/hash.Hasher.ts"; import { and$0302lm8 as result_and$0302lm8 } from "./core/result.ts"; @@ -86,7 +86,7 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.u8 = _10[0]; const b: rs.u8 = _10[1]; const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); - const key: Key.Key = { id: (((a as rs.u16) << 8) & 0xffff) | b as rs.u16, name: rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))), tags: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)) }; + const key: Key.Key = { id: (((a as rs.u16) << 8) & 0xffff) | b as rs.u16, name: rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))), tags: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)) }; const keys: DynHash.DynHash[] = [new of$stds_Key(key), new of$u8(a), new of$ref_str("k")]; const std: rs.Hasher = rs.hasher(); const fnv: Fnv.Fnv = new Fnv.Fnv({ hi: 0xcbf29ce4, lo: 0x84222325 } as rs.u64, rs.arcClone(log)); @@ -106,9 +106,9 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const _72: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_59, f); const arg = sum._0; const args17 = [_70, _71, _72, (f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_66.value), f, rs.u8Debug)]; - const _43: string = rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", args17[4], " "]); + const _43: rs.String = rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", args17[4], " "]); rs.refRelease(_66); - put(out, _43); + put(out, _43.v); const _79: rs.u8 = rs.u8Rem(a, 3); if (_79 === 0) { _78 = new of$hash_DefaultHasher(rs.hasher()); @@ -121,7 +121,7 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { boxed.writeU8$Hasher(b); const native: rs.Hasher = rs.hasher(); Key.dynHash$stds_DynHash(key, new of$hash_DefaultHasher(native)); - const _100: [rs.u8, string] = [a, key.name]; + const _100: [rs.u8, rs.String] = [a, key.name]; let _103: rs.Hasher = native; rs.hashTuple([rs.hash8, rs.hashStr])(_100, new rs.OwnHasher(rs.place(() => _103, (value2) => _103 = value2), hasher$mut_hash_DefaultHasher)); Key.hash$Hash_boxed_Box_dyn_hash_Hasher(key, rs.place(() => boxed, (value18) => boxed = value18)); @@ -134,63 +134,63 @@ export function stds(data: rs.ByteSlice, out: rs.ByteVec): void { const _129: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_124, f); const arg2 = sum2._0; const args18 = [_128, _129, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "])); + put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]).v); rs.drop(boxed); const _143: rs.RefCell = rs.refCellBorrow(log.value); - const _139: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_143.value), f, rs.u8Debug), " "]); + const _139: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_143.value), f, rs.u8Debug), " "]); rs.refRelease(_143); - put(out, _139); + put(out, _139.v); fnv[Symbol.dispose](); const _160: rs.RefCell = rs.refCellBorrow(log.value); - const _156: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_160.value), f, rs.u8Debug), " "]); + const _156: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_160.value), f, rs.u8Debug), " "]); rs.refRelease(_160); - put(out, _156); + put(out, _156.v); const _170: rs.RefCell = rs.refCellBorrowMut(log.value); rs.byteVecClear(_170.value); rs.refMutRelease(_170); - const text: string = rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))); - let s: string = "s:"; - const written: rs.Result = render(new ofPlace$String(rs.place(() => s, (value20) => s = value20)), a, text); - const upper: Upper.Upper = new Upper.Upper("", rs.u8Rem(b, 32) as rs.usize, rs.arcClone(log)); - const failed: rs.Result = render(new of$stds_Upper(upper), a, text); + const text: rs.String = rs.strCowIntoOwned(rs.stringFromUtf8Lossy(rs.byteSliceRange(data, 2))); + const s: rs.String = rs.stringFrom("s:"); + const written: rs.Result = render(new of$String(s), a, text.v); + const upper: Upper.Upper = new Upper.Upper(rs.stringNew(), rs.u8Rem(b, 32) as rs.usize, rs.arcClone(log)); + const failed: rs.Result = render(new of$stds_Upper(upper), a, text.v); const counter: Counter.Counter = { _0: 0 }; - const counted: rs.Result = render(new of$stds_Counter(counter), b, text); - const again: rs.Result = twice$dyn_fmt_Write(new ofPlace$String(rs.place(() => s, (value21) => s = value21)), "+"); - let inner: rs.Place = rs.place(() => s, (value22) => s = value22); - const again2: rs.Result = result_and$0302lm8(again, render(new ofPlace$mut_String(rs.place(() => inner, (value23) => inner = value23)), b, "&")); + const counted: rs.Result = render(new of$stds_Counter(counter), b, text.v); + const again: rs.Result = twice$dyn_fmt_Write(new of$String(s), "+"); + let inner: rs.String = s; + const again2: rs.Result = result_and$0302lm8(again, render(new ofPlace$mut_String(rs.place(() => inner, (value20) => inner = value20)), b, "&")); const _219: rs.RefCell = rs.refCellBorrow(log.value); - const _228: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s); + const _228: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s.v); const _229: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(written, f, rs.fmtUnit, rs.fmtErrorDebug); const arg3 = upper.s; - const _230: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, arg3); + const _230: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, arg3.v); const _231: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(failed, f, rs.fmtUnit, rs.fmtErrorDebug); const arg4 = counter._0; const args21 = [_228, _229, _230, _231, (f: rs.Formatter) => rs.usizeDisplay(arg4, f), (f: rs.Formatter) => rs.fmtResult(counted, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtResult(again2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_219.value), f, rs.u8Debug)]; - const _213: string = rs.fmtFormat([args21[0], " ", args21[1], " ", args21[2], " ", args21[3], " ", args21[4], " ", args21[5], " ", args21[6], " ", args21[7], " "]); + const _213: rs.String = rs.fmtFormat([args21[0], " ", args21[1], " ", args21[2], " ", args21[3], " ", args21[4], " ", args21[5], " ", args21[6], " ", args21[7], " "]); rs.refRelease(_219); - put(out, _213); + put(out, _213.v); const _246: Rendered.Rendered = { _0: a }; const _248: Rendered.Rendered = { _0: b }; const args22 = [(f: rs.Formatter) => Rendered.fmt$fmt_Display(_246, f), (f: rs.Formatter) => Rendered.fmt$fmt_Display(_248, f)]; - put(out, rs.fmtFormat([args22[0], " ", rs.fmtSpec({ align: ">", width: 12 }, args22[1]), " "])); + put(out, rs.fmtFormat([args22[0], " ", rs.fmtSpec({ align: ">", width: 12 }, args22[1]), " "]).v); if (rs.u8Rem(b, 2) === 0) { _255 = new of$stds_Counter({ _0: a as rs.usize }); } else { - _255 = new of$stds_Upper(new Upper.Upper("x", 64, rs.arcClone(log))); + _255 = new of$stds_Upper(new Upper.Upper(rs.stringFrom("x"), 64, rs.arcClone(log))); } const boxed2: fmt_Write.Write = _255; const written2: rs.Result = render(boxed2, b, "b"); rs.drop(boxed2); const _278: rs.RefCell = rs.refCellBorrow(log.value); const args23 = [(f: rs.Formatter) => rs.fmtResult(written2, f, rs.fmtUnit, rs.fmtErrorDebug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_278.value), f, rs.u8Debug)]; - const _274: string = rs.fmtFormat([args23[0], " ", args23[1], " "]); + const _274: rs.String = rs.fmtFormat([args23[0], " ", args23[1], " "]); rs.refRelease(_278); - put(out, _274); + put(out, _274.v); upper[Symbol.dispose](); const _297: rs.RefCell = rs.refCellBorrow(log.value); - const _293: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_297.value), f, rs.u8Debug)]); + const _293: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_297.value), f, rs.u8Debug)]); rs.refRelease(_297); - put(out, _293); + put(out, _293.v); log[Symbol.dispose](); } } diff --git a/ts/fixtures/lang/edits/expected/edits.Named.ts b/ts/fixtures/lang/edits/expected/edits.Named.ts index d989f5ebf..8559291f0 100644 --- a/ts/fixtures/lang/edits/expected/edits.Named.ts +++ b/ts/fixtures/lang/edits/expected/edits.Named.ts @@ -3,14 +3,14 @@ import * as rs from "./rs.ts"; export function clone$Clone(self: Named): Named { - return { id: self.id, name: self.name }; + return { id: self.id, name: rs.stringClone(self.name) }; } export function eq$cmp_PartialEq(self: Named, other: Named): boolean { if (!(self.id === other.id)) { return false; } - return self.name === other.name; + return rs.eqStr(self.name, other.name); } export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Ordering | undefined { @@ -26,7 +26,7 @@ export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Orderin /** An element that is not `Copy`, cloned and compared field by field. */ export interface Named { id: rs.u16; - name: string; + name: rs.String; } //# sourceMappingURL=edits.Named.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Tally.ts b/ts/fixtures/lang/edits/expected/edits.Tally.ts index 28df292eb..651b3e923 100644 --- a/ts/fixtures/lang/edits/expected/edits.Tally.ts +++ b/ts/fixtures/lang/edits/expected/edits.Tally.ts @@ -5,11 +5,11 @@ import * as rs from "./rs.ts"; /** What `mem::take` leaves its own `Default` in place of. */ export interface Tally { n: rs.u8; - names: rs.Vec; + names: rs.Vec; } export function default$Default(): Tally { - return { n: 7, names: rs.vecFrom(["fresh"]) }; + return { n: 7, names: rs.vecFrom([rs.stringFrom("fresh")]) }; } //# sourceMappingURL=edits.Tally.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 0083f2797..9b562e3bd 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -72,11 +72,11 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { for (const _33 of pairs.items) { putU16s(out, rs.sliceFrom([_33[0], _33[1]])); } - const names: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_238: rs.u8): string => { + const names: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_238: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_238))); }), undefined, 12, true); - rs.vecRetain(names, (s3: string): boolean => { - return rs.stringLen(s3) > 1; + rs.vecRetain(names, (s3: rs.String): boolean => { + return s3.len > 1; }); rs.byteVecPush(out, names.items.length & 0xff); const v2: rs.Vec = rs.vecFrom(words.items.slice()); @@ -93,18 +93,18 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } putU16s(out, rs.sliceFrom(v2.items)); while (true) { - const _66: string | undefined = rs.vecPopIfMut(names, (s4: rs.Place): boolean => { - s4.v = s4.v + "."; - return rs.usizeRem(rs.stringLen(s4.v), 3) !== 0; + const _66: rs.String | undefined = rs.vecPopIf(names, (s4: rs.String): boolean => { + rs.stringPush(s4, 46); + return rs.usizeRem(s4.len, 3) !== 0; }); if (_66 !== undefined) { - put(out, _66); + put(out, _66.v); } else { break; } } for (const _76 of names.items) { - put(out, _76); + put(out, _76.v); } const part8 = rs.usizeSaturatingSub(data.length, 1); const stop: rs.u16 = rs.u16Mul(at(part8) as rs.u16, 3); @@ -139,16 +139,16 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.vecDedupBy(tested, (a3: Named.Named, b10: Named.Named): boolean => { seen2.items.push(a3.id); seen2.items.push(b10.id); - return a3.name === b10.name; + return rs.eqStr(a3.name, b10.name); }); putU16s(out, rs.sliceFrom(seen2.items)); for (const _144 of tested.items) { - put(out, _144.name); + put(out, _144.name.v); } - const names2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_227: rs.u8): string => { + const names2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_227: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_227, 3)))); }), undefined, 12, true); - rs.vecDedupBy(names2, rs.same); + rs.vecDedupBy(names2, rs.eqStr); rs.byteVecPush(out, names2.items.length & 0xff); } else if (_8 === 2) { const v4: rs.Vec = rs.vecFrom(words.items.slice()); @@ -195,13 +195,13 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return o; })])); } - const names3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_223: rs.u8): string => { + const names3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_223: rs.u8): rs.String => { const b8: rs.u8 = _223; return text(rs.byteSliceFrom(Uint8Array.of(b8, rs.u8Div(b8, 16)))); }), undefined, 12, true); rs.sliceSort(rs.sliceFrom(names3.items), rs.cmpLt(rs.cmpStr), 12, true); for (const _263 of names3.items) { - put(out, _263); + put(out, _263.v); } } else if (_8 === 3) { const v6: rs.Vec = rs.vecFrom(words.items.slice()); @@ -249,7 +249,7 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const changed: rs.Vec = rs.vecFrom(named2.items.map(Named.clone$Clone)); const _411: Named.Named | undefined = rs.sliceFirst(rs.sliceFrom(changed.items)); if (_411 !== undefined) { - _411.name = _411.name + "!"; + rs.stringPush(_411.name, 33); } rs.byteVecPush(out, rs.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); rs.byteVecPush(out, !rs.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); @@ -268,12 +268,14 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.vecFrom(a02.items.slice()); })); rs.byteVecPush(out, rs.eqSlice(rs.eqSlice(rs.same))(_453, nested) ? 1 : 0); - const pair: [string, rs.u8] = [text(data), at(0)]; - const copy: [string, rs.u8] = rs.tupleClone(pair, [undefined, undefined]); - put(out, copy[0]); - const _470: [rs.u8, string] = [copy[1], copy[0]]; - const _474: [rs.u8, string] = [at(1), pair[0]]; - rs.byteVecPush(out, rs.cmpTuple<[rs.u8, string], rs.Ordering | undefined>([rs.cmp, rs.cmpStr])(_470, _474) === 1 ? 1 : 0); + const pair: [rs.String, rs.u8] = [text(data), at(0)]; + const copy: [rs.String, rs.u8] = rs.tupleClone(pair, [(a03: rs.String): rs.String => { + return rs.stringClone(a03); + }, undefined]); + put(out, copy[0].v); + const _470: [rs.u8, rs.String] = [copy[1], copy[0]]; + const _474: [rs.u8, rs.String] = [at(1), pair[0]]; + rs.byteVecPush(out, rs.cmpTuple<[rs.u8, rs.String], rs.Ordering | undefined>([rs.cmp, rs.cmpStr])(_470, _474) === 1 ? 1 : 0); const _483: [rs.u8, rs.u8] = [at(0), at(1)]; const _491: [rs.u8, rs.u8] = [at(1), at(0)]; rs.byteVecPush(out, rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])(_483, _491) === -1 ? 1 : 0); @@ -288,7 +290,7 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { tally = default_; rs.byteVecPush(out, taken3.n); rs.byteVecPush(out, tally.n); - put(out, tally.names.items[rs.idx(tally.names.items, 0)]); + put(out, tally.names.items[rs.idx(tally.names.items, 0)].v); let queue: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(words.items), undefined, 2, true), 2) as rs.VecDeque; const default_2 = rs.dequeNew(2) as rs.VecDeque; const taken4 = queue; @@ -337,9 +339,9 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, v7.items.length === 0 ? 1 : 0); const boxed: Named.Named = removed; const copy2: Named.Named = Named.clone$Clone(boxed); - copy2.name = copy2.name + "!"; - put(out, boxed.name); - put(out, copy2.name); + rs.stringPush(copy2.name, 33); + put(out, boxed.name.v); + put(out, copy2.name.v); const held: Named.Named | undefined = filter$184yuq2(boxed, (_27: Named.Named): boolean => { return rs.u8Rem(at(3), 2) === 0; }); @@ -370,50 +372,50 @@ export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _764: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(at(5))); rs.idx(_764, 0); rs.byteVecPush(out, _764.data[_764.start]); - const part6 = rs.fromUtf8ErrorClone(rs.resultUnwrapErr(rs.stringFromUtf8(rs.byteVecFrom(Uint8Array.of(97, 255, at(6)))), rs.fmtStr)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(part6, f)])); + const part6 = rs.fromUtf8ErrorClone(rs.resultUnwrapErr(rs.stringFromUtf8(rs.byteVecFrom(Uint8Array.of(97, 255, at(6)))), (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(part6, f)]).v); rs.byteVecPush(out, 16 & 0xff); rs.byteVecPush(out, 16 & 0xff); rs.byteVecPush(out, 4 & 0xff); rs.byteVecPush(out, 6 & 0xff); rs.byteVecPush(out, rs.u8Mul(4 & 0xff, 1 & 0xff)); } else { - const s2: string = text(data); + const s2: rs.String = text(data); const sep: rs.char[] = [47, 97]; - rs.byteVecPush(out, rs.strContains(s2, rs.patternChars(sep)) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s2, rs.patternChars(sep)) ? 1 : 0); - rs.byteVecPush(out, rs.iterCount(rs.strSplit(s2, rs.patternChars(sep))) & 0xff); - rs.byteVecPush(out, rs.strEndsWith(s2, "/") ? 1 : 0); - rs.byteVecPush(out, rs.strEndsWith(s2, "😀") ? 1 : 0); - rs.byteVecPush(out, rs.strEndsWith(s2, (c: rs.char): boolean => { + rs.byteVecPush(out, rs.strContains(s2.v, rs.patternChars(sep)) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s2.v, rs.patternChars(sep)) ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.strSplit(s2.v, rs.patternChars(sep))) & 0xff); + rs.byteVecPush(out, rs.strEndsWith(s2.v, "/") ? 1 : 0); + rs.byteVecPush(out, rs.strEndsWith(s2.v, "😀") ? 1 : 0); + rs.byteVecPush(out, rs.strEndsWith(s2.v, (c: rs.char): boolean => { return rs.isAsciiDigit(c); }) ? 1 : 0); - const _848: [string, string] | undefined = rs.strSplitOnce(s2, "/"); + const _848: [string, string] | undefined = rs.strSplitOnce(s2.v, "/"); if (_848 === undefined) { rs.byteVecPush(out, 253); } else { put(out, _848[0]); put(out, _848[1]); } - const _857: [string, string] | undefined = rs.strSplitOnce(s2, "a0"); + const _857: [string, string] | undefined = rs.strSplitOnce(s2.v, "a0"); if (_857 === undefined) { rs.byteVecPush(out, 253); } else { put(out, _857[0]); put(out, _857[1]); } - const iter11: rs.RangeInclusive = new rs.RangeInclusive(0, rs.usizeAdd(rs.stringLen(s2), 1), rs.usizeStep); + const iter11: rs.RangeInclusive = new rs.RangeInclusive(0, rs.usizeAdd(s2.len, 1), rs.usizeStep); while (true) { const _872: rs.usize | rs.Done = iter11.next(); if (_872 === rs.DONE) { break; } - rs.byteVecPush(out, rs.strIsCharBoundary(s2, _872) ? 1 : 0); + rs.byteVecPush(out, rs.strIsCharBoundary(s2.v, _872) ? 1 : 0); } - rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); - rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.strBytes(s2)), 3), undefined, true); - rs.byteVecPush(out, rs.strBytes(s2).len() & 0xff); - rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.strBytes(s2), (_22: rs.u8): boolean => { + rs.iterExtendBytes(out, rs.strBytes(s2.v), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.strBytes(s2.v)), 3), undefined, true); + rs.byteVecPush(out, rs.strBytes(s2.v).len() & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.strBytes(s2.v), (_22: rs.u8): boolean => { return _22 >= 128; })) & 0xff); } @@ -610,41 +612,37 @@ export function apply$Option_u8_u8_Option_u8_Option_T_replace_u8(_: (a0: rs.Plac } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_String_String_mem_replace_String(_: (a0: rs.Place, a1: string) => string, place: rs.Place, value: string): string { - return ((a0: rs.Place, a1: string): string => { - const old = a0.v; - a0.v = a1; - return old; +export function apply$String_String_String_mem_replace_String(_: (a0: rs.String, a1: rs.String) => rs.String, place: rs.String, value: rs.String): rs.String { + return ((a0: rs.String, a1: rs.String): rs.String => { + return rs.replaceIn(a0, a1); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_char_unit_String_push(_: (a0: rs.Place, a1: rs.char) => undefined, place: rs.Place, value: rs.char): void { - ((a0: rs.Place, a1: rs.char): undefined => { - a0.v = a0.v + String.fromCodePoint(a1); +export function apply$String_char_unit_String_push(_: (a0: rs.String, a1: rs.char) => undefined, place: rs.String, value: rs.char): void { + ((a0: rs.String, a1: rs.char): undefined => { + rs.stringPush(a0, a1); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_mut_String_unit_mem_swap_String(_: (a0: rs.Place, a1: rs.Place) => undefined, place: rs.Place, value: rs.Place): void { - ((a0: rs.Place, a1: rs.Place): undefined => { - const swapped = a0.v; - a0.v = a1.v; - a1.v = swapped; +export function apply$String_mut_String_unit_mem_swap_String(_: (a0: rs.String, a1: rs.String) => undefined, place: rs.String, value: rs.String): void { + ((a0: rs.String, a1: rs.String): undefined => { + Object.assign(a0, rs.replaceIn(a1, a0)); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_ref_String_unit_Clone_clone_from_String(_: (a0: rs.Place, a1: string) => undefined, place: rs.Place, value: string): void { - ((a0: rs.Place, a1: string): undefined => { - a0.v = a1; +export function apply$String_ref_String_unit_Clone_clone_from_String(_: (a0: rs.String, a1: rs.String) => undefined, place: rs.String, value: rs.String): void { + ((a0: rs.String, a1: rs.String): undefined => { + Object.assign(a0, rs.stringCloneFrom(a0, a1)); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_ref_str_unit_String_push_str(_: (a0: rs.Place, a1: string) => undefined, place: rs.Place, value: string): void { - ((a0: rs.Place, a1: string): undefined => { - a0.v = a0.v + a1; +export function apply$String_ref_str_unit_String_push_str(_: (a0: rs.String, a1: string) => undefined, place: rs.String, value: string): void { + ((a0: rs.String, a1: string): undefined => { + rs.stringPushStr(a0, a1); })(place, value); } @@ -714,15 +712,13 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), (n3: rs.usize): rs.u8 => { return n3 & 0xff; }), undefined, true); - const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): string => { + const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_210))); }), undefined, 12, true); - put(out, rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSliceMut(rs.sliceFrom(texts.items))), (a024: rs.Place): string => { - const taken9 = a024.v; - a024.v = ""; - return taken9; - }), undefined, 12, true).items, "")); - put(out, rs.strsJoin(texts.items, "")); + put(out, rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(texts.items)), (a024: rs.String): rs.String => { + return rs.replaceIn(a024, rs.stringNew()); + }), undefined, 12, true).items, "").v); + put(out, rs.strsJoin(texts.items, "").v); } else if (_5 === 1) { let n: rs.u8 = at(0); const _66: rs.u8 = at(1); @@ -740,14 +736,12 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _75: rs.u8 = at(2); rs.byteVecPush(out, replace(rs.place(() => n, (value4) => n = value4), _75)); rs.byteVecPush(out, n); - let s: string = text(data); - const _83: string = text(rs.byteSliceFrom(Uint8Array.of(at(0)))); - put(out, apply$String_String_String_mem_replace_String((a010: rs.Place, a19: string): string => { - const old8 = a010.v; - a010.v = a19; - return old8; - }, rs.place(() => s, (value5) => s = value5), _83)); - put(out, s); + const s: rs.String = text(data); + const _83: rs.String = text(rs.byteSliceFrom(Uint8Array.of(at(0)))); + put(out, apply$String_String_String_mem_replace_String((a010: rs.String, a19: rs.String): rs.String => { + return rs.replaceIn(a010, a19); + }, s, _83).v); + put(out, s.v); const v: rs.ByteVec = rs.byteSliceToByteVec(data); const old2: rs.ByteVec = ((a011: rs.ByteVec): rs.ByteVec => { return rs.replaceIn(a011, new rs.ByteVec()); @@ -760,20 +754,20 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const old9 = a012.v; a012.v = a110; return old9; - }, rs.place(() => held2, (value6) => held2 = value6), _121)), undefined, true); + }, rs.place(() => held2, (value5) => held2 = value5), _121)), undefined, true); rs.iterExtendBytes(out, rs.iterOption(held2), undefined, true); - apply$String_ref_str_unit_String_push_str((a013: rs.Place, a111: string): undefined => { - a013.v = a013.v + a111; - }, rs.place(() => s, (value7) => s = value7), "+"); - apply$String_char_unit_String_push((a014: rs.Place, a112: rs.char): undefined => { - a014.v = a014.v + String.fromCodePoint(a112); - }, rs.place(() => s, (value8) => s = value8), 33); + apply$String_ref_str_unit_String_push_str((a013: rs.String, a111: string): undefined => { + rs.stringPushStr(a013, a111); + }, s, "+"); + apply$String_char_unit_String_push((a014: rs.String, a112: rs.char): undefined => { + rs.stringPush(a014, a112); + }, s, 33); const _136: rs.usize = old2.length; - const _134: string = rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_136, f)); - apply$String_ref_String_unit_Clone_clone_from_String((a015: rs.Place, a113: string): undefined => { - a015.v = a113; - }, rs.place(() => s, (value9) => s = value9), _134); - put(out, s); + const _134: rs.String = rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_136, f), 0); + apply$String_ref_String_unit_Clone_clone_from_String((a015: rs.String, a113: rs.String): undefined => { + Object.assign(a015, rs.stringCloneFrom(a015, a113)); + }, s, _134); + put(out, s.v); const bytes2: rs.ByteVec = rs.byteSliceToByteVec(data); rs.iterForEach(rs.iterSliceMut(rs.byteVecSlice(bytes2)), (a016: rs.Place): undefined => { a016.v = rs.toAsciiUppercase(a016.v); @@ -823,22 +817,20 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { })(x, y); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(x)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(y)); - const texts2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): string => { + const texts2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(_22))); }), undefined, 12, true); - const others: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_26: rs.u8): string => { + const others: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_26: rs.u8): rs.String => { const b6: rs.u8 = _26; return text(rs.byteSliceFrom(Uint8Array.of(b6, b6))); }), undefined, 12, true); - rs.iterForEach(rs.iterZip(rs.iterSliceMut(rs.sliceFrom(texts2.items)), rs.iterSliceMut(rs.sliceFrom(others.items)), [false, false]), (_27: [rs.Place, rs.Place]): undefined => { - apply$String_mut_String_unit_mem_swap_String((a07: rs.Place, a16: rs.Place): undefined => { - const swapped4 = a07.v; - a07.v = a16.v; - a16.v = swapped4; + rs.iterForEach(rs.iterZip(rs.iterSlice(texts2.items), rs.iterSlice(others.items), [false, false]), (_27: [rs.String, rs.String]): undefined => { + apply$String_mut_String_unit_mem_swap_String((a07: rs.String, a16: rs.String): undefined => { + Object.assign(a07, rs.replaceIn(a16, a07)); }, _27[0], _27[1]); }); - put(out, rs.strsJoin(texts2.items, "")); - put(out, rs.strsJoin(others.items, "")); + put(out, rs.strsJoin(texts2.items, "").v); + put(out, rs.strsJoin(others.items, "").v); } else { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { @@ -1076,11 +1068,11 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void break; } const i: rs.usize = _224[0]; - _224[1].name = _224[1].name + "!"; + rs.stringPush(_224[1].name, 33); _224[1].id = rs.u16Add(_224[1].id, i & 0xffff); } for (const _236 of v3.items) { - put(out, _236.name); + put(out, _236.name.v); rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_236.id)), undefined, true); } const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_226: rs.u8): rs.u16[] => { @@ -1301,7 +1293,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_715 === rs.DONE) { break; } - _715.name = _715.name + "+"; + rs.stringPush(_715.name, 43); } const iter13: rs.Iter = rs.dequeIter(named); while (true) { @@ -1309,7 +1301,7 @@ export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_724 === rs.DONE) { break; } - put(out, _724.name); + put(out, _724.name.v); } const bytes2: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), 1, true) as rs.VecDeque; const _735: rs.Place | rs.Done = rs.dequeRangeMut(bytes2, undefined).next(); @@ -1595,7 +1587,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 3; while (iterStart2++ < iterEnd2) { - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecExtractIf(it2, f, rs.u16Debug)])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecExtractIf(it2, f, rs.u16Debug)]).v))), undefined, true); it2.next(); } rs.drop(it2); @@ -1607,7 +1599,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return { id: b12 as rs.u16, name: text(rs.byteSliceFrom(Uint8Array.of(b12))) }; }), undefined, 16, true); const taken: rs.Vec = rs.iterToVec(rs.vecExtractIf(named2, undefined, (n9: Named.Named): boolean => { - n9.name = n9.name + "+"; + rs.stringPush(n9.name, 43); return rs.u16Rem(n9.id, 2) === 0; }), "next", 16); const iter4: rs.Iter = rs.iterChain(rs.iterSlice(named2.items), rs.iterSlice(taken.items)); @@ -1616,7 +1608,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_130 === rs.DONE) { break; } - put(out, _130.name); + put(out, _130.name.v); } const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const _140: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(data.length, 1)), rs.usizeStep); @@ -1626,7 +1618,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }); const first: rs.u8 | undefined = rs.iterToOption(it3.next()); const args27 = [(f: rs.Formatter) => rs.fmtVecExtractIf(it3, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args27[0], args27[1]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args27[0], args27[1]]).v))), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(it3, "next"))); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); rs.vecExtractIfMut(w, undefined, (x2: rs.Place): boolean => { @@ -1716,7 +1708,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const s: rs.Iter = rs.spliceFrom(rs.vecSplice(pairs, r4, 4), _337, true); const first3: rs.u16[] | undefined = rs.iterToOption(s.next()); const args23 = [(f: rs.Formatter) => rs.fmtVecSplice(s, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))), (f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug))]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args23[0], args23[1]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args23[0], args23[1]]).v))), undefined, true); const removed: rs.Vec = rs.iterToVec(rs.iterChain(rs.iterOption(copy$Option_array2_u16(first3)), s), "next", 4); const iter5: rs.Iter<[rs.usize, rs.Slice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(pairs.items), rs.sliceFrom)); while (true) { @@ -1746,7 +1738,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }); const s2: rs.Iter = rs.spliceFrom(rs.byteVecSplice(bytes2, r5), _409); const back: rs.u8 | undefined = rs.iterToOption(s2.nextBack()); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecSplice(s2, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtCounted(value, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecSplice(s2, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtCounted(value, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]).v))), undefined, true); rs.drop(s2); rs.iterExtendBytes(out, rs.iterOption(back), undefined, true); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes2)); @@ -1754,7 +1746,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _453: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at(10) as rs.usize, rs.usizeAdd(tail.length, 1)), rs.usizeStep); const _454: Uint8Array = Uint8Array.of(170, 187); const s3: rs.Iter = rs.spliceFrom(rs.byteVecSplice(tail, _453), rs.iterSlice(_454), true); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecSplice(s3, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"]))])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtVecSplice(s3, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"]))]).v))), undefined, true); rs.iterExtendBytes(out, rs.iterRev(s3), "next"); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(tail)); const hints: rs.RefCell = new rs.RefCell(new rs.ByteVec()); @@ -1822,10 +1814,10 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_607 === rs.DONE) { break; } - _607.name = _607.name + "!"; + rs.stringPush(_607.name, 33); } for (const _616 of flat3.items) { - put(out, _616.name); + put(out, _616.name.v); } const flat4: rs.ByteVec = rs.byteVecIntoFlattened(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c3: rs.ByteSlice): Uint8Array => { rs.idx(c3, 0); @@ -1869,9 +1861,9 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return new Tracked.Tracked(t3.id, 9, t3.log); }, Tracked.cmp$cmp_Ord, rs.drop); mark(240); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(found, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(found, f, rs.usizeDebug, rs.usizeDebug)]).v))), undefined, true); const part3 = rs.dequeBinarySearch(q, probe, Tracked.cmp$cmp_Ord); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part3, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part3, f, rs.usizeDebug, rs.usizeDebug)]).v))), undefined, true); rs.byteVecPush(out, rs.dequePartitionPoint(q, (t4: Tracked.Tracked): boolean => { return t4.id < probe.id; }) & 0xff); @@ -1969,12 +1961,12 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const part = rs.dequeBinarySearchBy(named4, (n5: Named.Named): rs.Ordering => { return rs.cmp(n5.id, probe2); }); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); - const _947: string = text(rs.byteSliceFrom(Uint8Array.of(at(3)))); - const found4: rs.Result = rs.dequeBinarySearchByKey(named4, _947, (n6: Named.Named): string => { - return n6.name; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part, f, rs.usizeDebug, rs.usizeDebug)]).v))), undefined, true); + const _947: rs.String = text(rs.byteSliceFrom(Uint8Array.of(at(3)))); + const found4: rs.Result = rs.dequeBinarySearchByKey(named4, _947, (n6: Named.Named): rs.String => { + return rs.stringClone(n6.name); }, rs.cmpStr); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(found4, f, rs.usizeDebug, rs.usizeDebug)])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(found4, f, rs.usizeDebug, rs.usizeDebug)]).v))), undefined, true); rs.byteVecPush(out, rs.dequePartitionPoint(named4, (n7: Named.Named): boolean => { return n7.id <= probe2; }) & 0xff); @@ -1985,7 +1977,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } const _974: Named.Named | undefined = rs.dequeGet(named4, i4); if (_974 !== undefined) { - _974.name = _974.name + "?"; + rs.stringPush(_974.name, 63); } const iter15: rs.Iter = rs.dequeIter(named4); while (true) { @@ -1993,7 +1985,7 @@ export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void if (_984 === rs.DONE) { break; } - put(out, _984.name); + put(out, _984.name.v); } } } diff --git a/ts/fixtures/lang/edits/expected/harness.ts b/ts/fixtures/lang/edits/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/edits/expected/harness.ts +++ b/ts/fixtures/lang/edits/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/errors/expected/core/result.ts b/ts/fixtures/lang/errors/expected/core/result.ts index cb538e3b5..8d434615d 100644 --- a/ts/fixtures/lang/errors/expected/core/result.ts +++ b/ts/fixtures/lang/errors/expected/core/result.ts @@ -31,12 +31,12 @@ export function eq$1amzj8d(self: rs.Result return str_error_eq$1lr55px(self.error, (other as { ok: false; error: rs.ParseBoolError }).error); } -export function eq$1357wj0(self: rs.Result, other: rs.Result): boolean { +export function eq$1h622n4(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: string }).value; + return rs.eqStr(self.value, (other as { ok: true; value: rs.String }).value); } return string_eq$1enuhj8(self.error, (other as { ok: false; error: rs.FromUtf8Error }).error); } @@ -240,9 +240,9 @@ export function map$07r5pce(self: rs.Result, op: (a0: r return self as rs.Result; } -export function mapErr$1scmdah(self: rs.Result>, op: (a0: rs.Result) => rs.Result): rs.Result> { +export function mapErr$1102tun(self: rs.Result>, op: (a0: rs.Result) => rs.Result): rs.Result> { if (self.ok) { - return self as rs.Result>; + return self as rs.Result>; } return rs.Err(op(self.error)); } @@ -254,9 +254,9 @@ export function mapErr$0ka0di9(self: rs.Result, op: (a0: Err return rs.Err(op(self.error)); } -export function mapErr$1a5uolr(self: rs.Result, op: (a0: Error.Error) => string): rs.Result { +export function mapErr$1lqaapp(self: rs.Result, op: (a0: Error.Error) => rs.String): rs.Result { if (self.ok) { - return self as rs.Result; + return self as rs.Result; } return rs.Err(op(self.error)); } diff --git a/ts/fixtures/lang/errors/expected/errors.ts b/ts/fixtures/lang/errors/expected/errors.ts index a9ead37f7..67c7a4044 100644 --- a/ts/fixtures/lang/errors/expected/errors.ts +++ b/ts/fixtures/lang/errors/expected/errors.ts @@ -8,7 +8,7 @@ import type * as Error from "./core/error.Error.ts"; import { fromStr$1t58fis as num_fromStr$1t58fis } from "./core/num.ts"; import { eq$1uroq6x as num_error_eq$1uroq6x } from "./core/num/error.ts"; import { map$1hw1osb as option_map$1hw1osb, map$0jqf1o0 as option_map$0jqf1o0, map$0p4jgzx as option_map$0p4jgzx } from "./core/option.ts"; -import { eq$0ypn0py as result_eq$0ypn0py, eq$1amzj8d as result_eq$1amzj8d, eq$1357wj0 as result_eq$1357wj0, eq$0q0qbov as result_eq$0q0qbov, eq$1w4olsu as result_eq$1w4olsu, eq$1nt6phd as result_eq$1nt6phd, eq$0y6o605 as result_eq$0y6o605, eq$1ow2tmy as result_eq$1ow2tmy, eq$17fo3dq as result_eq$17fo3dq, eq$0trkzzw as result_eq$0trkzzw, eq$1fss0tv as result_eq$1fss0tv, eq$0rz6big as result_eq$0rz6big, eq$06v73px as result_eq$06v73px, eq$096f56j as result_eq$096f56j, eq$031vf96 as result_eq$031vf96, eq$1qyqhny as result_eq$1qyqhny, eq$0hvarbg as result_eq$0hvarbg, eq$03c8d7v as result_eq$03c8d7v, err$11tr79p, err$0bvotqj, err$1tv7qwu, err$069ojhs, map$1w6ihbb as result_map$1w6ihbb, map$18dk705 as result_map$18dk705, map$07r5pce as result_map$07r5pce, mapErr$1scmdah as result_mapErr$1scmdah, mapErr$0ka0di9 as result_mapErr$0ka0di9, mapErr$1a5uolr as result_mapErr$1a5uolr, mapErr$09oysgi as result_mapErr$09oysgi, mapErr$1xpyw31 as result_mapErr$1xpyw31, clone$0688qis as result_clone$0688qis } from "./core/result.ts"; +import { eq$0ypn0py as result_eq$0ypn0py, eq$1amzj8d as result_eq$1amzj8d, eq$1h622n4 as result_eq$1h622n4, eq$0q0qbov as result_eq$0q0qbov, eq$1w4olsu as result_eq$1w4olsu, eq$1nt6phd as result_eq$1nt6phd, eq$0y6o605 as result_eq$0y6o605, eq$1ow2tmy as result_eq$1ow2tmy, eq$17fo3dq as result_eq$17fo3dq, eq$0trkzzw as result_eq$0trkzzw, eq$1fss0tv as result_eq$1fss0tv, eq$0rz6big as result_eq$0rz6big, eq$06v73px as result_eq$06v73px, eq$096f56j as result_eq$096f56j, eq$031vf96 as result_eq$031vf96, eq$1qyqhny as result_eq$1qyqhny, eq$0hvarbg as result_eq$0hvarbg, eq$03c8d7v as result_eq$03c8d7v, err$11tr79p, err$0bvotqj, err$1tv7qwu, err$069ojhs, map$1w6ihbb as result_map$1w6ihbb, map$18dk705 as result_map$18dk705, map$07r5pce as result_map$07r5pce, mapErr$1102tun as result_mapErr$1102tun, mapErr$0ka0di9 as result_mapErr$0ka0di9, mapErr$1lqaapp as result_mapErr$1lqaapp, mapErr$09oysgi as result_mapErr$09oysgi, mapErr$1xpyw31 as result_mapErr$1xpyw31, clone$0688qis as result_clone$0688qis } from "./core/result.ts"; import { parse$1yfzdza, parse$1kyj9pm, parse$02m1946, parse$04z9euf, parse$092epd5, parse$1brosjp } from "./core/str.ts"; import { eq$1lr55px as str_error_eq$1lr55px } from "./core/str/error.ts"; import type * as Coded from "./errors.Coded.ts"; @@ -67,17 +67,17 @@ export function pairs$Result_Result_char_char_ParseCharError_str_ParseBoolError( } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_String_string_FromUtf8Error(values: rs.Slice>, out: rs.ByteVec): void { +export function pairs$Result_String_string_FromUtf8Error(values: rs.Slice>, out: rs.ByteVec): void { l1: for (const a of rs.sliceItems(values)) { - const iterS2: rs.Result[] = rs.sliceItems(values); + const iterS2: rs.Result[] = rs.sliceItems(values); let iterI2: number = 0; while (true) { - const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; if (_11 === rs.DONE) { continue l1; } - const b: rs.Result = _11; - rs.byteVecPush(out, (result_eq$1357wj0(a, b) ? 1 : 0) | (((!result_eq$1357wj0(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1h622n4(a, b) ? 1 : 0) | (((!result_eq$1h622n4(a, b) ? 1 : 0) << 1) & 0xff)); } } } @@ -471,15 +471,15 @@ export function parsed$u8(all: rs.Slice): rs.Vec = rs.sliceFrom([48, 49, 50, 53, 57, 43, 45, 46, 101, 97, 98, 78, 116, 102, 233]); const _15: rs.usize = rs.usizeRem(b as rs.usize, rs.sliceFrom([48, 49, 50, 53, 57, 43, 45, 46, 101, 97, 98, 78, 116, 102, 233]).length); rs.idx(_14, _15); - input = input + String.fromCodePoint(_14.data[_14.start + _15]); + rs.stringPush(input, _14.data[_14.start + _15]); } const all: rs.Vec = rs.vecFrom(["", "0", "-0", "1", "-1", "+", "a", "ab", "😀", "true", "false", "127", "128", "-128", "-129", "256", "18446744073709551615", "18446744073709551616", "-170141183460469231731687303715884105729", "1.5", "1e400", "NaN", "inf"].slice()); - all.items.push(input); + all.items.push(input.v); const bytes: rs.Vec = rs.vecFrom([rs.byteSliceFrom(Uint8Array.of()), rs.byteSliceFrom(Uint8Array.of(97)), rs.byteSliceFrom(Uint8Array.of(255)), rs.byteSliceFrom(Uint8Array.of(97, 255)), rs.byteSliceFrom(Uint8Array.of(195)), rs.byteSliceFrom(Uint8Array.of(97, 195)), rs.byteSliceFrom(Uint8Array.of(224, 128)), rs.byteSliceFrom(Uint8Array.of(240, 159, 152)), rs.byteSliceFrom(Uint8Array.of(240, 159, 152, 128)), rs.byteSliceFrom(Uint8Array.of(237, 160, 128))].slice()); bytes.items.push(data); const _32: rs.u8 = rs.u8Rem(kind, 16); @@ -513,7 +513,7 @@ export function eqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return rs.strFromUtf8(b7); }), undefined, 12, true).items), out); } else if (_32 === 10) { - pairs$Result_String_string_FromUtf8Error(rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(bytes.items), (b6: rs.ByteSlice): rs.Result => { + pairs$Result_String_string_FromUtf8Error(rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(bytes.items), (b6: rs.ByteSlice): rs.Result => { return rs.stringFromUtf8(rs.byteSliceToByteVec(b6)); }), undefined, 20, true).items), out); } else if (_32 === 11) { @@ -561,8 +561,8 @@ export function eqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { n = b2 as rs.usize; } - const text: string = rs.strSlice("ab", 0, rs.u8Rem(b2, 3) as rs.usize); - return [rs.byteVecTryReserve(new rs.ByteVec(), n), rs.stringTryReserve(text, n), rs.dequeTryReserve(rs.dequeNew(2) as rs.VecDeque, n), rs.hashTryReserve(rs.hashNew() as rs.HashSet, n, 469762048)]; + const text: rs.String = rs.stringFrom(rs.strSlice("ab", 0, rs.u8Rem(b2, 3) as rs.usize)); + return [rs.byteVecTryReserve(new rs.ByteVec(), n), rs.stringTryReserveExact(text, n), rs.dequeTryReserve(rs.dequeNew(2) as rs.VecDeque, n), rs.hashTryReserve(rs.hashNew() as rs.HashSet, n, 469762048)]; }, (value: rs.Result[]) => rs.iterSlice(value), true, 4), undefined, 8, true); pairs$collections_TryReserveError(rs.sliceFrom(rs.iterToVec(rs.iterFilterMap(rs.iterSlice(v7.items), (r: rs.Result): rs.TryReserveError | undefined => { return err$069ojhs(result_clone$0688qis(r)); @@ -598,16 +598,16 @@ export function DROPPED$init(): rs.Cell { } /** Each error in the chain, by `Display` and `Debug`. */ -export function chain(e: Error.Error): string { +export function chain(e: Error.Error): rs.String { const args5 = [(f: rs.Formatter) => e.fmt$Display(f), (f: rs.Formatter) => e.fmt$Debug(f)]; - let s: string = rs.fmtFormat([args5[0], " ", args5[1]]); + const s: rs.String = rs.fmtFormat([args5[0], " ", args5[1]]); let cur: Error.Error | undefined = e.source$Error(); while (true) { if (cur !== undefined) { const c: Error.Error = cur; const args6 = [(f: rs.Formatter) => c.fmt$Display(f), (f: rs.Formatter) => c.fmt$Debug(f)]; - const _17: string = rs.fmtFormat([" <- ", args6[0], " ", args6[1]]); - s = s + _17; + const _17: string = rs.fmtFormat([" <- ", args6[0], " ", args6[1]]).v; + rs.stringPushStr(s, _17); cur = c.source$Error(); } else { return s; @@ -634,7 +634,7 @@ export function failure(kind: rs.u8, n: rs.u8): Failure.Failure { export function checked(kind: rs.u8, n: rs.u8): rs.Result { if (!(rs.u8Rem(n, 4) === 0)) { const args3 = [(f: rs.Formatter) => rs.u8Display(n, f)]; - const _8: rs.Result = result_mapErr$09oysgi(num_fromStr$1t58fis(rs.fmtFormat([args3[0], args3[0]])), (a0: rs.ParseIntError): Failure.Failure => { + const _8: rs.Result = result_mapErr$09oysgi(num_fromStr$1t58fis(rs.fmtFormat([args3[0], args3[0]]).v), (a0: rs.ParseIntError): Failure.Failure => { return { tag: "Parse", _0: a0 }; }); if (_8.ok) { @@ -661,36 +661,36 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const a: rs.u8 = _10[0]; const b: rs.u8 = _10[1]; const _24: Failure.Failure = failure(a, b); - const _21: string = chain(new of$errors_Failure(_24)); + const _21: rs.String = chain(new of$errors_Failure(_24)); const _29: Leaf.Leaf = new Leaf.Leaf(a); - const _26: string = chain(new of$errors_Leaf(_29)); - const args41 = [(f: rs.Formatter) => rs.fmtPad(f, _21), (f: rs.Formatter) => rs.fmtPad(f, _26)]; - const _17: string = rs.fmtFormat([args41[0], " | ", args41[1], " | "]); + const _26: rs.String = chain(new of$errors_Leaf(_29)); + const args41 = [(f: rs.Formatter) => rs.fmtPad(f, _21.v), (f: rs.Formatter) => rs.fmtPad(f, _26.v)]; + const _17: rs.String = rs.fmtFormat([args41[0], " | ", args41[1], " | "]); _29[Symbol.dispose](); drop$errors_Failure(_24); - put(out, _17); + put(out, _17.v); const part = chain(new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part), " | "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part.v), " | "]).v); const reserved: Error.Error = rs.resultUnwrapErr(reserve(a), rs.fmtUnit); - const _63: string = chain(reserved); + const _63: rs.String = chain(reserved); const _66: boolean = reserved instanceof of$collections_TryReserveError || reserved instanceof ofPlace$collections_TryReserveError; - const args43 = [(f: rs.Formatter) => rs.fmtPad(f, _63), (f: rs.Formatter) => reserved.fmt$Debug(f), (f: rs.Formatter) => rs.fmtBool(_66, f)]; - put(out, rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[1]), " ", args43[2], " | "])); + const args43 = [(f: rs.Formatter) => rs.fmtPad(f, _63.v), (f: rs.Formatter) => reserved.fmt$Debug(f), (f: rs.Formatter) => rs.fmtBool(_66, f)]; + put(out, rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[1]), " ", args43[2], " | "]).v); const held: Failure.Failure = failure(a, b); - const _86: string = chain(new of$boxed_Box_errors_Failure(held)); - const _90: string = chain(new of$ref_errors_Failure(held)); - const args44 = [(f: rs.Formatter) => rs.fmtPad(f, _86), (f: rs.Formatter) => rs.fmtPad(f, _90)]; - put(out, rs.fmtFormat([args44[0], " | ", args44[1], " | "])); + const _86: rs.String = chain(new of$boxed_Box_errors_Failure(held)); + const _90: rs.String = chain(new of$ref_errors_Failure(held)); + const args44 = [(f: rs.Formatter) => rs.fmtPad(f, _86.v), (f: rs.Formatter) => rs.fmtPad(f, _90.v)]; + put(out, rs.fmtFormat([args44[0], " | ", args44[1], " | "]).v); const coded: Coded.Coded = new of$errors_Failure(failure(b, a)); const up: Error.Error = coded; const _111: rs.u8 = coded.code$Coded(); - const _114: string = chain(up); - const args45 = [(f: rs.Formatter) => rs.u8Display(_111, f), (f: rs.Formatter) => rs.fmtPad(f, _114)]; - put(out, rs.fmtFormat([args45[0], " ", args45[1], " | "])); + const _114: rs.String = chain(up); + const args45 = [(f: rs.Formatter) => rs.u8Display(_111, f), (f: rs.Formatter) => rs.fmtPad(f, _114.v)]; + put(out, rs.fmtFormat([args45[0], " ", args45[1], " | "]).v); const boxed: Transported.Transported = new Transported.Transported(coded); - const _129: string = chain(new of$errors_Transported(boxed)); - const args46 = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; - put(out, rs.fmtFormat([args46[0], " ", rs.fmtSpec({ alternate: true }, args46[1]), " | "])); + const _129: rs.String = chain(new of$errors_Transported(boxed)); + const args46 = [(f: rs.Formatter) => rs.fmtPad(f, _129.v), (f: rs.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; + put(out, rs.fmtFormat([args46[0], " ", rs.fmtSpec({ alternate: true }, args46[1]), " | "]).v); set$1ljkjlf(DROPPED, 0); const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): rs.Result => { const n: rs.u8 = _2; @@ -699,33 +699,33 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number for (const _149 of results.items) { if (_149.ok) { const arg = _149.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f), " "]).v); } else { const part2 = chain(_149.error); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part2), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part2.v), " "]).v); } } rs.dropVec(results, drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send); const part3 = get$0q7640n(DROPPED); - put(out, rs.fmtFormat(["| ", (f: rs.Formatter) => rs.u32Display(part3, f), " "])); + put(out, rs.fmtFormat(["| ", (f: rs.Formatter) => rs.u32Display(part3, f), " "]).v); set$1ljkjlf(DROPPED, 0); const leaf: Leaf.Leaf = new Leaf.Leaf(b); const borrowed: Error.Error = new of$ref_errors_Leaf(leaf); const part4 = chain(borrowed); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part4), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part4.v), " "]).v); rs.drop(borrowed); const part5 = get$0q7640n(DROPPED); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part5, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part5, f), " "]).v); leaf[Symbol.dispose](); const part6 = get$0q7640n(DROPPED); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part6, f), " | "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part6, f), " | "]).v); const coded2: Coded.Coded = new of$errors_Failure(failure(a, b)); const part7 = downcast(coded2); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part7), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part7.v), " "]).v); const errors: rs.Vec = rs.vecFrom([coded2, new of$errors_Leaf(new Leaf.Leaf(a)), new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))]); for (const _277 of errors.items) { const part8 = downcast(_277); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part8), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, part8.v), " "]).v); } const leaf2: Leaf.Leaf = new Leaf.Leaf(a); const e: Error.Error = new of$errors_Leaf(leaf2); @@ -734,7 +734,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number _298.code = rs.u8WrappingAdd(_298.code, b); } const arg2 = leaf2.code; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg2, f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg2, f), " "]).v); set$1ljkjlf(DROPPED, 0); for (const e2 of errors.items) { const _324: rs.Result = e2 instanceof of$errors_Failure ? rs.Ok(e2.v) : rs.Err(e2); @@ -743,7 +743,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const _334: rs.u8 = Failure.code$errors_Coded(f); const _337: rs.u32 = get$0q7640n(DROPPED); const args58 = [(f: rs.Formatter) => rs.u8Display(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; - put(out, rs.fmtFormat(["failure ", args58[0], " ", args58[1], " "])); + put(out, rs.fmtFormat(["failure ", args58[0], " ", args58[1], " "]).v); drop$errors_Failure(f); } else { const e3: Error.Error = _324.error; @@ -753,31 +753,31 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number const _356: rs.u32 = get$0q7640n(DROPPED); const arg3 = l.code; const args57 = [(f: rs.Formatter) => rs.u8Display(arg3, f), (f: rs.Formatter) => rs.u32Display(_356, f)]; - put(out, rs.fmtFormat(["leaf ", args57[0], " ", args57[1], " "])); + put(out, rs.fmtFormat(["leaf ", args57[0], " ", args57[1], " "]).v); l[Symbol.dispose](); } else { const e4: Error.Error = _345.error; - put(out, rs.fmtFormat([(f: rs.Formatter) => e4.fmt$Display(f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => e4.fmt$Display(f), " "]).v); rs.drop(e4); } } } const part9 = get$0q7640n(DROPPED); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part9, f), " "])); - const part10 = result_mapErr$1scmdah(result_mapErr$0ka0di9(checked(b, rs.u8WrappingMul(a, 4)), (e5: Error.Error): rs.Result => { + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part9, f), " "]).v); + const part10 = result_mapErr$1102tun(result_mapErr$0ka0di9(checked(b, rs.u8WrappingMul(a, 4)), (e5: Error.Error): rs.Result => { return result_map$18dk705(e5 instanceof of$errors_Failure ? rs.Ok(e5.v) : rs.Err(e5), (f2: Failure.Failure): rs.u8 => { const _03: rs.u8 = Failure.code$errors_Coded(f2); drop$errors_Failure(f2); return _03; }); - }), (e6: rs.Result): rs.Result => { - return result_mapErr$1a5uolr(e6, (e7: Error.Error): string => { - const _05: string = rs.fmtToString((f: rs.Formatter) => e7.fmt$Display(f)); + }), (e6: rs.Result): rs.Result => { + return result_mapErr$1lqaapp(e6, (e7: Error.Error): rs.String => { + const _05: rs.String = rs.fmtToString((f: rs.Formatter) => e7.fmt$Display(f)); rs.drop(e7); return _05; }); }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part10, f, rs.u8Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part10, f, rs.u8Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]).v); leaf2[Symbol.dispose](); boxed[Symbol.dispose](); drop$errors_Failure(held); @@ -786,7 +786,7 @@ export function objects(dataData: Uint8Array, dataStart: number, dataLen: number } /** Which of the crate's errors and std's `e` and its source are, and the `Failure` it holds. */ -export function downcast(e: Error.Error): string { +export function downcast(e: Error.Error): rs.String { const is: [boolean, boolean, boolean] = [e instanceof of$errors_Failure || e instanceof ofPlace$errors_Failure, e instanceof of$errors_Leaf, e instanceof of$num_ParseIntError || e instanceof ofPlace$num_ParseIntError]; const source: [boolean, rs.IntErrorKind | undefined] | undefined = option_map$1hw1osb(e.source$Error(), (s: Error.Error): [boolean, rs.IntErrorKind | undefined] => { return [s instanceof of$errors_Leaf, option_map$0p4jgzx(s instanceof of$num_ParseIntError ? s.v : s instanceof ofPlace$num_ParseIntError ? s.v.v : undefined, (p: rs.ParseIntError): rs.IntErrorKind => { diff --git a/ts/fixtures/lang/fields/expected/fields.ts b/ts/fixtures/lang/fields/expected/fields.ts index 2c706c473..e235f6905 100644 --- a/ts/fixtures/lang/fields/expected/fields.ts +++ b/ts/fixtures/lang/fields/expected/fields.ts @@ -95,12 +95,12 @@ export function fields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { p.headLen = _119.length; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(p.headLen & 0xff, q.headLen & 0xff, Couple.eq$cmp_PartialEq(p, q) ? 1 : 0))); rs.byteVecExtendFromSlice(out, new rs.ByteSlice(q.wordData, q.wordStart, q.wordLen)); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Couple.fmt$fmt_Debug(p, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Couple.fmt$fmt_Debug(p, f)]).v)); } const _148: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 3)); const open: Exposed.Exposed = { buf: _148, at: kind }; const args8 = [(f: rs.Formatter) => Exposed.fmt$fmt_Debug(open, f), (f: rs.Formatter) => Scanner.fmt$fmt_Debug(r2, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], args8[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], args8[1]]).v)); rs.byteVecPush(out, kind ^ (_148.length & 0xff)); if (!(rs.u8Rem(kind, 2) === 0)) { const _175: Glued.Glued = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; @@ -108,7 +108,7 @@ export function fields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { two = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Glued.fmt$fmt_Debug(two, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Glued.fmt$fmt_Debug(two, f)]).v)); rs.byteVecPush(out, rs.usizeAdd(two._0Len, two._1Len) & 0xff); const _195: Scanner.Scanner = SCANNER; rs.byteVecExtendFromSlice(out, new rs.ByteSlice(_195.bufData, _195.bufStart, _195.bufLen)); diff --git a/ts/fixtures/lang/floats/expected/floats.ts b/ts/fixtures/lang/floats/expected/floats.ts index 9c97c0b47..14acf42f5 100644 --- a/ts/fixtures/lang/floats/expected/floats.ts +++ b/ts/fixtures/lang/floats/expected/floats.ts @@ -43,7 +43,7 @@ export function putSecs(out: rs.ByteVec, d: rs.Result rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", rs.fmtSpec({ alternate: true }, args3[1])])); + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", rs.fmtSpec({ alternate: true }, args3[1])]).v); } } @@ -388,13 +388,13 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { const args17 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])])); + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])]).v); const args18 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ debugHex: "x" }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args18[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args18[4]) }, args18[2])])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f))); + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ debugHex: "x" }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args18[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args18[4]) }, args18[2])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f)).v); } else if (_13 === 1) { const args16 = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args16[0]), " ", rs.fmtSpec({ precision: 800 }, args16[1]), " ", rs.fmtSpec({ precision: 1100 }, args16[2]), " ", rs.fmtSpec({ precision: 65535 }, args16[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args16[0]), " ", rs.fmtSpec({ precision: 800 }, args16[1]), " ", rs.fmtSpec({ precision: 1100 }, args16[2]), " ", rs.fmtSpec({ precision: 65535 }, args16[0])]).v); } else if (_13 === 2) { const _72: [rs.f64, rs.ByteSlice] = take(_6[1]); const b: rs.f64 = _72[0]; @@ -405,7 +405,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _80: rs.Vec = rs.vecFrom([a, -0.0, 1e-7, 1e16, NaN]); const part = { level: a, peak: _78, history: _80 }; const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0]), "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])])); + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0]), "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])]).v); } else { let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); let iterStart: rs.i32 = 0; @@ -413,7 +413,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void while (iterStart++ < iterEnd) { const x: rs.f64 = rs.f64FromBits(step(rs.place(() => state, (value) => state = value))); const args13 = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f)]; - put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]])); + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]]).v); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 64; @@ -424,7 +424,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const r2: rs.u64 = step(rs.place(() => state, (value2) => state = value2)); const x2: rs.f64 = rs.u64ToF64(rs.u64Shr(r2, 11)) / rs.u64ToF64(rs.u64Shl(1, rs.u64Add(rs.u64Rem(r2, 24), 1))); const args14 = [(f: rs.Formatter) => rs.f64Debug(x2, f), (f: rs.Formatter) => rs.f64LowerExp(x2, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1]])); + put(out, rs.fmtFormat([args14[0], " ", args14[1]]).v); } } } @@ -444,14 +444,14 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { one(_6.value, out); } } else if (_4 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(data)) { const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); rs.idx(_21, _22); - s = s + String.fromCodePoint(_21.data[_21.start + _22] as rs.char); + rs.stringPush(s, _21.data[_21.start + _22] as rs.char); } - one(s, out); + one(s.v, out); } else { let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); let iterStart: rs.i32 = 0; @@ -463,19 +463,19 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); const len: rs.usize = rs.u64Low(rs.u64Add(rs.u64Rem(r, 40), 1)); const point: rs.usize = rs.usizeRem(rs.u64Low(rs.u64Shr(r, 8)), rs.usizeAdd(len, 1)); - let s2: string = ""; + const s2: rs.String = rs.stringNew(); let iterStart2: rs.usize = 0; const iterEnd2: rs.usize = len; while ((_60 = iterStart2++) < iterEnd2) { if (_60 === point) { - s2 = s2 + "."; + rs.stringPush(s2, 46); } const _69: rs.char = rs.u8Add(48, rs.u64Low(rs.u64Rem(step(rs.place(() => state, (value2) => state = value2)), 10)) & 0xff) as rs.char; - s2 = s2 + String.fromCodePoint(_69); + rs.stringPush(s2, _69); } const _85: rs.i64 = rs.i64Sub(rs.i64Cast(rs.u64Rem(rs.u64Shr(r, 16), 700)), 350); - const args3 = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_85, f)]; - one(rs.fmtFormat([args3[0], "e", args3[1]]), out); + const args3 = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_85, f)]; + one(rs.fmtFormat([args3[0], "e", args3[1]]).v, out); } } } @@ -487,11 +487,11 @@ export function one(s: string, out: rs.ByteVec): void { if (_4.ok) { const v: rs.f64 = _4.value; putF64(out, v); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.f64Debug(v, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.f64Debug(v, f)]).v); } else { const e: rs.ParseFloatError = _4.error; const args5 = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; - put(out, rs.fmtFormat([args5[0], "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", rs.fmtSpec({ align: ">", width: 30 }, args5[0]), "|", rs.fmtSpec({ precision: 7 }, args5[0])])); + put(out, rs.fmtFormat([args5[0], "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", rs.fmtSpec({ align: ">", width: 30 }, args5[0]), "|", rs.fmtSpec({ precision: 7 }, args5[0])]).v); } rs.byteVecPush(out, rs.f64FromStr(s).ok ? 1 : 0); } diff --git a/ts/fixtures/lang/folds/expected/folds.ts b/ts/fixtures/lang/folds/expected/folds.ts index a1ef6c514..3f17c304b 100644 --- a/ts/fixtures/lang/folds/expected/folds.ts +++ b/ts/fixtures/lang/folds/expected/folds.ts @@ -12,7 +12,7 @@ export function state$i64_Option_i64(out: rs.ByteVec, v: rs.i64 | undefined, r: const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.i64Debug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -21,7 +21,7 @@ export function state$i64_Option_tuple2_i64_usize(out: rs.ByteVec, v: [rs.i64, r const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.i64, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -30,7 +30,7 @@ export function state$i64_Option_tuple2_usize_i64(out: rs.ByteVec, v: [rs.usize, const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.i64], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.i64Debug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -39,7 +39,7 @@ export function state$i64_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -48,7 +48,7 @@ export function state$i64_Result_usize_unit(out: rs.ByteVec, v: rs.Result rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -57,7 +57,7 @@ export function state$i64_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -66,7 +66,7 @@ export function state$i64_tuple2_Option_i64_Option_i64(out: rs.ByteVec, v: [rs.i const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.i64Debug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -75,7 +75,7 @@ export function state$i64_tuple2_Option_i64_Option_usize(out: rs.ByteVec, v: [rs const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -84,7 +84,7 @@ export function state$i64_tuple2_Option_i64_usize(out: rs.ByteVec, v: [rs.i64 | const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -93,7 +93,7 @@ export function state$i64_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusi const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -102,7 +102,7 @@ export function state$i64_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusi const _14: rs.i64 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -111,7 +111,7 @@ export function state$u8_Option_tuple2_u8_usize(out: rs.ByteVec, v: [rs.u8, rs.u const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.u8, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -120,7 +120,7 @@ export function state$u8_Option_tuple2_usize_u8(out: rs.ByteVec, v: [rs.usize, r const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -129,7 +129,7 @@ export function state$u8_Option_u8(out: rs.ByteVec, v: rs.u8 | undefined, r: rs. const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -138,7 +138,7 @@ export function state$u8_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -147,7 +147,7 @@ export function state$u8_Result_usize_unit(out: rs.ByteVec, v: rs.Result rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -156,7 +156,7 @@ export function state$u8_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive< const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -165,7 +165,7 @@ export function state$u8_tuple2_Option_u8_Option_u8(out: rs.ByteVec, v: [rs.u8 | const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -174,7 +174,7 @@ export function state$u8_tuple2_Option_u8_Option_usize(out: rs.ByteVec, v: [rs.u const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -183,7 +183,7 @@ export function state$u8_tuple2_Option_u8_usize(out: rs.ByteVec, v: [rs.u8 | und const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -192,7 +192,7 @@ export function state$u8_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusiv const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** `r`'s state after `v`, what read it returned. */ @@ -201,7 +201,7 @@ export function state$u8_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusiv const _14: rs.u8 = rs.rangeInclusiveEnd(r); const _16: boolean = rs.rangeInclusiveIsEmpty(r); const args3 = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v); } /** diff --git a/ts/fixtures/lang/futures/expected/futures.ts b/ts/fixtures/lang/futures/expected/futures.ts index a26a374af..b2c5501d4 100644 --- a/ts/fixtures/lang/futures/expected/futures.ts +++ b/ts/fixtures/lang/futures/expected/futures.ts @@ -48,7 +48,7 @@ export function pollOnce$future_Pending_u8(f: rs.Future): rs.Poll } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Ready_String(f: rs.Ready): rs.Poll { +export function pollOnce$future_Ready_String(f: rs.Ready): rs.Poll { return f.poll(rs.NOOP_WAKER); } @@ -79,86 +79,86 @@ export function pollOnce$futures_readies_closure0(f: rs.Future): rs.Poll< /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Pending_futures_Logged(out: rs.ByteVec, _value: rs.Future): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtWriteStr(f, "Pending"))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtWriteStr(f, "Pending"))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_PollFn_futures_pendings_closure0(out: rs.ByteVec, _value: rs.Future): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn"))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn"))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_Option_Option_u8(out: rs.ByteVec, value: rs.Ready): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_Option_u8(out: rs.ByteVec, value: rs.Ready): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Ready_String(out: rs.ByteVec, value: rs.Ready): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.fmtStr)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.fmtStr))])); +export function debug$future_Ready_String(out: rs.ByteVec, value: rs.Ready): void { + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_u8(out: rs.ByteVec, value: rs.Ready): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.u8Debug)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.u8Debug)]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.u8Debug))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$future_Ready_unit(out: rs.ByteVec, value: rs.Ready): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.fmtUnit)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.fmtUnit))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => value.debug(f, rs.fmtUnit)]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => value.debug(f, rs.fmtUnit))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_Option_u8(out: rs.ByteVec, value: rs.Poll): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_Result_u8_String(out: rs.ByteVec, value: rs.Poll>): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr)))])); +export function debug$task_Poll_Result_u8_String(out: rs.ByteVec, value: rs.Poll>): void { + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_String(out: rs.ByteVec, value: rs.Poll): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr))])); +export function debug$task_Poll_String(out: rs.ByteVec, value: rs.Poll): void { + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_array2_u8(out: rs.ByteVec, value: rs.Poll): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_task_Poll_u8(out: rs.ByteVec, value: rs.Poll | rs.OuterPending): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_u8(out: rs.ByteVec, value: rs.Poll): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug))]).v); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ export function debug$task_Poll_unit(out: rs.ByteVec, value: rs.Poll): void { - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit))]).v); } /** @@ -191,11 +191,11 @@ export function readies(data: rs.ByteSlice, out: rs.ByteVec): void { debug$future_Ready_unit(out, new rs.Ready(undefined)); debug$future_Ready_Option_u8(out, new rs.Ready(rs.byteSliceFirst(data))); debug$future_Ready_Option_Option_u8(out, new rs.Ready(rs.None as rs.u8 | undefined | rs.None)); - const text_: rs.Ready = new rs.Ready(text(data)); + const text_: rs.Ready = new rs.Ready(text(data)); debug$future_Ready_String(out, text_); - const _52: rs.Poll = pollOnce$future_Ready_String(text_); + const _52: rs.Poll = pollOnce$future_Ready_String(text_); if (_52 !== rs.Pending) { - rs.iterExtendBytes(out, rs.strBytes(_52), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(_52.v), undefined, true); } debug$future_Ready_String(out, text_); const boxed: rs.Future = new rs.Ready(data.length); @@ -437,7 +437,7 @@ export function pendings(data: rs.ByteSlice, out: rs.ByteVec): void { */ export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { let q!: rs.Poll; - let r!: rs.Poll>; + let r!: rs.Poll>; for (const b of rs.byteSliceView(data)) { const p: rs.Poll = b; if (!(rs.u8Rem(b, 3) === 0)) { @@ -448,7 +448,7 @@ export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { debug$task_Poll_u8(out, p); debug$task_Poll_u8(out, q); const args3 = [(f: rs.Formatter) => rs.fmtPoll(q, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtPoll(p, f, rs.u8Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 4 }, args3[0]), "|", rs.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args3[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args3[1])])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 4 }, args3[0]), "|", rs.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args3[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args3[1])]).v); debug$task_Poll_Option_u8(out, poll_map$1jzbsum(b as rs.Poll, (o: rs.u8 | undefined): rs.u8 | undefined => { return filter$0hq86nl(o, (v: rs.u8): boolean => { return rs.u8Rem(v, 2) === 0; @@ -460,7 +460,7 @@ export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_38 === 1) { r = rs.Ok(b); } else { - r = rs.Err(rs.fmtToString((f: rs.Formatter) => rs.u8Display(b, f))); + r = rs.Err(rs.fmtToString((f: rs.Formatter) => rs.u8Display(b, f), 0)); } debug$task_Poll_Result_u8_String(out, r); debug$task_Poll_task_Poll_u8(out, nested(b)); diff --git a/ts/fixtures/lang/futures/expected/harness.ts b/ts/fixtures/lang/futures/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/futures/expected/harness.ts +++ b/ts/fixtures/lang/futures/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/hashes/expected/harness.ts b/ts/fixtures/lang/hashes/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/hashes/expected/harness.ts +++ b/ts/fixtures/lang/hashes/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Index.ts b/ts/fixtures/lang/hashes/expected/hashes.Index.ts index 3f63782f4..df8d22b57 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Index.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Index.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Index, other: Index): boolean { - if (!rs.hashEq(rs.same)(self.names, other.names)) { + if (!rs.hashEq(rs.eqStr)(self.names, other.names)) { return false; } return rs.hashEq()(self.seen, other.seen); @@ -11,7 +11,7 @@ export function eq$cmp_PartialEq(self: Index, other: Index): boolean { /** A type whose derived `PartialEq` compares the maps it holds. */ export interface Index { - names: rs.HashMap; + names: rs.HashMap; seen: rs.HashSet<[rs.u8, boolean]>; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Key.ts b/ts/fixtures/lang/hashes/expected/hashes.Key.ts index 8679e175e..5c9182424 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Key.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Key.ts @@ -5,14 +5,14 @@ import * as Fnv from "./hashes.Fnv.ts"; import * as Tally from "./hashes.Tally.ts"; export function clone$Clone(self: Key): Key { - return { _0: self._0, _1: self._1 }; + return { _0: self._0, _1: rs.stringClone(self._1) }; } export function eq$cmp_PartialEq(self: Key, other: Key): boolean { if (!(self._0 === other._0)) { return false; } - return self._1 === other._1; + return rs.eqStr(self._1, other._1); } export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void { @@ -45,7 +45,7 @@ export function cmp$cmp_Ord(self: Key, other: Key): rs.Ordering { /** A key that is a JS object. */ export interface Key { _0: rs.u16; - _1: string; + _1: rs.String; } //# sourceMappingURL=hashes.Key.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Packet.ts b/ts/fixtures/lang/hashes/expected/hashes.Packet.ts index 7471a87ff..4c2572bdc 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Packet.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Packet.ts @@ -49,7 +49,7 @@ export function hash$Hash_hashes_Switch(self: Packet, state: rs.Place; next: rs.i32 | undefined; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.ts b/ts/fixtures/lang/hashes/expected/hashes.ts index a81a33848..3a7a4ad97 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.ts @@ -67,7 +67,7 @@ export function digest$Option_u32(value: rs.u32 | undefined, out: rs.ByteVec): v } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$String(value: string, out: rs.ByteVec): void { +export function digest$String(value: rs.String, out: rs.ByteVec): void { const h: rs.Hasher = rs.hasher(); rs.hashStr(value, h); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); @@ -392,7 +392,7 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_5 === 1) { const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); digest$str(text, out); - digest$String(text, out); + digest$String(rs.stringFrom(text), out); digest$str("", out); digest$tuple2_ref_str_usize([text, rs.stringLen(text)] as [string, rs.usize], out); const arc: rs.Arc = new rs.Arc(text); @@ -417,7 +417,7 @@ export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { digest$Option_num_NonZero_u32(rs.nonZero((n | 1) >>> 0), out); } else if (_5 === 3) { const n2: rs.u64 = rs.u64Cast(w(0, 8)); - digest$hashes_Packet({ id: n2, flags: option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), name: result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "?"), tags: rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + digest$hashes_Packet({ id: n2, flags: option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), name: rs.stringFrom(result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "?")), tags: rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { return _2 as rs.u16; }), undefined, 2, true), next: thenSome$05ku0zn(rs.u64Rem(n2, 3) !== 0, rs.u64Low(n2) | 0) }, out); const _188: rs.u64 = rs.u64Rem(n2, 3); @@ -502,7 +502,9 @@ export function random(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashFinish(built)) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashOne(rs.buildHasher(copy), n, rs.hash64)) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashOne(rs.buildHasher(s), n, rs.hash64)) ? 1 : 0); - rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr), rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr)) ? 1 : 0); + const _53: rs.u64 = rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr); + const _57: rs.String = rs.stringFrom(text); + rs.byteVecPush(out, rs.u64Eq(_53, rs.hashOne(rs.buildHasher(other.state), _57, rs.hashStr)) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), [b, text] as [rs.u8, string], rs.hashTuple([rs.hash8, rs.hashStr])), rs.hashOne(rs.buildHasher(copy), [b, text] as [rs.u8, string], rs.hashTuple([rs.hash8, rs.hashStr]))) ? 1 : 0); rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), { _0: b }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined), rs.hashOne(rs.buildHasher(s), { _0: b ^ 240 }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined)) ? 1 : 0); const arc: rs.Arc = new rs.Arc(text); @@ -632,7 +634,7 @@ export function hashInto$hashes_Bare(h: Bare.Bare, data: rs.ByteSlice): void { rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); @@ -673,7 +675,7 @@ export function hashInto$hashes_Bare(h: Bare.Bare, data: rs.ByteSlice): void { const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Bare({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Bare({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -712,7 +714,7 @@ export function hashInto$hashes_Full(h: Full.Full, data: rs.ByteSlice): void { rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); @@ -753,7 +755,7 @@ export function hashInto$hashes_Full(h: Full.Full, data: rs.ByteSlice): void { const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Full({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Full({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -792,7 +794,7 @@ export function hashInto$hashes_Partial(h: Partial.Partial, data: rs.ByteSlice): rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); @@ -833,7 +835,7 @@ export function hashInto$hashes_Partial(h: Partial.Partial, data: rs.ByteSlice): const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Partial({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Partial({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -872,7 +874,7 @@ export function hashInto$hashes_Switch(h: rs.Place, data: rs.Byte rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); rs.hashStr(text, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); - rs.hashStr(text, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashStr(rs.stringFrom(text), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); rs.hashNothing(undefined, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); @@ -913,7 +915,7 @@ export function hashInto$hashes_Switch(h: rs.Place, data: rs.Byte const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); const _193: rs.u8 = rs.u128Low(a) & 0xff; - const _194: string = text; + const _194: rs.String = rs.stringFrom(text); const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Switch({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); Shape.hash$Hash_hashes_Switch({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); @@ -1069,7 +1071,7 @@ export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { rs.sliceSort(rs.sliceFrom(held.items), rs.cmpLt(rs.cmpTuple<[Key.Key, rs.u8], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 8, true); for (const _63 of held.items) { rs.byteVecPush(out, _63[0]._0 & 0xff); - put(out, _63[0]._1); + put(out, _63[0]._1.v); rs.byteVecPush(out, _63[1]); } const probe: Key.Key = { _0: first as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(first))) }; @@ -1243,18 +1245,18 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { _113.v = rs.u16Add(_113.v, _102); } }; - const _123: (a0: rs.ByteSlice) => rs.HashSet = (bytes3: rs.ByteSlice): rs.HashSet => { - const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_2: rs.u8): string => { + const _123: (a0: rs.ByteSlice) => rs.HashSet = (bytes3: rs.ByteSlice): rs.HashSet => { + const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_2: rs.u8): rs.String => { return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_2, 4)))); }); - return rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _3, undefined, undefined, 117440512); + return rs.hashExtendKeys(rs.hashNew(rs.HASH_TEXT) as rs.HashSet, _3, undefined, undefined, 117440512); }; const _175: (a0: rs.ByteSlice) => hashes_Index.Index = (bytes4: rs.ByteSlice): hashes_Index.Index => { - const _46: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_22: rs.u8): [rs.u8, string] => { + const _46: rs.Iter<[rs.u8, rs.String]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_22: rs.u8): [rs.u8, rs.String] => { const b4: rs.u8 = _22; - return [rs.u8Rem(b4, 8), text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(b4, 3))))] as [rs.u8, string]; + return [rs.u8Rem(b4, 8), text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(b4, 3))))] as [rs.u8, rs.String]; }); - const _33: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _46, undefined, undefined, undefined, 58720256); + const _33: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _46, undefined, undefined, undefined, 58720256); const _75: rs.Iter<[rs.u8, boolean]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_23: rs.u8): [rs.u8, boolean] => { const b5: rs.u8 = _23; return [rs.u8Rem(b5, 5), rs.u8Rem(b5, 2) === 0] as [rs.u8, boolean]; @@ -1332,20 +1334,20 @@ export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { const part7 = rs.byteVecSlice(flipped); const _118: rs.HashMap = _96(part7); rs.byteVecPush(out, !rs.hashEq(rs.same)(_114, _118) ? 1 : 0); - const _128: rs.HashSet = _123(data); + const _128: rs.HashSet = _123(data); const part8 = rs.byteVecSlice(reversed); - const _132: rs.HashSet = _123(part8); + const _132: rs.HashSet = _123(part8); rs.byteVecPush(out, rs.hashEq()(_128, _132) ? 1 : 0); - const _141: rs.HashSet = _123(data); - const _145: rs.HashSet = _123(shorter); + const _141: rs.HashSet = _123(data); + const _145: rs.HashSet = _123(shorter); rs.byteVecPush(out, rs.hashEq()(_141, _145) ? 1 : 0); - const _154: rs.HashSet = _123(data); + const _154: rs.HashSet = _123(data); const part9 = rs.byteVecSlice(flipped); - const _152: rs.Vec> = rs.vecFrom([_154, _123(part9)]); + const _152: rs.Vec> = rs.vecFrom([_154, _123(part9)]); const part10 = rs.byteVecSlice(reversed); - const _165: rs.HashSet = _123(part10); + const _165: rs.HashSet = _123(part10); const part11 = rs.byteVecSlice(flipped); - const _163: rs.Vec> = rs.vecFrom([_165, _123(part11)]); + const _163: rs.Vec> = rs.vecFrom([_165, _123(part11)]); rs.byteVecPush(out, rs.eqSeq(rs.hashEq())(_152, _163) ? 1 : 0); const _180: hashes_Index.Index = _175(data); const part12 = rs.byteVecSlice(reversed); @@ -1377,7 +1379,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _36: Tallied.Tallied = Tallied.default$Default(); rs.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, _36) ? 1 : 0); const args5 = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), (f: rs.Formatter) => rs.fmtOption(undefined, f, (_value: undefined, f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), rs.None), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(cloned, f), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(held, f)]; - put(out, rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", rs.fmtSpec({ alternate: true }, args5[3])])); + put(out, rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", rs.fmtSpec({ alternate: true }, args5[3])]).v); const word: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "✓"); const n: rs.u16 = rs.u128Low(wide(data, 0, 2)) & 0xffff; const built: Tally.Tally = Tally.default$Default(); @@ -1387,7 +1389,8 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { const _70: rs.u64 = rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), word, rs.hashStr, undefined, rs.drop); const _74: [rs.u8, string] = [n & 0xff, word]; const _72: rs.u64 = rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _74, rs.hashTuple([rs.hash8, rs.hashStr]), undefined, rs.drop); - const _79: Key.Key = { _0: n, _1: word }; + const _80: rs.String = rs.stringFrom(word); + const _79: Key.Key = { _0: n, _1: _80 }; const hashes: rs.u64[] = [_66, _68, _70, _72, rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _79, rs.hashOwn(Key.hash$Hash_hashes_Tally as (a0: Key.Key, a1: Tally.Tally) => undefined), undefined, rs.drop)]; built[Symbol.dispose](); const iter: rs.Iter = rs.iterSlice(hashes); @@ -1423,7 +1426,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { rs.sliceSort(rs.sliceFrom(entries.items), rs.cmpLt(rs.cmpTuple<[Key.Key, rs.u8], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 8, true); for (const _147 of entries.items) { rs.byteVecPush(out, _147[0]._0 & 0xff); - put(out, _147[0]._1); + put(out, _147[0]._1.v); rs.byteVecPush(out, _147[1]); } const probe: Key.Key = { _0: first as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(first))) }; @@ -1437,7 +1440,7 @@ export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { return undefined; }); rs.byteVecPush(out, rs.hashEq(rs.same)(keyed, _195) ? 1 : 0); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault")]).v); const _212: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.u8 => { return rs.u8Rem(b2, 4); }); diff --git a/ts/fixtures/lang/heap/expected/heap.ts b/ts/fixtures/lang/heap/expected/heap.ts index bf2b24fad..2ce6d4a0c 100644 --- a/ts/fixtures/lang/heap/expected/heap.ts +++ b/ts/fixtures/lang/heap/expected/heap.ts @@ -166,22 +166,22 @@ export function layouts(data: rs.ByteSlice, out: rs.ByteVec): void { align = rs.usizeShl(1, rs.u8Rem(b, 32)); } const made: rs.Result = rs.layoutFromSizeAlign(size, align); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(made, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(made, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]).v), undefined, true); if (!made.ok) { - rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(rs.LAYOUT_ERROR, f))), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(rs.LAYOUT_ERROR, f)).v), undefined, true); } const part3 = rs.layoutArray(rs.usizeShr(size, rs.u8Rem(b, 8)), 8, 8); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part3, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part3, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]).v), undefined, true); const unit: rs.Layout = rs.resultUnwrap(rs.layoutArray(size, 0, 1), rs.fmtLayoutErrorDebug); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(unit.size & 0xff, unit.align & 0xff)), undefined, true); } const _92: Fault.Fault = { tag: "Alloc", layout: { size: 16, align: 8 } }; const _94: rs.Layout = { size: 4, align: 4 }; const args11 = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(_92, f), (f: rs.Formatter) => rs.fmtLayoutDebug(_94, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args11[0], " ", args11[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args11[0], " ", args11[1]]).v), undefined, true); rs.byteVecPush(out, 8 & 0xff); const arg = { tag: "Overflow" } as Fault.Fault; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => Fault.fmt$fmt_Debug(arg, f)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => Fault.fmt$fmt_Debug(arg, f)]).v), undefined, true); } //# sourceMappingURL=heap.ts.map diff --git a/ts/fixtures/lang/hints/expected/hints.ts b/ts/fixtures/lang/hints/expected/hints.ts index 34b0774f0..30b4f7f32 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -2001,22 +2001,23 @@ export function hints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, it2.sizeHint()); } } else if (_37 === 16) { - const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_29: rs.u8): rs.char => { + const _353: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_29: rs.u8): rs.char => { const _5: rs.usize = rs.u8Rem(_29, 4) as rs.usize; if (!(_5 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _5); } return [97, 233, 128512, 2048][_5]; - })); + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _353); const _355: rs.u8 = rs.u8Rem(arm, 4); if (_355 === 0) { - walk$str_Chars(rs.strChars(s), steps, out); + walk$str_Chars(rs.strChars(s.v), steps, out); } else if (_355 === 1) { - walkFront$str_Split_char(rs.strSplit(s, "é"), steps, out); + walkFront$str_Split_char(rs.strSplit(s.v, "é"), steps, out); } else if (_355 === 2) { - walk$str_Bytes(rs.strBytes(s), steps, out); + walk$str_Bytes(rs.strBytes(s.v), steps, out); } else { - let t: string = s; + const t: rs.String = rs.stringClone(s); const _379: rs.RangeFrom = new rs.RangeFrom(rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.usizeDiv(bytes.length, 2)))), (_231: rs.u8): rs.usize => { const _512: rs.usize = rs.u8Rem(_231, 4) as rs.usize; if (!(_512 < 4)) { @@ -2024,7 +2025,7 @@ export function hints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } return [1, 2, 4, 3][_512]; }), rs.usizeAdd, 0), rs.usizeStep); - walk$string_Drain(rs.stringDrain(rs.place(() => t, (value) => t = value), _379), steps, out); + walk$string_Drain(rs.stringDrain(t, _379), steps, out); } } else if (_37 === 17) { const size: rs.usize = rs.usizeAdd(rs.usizeRem(at(1) as rs.usize, 4), 1); diff --git a/ts/fixtures/lang/ints/expected/ints.ts b/ts/fixtures/lang/ints/expected/ints.ts index 5212c863e..cd1d02bd8 100644 --- a/ts/fixtures/lang/ints/expected/ints.ts +++ b/ts/fixtures/lang/ints/expected/ints.ts @@ -2025,51 +2025,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_25 === 0) { const v2: rs.u8 = v; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v2))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v2, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v2, f), 0).v)); } else if (_25 === 1) { const v3: rs.u16 = v as rs.u16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v3))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v3, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v3, f), 0).v)); } else if (_25 === 2) { const v4: rs.u32 = v as rs.u32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v4))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v4, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v4, f), 0).v)); } else if (_25 === 3) { const v5: rs.u64 = v as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v5))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v5, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v5, f), 0).v)); } else if (_25 === 4) { const v6: rs.u128 = v as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v6))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v6, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v6, f), 0).v)); } else if (_25 === 5) { const v7: rs.usize = v as rs.usize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v7))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v7, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v7, f), 0).v)); } else if (_25 === 6) { const v8: rs.i8 = (v << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v8))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v8, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v8, f), 3).v)); } else if (_25 === 7) { const v9: rs.i16 = v as rs.i16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v9))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v9, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v9, f), 5).v)); } else if (_25 === 8) { const v10: rs.i32 = v as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v10))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v10, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v10, f), 10).v)); } else if (_25 === 9) { const v11: rs.i64 = v as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v11))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v11, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v11, f), 19).v)); } else if (_25 === 10) { const v12: rs.i128 = v as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v12))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v12, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v12, f), 39).v)); } else { const v13: rs.isize = v as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v13))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v13, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v13, f), 10).v)); } } else if (_5 === 1) { const buf2: Uint8Array = rs.bytes(2); @@ -2080,51 +2080,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_165 === 0) { const v15: rs.u8 = v14 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v15))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v15, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v15, f), 0).v)); } else if (_165 === 1) { const v16: rs.u16 = v14; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v16))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v16, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v16, f), 0).v)); } else if (_165 === 2) { const v17: rs.u32 = v14 as rs.u32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v17))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v17, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v17, f), 0).v)); } else if (_165 === 3) { const v18: rs.u64 = v14 as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v18))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v18, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v18, f), 0).v)); } else if (_165 === 4) { const v19: rs.u128 = v14 as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v19))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v19, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v19, f), 0).v)); } else if (_165 === 5) { const v20: rs.usize = v14 as rs.usize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v20))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v20, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v20, f), 0).v)); } else if (_165 === 6) { const v21: rs.i8 = (v14 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v21))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v21, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v21, f), 3).v)); } else if (_165 === 7) { const v22: rs.i16 = (v14 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v22))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v22, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v22, f), 5).v)); } else if (_165 === 8) { const v23: rs.i32 = v14 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v23))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v23, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v23, f), 10).v)); } else if (_165 === 9) { const v24: rs.i64 = v14 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v24))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v24, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v24, f), 19).v)); } else if (_165 === 10) { const v25: rs.i128 = v14 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v25))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v25, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v25, f), 39).v)); } else { const v26: rs.isize = v14 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v26))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v26, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v26, f), 10).v)); } } else if (_5 === 2) { const buf3: Uint8Array = rs.bytes(4); @@ -2135,51 +2135,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_305 === 0) { const v28: rs.u8 = v27 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v28))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v28, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v28, f), 0).v)); } else if (_305 === 1) { const v29: rs.u16 = v27 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v29))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v29, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v29, f), 0).v)); } else if (_305 === 2) { const v30: rs.u32 = v27; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v30))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v30, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v30, f), 0).v)); } else if (_305 === 3) { const v31: rs.u64 = v27 as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v31))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v31, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v31, f), 0).v)); } else if (_305 === 4) { const v32: rs.u128 = v27 as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v32))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v32, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v32, f), 0).v)); } else if (_305 === 5) { const v33: rs.usize = v27 as rs.usize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v33))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v33, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v33, f), 0).v)); } else if (_305 === 6) { const v34: rs.i8 = (v27 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v34))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v34, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v34, f), 3).v)); } else if (_305 === 7) { const v35: rs.i16 = (v27 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v35))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v35, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v35, f), 5).v)); } else if (_305 === 8) { const v36: rs.i32 = v27 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v36))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v36, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v36, f), 10).v)); } else if (_305 === 9) { const v37: rs.i64 = v27 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v37))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v37, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v37, f), 19).v)); } else if (_305 === 10) { const v38: rs.i128 = v27 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v38))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v38, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v38, f), 39).v)); } else { const v39: rs.isize = v27 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v39))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v39, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v39, f), 10).v)); } } else if (_5 === 3) { const buf4: Uint8Array = rs.bytes(8); @@ -2190,51 +2190,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_445 === 0) { const v41: rs.u8 = rs.u64Low(v40) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v41))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v41, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v41, f), 0).v)); } else if (_445 === 1) { const v42: rs.u16 = rs.u64Low(v40) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v42))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v42, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v42, f), 0).v)); } else if (_445 === 2) { const v43: rs.u32 = rs.u64Low(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v43))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v43, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v43, f), 0).v)); } else if (_445 === 3) { const v44: rs.u64 = v40; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v44))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v44, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v44, f), 0).v)); } else if (_445 === 4) { const v45: rs.u128 = rs.u128Cast(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v45))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v45, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v45, f), 0).v)); } else if (_445 === 5) { const v46: rs.usize = rs.u64Low(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v46))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v46, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v46, f), 0).v)); } else if (_445 === 6) { const v47: rs.i8 = (rs.u64Low(v40) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v47))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v47, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v47, f), 3).v)); } else if (_445 === 7) { const v48: rs.i16 = (rs.u64Low(v40) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v48))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v48, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v48, f), 5).v)); } else if (_445 === 8) { const v49: rs.i32 = rs.u64Low(v40) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v49))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v49, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v49, f), 10).v)); } else if (_445 === 9) { const v50: rs.i64 = rs.i64Cast(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v50))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v50, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v50, f), 19).v)); } else if (_445 === 10) { const v51: rs.i128 = rs.i128Cast(v40); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v51))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v51, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v51, f), 39).v)); } else { const v52: rs.isize = rs.u64Low(v40) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v52))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v52, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v52, f), 10).v)); } } else if (_5 === 4) { const buf5: Uint8Array = rs.bytes(16); @@ -2245,51 +2245,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_585 === 0) { const v54: rs.u8 = rs.u128Low(v53) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v54))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v54, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v54, f), 0).v)); } else if (_585 === 1) { const v55: rs.u16 = rs.u128Low(v53) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v55))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v55, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v55, f), 0).v)); } else if (_585 === 2) { const v56: rs.u32 = rs.u128Low(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v56))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v56, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v56, f), 0).v)); } else if (_585 === 3) { const v57: rs.u64 = rs.u64Cast(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v57))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v57, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v57, f), 0).v)); } else if (_585 === 4) { const v58: rs.u128 = v53; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v58))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v58, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v58, f), 0).v)); } else if (_585 === 5) { const v59: rs.usize = rs.u128Low(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v59))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v59, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v59, f), 0).v)); } else if (_585 === 6) { const v60: rs.i8 = (rs.u128Low(v53) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v60))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v60, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v60, f), 3).v)); } else if (_585 === 7) { const v61: rs.i16 = (rs.u128Low(v53) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v61))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v61, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v61, f), 5).v)); } else if (_585 === 8) { const v62: rs.i32 = rs.u128Low(v53) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v62))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v62, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v62, f), 10).v)); } else if (_585 === 9) { const v63: rs.i64 = rs.i64Cast(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v63))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v63, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v63, f), 19).v)); } else if (_585 === 10) { const v64: rs.i128 = rs.i128Cast(v53); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v64))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v64, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v64, f), 39).v)); } else { const v65: rs.isize = rs.u128Low(v53) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v65))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v65, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v65, f), 10).v)); } } else if (_5 === 5) { const buf6: Uint8Array = rs.bytes(4); @@ -2300,51 +2300,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_725 === 0) { const v67: rs.u8 = v66 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v67))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v67, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v67, f), 0).v)); } else if (_725 === 1) { const v68: rs.u16 = v66 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v68))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v68, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v68, f), 0).v)); } else if (_725 === 2) { const v69: rs.u32 = v66 as rs.u32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v69))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v69, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v69, f), 0).v)); } else if (_725 === 3) { const v70: rs.u64 = v66 as rs.u64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v70))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v70, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v70, f), 0).v)); } else if (_725 === 4) { const v71: rs.u128 = v66 as rs.u128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v71))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v71, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v71, f), 0).v)); } else if (_725 === 5) { const v72: rs.usize = v66; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v72))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v72, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v72, f), 0).v)); } else if (_725 === 6) { const v73: rs.i8 = (v66 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v73))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v73, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v73, f), 3).v)); } else if (_725 === 7) { const v74: rs.i16 = (v66 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v74))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v74, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v74, f), 5).v)); } else if (_725 === 8) { const v75: rs.i32 = v66 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v75))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v75, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v75, f), 10).v)); } else if (_725 === 9) { const v76: rs.i64 = v66 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v76))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v76, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v76, f), 19).v)); } else if (_725 === 10) { const v77: rs.i128 = v66 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v77))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v77, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v77, f), 39).v)); } else { const v78: rs.isize = v66 | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v78))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v78, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v78, f), 10).v)); } } else if (_5 === 6) { const buf7: Uint8Array = Uint8Array.of(0); @@ -2355,51 +2355,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_865 === 0) { const v80: rs.u8 = v79 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v80))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v80, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v80, f), 0).v)); } else if (_865 === 1) { const v81: rs.u16 = v79 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v81))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v81, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v81, f), 0).v)); } else if (_865 === 2) { const v82: rs.u32 = v79 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v82))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v82, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v82, f), 0).v)); } else if (_865 === 3) { const v83: rs.u64 = rs.u64Cast(v79); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v83))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v83, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v83, f), 0).v)); } else if (_865 === 4) { const v84: rs.u128 = rs.u128Cast(v79); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v84))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v84, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v84, f), 0).v)); } else if (_865 === 5) { const v85: rs.usize = v79 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v85))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v85, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v85, f), 0).v)); } else if (_865 === 6) { const v86: rs.i8 = v79; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v86))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v86, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v86, f), 3).v)); } else if (_865 === 7) { const v87: rs.i16 = v79 as rs.i16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v87))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v87, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v87, f), 5).v)); } else if (_865 === 8) { const v88: rs.i32 = v79 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v88))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v88, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v88, f), 10).v)); } else if (_865 === 9) { const v89: rs.i64 = v79 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v89))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v89, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v89, f), 19).v)); } else if (_865 === 10) { const v90: rs.i128 = v79 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v90))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v90, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v90, f), 39).v)); } else { const v91: rs.isize = v79 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v91))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v91, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v91, f), 10).v)); } } else if (_5 === 7) { const buf8: Uint8Array = rs.bytes(2); @@ -2410,51 +2410,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1005 === 0) { const v93: rs.u8 = v92 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v93))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v93, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v93, f), 0).v)); } else if (_1005 === 1) { const v94: rs.u16 = v92 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v94))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v94, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v94, f), 0).v)); } else if (_1005 === 2) { const v95: rs.u32 = v92 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v95))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v95, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v95, f), 0).v)); } else if (_1005 === 3) { const v96: rs.u64 = rs.u64Cast(v92); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v96))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v96, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v96, f), 0).v)); } else if (_1005 === 4) { const v97: rs.u128 = rs.u128Cast(v92); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v97))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v97, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v97, f), 0).v)); } else if (_1005 === 5) { const v98: rs.usize = v92 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v98))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v98, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v98, f), 0).v)); } else if (_1005 === 6) { const v99: rs.i8 = (v92 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v99))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v99, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v99, f), 3).v)); } else if (_1005 === 7) { const v100: rs.i16 = v92; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v100))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v100, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v100, f), 5).v)); } else if (_1005 === 8) { const v101: rs.i32 = v92 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v101))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v101, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v101, f), 10).v)); } else if (_1005 === 9) { const v102: rs.i64 = v92 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v102))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v102, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v102, f), 19).v)); } else if (_1005 === 10) { const v103: rs.i128 = v92 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v103))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v103, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v103, f), 39).v)); } else { const v104: rs.isize = v92 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v104))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v104, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v104, f), 10).v)); } } else if (_5 === 8) { const buf9: Uint8Array = rs.bytes(4); @@ -2465,51 +2465,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1145 === 0) { const v106: rs.u8 = v105 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v106))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v106, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v106, f), 0).v)); } else if (_1145 === 1) { const v107: rs.u16 = v105 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v107))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v107, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v107, f), 0).v)); } else if (_1145 === 2) { const v108: rs.u32 = v105 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v108))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v108, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v108, f), 0).v)); } else if (_1145 === 3) { const v109: rs.u64 = rs.u64Cast(v105); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v109))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v109, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v109, f), 0).v)); } else if (_1145 === 4) { const v110: rs.u128 = rs.u128Cast(v105); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v110))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v110, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v110, f), 0).v)); } else if (_1145 === 5) { const v111: rs.usize = v105 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v111))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v111, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v111, f), 0).v)); } else if (_1145 === 6) { const v112: rs.i8 = (v105 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v112))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v112, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v112, f), 3).v)); } else if (_1145 === 7) { const v113: rs.i16 = (v105 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v113))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v113, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v113, f), 5).v)); } else if (_1145 === 8) { const v114: rs.i32 = v105; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v114))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v114, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v114, f), 10).v)); } else if (_1145 === 9) { const v115: rs.i64 = v105 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v115))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v115, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v115, f), 19).v)); } else if (_1145 === 10) { const v116: rs.i128 = v105 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v116))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v116, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v116, f), 39).v)); } else { const v117: rs.isize = v105 as rs.isize; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v117))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v117, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v117, f), 10).v)); } } else if (_5 === 9) { const buf10: Uint8Array = rs.bytes(8); @@ -2520,51 +2520,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1285 === 0) { const v119: rs.u8 = rs.i64Low(v118) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v119))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v119, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v119, f), 0).v)); } else if (_1285 === 1) { const v120: rs.u16 = rs.i64Low(v118) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v120))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v120, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v120, f), 0).v)); } else if (_1285 === 2) { const v121: rs.u32 = rs.i64Low(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v121))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v121, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v121, f), 0).v)); } else if (_1285 === 3) { const v122: rs.u64 = rs.u64Cast(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v122))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v122, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v122, f), 0).v)); } else if (_1285 === 4) { const v123: rs.u128 = rs.u128Cast(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v123))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v123, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v123, f), 0).v)); } else if (_1285 === 5) { const v124: rs.usize = rs.i64Low(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v124))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v124, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v124, f), 0).v)); } else if (_1285 === 6) { const v125: rs.i8 = (rs.i64Low(v118) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v125))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v125, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v125, f), 3).v)); } else if (_1285 === 7) { const v126: rs.i16 = (rs.i64Low(v118) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v126))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v126, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v126, f), 5).v)); } else if (_1285 === 8) { const v127: rs.i32 = rs.i64Low(v118) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v127))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v127, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v127, f), 10).v)); } else if (_1285 === 9) { const v128: rs.i64 = v118; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v128))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v128, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v128, f), 19).v)); } else if (_1285 === 10) { const v129: rs.i128 = rs.i128Cast(v118); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v129))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v129, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v129, f), 39).v)); } else { const v130: rs.isize = rs.i64Low(v118) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v130))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v130, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v130, f), 10).v)); } } else if (_5 === 10) { const buf11: Uint8Array = rs.bytes(16); @@ -2575,51 +2575,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1425 === 0) { const v132: rs.u8 = rs.i128Low(v131) & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v132))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v132, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v132, f), 0).v)); } else if (_1425 === 1) { const v133: rs.u16 = rs.i128Low(v131) & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v133))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v133, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v133, f), 0).v)); } else if (_1425 === 2) { const v134: rs.u32 = rs.i128Low(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v134))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v134, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v134, f), 0).v)); } else if (_1425 === 3) { const v135: rs.u64 = rs.u64Cast(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v135))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v135, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v135, f), 0).v)); } else if (_1425 === 4) { const v136: rs.u128 = rs.u128Cast(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v136))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v136, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v136, f), 0).v)); } else if (_1425 === 5) { const v137: rs.usize = rs.i128Low(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v137))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v137, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v137, f), 0).v)); } else if (_1425 === 6) { const v138: rs.i8 = (rs.i128Low(v131) << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v138))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v138, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v138, f), 3).v)); } else if (_1425 === 7) { const v139: rs.i16 = (rs.i128Low(v131) << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v139))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v139, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v139, f), 5).v)); } else if (_1425 === 8) { const v140: rs.i32 = rs.i128Low(v131) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v140))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v140, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v140, f), 10).v)); } else if (_1425 === 9) { const v141: rs.i64 = rs.i64Cast(v131); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v141))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v141, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v141, f), 19).v)); } else if (_1425 === 10) { const v142: rs.i128 = v131; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v142))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v142, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v142, f), 39).v)); } else { const v143: rs.isize = rs.i128Low(v131) | 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v143))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v143, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v143, f), 10).v)); } } else { const buf12: Uint8Array = rs.bytes(4); @@ -2630,51 +2630,51 @@ export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec if (_1565 === 0) { const v145: rs.u8 = v144 & 0xff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v145))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v145, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v145, f), 0).v)); } else if (_1565 === 1) { const v146: rs.u16 = v144 & 0xffff; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v146))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v146, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v146, f), 0).v)); } else if (_1565 === 2) { const v147: rs.u32 = v144 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v147))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v147, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v147, f), 0).v)); } else if (_1565 === 3) { const v148: rs.u64 = rs.u64Cast(v144); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v148))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v148, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v148, f), 0).v)); } else if (_1565 === 4) { const v149: rs.u128 = rs.u128Cast(v144); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v149))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v149, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v149, f), 0).v)); } else if (_1565 === 5) { const v150: rs.usize = v144 >>> 0; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v150))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v150, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v150, f), 0).v)); } else if (_1565 === 6) { const v151: rs.i8 = (v144 << 24) >> 24; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v151))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v151, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v151, f), 3).v)); } else if (_1565 === 7) { const v152: rs.i16 = (v144 << 16) >> 16; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v152))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v152, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v152, f), 5).v)); } else if (_1565 === 8) { const v153: rs.i32 = v144 as rs.i32; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v153))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v153, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v153, f), 10).v)); } else if (_1565 === 9) { const v154: rs.i64 = v144 as rs.i64; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v154))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v154, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v154, f), 19).v)); } else if (_1565 === 10) { const v155: rs.i128 = v144 as rs.i128; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v155))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v155, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v155, f), 39).v)); } else { const v156: rs.isize = v144; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v156))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v156, f)))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v156, f), 10).v)); } } } @@ -2744,7 +2744,7 @@ export function fromHalves(hi: rs.u32, lo: rs.u32): rs.u64 { } /** `n` in `radix`, without a sign. */ -export function digits(n: rs.u128, radix: rs.u32): string { +export function digits(n: rs.u128, radix: rs.u32): rs.String { const out: rs.ByteVec = new rs.ByteVec(); while (true) { const _8: rs.usize = rs.u128Low(rs.u128Rem(n, radix as rs.u128)); @@ -2763,7 +2763,7 @@ export function digits(n: rs.u128, radix: rs.u32): string { } /** The digits of one more than `s`, in `radix`. */ -export function succ(s: string, radix: rs.u32): string { +export function succ(s: string, radix: rs.u32): rs.String { const out: rs.ByteVec = rs.byteSliceToByteVec(rs.stringAsBytes(s)); const iter: rs.Iter> = rs.iterRev(rs.iterSliceMut(rs.byteVecSlice(out))); while (true) { @@ -2795,24 +2795,24 @@ export function succ(s: string, radix: rs.u32): string { * its bounds and one past them, with signs and leading zeros, at and past the length * below which std skips its overflow checks, malformed signs, and stray characters. */ -export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32): rs.Vec { - const _7: [string, string] = [digits(max, radix), succ(digits(max, radix), radix)]; - const top: string = _7[0]; - const past: string = _7[1]; - const all: rs.Vec = rs.vecFrom([top, rs.fmtFormat(["+", (f: rs.Formatter) => rs.fmtPad(f, top)]), past, rs.fmtFormat(["+", (f: rs.Formatter) => rs.fmtPad(f, past)]), rs.fmtFormat(["000", (f: rs.Formatter) => rs.fmtPad(f, top)])]); - const upper: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.strBytes(top), (b: rs.u8): rs.u8 => { +export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32): rs.Vec { + const _7: [rs.String, rs.String] = [digits(max, radix), succ(digits(max, radix).v, radix)]; + const top: rs.String = _7[0]; + const past: rs.String = _7[1]; + const all: rs.Vec = rs.vecFrom([rs.stringClone(top), rs.fmtFormat(["+", (f: rs.Formatter) => rs.fmtPad(f, top.v)]), rs.stringClone(past), rs.fmtFormat(["+", (f: rs.Formatter) => rs.fmtPad(f, past.v)]), rs.fmtFormat(["000", (f: rs.Formatter) => rs.fmtPad(f, top.v)])]); + const upper: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.strBytes(top.v), (b: rs.u8): rs.u8 => { if (!(b > 57)) { return b; } return rs.u8Sub(b, 32); }), undefined, true); - const _53: string[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, top)]), rs.fmtFormat(["000", (f: rs.Formatter) => rs.fmtPad(f, past)]), rs.resultUnwrap(rs.stringFromUtf8(upper), rs.fmtFromUtf8ErrorDebug)]; + const _53: rs.String[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, top.v)]), rs.fmtFormat(["000", (f: rs.Formatter) => rs.fmtPad(f, past.v)]), rs.resultUnwrap(rs.stringFromUtf8(upper), rs.fmtFromUtf8ErrorDebug)]; rs.iterExtend(all, rs.iterSlice(_53), undefined, 12, true); if (rs.u128Gt(min, 0)) { - const _77: [string, string] = [digits(min, radix), succ(digits(min, radix), radix)]; - const bottom: string = _77[0]; - const below: string = _77[1]; - const _85: string[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, bottom)]), rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, below)]), rs.fmtFormat(["-000", (f: rs.Formatter) => rs.fmtPad(f, bottom)]), rs.fmtFormat(["-00", (f: rs.Formatter) => rs.fmtPad(f, below)])]; + const _77: [rs.String, rs.String] = [digits(min, radix), succ(digits(min, radix).v, radix)]; + const bottom: rs.String = _77[0]; + const below: rs.String = _77[1]; + const _85: rs.String[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, bottom.v)]), rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, below.v)]), rs.fmtFormat(["-000", (f: rs.Formatter) => rs.fmtPad(f, bottom.v)]), rs.fmtFormat(["-00", (f: rs.Formatter) => rs.fmtPad(f, below.v)])]; rs.iterExtend(all, rs.iterSlice(_85), undefined, 12, true); } const unchecked: rs.usize = rs.usizeSub(rs.usizeDiv(bits, 4), rs.u128Gt(min, 0) ? 1 : 0); @@ -2829,14 +2829,14 @@ export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32) break; } const len: rs.usize = _142; - let run: string = ""; + const run: rs.String = rs.stringNew(); const _149: rs.usize = rs.max(len, 1); let iterStart: rs.usize = 0; const iterEnd: rs.usize = _149; while (iterStart++ < iterEnd) { - run = run + String.fromCodePoint(high); + rs.stringPush(run, high); } - const _158: string[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, run)]), run]; + const _158: rs.String[] = [rs.fmtFormat(["-", (f: rs.Formatter) => rs.fmtPad(f, run.v)]), run]; rs.iterExtend(all, rs.iterSlice(_158), undefined, 12, true); } const _172: rs.usize = rs.usizeRem(radix as rs.usize, 36); @@ -2851,9 +2851,10 @@ export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32) if (_193 === rs.DONE) { break; } - all.items.push(_193); + const _199: rs.String = rs.stringFrom(_193); + all.items.push(_199); } - const _202: string[] = [rs.fmtFormat(["1", (f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]), rs.fmtFormat([(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)])]; + const _202: rs.String[] = [rs.fmtFormat(["1", (f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]), rs.fmtFormat([(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)])]; rs.iterExtend(all, rs.iterSlice(_202), undefined, 12, true); return all; } @@ -3043,7 +3044,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _40: rs.Result = num_fromStrRadix$1osjin2(_19.value, radix2); if (_40.ok) { const arg48 = _40.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg48, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg48, f)]).v); } else { const e: rs.ParseIntError = _40.error; const _56: rs.IntErrorKind = e.kind; @@ -3065,7 +3066,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _76: rs.IntErrorKind = e.kind; const args287 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _76), (f: rs.Formatter) => rs.i32Display(kind2, f), (f: rs.Formatter) => rs.fmtBool(over, f)]; - put(out, rs.fmtFormat([args287[0], "|", args287[1], "|", args287[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args287[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args287[0]), "|", args287[3], "|", args287[4]])); + put(out, rs.fmtFormat([args287[0], "|", args287[1], "|", args287[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args287[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args287[0]), "|", args287[3], "|", args287[4]]).v); } if (radix2 === 10) { const parsed: rs.Result = parse$1brosjp(_19.value); @@ -3079,19 +3080,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_15 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(rest)) { const _116: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _117: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_116, _117); - s = s + String.fromCodePoint(_116.data[_116.start + _117] as rs.char); + rs.stringPush(s, _116.data[_116.start + _117] as rs.char); } - const _128: string = s; + const _128: string = s.v; const radix3: rs.u32 = radix; const _131: rs.Result = num_fromStrRadix$1osjin2(_128, radix3); if (_131.ok) { const arg47 = _131.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg47, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg47, f)]).v); } else { const e2: rs.ParseIntError = _131.error; const _147: rs.IntErrorKind = e2.kind; @@ -3113,7 +3114,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _167: rs.IntErrorKind = e2.kind; const args285 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _167), (f: rs.Formatter) => rs.i32Display(kind3, f), (f: rs.Formatter) => rs.fmtBool(over2, f)]; - put(out, rs.fmtFormat([args285[0], "|", args285[1], "|", args285[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args285[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args285[0]), "|", args285[3], "|", args285[4]])); + put(out, rs.fmtFormat([args285[0], "|", args285[1], "|", args285[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args285[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args285[0]), "|", args285[3], "|", args285[4]]).v); } if (radix3 === 10) { const parsed2: rs.Result = parse$1brosjp(_128); @@ -3135,11 +3136,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix4: rs.u32 = _199; for (const _207 of edges(255, 0, 8, radix4).items) { + const _215: string = _207.v; const radix5: rs.u32 = radix4; - const _218: rs.Result = num_fromStrRadix$1osjin2(_207, radix5); + const _218: rs.Result = num_fromStrRadix$1osjin2(_215, radix5); if (_218.ok) { const arg46 = _218.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg46, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg46, f)]).v); } else { const e3: rs.ParseIntError = _218.error; const _234: rs.IntErrorKind = e3.kind; @@ -3161,11 +3163,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _254: rs.IntErrorKind = e3.kind; const args283 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e3, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e3, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _254), (f: rs.Formatter) => rs.i32Display(kind4, f), (f: rs.Formatter) => rs.fmtBool(over3, f)]; - put(out, rs.fmtFormat([args283[0], "|", args283[1], "|", args283[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args283[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args283[0]), "|", args283[3], "|", args283[4]])); + put(out, rs.fmtFormat([args283[0], "|", args283[1], "|", args283[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args283[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args283[0]), "|", args283[3], "|", args283[4]]).v); } if (radix5 === 10) { - const parsed3: rs.Result = parse$1brosjp(_207); - const from3: rs.Result = num_fromStr$1t58fis(_207); + const parsed3: rs.Result = parse$1brosjp(_215); + const from3: rs.Result = num_fromStr$1t58fis(_215); if (from3.ok) { max3 = rs.u8Mul(from3.value === 255 ? 1 : 0, 4); } else { @@ -3192,7 +3194,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _315: rs.Result = num_fromStrRadix$1osjin2(_310, radix7); if (_315.ok) { const arg45 = _315.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg45, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg45, f)]).v); } else { const e4: rs.ParseIntError = _315.error; const _331: rs.IntErrorKind = e4.kind; @@ -3214,7 +3216,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _351: rs.IntErrorKind = e4.kind; const args281 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _351), (f: rs.Formatter) => rs.i32Display(kind5, f), (f: rs.Formatter) => rs.fmtBool(over4, f)]; - put(out, rs.fmtFormat([args281[0], "|", args281[1], "|", args281[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args281[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args281[0]), "|", args281[3], "|", args281[4]])); + put(out, rs.fmtFormat([args281[0], "|", args281[1], "|", args281[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args281[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args281[0]), "|", args281[3], "|", args281[4]]).v); } if (radix7 === 10) { const parsed4: rs.Result = parse$1brosjp(_310); @@ -3249,7 +3251,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _414: rs.Result = num_fromStrRadix$1wu02v6(_393.value, radix9); if (_414.ok) { const arg44 = _414.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg44, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg44, f)]).v); } else { const e5: rs.ParseIntError = _414.error; const _430: rs.IntErrorKind = e5.kind; @@ -3271,7 +3273,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _450: rs.IntErrorKind = e5.kind; const args279 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _450), (f: rs.Formatter) => rs.i32Display(kind6, f), (f: rs.Formatter) => rs.fmtBool(over5, f)]; - put(out, rs.fmtFormat([args279[0], "|", args279[1], "|", args279[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args279[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args279[0]), "|", args279[3], "|", args279[4]])); + put(out, rs.fmtFormat([args279[0], "|", args279[1], "|", args279[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args279[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args279[0]), "|", args279[3], "|", args279[4]]).v); } if (radix9 === 10) { const parsed5: rs.Result = parse$0un0sth(_393.value); @@ -3285,19 +3287,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_389 === 1) { - let s3: string = ""; + const s3: rs.String = rs.stringNew(); for (const b2 of rs.byteSliceView(rest2)) { const _490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _491: rs.usize = rs.usizeRem(b2 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_490, _491); - s3 = s3 + String.fromCodePoint(_490.data[_490.start + _491] as rs.char); + rs.stringPush(s3, _490.data[_490.start + _491] as rs.char); } - const _502: string = s3; + const _502: string = s3.v; const radix10: rs.u32 = radix8; const _505: rs.Result = num_fromStrRadix$1wu02v6(_502, radix10); if (_505.ok) { const arg43 = _505.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg43, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg43, f)]).v); } else { const e6: rs.ParseIntError = _505.error; const _521: rs.IntErrorKind = e6.kind; @@ -3319,7 +3321,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _541: rs.IntErrorKind = e6.kind; const args277 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e6, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e6, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _541), (f: rs.Formatter) => rs.i32Display(kind7, f), (f: rs.Formatter) => rs.fmtBool(over6, f)]; - put(out, rs.fmtFormat([args277[0], "|", args277[1], "|", args277[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args277[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args277[0]), "|", args277[3], "|", args277[4]])); + put(out, rs.fmtFormat([args277[0], "|", args277[1], "|", args277[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args277[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args277[0]), "|", args277[3], "|", args277[4]]).v); } if (radix10 === 10) { const parsed6: rs.Result = parse$0un0sth(_502); @@ -3341,11 +3343,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix11: rs.u32 = _573; for (const _581 of edges(65535, 0, 16, radix11).items) { + const _589: string = _581.v; const radix12: rs.u32 = radix11; - const _592: rs.Result = num_fromStrRadix$1wu02v6(_581, radix12); + const _592: rs.Result = num_fromStrRadix$1wu02v6(_589, radix12); if (_592.ok) { const arg42 = _592.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg42, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg42, f)]).v); } else { const e7: rs.ParseIntError = _592.error; const _608: rs.IntErrorKind = e7.kind; @@ -3367,11 +3370,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _628: rs.IntErrorKind = e7.kind; const args275 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _628), (f: rs.Formatter) => rs.i32Display(kind8, f), (f: rs.Formatter) => rs.fmtBool(over7, f)]; - put(out, rs.fmtFormat([args275[0], "|", args275[1], "|", args275[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args275[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args275[0]), "|", args275[3], "|", args275[4]])); + put(out, rs.fmtFormat([args275[0], "|", args275[1], "|", args275[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args275[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args275[0]), "|", args275[3], "|", args275[4]]).v); } if (radix12 === 10) { - const parsed7: rs.Result = parse$0un0sth(_581); - const from7: rs.Result = num_fromStr$1gvvety(_581); + const parsed7: rs.Result = parse$0un0sth(_589); + const from7: rs.Result = num_fromStr$1gvvety(_589); if (from7.ok) { max7 = rs.u8Mul(from7.value === 65535 ? 1 : 0, 4); } else { @@ -3398,7 +3401,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _689: rs.Result = num_fromStrRadix$1wu02v6(_684, radix14); if (_689.ok) { const arg41 = _689.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg41, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg41, f)]).v); } else { const e8: rs.ParseIntError = _689.error; const _705: rs.IntErrorKind = e8.kind; @@ -3420,7 +3423,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _725: rs.IntErrorKind = e8.kind; const args273 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _725), (f: rs.Formatter) => rs.i32Display(kind9, f), (f: rs.Formatter) => rs.fmtBool(over8, f)]; - put(out, rs.fmtFormat([args273[0], "|", args273[1], "|", args273[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args273[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args273[0]), "|", args273[3], "|", args273[4]])); + put(out, rs.fmtFormat([args273[0], "|", args273[1], "|", args273[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args273[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args273[0]), "|", args273[3], "|", args273[4]]).v); } if (radix14 === 10) { const parsed8: rs.Result = parse$0un0sth(_684); @@ -3455,7 +3458,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _788: rs.Result = num_fromStrRadix$1ftrr55(_767.value, radix16); if (_788.ok) { const arg40 = _788.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg40, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg40, f)]).v); } else { const e9: rs.ParseIntError = _788.error; const _804: rs.IntErrorKind = e9.kind; @@ -3477,7 +3480,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _824: rs.IntErrorKind = e9.kind; const args271 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e9, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e9, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _824), (f: rs.Formatter) => rs.i32Display(kind10, f), (f: rs.Formatter) => rs.fmtBool(over9, f)]; - put(out, rs.fmtFormat([args271[0], "|", args271[1], "|", args271[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args271[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args271[0]), "|", args271[3], "|", args271[4]])); + put(out, rs.fmtFormat([args271[0], "|", args271[1], "|", args271[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args271[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args271[0]), "|", args271[3], "|", args271[4]]).v); } if (radix16 === 10) { const parsed9: rs.Result = parse$069xxen(_767.value); @@ -3491,19 +3494,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_763 === 1) { - let s5: string = ""; + const s5: rs.String = rs.stringNew(); for (const b3 of rs.byteSliceView(rest3)) { const _864: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _865: rs.usize = rs.usizeRem(b3 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_864, _865); - s5 = s5 + String.fromCodePoint(_864.data[_864.start + _865] as rs.char); + rs.stringPush(s5, _864.data[_864.start + _865] as rs.char); } - const _876: string = s5; + const _876: string = s5.v; const radix17: rs.u32 = radix15; const _879: rs.Result = num_fromStrRadix$1ftrr55(_876, radix17); if (_879.ok) { const arg39 = _879.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg39, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg39, f)]).v); } else { const e10: rs.ParseIntError = _879.error; const _895: rs.IntErrorKind = e10.kind; @@ -3525,7 +3528,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _915: rs.IntErrorKind = e10.kind; const args269 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _915), (f: rs.Formatter) => rs.i32Display(kind11, f), (f: rs.Formatter) => rs.fmtBool(over10, f)]; - put(out, rs.fmtFormat([args269[0], "|", args269[1], "|", args269[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args269[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args269[0]), "|", args269[3], "|", args269[4]])); + put(out, rs.fmtFormat([args269[0], "|", args269[1], "|", args269[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args269[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args269[0]), "|", args269[3], "|", args269[4]]).v); } if (radix17 === 10) { const parsed10: rs.Result = parse$069xxen(_876); @@ -3547,11 +3550,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix18: rs.u32 = _947; for (const _955 of edges(4294967295, 0, 32, radix18).items) { + const _963: string = _955.v; const radix19: rs.u32 = radix18; - const _966: rs.Result = num_fromStrRadix$1ftrr55(_955, radix19); + const _966: rs.Result = num_fromStrRadix$1ftrr55(_963, radix19); if (_966.ok) { const arg38 = _966.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg38, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg38, f)]).v); } else { const e11: rs.ParseIntError = _966.error; const _982: rs.IntErrorKind = e11.kind; @@ -3573,11 +3577,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1002: rs.IntErrorKind = e11.kind; const args267 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1002), (f: rs.Formatter) => rs.i32Display(kind12, f), (f: rs.Formatter) => rs.fmtBool(over11, f)]; - put(out, rs.fmtFormat([args267[0], "|", args267[1], "|", args267[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args267[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args267[0]), "|", args267[3], "|", args267[4]])); + put(out, rs.fmtFormat([args267[0], "|", args267[1], "|", args267[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args267[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args267[0]), "|", args267[3], "|", args267[4]]).v); } if (radix19 === 10) { - const parsed11: rs.Result = parse$069xxen(_955); - const from11: rs.Result = num_fromStr$1rjp7t4(_955); + const parsed11: rs.Result = parse$069xxen(_963); + const from11: rs.Result = num_fromStr$1rjp7t4(_963); if (from11.ok) { max11 = rs.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); } else { @@ -3604,7 +3608,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1063: rs.Result = num_fromStrRadix$1ftrr55(_1058, radix21); if (_1063.ok) { const arg37 = _1063.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg37, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg37, f)]).v); } else { const e12: rs.ParseIntError = _1063.error; const _1079: rs.IntErrorKind = e12.kind; @@ -3626,7 +3630,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1099: rs.IntErrorKind = e12.kind; const args265 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e12, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e12, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1099), (f: rs.Formatter) => rs.i32Display(kind13, f), (f: rs.Formatter) => rs.fmtBool(over12, f)]; - put(out, rs.fmtFormat([args265[0], "|", args265[1], "|", args265[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args265[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args265[0]), "|", args265[3], "|", args265[4]])); + put(out, rs.fmtFormat([args265[0], "|", args265[1], "|", args265[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args265[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args265[0]), "|", args265[3], "|", args265[4]]).v); } if (radix21 === 10) { const parsed12: rs.Result = parse$069xxen(_1058); @@ -3661,7 +3665,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1162: rs.Result = num_fromStrRadix$0al5jri(_1141.value, radix23); if (_1162.ok) { const arg36 = _1162.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg36, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg36, f)]).v); } else { const e13: rs.ParseIntError = _1162.error; const _1178: rs.IntErrorKind = e13.kind; @@ -3683,7 +3687,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1198: rs.IntErrorKind = e13.kind; const args263 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1198), (f: rs.Formatter) => rs.i32Display(kind14, f), (f: rs.Formatter) => rs.fmtBool(over13, f)]; - put(out, rs.fmtFormat([args263[0], "|", args263[1], "|", args263[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args263[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args263[0]), "|", args263[3], "|", args263[4]])); + put(out, rs.fmtFormat([args263[0], "|", args263[1], "|", args263[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args263[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args263[0]), "|", args263[3], "|", args263[4]]).v); } if (radix23 === 10) { const parsed13: rs.Result = parse$092epd5(_1141.value); @@ -3697,19 +3701,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_1137 === 1) { - let s7: string = ""; + const s7: rs.String = rs.stringNew(); for (const b4 of rs.byteSliceView(rest4)) { const _1238: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _1239: rs.usize = rs.usizeRem(b4 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_1238, _1239); - s7 = s7 + String.fromCodePoint(_1238.data[_1238.start + _1239] as rs.char); + rs.stringPush(s7, _1238.data[_1238.start + _1239] as rs.char); } - const _1250: string = s7; + const _1250: string = s7.v; const radix24: rs.u32 = radix22; const _1253: rs.Result = num_fromStrRadix$0al5jri(_1250, radix24); if (_1253.ok) { const arg35 = _1253.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg35, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg35, f)]).v); } else { const e14: rs.ParseIntError = _1253.error; const _1269: rs.IntErrorKind = e14.kind; @@ -3731,7 +3735,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1289: rs.IntErrorKind = e14.kind; const args261 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1289), (f: rs.Formatter) => rs.i32Display(kind15, f), (f: rs.Formatter) => rs.fmtBool(over14, f)]; - put(out, rs.fmtFormat([args261[0], "|", args261[1], "|", args261[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args261[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args261[0]), "|", args261[3], "|", args261[4]])); + put(out, rs.fmtFormat([args261[0], "|", args261[1], "|", args261[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args261[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args261[0]), "|", args261[3], "|", args261[4]]).v); } if (radix24 === 10) { const parsed14: rs.Result = parse$092epd5(_1250); @@ -3753,11 +3757,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix25: rs.u32 = _1321; for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 64, radix25).items) { + const _1337: string = _1329.v; const radix26: rs.u32 = radix25; - const _1340: rs.Result = num_fromStrRadix$0al5jri(_1329, radix26); + const _1340: rs.Result = num_fromStrRadix$0al5jri(_1337, radix26); if (_1340.ok) { const arg34 = _1340.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg34, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg34, f)]).v); } else { const e15: rs.ParseIntError = _1340.error; const _1356: rs.IntErrorKind = e15.kind; @@ -3779,11 +3784,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1376: rs.IntErrorKind = e15.kind; const args259 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e15, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e15, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1376), (f: rs.Formatter) => rs.i32Display(kind16, f), (f: rs.Formatter) => rs.fmtBool(over15, f)]; - put(out, rs.fmtFormat([args259[0], "|", args259[1], "|", args259[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args259[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args259[0]), "|", args259[3], "|", args259[4]])); + put(out, rs.fmtFormat([args259[0], "|", args259[1], "|", args259[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args259[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args259[0]), "|", args259[3], "|", args259[4]]).v); } if (radix26 === 10) { - const parsed15: rs.Result = parse$092epd5(_1329); - const from15: rs.Result = num_fromStr$0bkyuqf(_1329); + const parsed15: rs.Result = parse$092epd5(_1337); + const from15: rs.Result = num_fromStr$0bkyuqf(_1337); if (from15.ok) { max15 = rs.u8Mul(rs.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { @@ -3810,7 +3815,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1437: rs.Result = num_fromStrRadix$0al5jri(_1432, radix28); if (_1437.ok) { const arg33 = _1437.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg33, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg33, f)]).v); } else { const e16: rs.ParseIntError = _1437.error; const _1453: rs.IntErrorKind = e16.kind; @@ -3832,7 +3837,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1473: rs.IntErrorKind = e16.kind; const args257 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1473), (f: rs.Formatter) => rs.i32Display(kind17, f), (f: rs.Formatter) => rs.fmtBool(over16, f)]; - put(out, rs.fmtFormat([args257[0], "|", args257[1], "|", args257[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args257[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args257[0]), "|", args257[3], "|", args257[4]])); + put(out, rs.fmtFormat([args257[0], "|", args257[1], "|", args257[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args257[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args257[0]), "|", args257[3], "|", args257[4]]).v); } if (radix28 === 10) { const parsed16: rs.Result = parse$092epd5(_1432); @@ -3867,7 +3872,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1536: rs.Result = num_fromStrRadix$09i2k2a(_1515.value, radix30); if (_1536.ok) { const arg32 = _1536.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg32, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg32, f)]).v); } else { const e17: rs.ParseIntError = _1536.error; const _1552: rs.IntErrorKind = e17.kind; @@ -3889,7 +3894,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1572: rs.IntErrorKind = e17.kind; const args255 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1572), (f: rs.Formatter) => rs.i32Display(kind18, f), (f: rs.Formatter) => rs.fmtBool(over17, f)]; - put(out, rs.fmtFormat([args255[0], "|", args255[1], "|", args255[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args255[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args255[0]), "|", args255[3], "|", args255[4]])); + put(out, rs.fmtFormat([args255[0], "|", args255[1], "|", args255[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args255[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args255[0]), "|", args255[3], "|", args255[4]]).v); } if (radix30 === 10) { const parsed17: rs.Result = parse$11owssr(_1515.value); @@ -3903,19 +3908,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_1511 === 1) { - let s9: string = ""; + const s9: rs.String = rs.stringNew(); for (const b5 of rs.byteSliceView(rest5)) { const _1612: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _1613: rs.usize = rs.usizeRem(b5 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_1612, _1613); - s9 = s9 + String.fromCodePoint(_1612.data[_1612.start + _1613] as rs.char); + rs.stringPush(s9, _1612.data[_1612.start + _1613] as rs.char); } - const _1624: string = s9; + const _1624: string = s9.v; const radix31: rs.u32 = radix29; const _1627: rs.Result = num_fromStrRadix$09i2k2a(_1624, radix31); if (_1627.ok) { const arg31 = _1627.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg31, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg31, f)]).v); } else { const e18: rs.ParseIntError = _1627.error; const _1643: rs.IntErrorKind = e18.kind; @@ -3937,7 +3942,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1663: rs.IntErrorKind = e18.kind; const args253 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e18, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e18, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1663), (f: rs.Formatter) => rs.i32Display(kind19, f), (f: rs.Formatter) => rs.fmtBool(over18, f)]; - put(out, rs.fmtFormat([args253[0], "|", args253[1], "|", args253[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args253[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args253[0]), "|", args253[3], "|", args253[4]])); + put(out, rs.fmtFormat([args253[0], "|", args253[1], "|", args253[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args253[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args253[0]), "|", args253[3], "|", args253[4]]).v); } if (radix31 === 10) { const parsed18: rs.Result = parse$11owssr(_1624); @@ -3959,11 +3964,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix32: rs.u32 = _1695; for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 128, radix32).items) { + const _1710: string = _1702.v; const radix33: rs.u32 = radix32; - const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1702, radix33); + const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1710, radix33); if (_1713.ok) { const arg30 = _1713.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg30, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg30, f)]).v); } else { const e19: rs.ParseIntError = _1713.error; const _1729: rs.IntErrorKind = e19.kind; @@ -3985,11 +3991,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1749: rs.IntErrorKind = e19.kind; const args251 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1749), (f: rs.Formatter) => rs.i32Display(kind20, f), (f: rs.Formatter) => rs.fmtBool(over19, f)]; - put(out, rs.fmtFormat([args251[0], "|", args251[1], "|", args251[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args251[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args251[0]), "|", args251[3], "|", args251[4]])); + put(out, rs.fmtFormat([args251[0], "|", args251[1], "|", args251[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args251[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args251[0]), "|", args251[3], "|", args251[4]]).v); } if (radix33 === 10) { - const parsed19: rs.Result = parse$11owssr(_1702); - const from19: rs.Result = num_fromStr$0ihvy10(_1702); + const parsed19: rs.Result = parse$11owssr(_1710); + const from19: rs.Result = num_fromStr$0ihvy10(_1710); if (from19.ok) { max19 = rs.u8Mul(rs.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { @@ -4016,7 +4022,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1810: rs.Result = num_fromStrRadix$09i2k2a(_1805, radix35); if (_1810.ok) { const arg29 = _1810.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg29, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg29, f)]).v); } else { const e20: rs.ParseIntError = _1810.error; const _1826: rs.IntErrorKind = e20.kind; @@ -4038,7 +4044,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1846: rs.IntErrorKind = e20.kind; const args249 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1846), (f: rs.Formatter) => rs.i32Display(kind21, f), (f: rs.Formatter) => rs.fmtBool(over20, f)]; - put(out, rs.fmtFormat([args249[0], "|", args249[1], "|", args249[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args249[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args249[0]), "|", args249[3], "|", args249[4]])); + put(out, rs.fmtFormat([args249[0], "|", args249[1], "|", args249[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args249[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args249[0]), "|", args249[3], "|", args249[4]]).v); } if (radix35 === 10) { const parsed20: rs.Result = parse$11owssr(_1805); @@ -4073,7 +4079,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _1909: rs.Result = num_fromStrRadix$1479ec4(_1888.value, radix37); if (_1909.ok) { const arg28 = _1909.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg28, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg28, f)]).v); } else { const e21: rs.ParseIntError = _1909.error; const _1925: rs.IntErrorKind = e21.kind; @@ -4095,7 +4101,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _1945: rs.IntErrorKind = e21.kind; const args247 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e21, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e21, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1945), (f: rs.Formatter) => rs.i32Display(kind22, f), (f: rs.Formatter) => rs.fmtBool(over21, f)]; - put(out, rs.fmtFormat([args247[0], "|", args247[1], "|", args247[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args247[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args247[0]), "|", args247[3], "|", args247[4]])); + put(out, rs.fmtFormat([args247[0], "|", args247[1], "|", args247[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args247[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args247[0]), "|", args247[3], "|", args247[4]]).v); } if (radix37 === 10) { const parsed21: rs.Result = parse$07zoymb(_1888.value); @@ -4109,19 +4115,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_1884 === 1) { - let s11: string = ""; + const s11: rs.String = rs.stringNew(); for (const b6 of rs.byteSliceView(rest6)) { const _1985: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _1986: rs.usize = rs.usizeRem(b6 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_1985, _1986); - s11 = s11 + String.fromCodePoint(_1985.data[_1985.start + _1986] as rs.char); + rs.stringPush(s11, _1985.data[_1985.start + _1986] as rs.char); } - const _1997: string = s11; + const _1997: string = s11.v; const radix38: rs.u32 = radix36; const _2000: rs.Result = num_fromStrRadix$1479ec4(_1997, radix38); if (_2000.ok) { const arg27 = _2000.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg27, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg27, f)]).v); } else { const e22: rs.ParseIntError = _2000.error; const _2016: rs.IntErrorKind = e22.kind; @@ -4143,7 +4149,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2036: rs.IntErrorKind = e22.kind; const args245 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2036), (f: rs.Formatter) => rs.i32Display(kind23, f), (f: rs.Formatter) => rs.fmtBool(over22, f)]; - put(out, rs.fmtFormat([args245[0], "|", args245[1], "|", args245[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args245[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args245[0]), "|", args245[3], "|", args245[4]])); + put(out, rs.fmtFormat([args245[0], "|", args245[1], "|", args245[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args245[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args245[0]), "|", args245[3], "|", args245[4]]).v); } if (radix38 === 10) { const parsed22: rs.Result = parse$07zoymb(_1997); @@ -4165,11 +4171,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix39: rs.u32 = _2068; for (const _2076 of edges(4294967295, 0, 32, radix39).items) { + const _2084: string = _2076.v; const radix40: rs.u32 = radix39; - const _2087: rs.Result = num_fromStrRadix$1479ec4(_2076, radix40); + const _2087: rs.Result = num_fromStrRadix$1479ec4(_2084, radix40); if (_2087.ok) { const arg26 = _2087.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg26, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg26, f)]).v); } else { const e23: rs.ParseIntError = _2087.error; const _2103: rs.IntErrorKind = e23.kind; @@ -4191,11 +4198,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2123: rs.IntErrorKind = e23.kind; const args243 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2123), (f: rs.Formatter) => rs.i32Display(kind24, f), (f: rs.Formatter) => rs.fmtBool(over23, f)]; - put(out, rs.fmtFormat([args243[0], "|", args243[1], "|", args243[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args243[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args243[0]), "|", args243[3], "|", args243[4]])); + put(out, rs.fmtFormat([args243[0], "|", args243[1], "|", args243[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args243[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args243[0]), "|", args243[3], "|", args243[4]]).v); } if (radix40 === 10) { - const parsed23: rs.Result = parse$07zoymb(_2076); - const from23: rs.Result = num_fromStr$1jgkxdq(_2076); + const parsed23: rs.Result = parse$07zoymb(_2084); + const from23: rs.Result = num_fromStr$1jgkxdq(_2084); if (from23.ok) { max23 = rs.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); } else { @@ -4222,7 +4229,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2184: rs.Result = num_fromStrRadix$1479ec4(_2179, radix42); if (_2184.ok) { const arg25 = _2184.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg25, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg25, f)]).v); } else { const e24: rs.ParseIntError = _2184.error; const _2200: rs.IntErrorKind = e24.kind; @@ -4244,7 +4251,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2220: rs.IntErrorKind = e24.kind; const args241 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e24, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e24, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2220), (f: rs.Formatter) => rs.i32Display(kind25, f), (f: rs.Formatter) => rs.fmtBool(over24, f)]; - put(out, rs.fmtFormat([args241[0], "|", args241[1], "|", args241[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args241[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args241[0]), "|", args241[3], "|", args241[4]])); + put(out, rs.fmtFormat([args241[0], "|", args241[1], "|", args241[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args241[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args241[0]), "|", args241[3], "|", args241[4]]).v); } if (radix42 === 10) { const parsed24: rs.Result = parse$07zoymb(_2179); @@ -4279,7 +4286,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2283: rs.Result = num_fromStrRadix$0qyezqs(_2262.value, radix44); if (_2283.ok) { const arg24 = _2283.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg24, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg24, f)]).v); } else { const e25: rs.ParseIntError = _2283.error; const _2299: rs.IntErrorKind = e25.kind; @@ -4301,7 +4308,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2319: rs.IntErrorKind = e25.kind; const args239 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2319), (f: rs.Formatter) => rs.i32Display(kind26, f), (f: rs.Formatter) => rs.fmtBool(over25, f)]; - put(out, rs.fmtFormat([args239[0], "|", args239[1], "|", args239[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args239[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args239[0]), "|", args239[3], "|", args239[4]])); + put(out, rs.fmtFormat([args239[0], "|", args239[1], "|", args239[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args239[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args239[0]), "|", args239[3], "|", args239[4]]).v); } if (radix44 === 10) { const parsed25: rs.Result = parse$02m1946(_2262.value); @@ -4315,19 +4322,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_2258 === 1) { - let s13: string = ""; + const s13: rs.String = rs.stringNew(); for (const b7 of rs.byteSliceView(rest7)) { const _2359: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _2360: rs.usize = rs.usizeRem(b7 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_2359, _2360); - s13 = s13 + String.fromCodePoint(_2359.data[_2359.start + _2360] as rs.char); + rs.stringPush(s13, _2359.data[_2359.start + _2360] as rs.char); } - const _2371: string = s13; + const _2371: string = s13.v; const radix45: rs.u32 = radix43; const _2374: rs.Result = num_fromStrRadix$0qyezqs(_2371, radix45); if (_2374.ok) { const arg23 = _2374.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg23, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg23, f)]).v); } else { const e26: rs.ParseIntError = _2374.error; const _2390: rs.IntErrorKind = e26.kind; @@ -4349,7 +4356,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2410: rs.IntErrorKind = e26.kind; const args237 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2410), (f: rs.Formatter) => rs.i32Display(kind27, f), (f: rs.Formatter) => rs.fmtBool(over26, f)]; - put(out, rs.fmtFormat([args237[0], "|", args237[1], "|", args237[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args237[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args237[0]), "|", args237[3], "|", args237[4]])); + put(out, rs.fmtFormat([args237[0], "|", args237[1], "|", args237[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args237[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args237[0]), "|", args237[3], "|", args237[4]]).v); } if (radix45 === 10) { const parsed26: rs.Result = parse$02m1946(_2371); @@ -4371,11 +4378,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix46: rs.u32 = _2442; for (const _2453 of edges(127, rs.u128Add(127, 1), 8, radix46).items) { + const _2461: string = _2453.v; const radix47: rs.u32 = radix46; - const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2453, radix47); + const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2461, radix47); if (_2464.ok) { const arg22 = _2464.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg22, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg22, f)]).v); } else { const e27: rs.ParseIntError = _2464.error; const _2480: rs.IntErrorKind = e27.kind; @@ -4397,11 +4405,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2500: rs.IntErrorKind = e27.kind; const args235 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e27, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e27, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2500), (f: rs.Formatter) => rs.i32Display(kind28, f), (f: rs.Formatter) => rs.fmtBool(over27, f)]; - put(out, rs.fmtFormat([args235[0], "|", args235[1], "|", args235[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args235[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args235[0]), "|", args235[3], "|", args235[4]])); + put(out, rs.fmtFormat([args235[0], "|", args235[1], "|", args235[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args235[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args235[0]), "|", args235[3], "|", args235[4]]).v); } if (radix47 === 10) { - const parsed27: rs.Result = parse$02m1946(_2453); - const from27: rs.Result = num_fromStr$1amqoj7(_2453); + const parsed27: rs.Result = parse$02m1946(_2461); + const from27: rs.Result = num_fromStr$1amqoj7(_2461); if (from27.ok) { max27 = rs.u8Mul(from27.value === 127 ? 1 : 0, 4); } else { @@ -4428,7 +4436,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2561: rs.Result = num_fromStrRadix$0qyezqs(_2556, radix49); if (_2561.ok) { const arg21 = _2561.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg21, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg21, f)]).v); } else { const e28: rs.ParseIntError = _2561.error; const _2577: rs.IntErrorKind = e28.kind; @@ -4450,7 +4458,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2597: rs.IntErrorKind = e28.kind; const args233 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2597), (f: rs.Formatter) => rs.i32Display(kind29, f), (f: rs.Formatter) => rs.fmtBool(over28, f)]; - put(out, rs.fmtFormat([args233[0], "|", args233[1], "|", args233[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args233[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args233[0]), "|", args233[3], "|", args233[4]])); + put(out, rs.fmtFormat([args233[0], "|", args233[1], "|", args233[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args233[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args233[0]), "|", args233[3], "|", args233[4]]).v); } if (radix49 === 10) { const parsed28: rs.Result = parse$02m1946(_2556); @@ -4485,7 +4493,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2660: rs.Result = num_fromStrRadix$19vdb8q(_2639.value, radix51); if (_2660.ok) { const arg20 = _2660.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg20, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg20, f)]).v); } else { const e29: rs.ParseIntError = _2660.error; const _2676: rs.IntErrorKind = e29.kind; @@ -4507,7 +4515,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2696: rs.IntErrorKind = e29.kind; const args231 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2696), (f: rs.Formatter) => rs.i32Display(kind30, f), (f: rs.Formatter) => rs.fmtBool(over29, f)]; - put(out, rs.fmtFormat([args231[0], "|", args231[1], "|", args231[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args231[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args231[0]), "|", args231[3], "|", args231[4]])); + put(out, rs.fmtFormat([args231[0], "|", args231[1], "|", args231[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args231[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args231[0]), "|", args231[3], "|", args231[4]]).v); } if (radix51 === 10) { const parsed29: rs.Result = parse$00ajhlu(_2639.value); @@ -4521,19 +4529,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_2635 === 1) { - let s15: string = ""; + const s15: rs.String = rs.stringNew(); for (const b8 of rs.byteSliceView(rest8)) { const _2736: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _2737: rs.usize = rs.usizeRem(b8 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_2736, _2737); - s15 = s15 + String.fromCodePoint(_2736.data[_2736.start + _2737] as rs.char); + rs.stringPush(s15, _2736.data[_2736.start + _2737] as rs.char); } - const _2748: string = s15; + const _2748: string = s15.v; const radix52: rs.u32 = radix50; const _2751: rs.Result = num_fromStrRadix$19vdb8q(_2748, radix52); if (_2751.ok) { const arg19 = _2751.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg19, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg19, f)]).v); } else { const e30: rs.ParseIntError = _2751.error; const _2767: rs.IntErrorKind = e30.kind; @@ -4555,7 +4563,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2787: rs.IntErrorKind = e30.kind; const args229 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e30, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e30, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2787), (f: rs.Formatter) => rs.i32Display(kind31, f), (f: rs.Formatter) => rs.fmtBool(over30, f)]; - put(out, rs.fmtFormat([args229[0], "|", args229[1], "|", args229[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args229[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args229[0]), "|", args229[3], "|", args229[4]])); + put(out, rs.fmtFormat([args229[0], "|", args229[1], "|", args229[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args229[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args229[0]), "|", args229[3], "|", args229[4]]).v); } if (radix52 === 10) { const parsed30: rs.Result = parse$00ajhlu(_2748); @@ -4577,11 +4585,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix53: rs.u32 = _2819; for (const _2830 of edges(32767, rs.u128Add(32767, 1), 16, radix53).items) { + const _2838: string = _2830.v; const radix54: rs.u32 = radix53; - const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2830, radix54); + const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2838, radix54); if (_2841.ok) { const arg18 = _2841.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg18, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg18, f)]).v); } else { const e31: rs.ParseIntError = _2841.error; const _2857: rs.IntErrorKind = e31.kind; @@ -4603,11 +4612,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2877: rs.IntErrorKind = e31.kind; const args227 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2877), (f: rs.Formatter) => rs.i32Display(kind32, f), (f: rs.Formatter) => rs.fmtBool(over31, f)]; - put(out, rs.fmtFormat([args227[0], "|", args227[1], "|", args227[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args227[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args227[0]), "|", args227[3], "|", args227[4]])); + put(out, rs.fmtFormat([args227[0], "|", args227[1], "|", args227[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args227[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args227[0]), "|", args227[3], "|", args227[4]]).v); } if (radix54 === 10) { - const parsed31: rs.Result = parse$00ajhlu(_2830); - const from31: rs.Result = num_fromStr$0ehcbzz(_2830); + const parsed31: rs.Result = parse$00ajhlu(_2838); + const from31: rs.Result = num_fromStr$0ehcbzz(_2838); if (from31.ok) { max31 = rs.u8Mul(from31.value === 32767 ? 1 : 0, 4); } else { @@ -4634,7 +4643,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _2938: rs.Result = num_fromStrRadix$19vdb8q(_2933, radix56); if (_2938.ok) { const arg17 = _2938.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg17, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg17, f)]).v); } else { const e32: rs.ParseIntError = _2938.error; const _2954: rs.IntErrorKind = e32.kind; @@ -4656,7 +4665,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _2974: rs.IntErrorKind = e32.kind; const args225 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2974), (f: rs.Formatter) => rs.i32Display(kind33, f), (f: rs.Formatter) => rs.fmtBool(over32, f)]; - put(out, rs.fmtFormat([args225[0], "|", args225[1], "|", args225[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args225[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args225[0]), "|", args225[3], "|", args225[4]])); + put(out, rs.fmtFormat([args225[0], "|", args225[1], "|", args225[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args225[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args225[0]), "|", args225[3], "|", args225[4]]).v); } if (radix56 === 10) { const parsed32: rs.Result = parse$00ajhlu(_2933); @@ -4691,7 +4700,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3037: rs.Result = num_fromStrRadix$1ct8u92(_3016.value, radix58); if (_3037.ok) { const arg16 = _3037.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg16, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg16, f)]).v); } else { const e33: rs.ParseIntError = _3037.error; const _3053: rs.IntErrorKind = e33.kind; @@ -4713,7 +4722,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3073: rs.IntErrorKind = e33.kind; const args223 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e33, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e33, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3073), (f: rs.Formatter) => rs.i32Display(kind34, f), (f: rs.Formatter) => rs.fmtBool(over33, f)]; - put(out, rs.fmtFormat([args223[0], "|", args223[1], "|", args223[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args223[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args223[0]), "|", args223[3], "|", args223[4]])); + put(out, rs.fmtFormat([args223[0], "|", args223[1], "|", args223[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args223[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args223[0]), "|", args223[3], "|", args223[4]]).v); } if (radix58 === 10) { const parsed33: rs.Result = parse$14v13am(_3016.value); @@ -4727,19 +4736,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_3012 === 1) { - let s17: string = ""; + const s17: rs.String = rs.stringNew(); for (const b9 of rs.byteSliceView(rest9)) { const _3113: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _3114: rs.usize = rs.usizeRem(b9 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_3113, _3114); - s17 = s17 + String.fromCodePoint(_3113.data[_3113.start + _3114] as rs.char); + rs.stringPush(s17, _3113.data[_3113.start + _3114] as rs.char); } - const _3125: string = s17; + const _3125: string = s17.v; const radix59: rs.u32 = radix57; const _3128: rs.Result = num_fromStrRadix$1ct8u92(_3125, radix59); if (_3128.ok) { const arg15 = _3128.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg15, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg15, f)]).v); } else { const e34: rs.ParseIntError = _3128.error; const _3144: rs.IntErrorKind = e34.kind; @@ -4761,7 +4770,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3164: rs.IntErrorKind = e34.kind; const args221 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3164), (f: rs.Formatter) => rs.i32Display(kind35, f), (f: rs.Formatter) => rs.fmtBool(over34, f)]; - put(out, rs.fmtFormat([args221[0], "|", args221[1], "|", args221[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args221[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args221[0]), "|", args221[3], "|", args221[4]])); + put(out, rs.fmtFormat([args221[0], "|", args221[1], "|", args221[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args221[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args221[0]), "|", args221[3], "|", args221[4]]).v); } if (radix59 === 10) { const parsed34: rs.Result = parse$14v13am(_3125); @@ -4783,11 +4792,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix60: rs.u32 = _3196; for (const _3207 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix60).items) { + const _3215: string = _3207.v; const radix61: rs.u32 = radix60; - const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3207, radix61); + const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3215, radix61); if (_3218.ok) { const arg14 = _3218.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg14, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg14, f)]).v); } else { const e35: rs.ParseIntError = _3218.error; const _3234: rs.IntErrorKind = e35.kind; @@ -4809,11 +4819,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3254: rs.IntErrorKind = e35.kind; const args219 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3254), (f: rs.Formatter) => rs.i32Display(kind36, f), (f: rs.Formatter) => rs.fmtBool(over35, f)]; - put(out, rs.fmtFormat([args219[0], "|", args219[1], "|", args219[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args219[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args219[0]), "|", args219[3], "|", args219[4]])); + put(out, rs.fmtFormat([args219[0], "|", args219[1], "|", args219[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args219[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args219[0]), "|", args219[3], "|", args219[4]]).v); } if (radix61 === 10) { - const parsed35: rs.Result = parse$14v13am(_3207); - const from35: rs.Result = num_fromStr$1ckv470(_3207); + const parsed35: rs.Result = parse$14v13am(_3215); + const from35: rs.Result = num_fromStr$1ckv470(_3215); if (from35.ok) { max35 = rs.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); } else { @@ -4840,7 +4850,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3315: rs.Result = num_fromStrRadix$1ct8u92(_3310, radix63); if (_3315.ok) { const arg13 = _3315.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg13, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg13, f)]).v); } else { const e36: rs.ParseIntError = _3315.error; const _3331: rs.IntErrorKind = e36.kind; @@ -4862,7 +4872,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3351: rs.IntErrorKind = e36.kind; const args217 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e36, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e36, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3351), (f: rs.Formatter) => rs.i32Display(kind37, f), (f: rs.Formatter) => rs.fmtBool(over36, f)]; - put(out, rs.fmtFormat([args217[0], "|", args217[1], "|", args217[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args217[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args217[0]), "|", args217[3], "|", args217[4]])); + put(out, rs.fmtFormat([args217[0], "|", args217[1], "|", args217[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args217[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args217[0]), "|", args217[3], "|", args217[4]]).v); } if (radix63 === 10) { const parsed36: rs.Result = parse$14v13am(_3310); @@ -4897,7 +4907,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3414: rs.Result = num_fromStrRadix$04fc4zz(_3393.value, radix65); if (_3414.ok) { const arg12 = _3414.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg12, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg12, f)]).v); } else { const e37: rs.ParseIntError = _3414.error; const _3430: rs.IntErrorKind = e37.kind; @@ -4919,7 +4929,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3450: rs.IntErrorKind = e37.kind; const args215 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3450), (f: rs.Formatter) => rs.i32Display(kind38, f), (f: rs.Formatter) => rs.fmtBool(over37, f)]; - put(out, rs.fmtFormat([args215[0], "|", args215[1], "|", args215[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args215[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args215[0]), "|", args215[3], "|", args215[4]])); + put(out, rs.fmtFormat([args215[0], "|", args215[1], "|", args215[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args215[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args215[0]), "|", args215[3], "|", args215[4]]).v); } if (radix65 === 10) { const parsed37: rs.Result = parse$0px1msj(_3393.value); @@ -4933,19 +4943,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_3389 === 1) { - let s19: string = ""; + const s19: rs.String = rs.stringNew(); for (const b10 of rs.byteSliceView(rest10)) { const _3490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _3491: rs.usize = rs.usizeRem(b10 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_3490, _3491); - s19 = s19 + String.fromCodePoint(_3490.data[_3490.start + _3491] as rs.char); + rs.stringPush(s19, _3490.data[_3490.start + _3491] as rs.char); } - const _3502: string = s19; + const _3502: string = s19.v; const radix66: rs.u32 = radix64; const _3505: rs.Result = num_fromStrRadix$04fc4zz(_3502, radix66); if (_3505.ok) { const arg11 = _3505.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg11, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg11, f)]).v); } else { const e38: rs.ParseIntError = _3505.error; const _3521: rs.IntErrorKind = e38.kind; @@ -4967,7 +4977,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3541: rs.IntErrorKind = e38.kind; const args213 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e38, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3541), (f: rs.Formatter) => rs.i32Display(kind39, f), (f: rs.Formatter) => rs.fmtBool(over38, f)]; - put(out, rs.fmtFormat([args213[0], "|", args213[1], "|", args213[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args213[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args213[0]), "|", args213[3], "|", args213[4]])); + put(out, rs.fmtFormat([args213[0], "|", args213[1], "|", args213[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args213[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args213[0]), "|", args213[3], "|", args213[4]]).v); } if (radix66 === 10) { const parsed38: rs.Result = parse$0px1msj(_3502); @@ -4989,11 +4999,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix67: rs.u32 = _3573; for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, 1), 64, radix67).items) { + const _3592: string = _3584.v; const radix68: rs.u32 = radix67; - const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3584, radix68); + const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3592, radix68); if (_3595.ok) { const arg10 = _3595.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg10, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg10, f)]).v); } else { const e39: rs.ParseIntError = _3595.error; const _3611: rs.IntErrorKind = e39.kind; @@ -5015,11 +5026,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3631: rs.IntErrorKind = e39.kind; const args211 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e39, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e39, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3631), (f: rs.Formatter) => rs.i32Display(kind40, f), (f: rs.Formatter) => rs.fmtBool(over39, f)]; - put(out, rs.fmtFormat([args211[0], "|", args211[1], "|", args211[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args211[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args211[0]), "|", args211[3], "|", args211[4]])); + put(out, rs.fmtFormat([args211[0], "|", args211[1], "|", args211[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args211[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args211[0]), "|", args211[3], "|", args211[4]]).v); } if (radix68 === 10) { - const parsed39: rs.Result = parse$0px1msj(_3584); - const from39: rs.Result = num_fromStr$00n8jbp(_3584); + const parsed39: rs.Result = parse$0px1msj(_3592); + const from39: rs.Result = num_fromStr$00n8jbp(_3592); if (from39.ok) { max39 = rs.u8Mul(rs.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { @@ -5046,7 +5057,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3692: rs.Result = num_fromStrRadix$04fc4zz(_3687, radix70); if (_3692.ok) { const arg9 = _3692.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg9, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg9, f)]).v); } else { const e40: rs.ParseIntError = _3692.error; const _3708: rs.IntErrorKind = e40.kind; @@ -5068,7 +5079,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3728: rs.IntErrorKind = e40.kind; const args209 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e40, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e40, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3728), (f: rs.Formatter) => rs.i32Display(kind41, f), (f: rs.Formatter) => rs.fmtBool(over40, f)]; - put(out, rs.fmtFormat([args209[0], "|", args209[1], "|", args209[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args209[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args209[0]), "|", args209[3], "|", args209[4]])); + put(out, rs.fmtFormat([args209[0], "|", args209[1], "|", args209[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args209[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args209[0]), "|", args209[3], "|", args209[4]]).v); } if (radix70 === 10) { const parsed40: rs.Result = parse$0px1msj(_3687); @@ -5103,7 +5114,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _3791: rs.Result = num_fromStrRadix$0cysu2u(_3770.value, radix72); if (_3791.ok) { const arg8 = _3791.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg8, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg8, f)]).v); } else { const e41: rs.ParseIntError = _3791.error; const _3807: rs.IntErrorKind = e41.kind; @@ -5125,7 +5136,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3827: rs.IntErrorKind = e41.kind; const args207 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e41, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e41, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3827), (f: rs.Formatter) => rs.i32Display(kind42, f), (f: rs.Formatter) => rs.fmtBool(over41, f)]; - put(out, rs.fmtFormat([args207[0], "|", args207[1], "|", args207[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args207[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args207[0]), "|", args207[3], "|", args207[4]])); + put(out, rs.fmtFormat([args207[0], "|", args207[1], "|", args207[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args207[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args207[0]), "|", args207[3], "|", args207[4]]).v); } if (radix72 === 10) { const parsed41: rs.Result = parse$1kyj9pm(_3770.value); @@ -5139,19 +5150,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_3766 === 1) { - let s21: string = ""; + const s21: rs.String = rs.stringNew(); for (const b11 of rs.byteSliceView(rest11)) { const _3867: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _3868: rs.usize = rs.usizeRem(b11 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_3867, _3868); - s21 = s21 + String.fromCodePoint(_3867.data[_3867.start + _3868] as rs.char); + rs.stringPush(s21, _3867.data[_3867.start + _3868] as rs.char); } - const _3879: string = s21; + const _3879: string = s21.v; const radix73: rs.u32 = radix71; const _3882: rs.Result = num_fromStrRadix$0cysu2u(_3879, radix73); if (_3882.ok) { const arg7 = _3882.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg7, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg7, f)]).v); } else { const e42: rs.ParseIntError = _3882.error; const _3898: rs.IntErrorKind = e42.kind; @@ -5173,7 +5184,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _3918: rs.IntErrorKind = e42.kind; const args205 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e42, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e42, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3918), (f: rs.Formatter) => rs.i32Display(kind43, f), (f: rs.Formatter) => rs.fmtBool(over42, f)]; - put(out, rs.fmtFormat([args205[0], "|", args205[1], "|", args205[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args205[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args205[0]), "|", args205[3], "|", args205[4]])); + put(out, rs.fmtFormat([args205[0], "|", args205[1], "|", args205[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args205[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args205[0]), "|", args205[3], "|", args205[4]]).v); } if (radix73 === 10) { const parsed42: rs.Result = parse$1kyj9pm(_3879); @@ -5195,11 +5206,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix74: rs.u32 = _3950; for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 1), 128, radix74).items) { + const _3969: string = _3961.v; const radix75: rs.u32 = radix74; - const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3961, radix75); + const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3969, radix75); if (_3972.ok) { const arg6 = _3972.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg6, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg6, f)]).v); } else { const e43: rs.ParseIntError = _3972.error; const _3988: rs.IntErrorKind = e43.kind; @@ -5221,11 +5233,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4008: rs.IntErrorKind = e43.kind; const args203 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e43, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e43, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4008), (f: rs.Formatter) => rs.i32Display(kind44, f), (f: rs.Formatter) => rs.fmtBool(over43, f)]; - put(out, rs.fmtFormat([args203[0], "|", args203[1], "|", args203[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args203[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args203[0]), "|", args203[3], "|", args203[4]])); + put(out, rs.fmtFormat([args203[0], "|", args203[1], "|", args203[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args203[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args203[0]), "|", args203[3], "|", args203[4]]).v); } if (radix75 === 10) { - const parsed43: rs.Result = parse$1kyj9pm(_3961); - const from43: rs.Result = num_fromStr$1el0yvy(_3961); + const parsed43: rs.Result = parse$1kyj9pm(_3969); + const from43: rs.Result = num_fromStr$1el0yvy(_3969); if (from43.ok) { max43 = rs.u8Mul(rs.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { @@ -5252,7 +5264,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4069: rs.Result = num_fromStrRadix$0cysu2u(_4064, radix77); if (_4069.ok) { const arg5 = _4069.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg5, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg5, f)]).v); } else { const e44: rs.ParseIntError = _4069.error; const _4085: rs.IntErrorKind = e44.kind; @@ -5274,7 +5286,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4105: rs.IntErrorKind = e44.kind; const args201 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e44, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e44, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4105), (f: rs.Formatter) => rs.i32Display(kind45, f), (f: rs.Formatter) => rs.fmtBool(over44, f)]; - put(out, rs.fmtFormat([args201[0], "|", args201[1], "|", args201[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args201[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args201[0]), "|", args201[3], "|", args201[4]])); + put(out, rs.fmtFormat([args201[0], "|", args201[1], "|", args201[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args201[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args201[0]), "|", args201[3], "|", args201[4]]).v); } if (radix77 === 10) { const parsed44: rs.Result = parse$1kyj9pm(_4064); @@ -5309,7 +5321,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4168: rs.Result = num_fromStrRadix$1nys6eo(_4147.value, radix79); if (_4168.ok) { const arg4 = _4168.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg4, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg4, f)]).v); } else { const e45: rs.ParseIntError = _4168.error; const _4184: rs.IntErrorKind = e45.kind; @@ -5331,7 +5343,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4204: rs.IntErrorKind = e45.kind; const args199 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e45, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e45, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4204), (f: rs.Formatter) => rs.i32Display(kind46, f), (f: rs.Formatter) => rs.fmtBool(over45, f)]; - put(out, rs.fmtFormat([args199[0], "|", args199[1], "|", args199[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args199[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args199[0]), "|", args199[3], "|", args199[4]])); + put(out, rs.fmtFormat([args199[0], "|", args199[1], "|", args199[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args199[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args199[0]), "|", args199[3], "|", args199[4]]).v); } if (radix79 === 10) { const parsed45: rs.Result = parse$1g90yxu(_4147.value); @@ -5345,19 +5357,19 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } } } else if (_4143 === 1) { - let s23: string = ""; + const s23: rs.String = rs.stringNew(); for (const b12 of rs.byteSliceView(rest12)) { const _4244: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); const _4245: rs.usize = rs.usizeRem(b12 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); rs.idx(_4244, _4245); - s23 = s23 + String.fromCodePoint(_4244.data[_4244.start + _4245] as rs.char); + rs.stringPush(s23, _4244.data[_4244.start + _4245] as rs.char); } - const _4256: string = s23; + const _4256: string = s23.v; const radix80: rs.u32 = radix78; const _4259: rs.Result = num_fromStrRadix$1nys6eo(_4256, radix80); if (_4259.ok) { const arg3 = _4259.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg3, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg3, f)]).v); } else { const e46: rs.ParseIntError = _4259.error; const _4275: rs.IntErrorKind = e46.kind; @@ -5379,7 +5391,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4295: rs.IntErrorKind = e46.kind; const args197 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e46, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e46, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4295), (f: rs.Formatter) => rs.i32Display(kind47, f), (f: rs.Formatter) => rs.fmtBool(over46, f)]; - put(out, rs.fmtFormat([args197[0], "|", args197[1], "|", args197[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args197[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args197[0]), "|", args197[3], "|", args197[4]])); + put(out, rs.fmtFormat([args197[0], "|", args197[1], "|", args197[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args197[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args197[0]), "|", args197[3], "|", args197[4]]).v); } if (radix80 === 10) { const parsed46: rs.Result = parse$1g90yxu(_4256); @@ -5401,11 +5413,12 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const radix81: rs.u32 = _4327; for (const _4338 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix81).items) { + const _4346: string = _4338.v; const radix82: rs.u32 = radix81; - const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4338, radix82); + const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4346, radix82); if (_4349.ok) { const arg2 = _4349.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]).v); } else { const e47: rs.ParseIntError = _4349.error; const _4365: rs.IntErrorKind = e47.kind; @@ -5427,11 +5440,11 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4385: rs.IntErrorKind = e47.kind; const args195 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e47, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e47, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4385), (f: rs.Formatter) => rs.i32Display(kind48, f), (f: rs.Formatter) => rs.fmtBool(over47, f)]; - put(out, rs.fmtFormat([args195[0], "|", args195[1], "|", args195[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args195[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args195[0]), "|", args195[3], "|", args195[4]])); + put(out, rs.fmtFormat([args195[0], "|", args195[1], "|", args195[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args195[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args195[0]), "|", args195[3], "|", args195[4]]).v); } if (radix82 === 10) { - const parsed47: rs.Result = parse$1g90yxu(_4338); - const from47: rs.Result = num_fromStr$0ytcpik(_4338); + const parsed47: rs.Result = parse$1g90yxu(_4346); + const from47: rs.Result = num_fromStr$0ytcpik(_4346); if (from47.ok) { max47 = rs.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); } else { @@ -5458,7 +5471,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const _4446: rs.Result = num_fromStrRadix$1nys6eo(_4441, radix84); if (_4446.ok) { const arg = _4446.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg, f)]).v); } else { const e48: rs.ParseIntError = _4446.error; const _4462: rs.IntErrorKind = e48.kind; @@ -5480,7 +5493,7 @@ export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat } const _4482: rs.IntErrorKind = e48.kind; const args193 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e48, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e48, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4482), (f: rs.Formatter) => rs.i32Display(kind49, f), (f: rs.Formatter) => rs.fmtBool(over48, f)]; - put(out, rs.fmtFormat([args193[0], "|", args193[1], "|", args193[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args193[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args193[0]), "|", args193[3], "|", args193[4]])); + put(out, rs.fmtFormat([args193[0], "|", args193[1], "|", args193[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args193[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args193[0]), "|", args193[3], "|", args193[4]]).v); } if (radix84 === 10) { const parsed48: rs.Result = parse$1g90yxu(_4441); diff --git a/ts/fixtures/lang/iters/expected/core/option.ts b/ts/fixtures/lang/iters/expected/core/option.ts index ffb5a6222..a8dfac397 100644 --- a/ts/fixtures/lang/iters/expected/core/option.ts +++ b/ts/fixtures/lang/iters/expected/core/option.ts @@ -40,9 +40,9 @@ export function unwrapOr$15hbiwd(self: rs.u64 | undefined, default_: rs.u64): rs return self; } -export function unwrapOrDefault$165pyh5(self: string | undefined): string { +export function unwrapOrDefault$1exlfpa(self: rs.String | undefined): rs.String { if (self === undefined) { - return ""; + return rs.stringNew(); } return self; } @@ -54,14 +54,14 @@ export function unwrapOrDefault$0w012ed(self: rs.ByteVec | undefined): rs.ByteVe return self; } -export function map$1uo1d4o(self: string | undefined, _: (a0: string) => string): string | undefined { +export function map$06og5bz(self: rs.String | undefined, _: (a0: rs.String) => string): string | undefined { if (self === undefined) { return undefined; } - return self; + return self.v; } -export function map$1bpbukm(self: rs.Vec | undefined, f: (a0: rs.Vec) => string): string | undefined { +export function map$1wdw03s(self: rs.Vec | undefined, f: (a0: rs.Vec) => string): string | undefined { if (self === undefined) { return undefined; } @@ -75,7 +75,7 @@ export function map$167hjon(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => s return rs.strCowStr(self); } -export function map$0og67wk(self: [rs.u8, string] | undefined, f: (a0: [rs.u8, string]) => string): string | undefined { +export function map$1p2lbl3(self: [rs.u8, rs.String] | undefined, f: (a0: [rs.u8, rs.String]) => rs.String): rs.String | undefined { if (self === undefined) { return undefined; } @@ -125,7 +125,7 @@ export function map$14ju55r(self: rs.usize | undefined, f: (a0: rs.usize) => rs. return f(self); } -export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { +export function mapOr$1fzqoua(self: rs.String | undefined, default_: rs.u8, f: (a0: rs.String) => rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -195,7 +195,7 @@ export function mapOr$02sqh24(self: rs.Place | undefined, default_: rs.u8 return f(self); } -export function mapOr$0g9tml1(self: string | undefined, default_: rs.u32, f: (a0: string) => rs.u32): rs.u32 { +export function mapOr$085bdex(self: rs.String | undefined, default_: rs.u32, f: (a0: rs.String) => rs.u32): rs.u32 { if (self === undefined) { return default_; } @@ -209,6 +209,13 @@ export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: return f(self); } +export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$164lw4w(self: rs.u16 | undefined, default_: rs.u32, f: (a0: rs.u16) => rs.u32): rs.u32 { if (self === undefined) { return default_; @@ -286,9 +293,9 @@ export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a return f(self); } -export function asDeref$0w8at8i(self: string | undefined): string | undefined { - return map$1uo1d4o(self, (a0: string): string => { - return a0; +export function asDeref$0wpj87j(self: rs.String | undefined): string | undefined { + return map$06og5bz(self, (a0: rs.String): string => { + return a0.v; }); } @@ -298,7 +305,7 @@ export function asDeref$0pg0e8a(self: rs.StrCow | undefined): string | undefined }); } -export function andThen$1g5wbds(self: rs.u8 | undefined, f: (a0: rs.u8) => string | undefined): string | undefined { +export function andThen$1x5oz34(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.String | undefined): rs.String | undefined { if (self === undefined) { return undefined; } @@ -322,11 +329,11 @@ export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) = return undefined; } -export function clone$14nprly(self: string | undefined): string | undefined { +export function clone$0dg4ec5(self: rs.String | undefined): rs.String | undefined { if (self === undefined) { return undefined; } - return self; + return rs.stringClone(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Holder.ts b/ts/fixtures/lang/iters/expected/iters.Holder.ts index 1993ee4ce..fb0744d0a 100644 --- a/ts/fixtures/lang/iters/expected/iters.Holder.ts +++ b/ts/fixtures/lang/iters/expected/iters.Holder.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { map$0og67wk as option_map$0og67wk, map$1oqs2fe as option_map$1oqs2fe, mapOr$0g9tml1 as option_mapOr$0g9tml1, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$164lw4w as option_mapOr$164lw4w, andThen$1g5wbds as option_andThen$1g5wbds, andThen$1fnqvxl as option_andThen$1fnqvxl, clone$14nprly as option_clone$14nprly } from "./core/option.ts"; +import { map$1p2lbl3 as option_map$1p2lbl3, map$1oqs2fe as option_map$1oqs2fe, mapOr$085bdex as option_mapOr$085bdex, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$164lw4w as option_mapOr$164lw4w, andThen$1x5oz34 as option_andThen$1x5oz34, andThen$1fnqvxl as option_andThen$1fnqvxl, clone$0dg4ec5 as option_clone$0dg4ec5 } from "./core/option.ts"; /** * std's iterators held in the crate's own fields, over a parameter's items, as rangemap's @@ -24,22 +24,22 @@ export class Holder { } /** One step of each by `op`, writing what it yields by `code`, and the item it last took. */ -export function step$String_slice_Iter_u8(self: Holder>, op: rs.u8, code: (a0: string) => rs.u32, out: rs.ByteVec): void { - let item!: string | undefined; +export function step$String_slice_Iter_u8(self: Holder>, op: rs.u8, code: (a0: rs.String) => rs.u32, out: rs.ByteVec): void { + let item!: rs.String | undefined; const _6: rs.u8 = rs.u8Rem(op, 6); if (_6 === 0) { - const _8: string | undefined = rs.iterToOption((self.slice as rs.Iter).next()); - item = _8 === undefined ? undefined : _8; + const _8: rs.String | undefined = rs.iterToOption((self.slice as rs.Iter).next()); + item = _8 === undefined ? undefined : rs.stringClone(_8); } else if (_6 === 1) { - const _10: string | undefined = rs.iterToOption((self.slice as rs.Iter).nextBack()); - item = _10 === undefined ? undefined : _10; + const _10: rs.String | undefined = rs.iterToOption((self.slice as rs.Iter).nextBack()); + item = _10 === undefined ? undefined : rs.stringClone(_10); } else if (_6 === 2) { - item = option_map$0og67wk(rs.iterToOption((self.tree as rs.Iter<[rs.u8, string]>).next()), (_210: [rs.u8, string]): string => { - return _210[1]; + item = option_map$1p2lbl3(rs.iterToOption((self.tree as rs.Iter<[rs.u8, rs.String]>).next()), (_210: [rs.u8, rs.String]): rs.String => { + return rs.stringClone(_210[1]); }); } else if (_6 === 3) { - item = option_map$0og67wk(rs.iterToOption((self.tree as rs.Iter<[rs.u8, string]>).nextBack()), (_25: [rs.u8, string]): string => { - return _25[1]; + item = option_map$1p2lbl3(rs.iterToOption((self.tree as rs.Iter<[rs.u8, rs.String]>).nextBack()), (_25: [rs.u8, rs.String]): rs.String => { + return rs.stringClone(_25[1]); }); } else if (_6 === 4) { item = rs.iterToOption(self.owned.next()); @@ -47,17 +47,17 @@ export function step$String_slice_Iter_u8(self: Holder>, rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.peekablePeek(self.peeked), 255, (_2: rs.u8): rs.u8 => { return _2; })); - item = option_andThen$1g5wbds(rs.peekableNextIf(self.peeked, (_22: rs.u8): boolean => { + item = option_andThen$1x5oz34(rs.peekableNextIf(self.peeked, (_22: rs.u8): boolean => { return rs.u8Rem(_22, 2) === 0; - }), (_24: rs.u8): string | undefined => { - return option_clone$14nprly(self.last); + }), (_24: rs.u8): rs.String | undefined => { + return option_clone$0dg4ec5(self.last); }); } - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$0g9tml1(item, 4294967295, code)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$085bdex(item, 4294967295, code)).reverse()), undefined, true); if (item !== undefined) { self.last = item; } - rs.byteVecPush(out, (self.slice as rs.Iter).len() & 0xff); + rs.byteVecPush(out, (self.slice as rs.Iter).len() & 0xff); rs.byteVecPush(out, self.owned.len() & 0xff); } diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index a454fea78..f01aae6db 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { drop$iters_Ticks, of$u8 } from "./lib.ts"; import { thenSome$1ctlqen, thenSome$1gvhopg, thenSome$0quywni, thenSome$1n1oy1h } from "./core/bool.ts"; -import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$00tqxtm as option_unwrapOr$00tqxtm, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$1g3ltyz as option_unwrapOr$1g3ltyz, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$1uo1d4o as option_map$1uo1d4o, map$1bpbukm as option_map$1bpbukm, map$0vu84i0 as option_map$0vu84i0, map$1806e7m as option_map$1806e7m, map$1yjmt5m as option_map$1yjmt5m, map$057a36e as option_map$057a36e, map$14ju55r as option_map$14ju55r, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$127irwp as option_mapOr$127irwp, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1i4rvy8 as option_mapOr$1i4rvy8, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$041x3r2 as option_mapOr$041x3r2, mapOr$14runhi as option_mapOr$14runhi, mapOr$0dfpyun as option_mapOr$0dfpyun, mapOr$0p9po8x as option_mapOr$0p9po8x, mapOr$02sqh24 as option_mapOr$02sqh24, mapOr$0g9tml1 as option_mapOr$0g9tml1, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$164lw4w as option_mapOr$164lw4w, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0llggqq as option_mapOr$0llggqq, mapOr$1ifh11y as option_mapOr$1ifh11y, mapOr$1r07vli as option_mapOr$1r07vli, mapOr$0olig48 as option_mapOr$0olig48, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$17ts8jj as option_mapOr$17ts8jj, mapOr$07pvkk0 as option_mapOr$07pvkk0, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0pg0e8a as option_asDeref$0pg0e8a, filter$0hq86nl } from "./core/option.ts"; +import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$00tqxtm as option_unwrapOr$00tqxtm, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$1g3ltyz as option_unwrapOr$1g3ltyz, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOrDefault$1exlfpa as option_unwrapOrDefault$1exlfpa, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$06og5bz as option_map$06og5bz, map$1wdw03s as option_map$1wdw03s, map$0vu84i0 as option_map$0vu84i0, map$1806e7m as option_map$1806e7m, map$1yjmt5m as option_map$1yjmt5m, map$057a36e as option_map$057a36e, map$14ju55r as option_map$14ju55r, mapOr$1fzqoua as option_mapOr$1fzqoua, mapOr$127irwp as option_mapOr$127irwp, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1i4rvy8 as option_mapOr$1i4rvy8, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$041x3r2 as option_mapOr$041x3r2, mapOr$14runhi as option_mapOr$14runhi, mapOr$0dfpyun as option_mapOr$0dfpyun, mapOr$0p9po8x as option_mapOr$0p9po8x, mapOr$02sqh24 as option_mapOr$02sqh24, mapOr$085bdex as option_mapOr$085bdex, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$164lw4w as option_mapOr$164lw4w, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0llggqq as option_mapOr$0llggqq, mapOr$1ifh11y as option_mapOr$1ifh11y, mapOr$1r07vli as option_mapOr$1r07vli, mapOr$0olig48 as option_mapOr$0olig48, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$17ts8jj as option_mapOr$17ts8jj, mapOr$07pvkk0 as option_mapOr$07pvkk0, mapOr$188iunt as option_mapOr$188iunt, asDeref$0wpj87j as option_asDeref$0wpj87j, asDeref$0pg0e8a as option_asDeref$0pg0e8a, filter$0hq86nl } from "./core/option.ts"; import { unwrapOr$0a3q6xs as result_unwrapOr$0a3q6xs } from "./core/result.ts"; import type * as Badge from "./iters.Badge.ts"; import * as Bag from "./iters.Bag.ts"; @@ -400,9 +400,9 @@ export function eq$cmp_PartialEq_iters_Quarter_array2_u8(self: rs.ByteSlice, oth return rs.iterSum(rs.iterSlice(rs.byteSliceView(self)), rs.u8Add, 0) === other._0; } -export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quarter.Quarter): boolean { +export function eq$cmp_PartialEq_iters_Quarter_String(self: rs.String, other: Quarter.Quarter): boolean { rs.cellSet(other._1, rs.u8WrappingAdd(other._1.v, 4)); - return rs.stringLen(self) === other._0 as rs.usize; + return self.len === other._0 as rs.usize; } /** @@ -411,9 +411,9 @@ export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quart * first item, and a mismatch keeps the item for the next `next`. */ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { - const _3: (a0: rs.u8) => string = (b: rs.u8): string => { + const _3: (a0: rs.u8) => rs.String = (b: rs.u8): rs.String => { const _42: rs.char = rs.u8Add(97, rs.u8Rem(b, 3)) as rs.char; - return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_42, f)); + return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_42, f), 0); }; const _4: (a0: string | undefined) => rs.u8 = (w: string | undefined): rs.u8 => { return option_mapOr$1nyk1yj(w, 170, (w2: string): rs.u8 => { @@ -430,90 +430,96 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { const _159: (a0: rs.u8) => rs.Vec = (b2: rs.u8): rs.Vec => { return rs.vecFromElem(((rs.u8Rem(b2, 2) as rs.u16) << 9) & 0xffff, rs.u8Rem(b2, 3) as rs.usize, undefined); }; - const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): string => { + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.String => { return _3(_2); }), undefined, 12, true); - const _12: string | undefined = rs.sliceFirst(rs.sliceFrom(words.items)); - const first: string = option_unwrapOrDefault$165pyh5(_12 === undefined ? undefined : _12); - const it: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.slice()))); - const part = option_asDeref$0w8at8i(rs.peekableNextIfEq(it, "a", (a0: string, a1: string): boolean => { - return a0 === a1; + const _12: rs.String | undefined = rs.sliceFirst(rs.sliceFrom(words.items)); + const first: rs.String = option_unwrapOrDefault$1exlfpa(_12 === undefined ? undefined : rs.stringClone(_12)); + const it: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.map((a0: rs.String): rs.String => { + return rs.stringClone(a0); + })))); + const part = option_asDeref$0wpj87j(rs.peekableNextIfEq(it, "a", (a02: rs.String, a1: string): boolean => { + return rs.eqStr(a02, a1); })); rs.byteVecPush(out, _4(part)); - const part2 = option_asDeref$0w8at8i(rs.peekableNextIfEq(it, "b", (a02: string, a12: string): boolean => { - return a02 === a12; + const part2 = option_asDeref$0wpj87j(rs.peekableNextIfEq(it, "b", (a03: rs.String, a12: string): boolean => { + return rs.eqStr(a03, a12); })); rs.byteVecPush(out, _4(part2)); - const part3 = option_asDeref$0w8at8i(rs.iterToOption(it.next())); + const part3 = option_asDeref$0wpj87j(rs.iterToOption(it.next())); rs.byteVecPush(out, _4(part3)); - const it2: rs.Peekable = rs.iterPeekable(rs.iterSlice(words.items)); - const part4 = option_map$1uo1d4o(rs.peekableNextIfEq(it2, first, (a03: string, a13: string): boolean => { - return a03 === a13; - }), (a04: string): string => { - return a04; + const it2: rs.Peekable = rs.iterPeekable(rs.iterSlice(words.items)); + const part4 = option_map$06og5bz(rs.peekableNextIfEq(it2, first.v, (a04: rs.String, a13: string): boolean => { + return rs.eqStr(a04, a13); + }), (a05: rs.String): string => { + return a05.v; }); rs.byteVecPush(out, _4(part4)); - const part5 = option_map$1uo1d4o(rs.peekableNextIfEq(it2, "c", (a05: string, a14: string): boolean => { - return a05 === a14; - }), (a06: string): string => { - return a06; + const part5 = option_map$06og5bz(rs.peekableNextIfEq(it2, "c", (a06: rs.String, a14: string): boolean => { + return rs.eqStr(a06, a14); + }), (a07: rs.String): string => { + return a07.v; }); rs.byteVecPush(out, _4(part5)); - const part6 = option_map$1uo1d4o(rs.iterToOption(it2.next()), (a07: string): string => { - return a07; + const part6 = option_map$06og5bz(rs.iterToOption(it2.next()), (a08: rs.String): string => { + return a08.v; }); rs.byteVecPush(out, _4(part6)); - const it3: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (a08: string): string => { - return a08; + const it3: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (a09: rs.String): string => { + return a09.v; })); - const part7 = rs.peekableNextIfEq(it3, first, (a09: string, a15: string): boolean => { - return a09 === a15; + const part7 = rs.peekableNextIfEq(it3, first, (a010: string, a15: rs.String): boolean => { + return rs.eqStr(a010, a15); }); rs.byteVecPush(out, _4(part7)); const part8 = rs.iterToOption(it3.next()); rs.byteVecPush(out, _4(part8)); - const it4: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.Vec => { + const it4: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.Vec => { return rs.vecFrom([_3(_24)]); })); - const _107: rs.Vec = rs.vecFrom([first]); - const part9 = option_map$1bpbukm(rs.peekableNextIfEq(it4, _107, (a010: rs.Vec, a16: rs.Vec): boolean => { - return rs.eqSlice(rs.same)(a010, a16); - }), (v3: rs.Vec): string => { - return v3.items[rs.idx(v3.items, 0)]; + const _107: rs.Vec = rs.vecFrom([first.v]); + const part9 = option_map$1wdw03s(rs.peekableNextIfEq(it4, _107, (a011: rs.Vec, a16: rs.Vec): boolean => { + return rs.eqSlice(rs.eqStr)(a011, a16); + }), (v3: rs.Vec): string => { + return v3.items[rs.idx(v3.items, 0)].v; }); rs.byteVecPush(out, _4(part9)); - const part10 = option_map$1bpbukm(rs.iterToOption(it4.next()), (v4: rs.Vec): string => { - return v4.items[rs.idx(v4.items, 0)]; + const part10 = option_map$1wdw03s(rs.iterToOption(it4.next()), (v4: rs.Vec): string => { + return v4.items[rs.idx(v4.items, 0)].v; }); rs.byteVecPush(out, _4(part10)); - const it5: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (w3: string): rs.StrCow => { - return new rs.Borrowed(w3); + const it5: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (w3: rs.String): rs.StrCow => { + return new rs.Borrowed(w3.v); })); - const part11 = option_asDeref$0pg0e8a(rs.peekableNextIfEq(it5, "b", (a011: rs.StrCow, a17: string): boolean => { - return rs.strCowStr(a011) === a17; + const part11 = option_asDeref$0pg0e8a(rs.peekableNextIfEq(it5, "b", (a012: rs.StrCow, a17: string): boolean => { + return rs.strCowStr(a012) === a17; })); rs.byteVecPush(out, _4(part11)); const part12 = option_asDeref$0pg0e8a(rs.iterToOption(it5.next())); rs.byteVecPush(out, _4(part12)); - const part13 = option_asDeref$0w8at8i(rs.peekableNextIfEq(rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.slice()))), first, (a012: string, a18: rs.StrCow): boolean => { - return a012 === rs.strCowStr(a18); + const it6: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.map((a013: rs.String): rs.String => { + return rs.stringClone(a013); + })))); + const _155: rs.StrCow = rs.stringClone(first); + const part13 = option_asDeref$0wpj87j(rs.peekableNextIfEq(it6, _155, (a014: rs.String, a18: rs.StrCow): boolean => { + return rs.eqStr(a014, rs.strCowStr(a18)); })); rs.byteVecPush(out, _4(part13)); const it7: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): rs.Vec => { return _159(_26); })); const _171: rs.Slice = rs.sliceFrom([0]); - const part14 = rs.peekableNextIfEq(it7, _171, (a013: rs.Vec, a19: rs.Slice): boolean => { - return rs.eqSlice(rs.same)(a013, a19); + const part14 = rs.peekableNextIfEq(it7, _171, (a015: rs.Vec, a19: rs.Slice): boolean => { + return rs.eqSlice(rs.same)(a015, a19); }); rs.byteVecPush(out, _158(part14)); - const part15 = rs.peekableNextIfEq(it7, [512, 512], (a, b) => ((a014: rs.Vec, a110: rs.Slice): boolean => { - return rs.eqSlice(rs.same)(a014, a110); + const part15 = rs.peekableNextIfEq(it7, [512, 512], (a, b) => ((a016: rs.Vec, a110: rs.Slice): boolean => { + return rs.eqSlice(rs.same)(a016, a110); })(a, rs.sliceFrom(b))); rs.byteVecPush(out, _158(part15)); const _188: rs.Slice = rs.sliceFrom([]); - const part16 = rs.peekableNextIfEq(it7, _188, (a015: rs.Vec, a111: rs.Slice): boolean => { - return rs.eqSlice(rs.same)(a015, a111); + const part16 = rs.peekableNextIfEq(it7, _188, (a017: rs.Vec, a111: rs.Slice): boolean => { + return rs.eqSlice(rs.same)(a017, a111); }); rs.byteVecPush(out, _158(part16)); const part17 = rs.iterToOption(it7.next()); @@ -523,8 +529,8 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.byteVecOf(rs.u8Rem(b6, 2), rs.u8Rem(b6, 3) as rs.usize); })); const _203: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(1)), 0); - rs.byteVecPush(out, option_mapOr$0g5x999(rs.peekableNextIfEq(it8, _203, (a016: rs.ByteVec, a112: rs.ByteSlice): boolean => { - return rs.eqBytes(a016, a112); + rs.byteVecPush(out, option_mapOr$0g5x999(rs.peekableNextIfEq(it8, _203, (a018: rs.ByteVec, a112: rs.ByteSlice): boolean => { + return rs.eqBytes(a018, a112); }), 170, (v5: rs.ByteVec): rs.u8 => { return v5.length & 0xff; })); @@ -540,8 +546,8 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { })); const _217: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(0, 1)), 0); rs.byteVecPush(out, option_mapOr$1i4rvy8(rs.peekableNextIfEq(it9, _217, (a: Uint8Array, b7: rs.ByteSlice): boolean => { - return ((a017: rs.ByteSlice, a113: rs.ByteSlice): boolean => { - return rs.eqBytes(a017, a113); + return ((a019: rs.ByteSlice, a113: rs.ByteSlice): boolean => { + return rs.eqBytes(a019, a113); })(rs.byteSliceFrom(a), b7); }), 170, (p: Uint8Array): rs.u8 => { return p[1]; @@ -560,14 +566,14 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const it10: rs.Peekable> = rs.iterPeekable(rs.iterSliceMut(rs.byteVecSlice(bytes))); const _242: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); - const _239: rs.Place | undefined = rs.peekableNextIfEq(it10, _242, (a018: rs.Place, a114: rs.u8): boolean => { - return a018.v === a114; + const _239: rs.Place | undefined = rs.peekableNextIfEq(it10, _242, (a020: rs.Place, a114: rs.u8): boolean => { + return a020.v === a114; }); if (_239 !== undefined) { _239.v = _239.v ^ 64; } - rs.byteVecPush(out, option_mapOr$02sqh24(rs.peekableNextIfEq(it10, 3, (a019: rs.Place, a115: rs.u8): boolean => { - return a019.v === a115; + rs.byteVecPush(out, option_mapOr$02sqh24(rs.peekableNextIfEq(it10, 3, (a021: rs.Place, a115: rs.u8): boolean => { + return a021.v === a115; }), 170, (b9: rs.Place): rs.u8 => { return b9.v; })); @@ -590,16 +596,16 @@ export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { const it12: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.peekableNextIfEq(it12, { _0: want ^ 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.peekableNextIfEq(it12, { _0: want, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); - const it13: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): string => { - return rs.strSlice("ab", 0, rs.u8Rem(_213, 3) as rs.usize); + const it13: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): rs.String => { + return rs.stringFrom(rs.strSlice("ab", 0, rs.u8Rem(_213, 3) as rs.usize)); })); - rs.byteVecPush(out, option_mapOr$1nyk1yj(rs.peekableNextIfEq(it13, { _0: 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_String), 170, (w4: string): rs.u8 => { - return rs.stringLen(w4) & 0xff; + rs.byteVecPush(out, option_mapOr$1fzqoua(rs.peekableNextIfEq(it13, { _0: 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_String), 170, (w4: rs.String): rs.u8 => { + return w4.len & 0xff; })); - rs.byteVecPush(out, option_mapOr$1nyk1yj(rs.iterToOption(it13.next()), 170, (w5: string): rs.u8 => { - return rs.stringLen(w5) & 0xff; + rs.byteVecPush(out, option_mapOr$1fzqoua(rs.iterToOption(it13.next()), 170, (w5: rs.String): rs.u8 => { + return w5.len & 0xff; })); - rs.byteVecPush(out, eq$cmp_PartialEq_iters_Quarter_String("ab", { _0: want, _1: calls }) ? 1 : 0); + rs.byteVecPush(out, eq$cmp_PartialEq_iters_Quarter_String(rs.stringFrom("ab"), { _0: want, _1: calls }) ? 1 : 0); rs.byteVecPush(out, calls.v); } @@ -1738,7 +1744,7 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { const _31: Doubled.Doubled = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; const _33: Doubled.Doubled = { _0Data: _34.data, _0Start: _34.start, _0Len: _34.length }; const args3 = [(f: rs.Formatter) => Doubled.fmt$fmt_Debug(_31, f), (f: rs.Formatter) => Doubled.fmt$fmt_Debug(_33, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1])]).v)); const tags: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tag.Tag => { const b3: rs.u8 = _2; return { bytes: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(b3, ~b3 & 0xff))) }; @@ -6557,7 +6563,8 @@ export function adapted(a: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterTake(rs.iterStepBy(new rs.RangeFrom(lo, rs.u8Step), 3), 4), "next")), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(rs.stringExtendChars("", rs.iterTake(new rs.RangeFrom(97, rs.charStep), rs.usizeRem(n, 6)))), undefined, true); + const _71: rs.Iter = rs.iterTake(new rs.RangeFrom(97, rs.charStep), rs.usizeRem(n, 6)); + rs.iterExtendBytes(out, rs.strBytes(rs.stringExtendChars(rs.stringNew(), _71).v), undefined, true); const _77: [rs.usize, rs.usize | undefined] = rs.iterZip(it(), new rs.RangeFrom(lo, rs.u8Step), "len").sizeHint(); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$188iunt(_77[1], 238, (h: rs.usize): rs.u8 => { return h & 0xff; @@ -6756,13 +6763,13 @@ export function bounded$char(table: rs.Slice, at: rs.usize[], out: rs.B const _111: [rs.char, rs.char] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_111[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_113[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.char }, { end: rs.char; inclusive: true }] = [new rs.RangeFrom(a, rs.charStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.char } = _137[1]; const through: { end: rs.char; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.fmtCharDebug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.fmtCharDebug))]).v), undefined, true); return [a, b] as [rs.char, rs.char]; } @@ -6825,13 +6832,13 @@ export function bounded$f32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.f32, rs.f32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_111[0], f), (f: rs.Formatter) => rs.f32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_113[0], f), (f: rs.Formatter) => rs.f32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.f32 }, { end: rs.f32; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.f32 } = _137[1]; const through: { end: rs.f32; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f32Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f32Debug))]).v), undefined, true); return [a, b] as [rs.f32, rs.f32]; } @@ -6894,13 +6901,13 @@ export function bounded$f64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.f64, rs.f64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_111[0], f), (f: rs.Formatter) => rs.f64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_113[0], f), (f: rs.Formatter) => rs.f64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.f64 }, { end: rs.f64; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.f64 } = _137[1]; const through: { end: rs.f64; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f64Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f64Debug))]).v), undefined, true); return [a, b] as [rs.f64, rs.f64]; } @@ -6963,13 +6970,13 @@ export function bounded$i128(table: rs.Slice, at: rs.usize[], out: rs.B const _111: [rs.i128, rs.i128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_111[0], f), (f: rs.Formatter) => rs.i128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_113[0], f), (f: rs.Formatter) => rs.i128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i128 }, { end: rs.i128; inclusive: true }] = [new rs.RangeFrom(a, rs.i128Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i128 } = _137[1]; const through: { end: rs.i128; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i128Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i128Debug))]).v), undefined, true); return [a, b] as [rs.i128, rs.i128]; } @@ -7032,13 +7039,13 @@ export function bounded$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.i16, rs.i16] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_111[0], f), (f: rs.Formatter) => rs.i16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_113[0], f), (f: rs.Formatter) => rs.i16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i16 }, { end: rs.i16; inclusive: true }] = [new rs.RangeFrom(a, rs.i16Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i16 } = _137[1]; const through: { end: rs.i16; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i16Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i16Debug))]).v), undefined, true); return [a, b] as [rs.i16, rs.i16]; } @@ -7101,13 +7108,13 @@ export function bounded$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.i32, rs.i32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_111[0], f), (f: rs.Formatter) => rs.i32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_113[0], f), (f: rs.Formatter) => rs.i32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i32 }, { end: rs.i32; inclusive: true }] = [new rs.RangeFrom(a, rs.i32Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i32 } = _137[1]; const through: { end: rs.i32; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i32Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i32Debug))]).v), undefined, true); return [a, b] as [rs.i32, rs.i32]; } @@ -7170,13 +7177,13 @@ export function bounded$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.i64, rs.i64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_111[0], f), (f: rs.Formatter) => rs.i64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_113[0], f), (f: rs.Formatter) => rs.i64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i64 }, { end: rs.i64; inclusive: true }] = [new rs.RangeFrom(a, rs.i64Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i64 } = _137[1]; const through: { end: rs.i64; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i64Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i64Debug))]).v), undefined, true); return [a, b] as [rs.i64, rs.i64]; } @@ -7239,13 +7246,13 @@ export function bounded$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const _111: [rs.i8, rs.i8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_111[0], f), (f: rs.Formatter) => rs.i8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_113[0], f), (f: rs.Formatter) => rs.i8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.i8 }, { end: rs.i8; inclusive: true }] = [new rs.RangeFrom(a, rs.i8Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.i8 } = _137[1]; const through: { end: rs.i8; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i8Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i8Debug))]).v), undefined, true); return [a, b] as [rs.i8, rs.i8]; } @@ -7308,13 +7315,13 @@ export function bounded$isize(table: rs.Slice, at: rs.usize[], out: rs const _111: [rs.isize, rs.isize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_111[0], f), (f: rs.Formatter) => rs.isizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_113[0], f), (f: rs.Formatter) => rs.isizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.isize }, { end: rs.isize; inclusive: true }] = [new rs.RangeFrom(a, rs.isizeStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.isize } = _137[1]; const through: { end: rs.isize; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.isizeDebug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.isizeDebug))]).v), undefined, true); return [a, b] as [rs.isize, rs.isize]; } @@ -7377,13 +7384,13 @@ export function bounded$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const _111: [rs.u128, rs.u128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u128 } = _137[1]; const through: { end: rs.u128; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]).v), undefined, true); return [a, b] as [rs.u128, rs.u128]; } @@ -7446,13 +7453,13 @@ export function bounded$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const _111: [rs.u64, rs.u64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u64 } = _137[1]; const through: { end: rs.u64; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]).v), undefined, true); return [a, b] as [rs.u64, rs.u64]; } @@ -7515,13 +7522,13 @@ export function bounded$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const _111: [rs.u8, rs.u8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u8 } = _137[1]; const through: { end: rs.u8; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]).v), undefined, true); return [a, b] as [rs.u8, rs.u8]; } @@ -7584,13 +7591,13 @@ export function bounded$num_NonZero_usize(table: rs.Slice, at: rs.usiz const _111: [rs.usize, rs.usize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.usize } = _137[1]; const through: { end: rs.usize; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]).v), undefined, true); return [a, b] as [rs.usize, rs.usize]; } @@ -7653,13 +7660,13 @@ export function bounded$u128(table: rs.Slice, at: rs.usize[], out: rs.B const _111: [rs.u128, rs.u128] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.u128Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u128 } = _137[1]; const through: { end: rs.u128; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]).v), undefined, true); return [a, b] as [rs.u128, rs.u128]; } @@ -7722,13 +7729,13 @@ export function bounded$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.u16, rs.u16] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_111[0], f), (f: rs.Formatter) => rs.u16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_113[0], f), (f: rs.Formatter) => rs.u16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u16 }, { end: rs.u16; inclusive: true }] = [new rs.RangeFrom(a, rs.u16Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u16 } = _137[1]; const through: { end: rs.u16; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u16Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u16Debug))]).v), undefined, true); return [a, b] as [rs.u16, rs.u16]; } @@ -7791,13 +7798,13 @@ export function bounded$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.u32, rs.u32] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_111[0], f), (f: rs.Formatter) => rs.u32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_113[0], f), (f: rs.Formatter) => rs.u32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u32 }, { end: rs.u32; inclusive: true }] = [new rs.RangeFrom(a, rs.u32Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u32 } = _137[1]; const through: { end: rs.u32; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u32Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u32Debug))]).v), undefined, true); return [a, b] as [rs.u32, rs.u32]; } @@ -7860,13 +7867,13 @@ export function bounded$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _111: [rs.u64, rs.u64] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.u64Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u64 } = _137[1]; const through: { end: rs.u64; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]).v), undefined, true); return [a, b] as [rs.u64, rs.u64]; } @@ -7929,13 +7936,13 @@ export function bounded$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const _111: [rs.u8, rs.u8] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.u8Step), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.u8 } = _137[1]; const through: { end: rs.u8; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]).v), undefined, true); return [a, b] as [rs.u8, rs.u8]; } @@ -7998,13 +8005,13 @@ export function bounded$usize(table: rs.Slice, at: rs.usize[], out: rs const _111: [rs.usize, rs.usize] = [start, end]; const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; const args5 = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7]]).v), undefined, true); const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.usizeStep), { end: b }, { end: b, inclusive: true }]; const from: rs.RangeFrom = _137[0]; const to: { end: rs.usize } = _137[1]; const through: { end: rs.usize; inclusive: true } = _137[2]; const part = rs.sliceFrom([rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(part), f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]).v), undefined, true); return [a, b] as [rs.usize, rs.usize]; } @@ -8643,11 +8650,11 @@ export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.B const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.fmtCharDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8668,7 +8675,7 @@ export function stepped$char(table: rs.Slice, at: rs.usize[], out: rs.B const start2: rs.char = _140[0]; const end2: rs.char = _140[1]; const args9 = [(f: rs.Formatter) => rs.fmtCharDebug(start2, f), (f: rs.Formatter) => rs.fmtCharDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -8737,11 +8744,11 @@ export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.B const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI128), rs.rangeEq(rs.i128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); const _111: boolean = rs.rangeEq(rs.i128Eq)(r, _114); @@ -8762,7 +8769,7 @@ export function stepped$i128(table: rs.Slice, at: rs.usize[], out: rs.B const start2: rs.i128 = _140[0]; const end2: rs.i128 = _140[1]; const args9 = [(f: rs.Formatter) => rs.i128Debug(start2, f), (f: rs.Formatter) => rs.i128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -8831,11 +8838,11 @@ export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i16Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8856,7 +8863,7 @@ export function stepped$i16(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.i16 = _140[0]; const end2: rs.i16 = _140[1]; const args9 = [(f: rs.Formatter) => rs.i16Debug(start2, f), (f: rs.Formatter) => rs.i16Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -8925,11 +8932,11 @@ export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i32Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -8950,7 +8957,7 @@ export function stepped$i32(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.i32 = _140[0]; const end2: rs.i32 = _140[1]; const args9 = [(f: rs.Formatter) => rs.i32Debug(start2, f), (f: rs.Formatter) => rs.i32Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9019,11 +9026,11 @@ export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI64), rs.rangeEq(rs.i64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); const _111: boolean = rs.rangeEq(rs.i64Eq)(r, _114); @@ -9044,7 +9051,7 @@ export function stepped$i64(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.i64 = _140[0]; const end2: rs.i64 = _140[1]; const args9 = [(f: rs.Formatter) => rs.i64Debug(start2, f), (f: rs.Formatter) => rs.i64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9113,11 +9120,11 @@ export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9138,7 +9145,7 @@ export function stepped$i8(table: rs.Slice, at: rs.usize[], out: rs.ByteV const start2: rs.i8 = _140[0]; const end2: rs.i8 = _140[1]; const args9 = [(f: rs.Formatter) => rs.i8Debug(start2, f), (f: rs.Formatter) => rs.i8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9207,11 +9214,11 @@ export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashIsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.isizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.isizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9232,7 +9239,7 @@ export function stepped$isize(table: rs.Slice, at: rs.usize[], out: rs const start2: rs.isize = _140[0]; const end2: rs.isize = _140[1]; const args9 = [(f: rs.Formatter) => rs.isizeDebug(start2, f), (f: rs.Formatter) => rs.isizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9301,11 +9308,11 @@ export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); @@ -9326,7 +9333,7 @@ export function stepped$num_NonZero_u128(table: rs.Slice, at: rs.usize[ const start2: rs.u128 = _140[0]; const end2: rs.u128 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9395,11 +9402,11 @@ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); @@ -9420,7 +9427,7 @@ export function stepped$num_NonZero_u64(table: rs.Slice, at: rs.usize[], const start2: rs.u64 = _140[0]; const end2: rs.u64 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9489,11 +9496,11 @@ export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9514,7 +9521,7 @@ export function stepped$num_NonZero_u8(table: rs.Slice, at: rs.usize[], o const start2: rs.u8 = _140[0]; const end2: rs.u8 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9583,11 +9590,11 @@ export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usiz const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295))]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9608,7 +9615,7 @@ export function stepped$num_NonZero_usize(table: rs.Slice, at: rs.usiz const start2: rs.usize = _140[0]; const end2: rs.usize = _140[1]; const args9 = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9677,11 +9684,11 @@ export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.B const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); @@ -9702,7 +9709,7 @@ export function stepped$u128(table: rs.Slice, at: rs.usize[], out: rs.B const start2: rs.u128 = _140[0]; const end2: rs.u128 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9771,11 +9778,11 @@ export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u16Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9796,7 +9803,7 @@ export function stepped$u16(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.u16 = _140[0]; const end2: rs.u16 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u16Debug(start2, f), (f: rs.Formatter) => rs.u16Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9865,11 +9872,11 @@ export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u32Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -9890,7 +9897,7 @@ export function stepped$u32(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.u32 = _140[0]; const end2: rs.u32 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u32Debug(start2, f), (f: rs.Formatter) => rs.u32Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -9959,11 +9966,11 @@ export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); @@ -9984,7 +9991,7 @@ export function stepped$u64(table: rs.Slice, at: rs.usize[], out: rs.Byt const start2: rs.u64 = _140[0]; const end2: rs.u64 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -10053,11 +10060,11 @@ export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -10078,7 +10085,7 @@ export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec) const start2: rs.u8 = _140[0]; const end2: rs.u8 = _140[1]; const args9 = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -10147,11 +10154,11 @@ export function stepped$usize(table: rs.Slice, at: rs.usize[], out: rs const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep)]; const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); const args7 = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2]]).v), undefined, true); const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; const args8 = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0], " ", args8[1]]).v), undefined, true); const _109: boolean = rs.rangeInclusiveIsEmpty(r); const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); const _111: boolean = rs.rangeEq(rs.same)(r, _114); @@ -10172,7 +10179,7 @@ export function stepped$usize(table: rs.Slice, at: rs.usize[], out: rs const start2: rs.usize = _140[0]; const end2: rs.usize = _140[1]; const args9 = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args9[0], " ", args9[1]]).v), undefined, true); } } @@ -11644,23 +11651,25 @@ export function byValue(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } /** `Holder` over items `make` makes of the input, stepped by its bytes. */ -export function held$String_iters_held_fields_closure2(data: rs.ByteSlice, make: (a0: rs.u8) => string, code: (a0: string) => rs.u32, out: rs.ByteVec): void { - const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): string => { +export function held$String_iters_held_fields_closure2(data: rs.ByteSlice, make: (a0: rs.u8) => rs.String, code: (a0: rs.String) => rs.u32, out: rs.ByteVec): void { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.String => { return make(_2); }), undefined, 12, true); - const _11: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, string] => { + const _11: rs.Iter<[rs.u8, rs.String]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, rs.String] => { const b2: rs.u8 = _24; - return [b2, make(b2)] as [rs.u8, string]; + return [b2, make(b2)] as [rs.u8, rs.String]; }); - const tree: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _11, true, undefined, undefined, undefined, 16, true); + const tree: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _11, true, undefined, undefined, undefined, 16, true); const _17: [rs.u8, rs.u8] = [option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), option_unwrapOr$1fr498u(rs.byteSliceLast(data), 0)]; const lo: rs.u8 = _17[0]; const hi: rs.u8 = _17[1]; - const held: Holder.Holder> = new Holder.Holder(rs.iterSlice(items.items) as rs.Iter>, rs.btreeRange(tree, new rs.RangeInclusive(rs.min(lo, hi), rs.max(lo, hi), rs.u8Step)) as rs.Iter<[rs.u8, rs.Ptr]>, rs.vecIntoIter(rs.vecFrom(items.items.slice())), rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))), undefined); + const held: Holder.Holder> = new Holder.Holder(rs.iterSlice(items.items) as rs.Iter>, rs.btreeRange(tree, new rs.RangeInclusive(rs.min(lo, hi), rs.max(lo, hi), rs.u8Step)) as rs.Iter<[rs.u8, rs.Ptr]>, rs.vecIntoIter(rs.vecFrom(items.items.map((a0: rs.String): rs.String => { + return rs.stringClone(a0); + }))), rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))), undefined); for (const _41 of rs.byteSliceView(data)) { Holder.step$String_slice_Iter_u8(held, _41, code, out); } - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$0g9tml1(held.last, 4294967295, code)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$085bdex(held.last, 4294967295, code)).reverse()), undefined, true); } /** `Holder` over items `make` makes of the input, stepped by its bytes. */ @@ -11695,12 +11704,13 @@ export function heldFields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): vo return v as rs.u32; }, out); } else { - held$String_iters_held_fields_closure2(data, (b: rs.u8): string => { - return rs.stringExtend("", rs.iterMap(new rs.Range(0, rs.u8Rem(b, 5)), (_2: rs.u8): string => { + held$String_iters_held_fields_closure2(data, (b: rs.u8): rs.String => { + const _32: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(b, 5)), (_2: rs.u8): string => { return "ab"; - })); - }, (s: string): rs.u32 => { - return rs.u32Add(rs.u32Mul(rs.stringLen(s) as rs.u32, 1000), rs.iterSum(rs.iterMap(rs.strBytes(s), (a0: rs.u8): rs.u32 => { + }); + return rs.stringExtend(rs.stringNew(), _32); + }, (s: rs.String): rs.u32 => { + return rs.u32Add(rs.u32Mul(s.len as rs.u32, 1000), rs.iterSum(rs.iterMap(rs.strBytes(s.v), (a0: rs.u8): rs.u32 => { return a0 as rs.u32; }), rs.u32Add, 0)); }, out); diff --git a/ts/fixtures/lang/joins/expected/harness.ts b/ts/fixtures/lang/joins/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/joins/expected/harness.ts +++ b/ts/fixtures/lang/joins/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/joins/expected/joins.ts b/ts/fixtures/lang/joins/expected/joins.ts index 6279d10b2..eab66a700 100644 --- a/ts/fixtures/lang/joins/expected/joins.ts +++ b/ts/fixtures/lang/joins/expected/joins.ts @@ -181,25 +181,25 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { flush(log.value, out); log[Symbol.dispose](); } else if (_26 === 4) { - const owned2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (p3: rs.ByteSlice): string => { + const owned2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(parts)), (p3: rs.ByteSlice): rs.String => { return text(p3); }), undefined, 12, true); - const sep4: string = text(seps); - put(out, rs.strsJoin(owned2.items, "")); - const _409: rs.Slice = rs.sliceFrom(owned2.items); - const _411: string = sep4; - put(out, rs.strsJoin(rs.sliceItems(_409), _411)); - const borrowed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(owned2.items), (a0: string): string => { - return a0; + const sep4: rs.String = text(seps); + put(out, rs.strsJoin(owned2.items, "").v); + const _409: rs.Slice = rs.sliceFrom(owned2.items); + const _411: string = sep4.v; + put(out, rs.strsJoin(rs.sliceItems(_409), _411).v); + const borrowed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(owned2.items), (a0: rs.String): string => { + return a0.v; }), undefined, 8, true); - put(out, rs.strsJoin(borrowed.items, "")); + put(out, rs.strsJoin(borrowed.items, "").v); const _428: rs.Slice = rs.sliceFrom(borrowed.items); - const _430: string = sep4; - put(out, rs.strsJoin(rs.sliceItems(_428), _430)); - put(out, rs.strsJoin([], "")); - const _443: rs.Slice = rs.sliceFrom([]); - const _445: string = sep4; - put(out, rs.strsJoin(rs.sliceItems(_443), _445)); + const _430: string = sep4.v; + put(out, rs.strsJoin(rs.sliceItems(_428), _430).v); + put(out, rs.strsJoin([], "").v); + const _443: rs.Slice = rs.sliceFrom([]); + const _445: string = sep4.v; + put(out, rs.strsJoin(rs.sliceItems(_443), _445).v); } else if (_26 === 5) { const cows: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.sliceItems(parts))), (_22: [rs.usize, rs.ByteSlice]): rs.ByteCow => { const i2: rs.usize = _22[0]; @@ -230,12 +230,12 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } return text(_214[1]); }), undefined, 12, true); - put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "")); - put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "--")); + put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "").v); + put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "--").v); } else { const big: rs.ByteVec = rs.byteVecOf(1, 1 << 16); const wide4: rs.Vec = rs.vecFromElem(1, 1 << 16, undefined); - const text_: string = text(rs.byteVecSlice(big)); + const text_: rs.String = text(rs.byteVecSlice(big)); const refs: (a0: rs.usize) => rs.Vec = (n: rs.usize): rs.Vec => { return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0), n, undefined); }; @@ -249,9 +249,9 @@ export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_512 === 3) { wides(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(wide4.items), rs.usizeAdd(1 << 14, 1), undefined).items), 2), out); } else if (_512 === 4) { - put(out, rs.strsJoin(rs.vecFromElem(text_, rs.usizeAdd(1 << 15, 1), undefined).items, "")); + put(out, rs.strsJoin(rs.vecFromElem(text_.v, rs.usizeAdd(1 << 15, 1), undefined).items, "").v); } else if (_512 === 5) { - put(out, rs.strsJoin(rs.vecFromElem(text_, rs.usizeAdd(1 << 16, 1), undefined).items, "")); + put(out, rs.strsJoin(rs.vecFromElem(text_.v, rs.usizeAdd(1 << 16, 1), undefined).items, "").v); } else { const sep5: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 1 << 16), (i: rs.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; diff --git a/ts/fixtures/lang/keys/expected/keys.ts b/ts/fixtures/lang/keys/expected/keys.ts index 720a57a3f..8a1c5b499 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -73,7 +73,7 @@ export function name(b: rs.u8): Name.Name { if (rs.u8Rem(b, 2) === 0) { text = new rs.Arc(_3[_4]); } else { - text = new rs.Arc(_3[_4]); + text = new rs.Arc(rs.stringFrom(_3[_4]).v); } return new Name.Name(text, small(rs.u8Div(b, 64))); } @@ -129,15 +129,15 @@ export function partial(o: rs.Ordering | undefined): rs.u8 { } /** The index of the first of `keys` that borrows as `q`. */ -export function find$String_str(keys: rs.Slice, q: string): rs.u8 { - const iter: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(keys))); +export function find$String_str(keys: rs.Slice, q: string): rs.u8 { + const iter: rs.Iter<[rs.usize, rs.String]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(keys))); while (true) { - const _7: [rs.usize, string] | rs.Done = iter.next(); + const _7: [rs.usize, rs.String] | rs.Done = iter.next(); if (_7 === rs.DONE) { break; } const i: rs.usize = _7[0]; - if (_7[1] === q) { + if (_7[1].v === q) { return i & 0xff; } } @@ -676,7 +676,7 @@ export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _106); } const _105: string[] = ["", "a", "ab", "", "￿", "𐀀"]; - rs.byteVecPush(out, find$String_str(rs.sliceFrom([text, _105[_106]]), _105[_106])); + rs.byteVecPush(out, find$String_str(rs.sliceFrom([rs.stringFrom(text), rs.stringFrom(_105[_106])]), _105[_106])); const _127: rs.Arc[] = [a.text, b.text]; rs.byteVecPush(out, find$sync_Arc_str_str(rs.sliceFrom(_127), _105[_106])); rs.dropAll(_127); diff --git a/ts/fixtures/lang/lists/expected/lists.ts b/ts/fixtures/lang/lists/expected/lists.ts index cfe5f4333..049e0bc0b 100644 --- a/ts/fixtures/lang/lists/expected/lists.ts +++ b/ts/fixtures/lang/lists/expected/lists.ts @@ -234,7 +234,7 @@ export function edges(data: rs.ByteSlice, out: rs.ByteVec): void { /** `Debug` of the lists and of their iterators part read, plain, pretty, and in hex. */ export function printed(l: rs.LinkedList, m: rs.LinkedList, out: rs.ByteVec): void { - let text: string = ""; + const text: rs.String = rs.stringNew(); const it: rs.Iter = rs.listIter(l); it.next(); const owned: rs.Iter = rs.listIter(rs.listClone(m, undefined)); @@ -242,8 +242,8 @@ export function printed(l: rs.LinkedList, m: rs.LinkedList, out: r const lent: rs.Iter> = rs.listIterMut(rs.listClone(m, undefined)); lent.next(); const args3 = [(f: rs.Formatter) => rs.fmtList(rs.listIter(l), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.listIter(m), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtListIter(it, f, rs.u8Debug, rs.usizeDebug, "Iter"), (f: rs.Formatter) => rs.fmtIter(owned, f, rs.u8Debug, ["IntoIter"]), (f: rs.Formatter) => rs.fmtListIter(lent, f, rs.u8Debug, rs.usizeDebug, "IterMut")]; - text = rs.fmtWriteString(text, [args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ debugHex: "x" }, args3[2]), "|", rs.fmtSpec({ alternate: true }, args3[2]), "|", args3[3], "|", args3[4]]).s; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); + rs.fmtWriteString(text, [args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ debugHex: "x" }, args3[2]), "|", rs.fmtSpec({ alternate: true }, args3[2]), "|", args3[3], "|", args3[4]]); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); } /** A list of `Tally`s, which JS changes in place rather than through places. */ @@ -294,13 +294,13 @@ export function tallies(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.listContains(l, { n: 120 }, Tally.eq$cmp_PartialEq) ? 1 : 0); rs.byteVecPush(out, rs.cmpList(Tally.cmp$cmp_Ord)(l, copy) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashOf$collections_LinkedList_lists_Tally(taken), hashOf$collections_LinkedList_lists_Tally(rest)) ? 1 : 0); - let text: string = ""; + const text: rs.String = rs.stringNew(); const part = rs.iterToVec(rs.iterTake(rs.iterRev(rs.listIter(rest)), 2), undefined, 4, true); const args5 = [(f: rs.Formatter) => rs.fmtList(part.items, f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rs.fmtWriteString(text, [args5[0]]).s; + rs.fmtWriteString(text, [args5[0]]); const args6 = [(f: rs.Formatter) => rs.fmtList(rs.listIter(taken), f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rs.fmtWriteString(text, [rs.fmtSpec({ alternate: true }, args6[0])]).s; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); + rs.fmtWriteString(text, [rs.fmtSpec({ alternate: true }, args6[0])]); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); } //# sourceMappingURL=lists.ts.map diff --git a/ts/fixtures/lang/locks/expected/locks.Held.ts b/ts/fixtures/lang/locks/expected/locks.Held.ts index d4e2dc66b..114884856 100644 --- a/ts/fixtures/lang/locks/expected/locks.Held.ts +++ b/ts/fixtures/lang/locks/expected/locks.Held.ts @@ -19,7 +19,7 @@ export function deref$ops_Deref_Option_u8(self: Held): rs.u8 return self._0.value; } -export function deref$ops_Deref_String(self: Held): string { +export function deref$ops_Deref_String(self: Held): rs.String { return self._0.value; } @@ -35,8 +35,8 @@ export function derefMut$ops_DerefMut_Option_u8(self: Held): return rs.place(() => self._0.value, (value) => self._0.value = value); } -export function derefMut$ops_DerefMut_String(self: Held): rs.Place { - return rs.place(() => self._0.value, (value) => self._0.value = value); +export function derefMut$ops_DerefMut_String(self: Held): rs.String { + return self._0.value; } export function derefMut$ops_DerefMut_Vec_u8(self: Held): rs.ByteVec { diff --git a/ts/fixtures/lang/locks/expected/locks.Shared.ts b/ts/fixtures/lang/locks/expected/locks.Shared.ts index b16b84883..ce404354e 100644 --- a/ts/fixtures/lang/locks/expected/locks.Shared.ts +++ b/ts/fixtures/lang/locks/expected/locks.Shared.ts @@ -23,7 +23,7 @@ export function new$Option_u8(value: rs.u8 | undefined): Shared { +export function new$String(value: rs.String): Shared { return new Shared(new rs.Arc(new rs.Mutex(value))); } @@ -39,7 +39,7 @@ export function lock$Option_u8(self: Shared): Held.Held): Held.Held { +export function lock$String(self: Shared): Held.Held { return new Held.Held(rs.mutexLock(self._0.value)); } diff --git a/ts/fixtures/lang/locks/expected/locks.ts b/ts/fixtures/lang/locks/expected/locks.ts index 2d5d506f3..6607e3f4e 100644 --- a/ts/fixtures/lang/locks/expected/locks.ts +++ b/ts/fixtures/lang/locks/expected/locks.ts @@ -75,12 +75,12 @@ export function locks(data: rs.ByteSlice, out: rs.ByteVec): void { const _107: rs.Mutex = rs.mutexLock(lock._0); _107.value = rs.u32Add(_107.value, _104); rs.mutexUnlock(_107); - const free: string = rs.fmtFormat([(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]); + const free: rs.String = rs.fmtFormat([(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]); const guard: rs.Result, rs.TryLockError>> = rs.mutexTryLock(lock._0); - const held3: string = rs.fmtFormat([(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]); + const held3: rs.String = rs.fmtFormat([(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]); const _139: boolean = guard.ok; - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, held3), (f: rs.Formatter) => rs.fmtBool(_139, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args9[0], " ", args9[1], " ", args9[2]]))); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, free.v), (f: rs.Formatter) => rs.fmtPad(f, held3.v), (f: rs.Formatter) => rs.fmtBool(_139, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args9[0], " ", args9[1], " ", args9[2]]).v)); drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(guard); } else if (_18 === 6) { rs.byteVecPush(out, false ? 1 : 0); @@ -612,62 +612,63 @@ export function mutexMapped(data: rs.ByteSlice, out: rs.ByteVec): void { * as std writes what each lends. */ export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.char => { + const _4: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.char => { return rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char; - })); - const mutex: rs.Mutex<[rs.u8, string]> = new rs.Mutex([data.length & 0xff, text] as [rs.u8, string]); - const lock: rs.RefCell<[rs.ByteVec, string]> = new rs.RefCell([rs.byteSliceToByteVec(data), text] as [rs.ByteVec, string]); - const guard: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); - const args21 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(guard.value[0], f), (f: rs.Formatter) => rs.fmtStr(guard.value[1], f)], f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args21[0], " ", rs.fmtSpec({ alternate: true }, args21[0])]))); - const n: rs.Mutex = rs.mutexMap(guard, ((t: [rs.u8, string]): rs.Place => { + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _4); + const mutex: rs.Mutex<[rs.u8, rs.String]> = new rs.Mutex([data.length & 0xff, rs.stringClone(text)] as [rs.u8, rs.String]); + const lock: rs.RefCell<[rs.ByteVec, rs.String]> = new rs.RefCell([rs.byteSliceToByteVec(data), text] as [rs.ByteVec, rs.String]); + const guard: rs.Mutex<[rs.u8, rs.String]> = rs.mutexLock(mutex); + const args21 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(guard.value[0], f), (f: rs.Formatter) => rs.fmtStr(guard.value[1].v, f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args21[0], " ", rs.fmtSpec({ alternate: true }, args21[0])]).v)); + const n: rs.Mutex = rs.mutexMap(guard, ((t: [rs.u8, rs.String]): rs.Place => { return rs.place(() => t[0], (value) => t[0] = value); })(guard.value)); const args22 = [(f: rs.Formatter) => rs.u8Display(n.value, f), (f: rs.Formatter) => rs.u8Debug(n.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ align: ">", width: 4 }, args22[0]), " ", rs.fmtSpec({ zero: true, width: 4 }, args22[0])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ align: ">", width: 4 }, args22[0]), " ", rs.fmtSpec({ zero: true, width: 4 }, args22[0])]).v)); const n2: rs.Mutex = rs.mutexMap(n, ((n3: rs.Place): rs.Place => { return n3; })(rs.valuePlace(n))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat(["[", rs.fmtSpec({ align: "<", width: 3 }, (f: rs.Formatter) => rs.u8Display(n2.value, f)), "]"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat(["[", rs.fmtSpec({ align: "<", width: 3 }, (f: rs.Formatter) => rs.u8Display(n2.value, f)), "]"]).v)); rs.mutexUnlock(n2); - const _58: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); - const text2: rs.Mutex = rs.mutexMap(_58, ((t2: [rs.u8, string]): rs.Place => { - return rs.place(() => t2[1], (value2) => t2[1] = value2); - })(_58.value)); - const args24 = [(f: rs.Formatter) => rs.fmtPad(f, text2.value), (f: rs.Formatter) => rs.fmtStr(text2.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args24[0], " ", args24[1], " [", rs.fmtSpec({ align: "^", width: 9 }, args24[0]), "]"]))); + const _58: rs.Mutex<[rs.u8, rs.String]> = rs.mutexLock(mutex); + const text2: rs.Mutex = rs.mutexMap(_58, rs.partPlace(((t2: [rs.u8, rs.String]): rs.String => { + return t2[1]; + })(_58.value))); + const args24 = [(f: rs.Formatter) => rs.fmtPad(f, text2.value.v), (f: rs.Formatter) => rs.fmtStr(text2.value.v, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args24[0], " ", args24[1], " [", rs.fmtSpec({ align: "^", width: 9 }, args24[0]), "]"]).v)); rs.mutexUnlock(text2); - const read: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(read.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(read.value[1], f)], f)]))); - const bytes: rs.RefCell = rs.refMap(read, ((t3: [rs.ByteVec, string]): rs.ByteVec => { + const read: rs.RefCell<[rs.ByteVec, rs.String]> = rs.rwLockRead(lock); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(read.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(read.value[1].v, f)], f)]).v)); + const bytes: rs.RefCell = rs.refMap(read, ((t3: [rs.ByteVec, rs.String]): rs.ByteVec => { return t3[0]; })(read.value)); const args26 = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes.value), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0])]))); - const _104: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); - const text3: rs.RefCell = rs.refMap(_104, ((t4: [rs.ByteVec, string]): string => { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0])]).v)); + const _104: rs.RefCell<[rs.ByteVec, rs.String]> = rs.rwLockRead(lock); + const text3: rs.RefCell = rs.refMap(_104, ((t4: [rs.ByteVec, rs.String]): rs.String => { return t4[1]; })(_104.value)); - const first: rs.RefCell = rs.refMap(text3, ((t5: string): string => { - return option_unwrapOr$1iemzn8(rs.strGet(t5, 0, 1), "-"); + const first: rs.RefCell = rs.refMap(text3, ((t5: rs.String): string => { + return option_unwrapOr$1iemzn8(rs.strGet(t5.v, 0, 1), "-"); })(text3.value)); const args27 = [(f: rs.Formatter) => rs.fmtPad(f, first.value), (f: rs.Formatter) => rs.fmtStr(first.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args27[0], " ", args27[1], " ", rs.fmtSpec({ align: ">", width: 3 }, args27[0])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args27[0], " ", args27[1], " ", rs.fmtSpec({ align: ">", width: 3 }, args27[0])]).v)); rs.refRelease(first); rs.refRelease(bytes); - const write: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockWrite(lock); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(write.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(write.value[1], f)], f)]))); - const text4: rs.RefCell = rs.refMutMap(write, ((t6: [rs.ByteVec, string]): rs.Place => { - return rs.place(() => t6[1], (value3) => t6[1] = value3); - })(write.value)); - text4.value = text4.value + "!"; - const args29 = [(f: rs.Formatter) => rs.fmtPad(f, text4.value), (f: rs.Formatter) => rs.fmtStr(text4.value, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args29[0], " ", args29[1]]))); - const _154: rs.RefCell = text4; - const text5: rs.RefCell = rs.refMutMap(_154, ((t7: rs.Place): rs.Place => { + const write: rs.RefCell<[rs.ByteVec, rs.String]> = rs.rwLockWrite(lock); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(write.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(write.value[1].v, f)], f)]).v)); + const text4: rs.RefCell = rs.refMutMap(write, rs.partPlace(((t6: [rs.ByteVec, rs.String]): rs.String => { + return t6[1]; + })(write.value))); + rs.stringPush(text4.value, 33); + const args29 = [(f: rs.Formatter) => rs.fmtPad(f, text4.value.v), (f: rs.Formatter) => rs.fmtStr(text4.value.v, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args29[0], " ", args29[1]]).v)); + const _154: rs.RefCell = text4; + const text5: rs.RefCell = rs.refMutMap(_154, rs.partPlace(((t7: rs.String): rs.String => { return t7; - })(rs.valuePlace(_154))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([rs.fmtSpec({ align: ">", width: 12 }, (f: rs.Formatter) => rs.fmtPad(f, text5.value))]))); + })(_154.value))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([rs.fmtSpec({ align: ">", width: 12 }, (f: rs.Formatter) => rs.fmtPad(f, text5.value.v))]).v)); rs.refMutRelease(text5); } @@ -861,7 +862,7 @@ export function held$u32(lock: rs.RefCell): rs.u8 { * and locked while each writes what it holds. */ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; const mutex: rs.Arc> = new rs.Arc(new rs.Mutex(0)); const lock: rs.RefCell>> = new rs.RefCell(rs.vecFrom([new rs.Mutex(97)])); for (const op of rs.byteSliceView(data)) { @@ -872,9 +873,9 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { _22.value = v; rs.mutexUnlock(_22); const args26 = [(f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; - const free: string = rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args26[0])]); + const free: rs.String = rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args26[0])]); const _held: rs.Mutex = rs.mutexLock(mutex.value); - const args27 = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; + const args27 = [(f: rs.Formatter) => rs.fmtPad(f, free.v), (f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; text = rs.fmtFormat([args27[0], " ", args27[1], " ", rs.fmtSpec({ alternate: true }, args27[1]), " ", rs.fmtSpec({ align: ">", width: 12 }, args27[1])]); rs.mutexUnlock(_held); } else if (_18 === 1) { @@ -883,12 +884,12 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { _52.value.items.push(_55); rs.refMutRelease(_52); const args23 = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; - const free2: string = rs.fmtFormat([args23[0], " ", rs.fmtSpec({ alternate: true }, args23[0])]); + const free2: rs.String = rs.fmtFormat([args23[0], " ", rs.fmtSpec({ alternate: true }, args23[0])]); const read: rs.RefCell>> = rs.rwLockRead(lock); - const shared: string = rs.fmtFormat([(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]); + const shared: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]); const _85: rs.Vec> = read.value; const _held2: rs.Mutex = rs.mutexLock(_85.items[rs.idx(_85.items, 0)]); - const args25 = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.fmtPad(f, shared), (f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + const args25 = [(f: rs.Formatter) => rs.fmtPad(f, free2.v), (f: rs.Formatter) => rs.fmtPad(f, shared.v), (f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; text = rs.fmtFormat([args25[0], " ", args25[1], " ", args25[2], " ", rs.fmtSpec({ alternate: true }, args25[2])]); rs.mutexUnlock(_held2); rs.refRelease(read); @@ -914,10 +915,10 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { mutex2[Symbol.dispose](); } } else { - const part = new rs.RefCell(new rs.Mutex("s")); - text = rs.fmtFormat([(f: rs.Formatter) => rs.rwLockDebug(part, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtStr))]); + const part = new rs.RefCell(new rs.Mutex(rs.stringFrom("s"))); + text = rs.fmtFormat([(f: rs.Formatter) => rs.rwLockDebug(part, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)))]); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } mutex[Symbol.dispose](); } @@ -931,7 +932,7 @@ export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { export function guarded(data: rs.ByteSlice, out: rs.ByteVec): void { const slot: Shared.Shared = Shared.new$Option_u8(undefined); const number: Shared.Shared = Shared.new$u32(0); - const text: Shared.Shared = Shared.new$String(""); + const text: Shared.Shared = Shared.new$String(rs.stringNew()); const seen: Shared.Shared = Shared.new$Vec_u8(new rs.ByteVec()); const tally: [rs.u8, rs.u8 | undefined] = [0, undefined]; for (const op of rs.byteSliceView(data)) { @@ -974,14 +975,13 @@ export function guarded(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, option_unwrapOr$1fr498u(Held.deref$ops_Deref_Option_u8(_67), 254)); _67[Symbol.dispose](); } else if (_18 === 4) { - const _72: Held.Held = Shared.lock$String(text); - const _70: rs.Place = Held.derefMut$ops_DerefMut_String(_72); - _70.v = _70.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + const _72: Held.Held = Shared.lock$String(text); + rs.stringPush(Held.derefMut$ops_DerefMut_String(_72), rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); _72[Symbol.dispose](); - const held2: Held.Held = Shared.lock$String(text); - if (rs.stringLen(Held.deref$ops_Deref_String(held2)) > 3) { - const _85: string = rs.strToUppercase(Held.deref$ops_Deref_String(held2)); - Held.derefMut$ops_DerefMut_String(held2).v = _85; + const held2: Held.Held = Shared.lock$String(text); + if (Held.deref$ops_Deref_String(held2).len > 3) { + const _85: rs.String = rs.strToUppercase(Held.deref$ops_Deref_String(held2).v); + Object.assign(Held.derefMut$ops_DerefMut_String(held2), _85); } const _94: Held.Held = Shared.lock$Vec_u8(seen); rs.byteVecPush(Held.derefMut$ops_DerefMut_Vec_u8(_94), op); @@ -1002,8 +1002,8 @@ export function guarded(data: rs.ByteSlice, out: rs.ByteVec): void { const _119: Held.Held = Shared.lock$u32(number); rs.byteVecPush(out, Held.deref$ops_Deref_u32(_119) & 0xff); _119[Symbol.dispose](); - const _125: Held.Held = Shared.lock$String(text); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(Held.deref$ops_Deref_String(_125))); + const _125: Held.Held = Shared.lock$String(text); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(Held.deref$ops_Deref_String(_125).v)); _125[Symbol.dispose](); const _131: Held.Held = Shared.lock$Vec_u8(seen); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(Held.deref$ops_Deref_Vec_u8(_131))); diff --git a/ts/fixtures/lang/manual/expected/manual.ts b/ts/fixtures/lang/manual/expected/manual.ts index 25daf5502..068d69729 100644 --- a/ts/fixtures/lang/manual/expected/manual.ts +++ b/ts/fixtures/lang/manual/expected/manual.ts @@ -104,11 +104,12 @@ export function needs$unit(): boolean { * generic body that branches on it does, as std's collections do; and types' names. */ export function needsDrops(data: rs.ByteSlice, out: rs.ByteVec): void { - const captured = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _4: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { return _2 as rs.char; - })); + }); + const captured = rs.stringExtendChars(rs.stringNew(), _4); const named: () => rs.usize = (): rs.usize => { - return rs.stringLen(captured); + return captured.len; }; const copied: () => rs.usize = (): rs.usize => { return data.length; @@ -117,8 +118,8 @@ export function needsDrops(data: rs.ByteSlice, out: rs.ByteVec): void { return a0 ? 1 : 0; })), undefined, true); rs.byteVecPush(out, (named() & 0xff) ^ (copied() & 0xff)); - rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$String(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b2, f)); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$String(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b2, f), 0); }), undefined, 12, true))).reverse()), undefined, true); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$u8(rs.byteSliceToByteVec(data))).reverse()), undefined, true); const iter: rs.Iter = rs.iterSlice(["lang_manual_fixture::manual::ByHand", "core::option::Option<&[alloc::string::String]>", "lang_manual_fixture::manual::needs_drops::{{closure}}", "[u8]", nameOf$u8(), nameOf$String()]); @@ -155,7 +156,7 @@ export function nameOf$u8(): string { * How many items a generic body drops one by one, as std's collections do only of a type * that needs dropping, and forgets the rest. */ -export function droppedByHand$String(items: rs.Vec): rs.u32 { +export function droppedByHand$String(items: rs.Vec): rs.u32 { if (false) { return 0; } diff --git a/ts/fixtures/lang/nested/expected/nested.ts b/ts/fixtures/lang/nested/expected/nested.ts index d14668725..e1e300287 100644 --- a/ts/fixtures/lang/nested/expected/nested.ts +++ b/ts/fixtures/lang/nested/expected/nested.ts @@ -123,7 +123,7 @@ export function made(data: rs.ByteSlice, out: rs.ByteVec): void { const tagged: Tagged.Tagged = new Tagged.Tagged(u, _106); rs.byteVecPush(out, (tagged.value !== rs.None ? 1 : 0) | ((order(tagged.order) << 1) & 0xff)); const args3 = [(f: rs.Formatter) => rs.fmtOption(o, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(u, f, rs.fmtUnit, rs.None)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1]]).v)); } } @@ -451,7 +451,7 @@ export function closures(data: rs.ByteSlice, out: rs.ByteVec): void { if (240 <= data.data[data.start]) { if (data.data[data.start] <= 255) { const b: rs.u8 = data.data[data.start]; - let s: string = ""; + const s: rs.String = rs.stringNew(); const rest3: rs.Iter = rs.iterMap(new rs.Range(0, 2147483647), (_224: rs.usize): rs.char => { rs.panicFmt(["read"]); }); @@ -461,14 +461,14 @@ export function closures(data: rs.ByteSlice, out: rs.ByteVec): void { }, undefined, rs.None), (_30: undefined): rs.char => { return 97; }), rest3); - s = rs.stringExtendChars(s, _137); + rs.stringExtendChars(s, _137); } else { const _142: rs.Iter = rs.iterChain(rs.iterMap(rs.iterSuccessors(undefined as rs.u8 | undefined | rs.None, (_225: rs.u8 | undefined): rs.u8 | undefined | rs.None => { return rs.None; }, undefined, rs.None), (_226: rs.u8 | undefined): rs.char => { return 97; }), rest3); - s = rs.stringExtendChars(s, _142); + rs.stringExtendChars(s, _142); } } } @@ -780,7 +780,7 @@ export function units(data: rs.ByteSlice, out: rs.ByteVec): void { const e: rs.Result = result_mapErr$136pgpq(option_okOr$06f2ml7(rs.byteSliceFirst(data), undefined), (_: undefined): undefined => {}); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(o !== rs.None ? 1 : 0, none !== rs.None ? 1 : 0, r.ok ? 1 : 0, !e.ok ? 1 : 0)), undefined, true); const args3 = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtOption(o, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtUnit, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(e, f, rs.u8Debug, rs.fmtUnit)]; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4]]).v))), undefined, true); } //# sourceMappingURL=nested.ts.map diff --git a/ts/fixtures/lang/orders/expected/core/cmp.ts b/ts/fixtures/lang/orders/expected/core/cmp.ts index 67e100148..e82809bf4 100644 --- a/ts/fixtures/lang/orders/expected/core/cmp.ts +++ b/ts/fixtures/lang/orders/expected/core/cmp.ts @@ -3,7 +3,7 @@ import * as rs from "../rs.ts"; import * as Item from "../orders.Item.ts"; -export function min$0tf7r1u(v1: string, v2: string): string { +export function min$10ohimp(v1: rs.String, v2: rs.String): rs.String { return rs.ordMin(v1, v2, rs.cmpLt(rs.cmpStr)); } @@ -74,7 +74,7 @@ export function minByKey$1qsvvgc(v1: Item.Item, v2: Item.Item, f: (a0: Item.Item return _0; } -export function max$0mrbrbr(v1: string, v2: string): string { +export function max$16nac37(v1: rs.String, v2: rs.String): rs.String { return rs.ordMax(v1, v2, rs.cmpLt(rs.cmpStr)); } diff --git a/ts/fixtures/lang/orders/expected/orders.ts b/ts/fixtures/lang/orders/expected/orders.ts index 61cbd61a7..d37902d2e 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { copy$tuple2_u8_u8 } from "./lib.ts"; import { thenSome$1qfl7tz } from "./core/bool.ts"; -import { min$0tf7r1u, min$0hz2v7s, min$1akgklh, min$094dtzd, minBy$18ytev0, minBy$0p6yz91, minByKey$1qsvvgc, max$0mrbrbr, max$0vq2d0c, max$0n458i1, max$1nu2xoq, max$12ifqlw, max$0we2ghu, maxBy$1ghjx71, maxBy$1gr65n2, maxByKey$1a9sf4b } from "./core/cmp.ts"; +import { min$10ohimp, min$0hz2v7s, min$1akgklh, min$094dtzd, minBy$18ytev0, minBy$0p6yz91, minByKey$1qsvvgc, max$16nac37, max$0vq2d0c, max$0n458i1, max$1nu2xoq, max$12ifqlw, max$0we2ghu, maxBy$1ghjx71, maxBy$1gr65n2, maxByKey$1a9sf4b } from "./core/cmp.ts"; import { unwrapOr$18rai12 as option_unwrapOr$18rai12, map$0adj75b as option_map$0adj75b, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$13h3wxw as option_mapOr$13h3wxw, mapOr$172961h as option_mapOr$172961h, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$0i0fno7 as option_mapOr$0i0fno7 } from "./core/option.ts"; import { eq$1wvyxyw as result_eq$1wvyxyw, eq$0p2ygx3 as result_eq$0p2ygx3, partialCmp$1frpo9k as result_partialCmp$1frpo9k, partialCmp$1ks7sga as result_partialCmp$1ks7sga, partialCmp$0rzsy3r as result_partialCmp$0rzsy3r, partialCmp$0wss1z6 as result_partialCmp$0wss1z6, cmp$0lhhufb as result_cmp$0lhhufb, cmp$13u97s2 as result_cmp$13u97s2, cmp$0h35u3j as result_cmp$0h35u3j, cmp$18cbpvu as result_cmp$18cbpvu } from "./core/result.ts"; import { eq$1qrb1lw as poll_eq$1qrb1lw, cmp$17et0iz as poll_cmp$17et0iz, partialCmp$1gaal0x as poll_partialCmp$1gaal0x, partialCmp$12m7vp8 as poll_partialCmp$12m7vp8 } from "./core/task/poll.ts"; @@ -75,10 +75,10 @@ export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, o const b: rs.u8 = _13[1]; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(max$0we2ghu(a, b), min$094dtzd(a, b), max$0n458i1((a << 24) >> 24, (b << 24) >> 24) & 0xff)), undefined, true); const _37: rs.u8 = rs.u8Div(b, 2); - const _32: [string, string] = [rs.fmtToString((f: rs.Formatter) => rs.u8Display(a, f)), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_37, f))]; - const s: string = _32[0]; - const t: string = _32[1]; - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.stringLen(max$0mrbrbr(s, t)) & 0xff, rs.stringLen(min$0tf7r1u(s, t)) & 0xff)), undefined, true); + const _32: [rs.String, rs.String] = [rs.fmtToString((f: rs.Formatter) => rs.u8Display(a, f), 0), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_37, f), 0)]; + const s: rs.String = _32[0]; + const t: rs.String = _32[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(max$16nac37(rs.stringClone(s), rs.stringClone(t)).len & 0xff, min$10ohimp(s, t).len & 0xff)), undefined, true); const _55: [Item.Item, Item.Item] = [item(rs.usizeMul(2, i), a), item(rs.usizeAdd(rs.usizeMul(2, i), 1), b)]; const x: Item.Item = _55[0]; const y: Item.Item = _55[1]; @@ -216,16 +216,16 @@ export function sorted(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), rs.lent(key)), rs.le, true) ? 1 : 0); rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), rs.lent(key)), rs.le, true) ? 1 : 0); flush(out); - const strings: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (b7: rs.u8): string => { + const strings: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (b7: rs.u8): rs.String => { const _415: rs.u8 = rs.u8Rem(b7, 16); - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_415, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_415, f), 0); }), undefined, 12, true); rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceIsSorted(_12, rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), (a5: rs.u8, b8: rs.u8): boolean => { return rs.u8Div(a5, 4) <= rs.u8Div(b8, 4); }) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (_25: rs.u8): rs.u8 => { return rs.u8Rem(_25, 8); - }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), rs.le) ? 1 : 0, rs.sliceIsSorted(rs.sliceFrom(strings.items), rs.cmpLe(rs.cmpStr)) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(strings.items), (a0: string): rs.usize => { - return rs.stringLen(a0); + }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), rs.le) ? 1 : 0, rs.sliceIsSorted(rs.sliceFrom(strings.items), rs.cmpLe(rs.cmpStr)) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(strings.items), (a0: rs.String): rs.usize => { + return a0.len; }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (_29: rs.u8): rs.f64 => { return (_29 as rs.f64) / 3.0; }), rs.cmpLe(rs.f64PartialCmp)) ? 1 : 0)), undefined, true); @@ -383,7 +383,7 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { rs.heapPush(bytes, data.length & 0xff, rs.le); rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.from(bytes.items)))), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapIntoSortedVec(rs.heapClone(bytes, undefined), rs.le, rs.ge, rs.lt))), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(bytes.items, f, rs.u8Debug)])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(bytes.items, f, rs.u8Debug)]).v), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(bytes)), undefined, true); const least: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { return _2; @@ -401,24 +401,26 @@ export function values(data: rs.ByteSlice, out: rs.ByteVec): void { } } const _51: rs.usize = data.length; - const strings: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(["pear", "apple", rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_51, f))]), undefined, 12, true), rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); - const copy: rs.BinaryHeap = rs.heapClone(strings, undefined); - const _56: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): string => { + const strings: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice([rs.stringFrom("pear"), rs.stringFrom("apple"), rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_51, f), 0)]), undefined, 12, true), rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); + const copy: rs.BinaryHeap = rs.heapClone(strings, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }); + const _56: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): rs.String => { const _43: rs.u8 = rs.u8Rem(b4, 10); - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_43, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_43, f), 0); }); rs.heapExtend(copy, _56, rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr), undefined, 12, true); - rs.heapRetain(copy, (s: string): boolean => { - if (!(rs.stringLen(s) > 1)) { - return rs.cmpStr(s, "5") === -1; + rs.heapRetain(copy, (s: rs.String): boolean => { + if (!(s.len > 1)) { + return rs.cmpStr(s.v, "5") === -1; } return true; }, rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); - rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(copy.items), (s2: string): rs.Iter => { - return rs.strBytes(s2); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(copy.items), (s2: rs.String): rs.Iter => { + return rs.strBytes(s2.v); }, undefined, true), "next"); - rs.iterExtendBytes(out, rs.iterMap(rs.heapIter(strings), (s3: string): rs.u8 => { - return rs.stringLen(s3) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.heapIter(strings), (s3: rs.String): rs.u8 => { + return s3.len & 0xff; }), "next"); const pairs: rs.BinaryHeap<[rs.u8, rs.u8]> = rs.heapNew() as rs.BinaryHeap<[rs.u8, rs.u8]>; const _73: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, rs.u8] => { diff --git a/ts/fixtures/lang/panics/caller.ts b/ts/fixtures/lang/panics/caller.ts index 953b7fe88..09caea6c5 100644 --- a/ts/fixtures/lang/panics/caller.ts +++ b/ts/fixtures/lang/panics/caller.ts @@ -1,4 +1,8 @@ // What `panics`' hooks wrote, which `differential.ts` compares after each case. +import { note as noted } from "./lib.ts"; + export { ops, run } from "./lang.ts"; -export { note } from "./lib.ts"; + +/** What the hooks wrote since the last call, as a JS string. */ +export const note = (): string => noted().v; diff --git a/ts/fixtures/lang/panics/expected/harness.ts b/ts/fixtures/lang/panics/expected/harness.ts index c64676b77..df649c7e4 100644 --- a/ts/fixtures/lang/panics/expected/harness.ts +++ b/ts/fixtures/lang/panics/expected/harness.ts @@ -36,8 +36,8 @@ export function op(name: string): rs.u16 { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -49,7 +49,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/panics/expected/lib.ts b/ts/fixtures/lang/panics/expected/lib.ts index 303963f04..7d3cffef5 100644 --- a/ts/fixtures/lang/panics/expected/lib.ts +++ b/ts/fixtures/lang/panics/expected/lib.ts @@ -19,9 +19,9 @@ export function drop$Result_u8_boxed_Box_dyn_Any_marker_Send(_1: rs.Result undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::called", panics_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::raised", raised as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::called", located_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::read", read as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::panicked", panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } -export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); +export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); -export function NOTE$init(): rs.RefCell { - return new rs.RefCell(""); +export function NOTE$init(): rs.RefCell { + return new rs.RefCell(rs.stringNew()); } /** Take what the hooks wrote since the last call. */ -export function note(): string { - return rs.localKeyWithBorrowMutPlace(NOTE, (a0: rs.Place): string => { - const taken = a0.v; - a0.v = ""; - return taken; +export function note(): rs.String { + return rs.localKeyWithBorrowMut(NOTE, (a0: rs.String): rs.String => { + return rs.replaceIn(a0, rs.stringNew()); }); } diff --git a/ts/fixtures/lang/panics/expected/located.ts b/ts/fixtures/lang/panics/expected/located.ts index 6b5e8aa46..65667c8d0 100644 --- a/ts/fixtures/lang/panics/expected/located.ts +++ b/ts/fixtures/lang/panics/expected/located.ts @@ -72,7 +72,7 @@ export function generic$u8(t: rs.u8): rs.Location { /** Each location's `Display`, a line each. */ export function lines(out: rs.ByteVec, at: rs.Slice): void { for (const _5 of rs.sliceItems(at)) { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f), "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f), "\n"]).v)); } } @@ -130,7 +130,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; const args3 = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], args3[1], args3[0], args3[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], args3[1], args3[0], args3[2]]).v)); } } @@ -143,19 +143,15 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); const _9: rs.u8 = rs.u8Rem(kind, 4); if (_9 === 0) { - let s: string = ""; + const s: rs.String = rs.stringNew(); const _18: string = a.file; const _20: rs.u32 = a.line; const _22: rs.u32 = a.col; const args8 = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; - const written = rs.fmtWriteString(s, [args8[0], "|", args8[1], "|", args8[2], "|"]); - s = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug); + rs.resultUnwrap(rs.fmtWriteString(s, [args8[0], "|", args8[1], "|", args8[2], "|"]), rs.fmtErrorDebug); const args9 = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; - const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[2]), "|", rs.fmtSpec({ debugHex: "x" }, args9[2])]); - s = written2.s; - rs.resultUnwrap(written2.result, rs.fmtErrorDebug); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.resultUnwrap(rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[2]), "|", rs.fmtSpec({ debugHex: "x" }, args9[2])]), rs.fmtErrorDebug); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } else if (_9 === 1) { const copy: rs.Location = a; const same: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); @@ -190,7 +186,7 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const held: Held$read.Held = { at: a, maybe: _117 }; const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; const args7 = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], "|", args7[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], "|", args7[1]]).v)); } } diff --git a/ts/fixtures/lang/panics/expected/panics.ts b/ts/fixtures/lang/panics/expected/panics.ts index 3a048f957..4932152e5 100644 --- a/ts/fixtures/lang/panics/expected/panics.ts +++ b/ts/fixtures/lang/panics/expected/panics.ts @@ -16,8 +16,8 @@ export function seven(): rs.u8 { } /** What `f` returns, through `catch_unwind`. */ -export function caught$String_panics_called_closure6(f: () => string): string { - const _2: rs.Result = rs.Ok(f()); +export function caught$String_panics_called_closure6(f: () => rs.String): rs.String { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } @@ -131,20 +131,20 @@ export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_7 === 3) { const _132: rs.u8 = first; const _134: rs.u8 = first; - const _136: string = text(data); + const _136: rs.String = text(data); const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; const _144: [rs.u8, string] = [first, "a"]; - const args3 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ width: 5 }, args3[3]), "|", args3[4], "|", rs.fmtSpec({ alternate: true }, args3[5])]))); + const args3 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136.v, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ width: 5 }, args3[3]), "|", args3[4], "|", rs.fmtSpec({ alternate: true }, args3[5])]).v)); } else if (_7 === 4) { const d: rs.u8 = 0; - const s2: string = ""; + const s2: rs.String = rs.stringNew(); const p2: Point.Point = Point.default$Default(); const v3: rs.ByteVec = new rs.ByteVec(); const e: rs.u8 = first; f = rs.byteSliceToByteVec(data); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, rs.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, s2.len & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); } else { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const a2: Logged.Logged = new Logged.Logged(1, log); @@ -230,9 +230,9 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rs.ByteVec => { return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): rs.String => { return rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(first, f)]); - }))); + }).v)); } else if (_10 === 3) { rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { return rs.u8WrappingMul(first, 2); @@ -284,7 +284,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return n2; }); const args6 = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]).v)); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); @@ -497,7 +497,7 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (_9 === 0) { rs.panic("a payload of text"); } else if (_9 === 1) { - rs.panic(text(data)); + rs.panic(text(data).v); } else if (_9 === 2) { rs.panic("Box"); } else if (_9 === 3) { @@ -521,9 +521,9 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { const boxed: Any.Any = new of$u8(first); new of$u8(first); - const synced: Any.Any = new of$String(""); + const synced: Any.Any = new of$String(rs.stringNew()); const args3 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args3[2]), "|", args3[3]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args3[2]), "|", args3[3]]).v)); rs.drop(synced); rs.drop(boxed); } diff --git a/ts/fixtures/lang/panics/hook/expected/core/option.ts b/ts/fixtures/lang/panics/hook/expected/core/option.ts index 6f168ecb0..77c48304e 100644 --- a/ts/fixtures/lang/panics/hook/expected/core/option.ts +++ b/ts/fixtures/lang/panics/hook/expected/core/option.ts @@ -16,6 +16,13 @@ export function map$18ftgyp(self: rs.char | undefined, _: (a0: rs.char) => rs.u3 return self as rs.u32; } +export function map$0ded99z(self: rs.String | undefined, _: (a0: rs.String) => rs.usize): rs.usize | undefined { + if (self === undefined) { + return undefined; + } + return self.cap; +} + export function map$04ry0e1(self: rs.u32 | undefined, f: (a0: rs.u32) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; diff --git a/ts/fixtures/lang/panics/hook/expected/harness.ts b/ts/fixtures/lang/panics/hook/expected/harness.ts index 35368b25b..c05c59358 100644 --- a/ts/fixtures/lang/panics/hook/expected/harness.ts +++ b/ts/fixtures/lang/panics/hook/expected/harness.ts @@ -36,8 +36,8 @@ export function op(name: string): rs.u16 { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -49,7 +49,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13, { file: "fixtures/lang/panics/src/../../harness.rs", line: 62, col: 16 }, true); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts index 27407d09c..4710c5ca5 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts @@ -13,14 +13,14 @@ export interface Shown { export function fmt$fmt_Display(self: Shown, f: rs.Formatter): rs.Result { const part = rs.panicking(); - const line: string = rs.fmtFormat(["shown ", (f: rs.Formatter) => rs.fmtBool(part, f), "\n"]); - rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { - note.v = note.v + line; + const line: rs.String = rs.fmtFormat(["shown ", (f: rs.Formatter) => rs.fmtBool(part, f), "\n"]); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + rs.stringPushStr(note, line.v); }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); if (!self.again) { return rs.fmtWriteStr(f, "shown"); } - rs.panicFmt(["shown"], { file: "fixtures/lang/panics/src/hooked.rs", line: 139, col: 13 }); + rs.panicFmt(["shown"], { file: "fixtures/lang/panics/src/hooked.rs", line: 156, col: 13 }); } //# sourceMappingURL=hooked.Shown.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.ts b/ts/fixtures/lang/panics/hook/expected/hooked.ts index ad03caa95..b78beeb33 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8, drop$bytes_buf_Take_bytes_Bytes, of$String, of$ref_str, of$u32, ofPlace$String, ofPlace$ref_str, ofPlace$u32, NOTE } from "./lib.ts"; +import { drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8, drop$bytes_buf_Take_bytes_Bytes, of$String, of$ref_str, of$u32, ofPlace$ref_str, ofPlace$u32, NOTE } from "./lib.ts"; import { take$bytes_Buf_bytes_Bytes as buf_impl_take$bytes_Buf_bytes_Bytes } from "./bytes/buf/buf_impl.ts"; import * as Take from "./bytes/buf/take.Take.ts"; import * as UninitSlice from "./bytes/buf/uninit_slice.UninitSlice.ts"; import type * as Any from "./core/any.Any.ts"; -import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$18ftgyp as option_map$18ftgyp, map$04ry0e1 as option_map$04ry0e1, mapOr$14runhi as option_mapOr$14runhi, filter$0hq86nl } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$18ftgyp as option_map$18ftgyp, map$0ded99z as option_map$0ded99z, map$04ry0e1 as option_map$04ry0e1, mapOr$14runhi as option_mapOr$14runhi, filter$0hq86nl } from "./core/option.ts"; import { map$1hfd4x1 as result_map$1hfd4x1, unwrapOrDefault$0t7trfe as result_unwrapOrDefault$0t7trfe, unwrapOr$1tftpn5 as result_unwrapOr$1tftpn5 } from "./core/result.ts"; import * as Lying from "./hooked.Lying.ts"; import * as Shown from "./hooked.Shown.ts"; @@ -17,33 +17,33 @@ import { withBorrow$097wfl1 } from "./std/thread/local.ts"; * parts, and whether the thread is panicking. */ export function record(info: rs.PanicHookInfo): void { - let kind!: string; + let kind!: rs.String; const payload: Any.Any = rs.hookPayload(info, of$ref_str, of$String); if (!(payload instanceof of$ref_str || payload instanceof ofPlace$ref_str)) { - if (!(payload instanceof of$String || payload instanceof ofPlace$String)) { + if (!(payload instanceof of$String)) { const _8: rs.u32 | undefined = payload instanceof of$u32 ? payload.v : payload instanceof ofPlace$u32 ? payload.v.v : undefined; if (_8 !== undefined) { kind = rs.fmtFormat(["u32 ", (f: rs.Formatter) => rs.u32Display(_8, f)]); } else { - kind = "other"; + kind = rs.stringFrom("other"); } } else { - kind = "String"; + kind = rs.stringFrom("String"); } } else { - kind = "&str"; + kind = rs.stringFrom("&str"); } const at: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 39, col: 30 }); - const _27: string = rs.strReplace(rs.fmtToString((f: rs.Formatter) => rs.fmtPanicHookInfoDisplay(info, f)), at.file, stdNamed(at.file)); + const _27: rs.String = rs.strReplace(rs.fmtToString((f: rs.Formatter) => rs.fmtPanicHookInfoDisplay(info, f)).v, at.file, stdNamed(at.file).v, true); const _37: string | undefined = info.text; - const _39: string = stdNamed(at.file); + const _39: rs.String = stdNamed(at.file); const _42: rs.u32 = at.line; const _44: rs.u32 = at.col; const _46: boolean = rs.panicking(); - const args6 = [(f: rs.Formatter) => rs.fmtPad(f, _27), (f: rs.Formatter) => rs.fmtPad(f, kind), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtPad(f, _39), (f: rs.Formatter) => rs.u32Display(_42, f), (f: rs.Formatter) => rs.u32Display(_44, f), (f: rs.Formatter) => rs.fmtBool(_46, f)]; - const line: string = rs.fmtFormat([args6[0], "\n", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", args6[6], "\n"]); - rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { - note.v = note.v + line; + const args6 = [(f: rs.Formatter) => rs.fmtPad(f, _27.v), (f: rs.Formatter) => rs.fmtPad(f, kind.v), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtPad(f, _39.v), (f: rs.Formatter) => rs.u32Display(_42, f), (f: rs.Formatter) => rs.u32Display(_44, f), (f: rs.Formatter) => rs.fmtBool(_46, f)]; + const line: rs.String = rs.fmtFormat([args6[0], "\n", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", args6[6], "\n"]); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + rs.stringPushStr(note, line.v); }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); } @@ -53,7 +53,7 @@ export function record(info: rs.PanicHookInfo): void { * generic or inlined function, and by `/rustc//library/` where std's own build * did, as the translation always does. */ -export function stdNamed(file: string): string { +export function stdNamed(file: string): rs.String { const _2: [string, string] | undefined = rs.strSplitOnce(file, "/library/"); b1: { if (_2 !== undefined) { @@ -66,7 +66,7 @@ export function stdNamed(file: string): string { return rs.fmtFormat(["/library/", (f: rs.Formatter) => rs.fmtPad(f, part)]); } } - return file; + return rs.stringFrom(file); } /** Replace the hook with one that records each panic, then passes it on. */ @@ -80,6 +80,26 @@ export function hook(): void { }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); } +/** + * Have the hook also write a `String` payload's capacity, which `panic!` formats into one + * from empty and `panic_any` keeps. + */ +export function sized(): void { + const captured = rs.takeHook(); + rs.setHook(rs.closure((info: rs.PanicHookInfo): undefined => { + const _52: Any.Any = rs.hookPayload(info, of$ref_str, of$String); + const capacity: rs.usize | undefined = option_map$0ded99z(_52 instanceof of$String ? _52.v : undefined, (a0: rs.String): rs.usize => { + return a0.cap; + }); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + rs.stringPushStr(note, rs.fmtFormat(["capacity ", (f: rs.Formatter) => rs.fmtOption(capacity, f, rs.usizeDebug), "\n"]).v); + }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); + captured(info); + }, (): void => { + rs.drop(captured); + }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); +} + export function tracked(n: rs.u8, caller: rs.Location): rs.u8 { rs.panicFmt(["tracked ", (f: rs.Formatter) => rs.u8Display(n, f)], caller); } @@ -89,91 +109,94 @@ export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); hook(); const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(n, n)); - const _10: rs.u8 = rs.u8Rem(kind, 32, { file: "fixtures/lang/panics/src/hooked.rs", line: 84, col: 11 }); + const _10: rs.u8 = rs.u8Rem(kind, 32, { file: "fixtures/lang/panics/src/hooked.rs", line: 95, col: 11 }); if (_10 === 0) { - rs.panicFmt(["literal"], { file: "fixtures/lang/panics/src/hooked.rs", line: 85, col: 14 }); + rs.panicFmt(["literal"], { file: "fixtures/lang/panics/src/hooked.rs", line: 96, col: 14 }); } else if (_10 === 1) { - rs.panicFmt(["formatted ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 86, col: 14 }); + sized(); + rs.panicFmt(["formatted ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 99, col: 13 }); } else if (_10 === 2) { - rs.byteVecPush(out, v.data[rs.idx(v, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 25 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 24 })]); + rs.byteVecPush(out, v.data[rs.idx(v, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 25 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 24 })]); } else if (_10 === 3) { - rs.byteVecPush(out, rs.u8Add(rs.max(n, 200), rs.max(n, 100), { file: "fixtures/lang/panics/src/hooked.rs", line: 88, col: 23 })); + rs.byteVecPush(out, rs.u8Add(rs.max(n, 200), rs.max(n, 100), { file: "fixtures/lang/panics/src/hooked.rs", line: 102, col: 23 })); } else if (_10 === 4) { - rs.byteVecPush(out, rs.optionUnwrap(filter$0hq86nl(n, (_24: rs.u8): boolean => { + rs.byteVecPush(out, rs.optionUnwrap(filter$0hq86nl(n, (_25: rs.u8): boolean => { return false; - }), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 89, col: 49 })); + }), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 103, col: 49 })); } else if (_10 === 5) { - rs.byteVecPush(out, rs.resultUnwrap(rs.Err(n), rs.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 90, col: 40 })); + rs.byteVecPush(out, rs.resultUnwrap(rs.Err(n), rs.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 40 })); } else if (_10 === 6) { rs.byteVecPush(out, rs.optionExpect(filter$0hq86nl(n, (_2: rs.u8): boolean => { return false; - }), "expected", undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 91, col: 49 })); + }), "expected", undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 49 })); } else if (_10 === 7) { - const part2 = rs.usizeAdd(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 51 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 39 }); - rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteVecSlice(v), part2, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 38 })); + const part2 = rs.usizeAdd(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 51 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 39 }); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteVecSlice(v), part2, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 38 })); } else if (_10 === 8) { const cell: rs.RefCell = new rs.RefCell(n); - const _held: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 95, col: 30 }); - const _56: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 96, col: 28 }); - rs.byteVecPush(out, _56.value); - rs.refMutRelease(_56); + const _held: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 109, col: 30 }); + const _57: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 28 }); + rs.byteVecPush(out, _57.value); + rs.refMutRelease(_57); rs.refMutRelease(_held); } else if (_10 === 9) { rs.byteVecPush(out, rs.intPow(rs.max(n, 2), 9, 8, false, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/mod.rs", line: 590, col: 5 })); } else if (_10 === 10) { - rs.byteVecPush(out, rs.u8Div(100, rs.u8WrappingMul(n, 0), { file: "fixtures/lang/panics/src/hooked.rs", line: 99, col: 24 })); + rs.byteVecPush(out, rs.u8Div(100, rs.u8WrappingMul(n, 0), { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 24 })); } else if (_10 === 11) { - rs.byteVecPush(out, rs.byteVecRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 34 })); + rs.byteVecPush(out, rs.byteVecRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 34 })); } else if (_10 === 12) { - rs.byteVecPush(out, rs.byteVecSwapRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 46 }))); + rs.byteVecPush(out, rs.byteVecSwapRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 115, col: 46 }))); } else if (_10 === 13) { - rs.byteSliceRotateLeft(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 102, col: 37 })); + rs.byteSliceRotateLeft(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 116, col: 37 })); } else if (_10 === 14) { - rs.byteVecPush(out, rs.hashIndex(rs.hashNew() as rs.HashMap, n, { file: "fixtures/lang/panics/src/hooked.rs", line: 103, col: 48 })); + rs.byteVecPush(out, rs.hashIndex(rs.hashNew() as rs.HashMap, n, { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 48 })); } else if (_10 === 15) { - rs.panicAny(new of$u32(n as rs.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 15 }); + rs.panicAny(new of$u32(n as rs.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 118, col: 15 }); } else if (_10 === 16) { - rs.panic(rs.fmtFormat(["any ", (f: rs.Formatter) => rs.u8Display(n, f)]), { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); + sized(); + const _94: rs.String = rs.fmtFormat(["any ", (f: rs.Formatter) => rs.u8Display(n, f)]); + rs.panic(_94.v, { file: "fixtures/lang/panics/src/hooked.rs", line: 121, col: 13 }, _94); } else if (_10 === 17) { - const _104: rs.u8 = rs.u8WrappingAdd(n, 1); - if (!(n === _104)) { - rs.assertFailed("==", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(_104, f), ["differ"], { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 15 }); + const _106: rs.u8 = rs.u8WrappingAdd(n, 1); + if (!(n === _106)) { + rs.assertFailed("==", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(_106, f), ["differ"], { file: "fixtures/lang/panics/src/hooked.rs", line: 123, col: 15 }); } } else if (_10 === 18) { - rs.byteVecPush(out, tracked(n, { file: "fixtures/lang/panics/src/hooked.rs", line: 107, col: 24 })); + rs.byteVecPush(out, tracked(n, { file: "fixtures/lang/panics/src/hooked.rs", line: 124, col: 24 })); } else if (_10 === 19) { - rs.byteVecPush(out, rs.dequeIndex(rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFrom(rs.byteVecView(v))), 1, true) as rs.VecDeque, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 49 })); + rs.byteVecPush(out, rs.dequeIndex(rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFrom(rs.byteVecView(v))), 1, true) as rs.VecDeque, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 125, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 125, col: 49 })); } else if (_10 === 20) { rs.byteVecPush(out, result_unwrapOr$1tftpn5(rs.u8TryFrom(rs.durationAsSecs(rs.durationAdd({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)))), 0)); } else if (_10 === 21) { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strSlice("éé", 0, rs.usizeAdd(rs.usizeMul(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 56 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 41 }))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strSlice("éé", 0, rs.usizeAdd(rs.usizeMul(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 56 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 44 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 127, col: 41 }))); } else if (_10 === 22) { - rs.iterExtendBytes(out, rs.iterStepBy(new rs.Range(0, n), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 111, col: 41 }), undefined, 255, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(new rs.Range(0, n), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 128, col: 41 }), undefined, 255, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 23) { - const _150: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _152: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 112, col: 42 }), rs.usizeStep); - rs.iterExtendBytes(out, rs.byteVecDrain(_150, _152, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), "fold", true); + const _152: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _154: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 129, col: 42 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.byteVecDrain(_152, _154, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), "fold", true); } else if (_10 === 24) { - rs.panic("any", { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 15 }, false); + rs.panic("any", { file: "fixtures/lang/panics/src/hooked.rs", line: 130, col: 15 }); } else if (_10 === 25) { - rs.iterExtendBytes(out, rs.iterStepBy(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 43 }), undefined, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 131, col: 43 }), undefined, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 26) { - const _165: rs.u8 = rs.u8WrappingAdd(n, 1); - if (!(n === _165)) { - rs.panic("assertion failed: n == n.wrapping_add(1)", { file: "fixtures/lang/panics/src/hooked.rs", line: 115, col: 15 }); + const _167: rs.u8 = rs.u8WrappingAdd(n, 1); + if (!(n === _167)) { + rs.panic("assertion failed: n == n.wrapping_add(1)", { file: "fixtures/lang/panics/src/hooked.rs", line: 132, col: 15 }); } } else if (_10 === 27) { - rs.panic("explicit panic", { file: "fixtures/lang/panics/src/hooked.rs", line: 116, col: 15 }); + rs.panic("explicit panic", { file: "fixtures/lang/panics/src/hooked.rs", line: 133, col: 15 }); } else if (_10 === 28) { - rs.panic("internal error: entered unreachable code", { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 15 }); + rs.panic("internal error: entered unreachable code", { file: "fixtures/lang/panics/src/hooked.rs", line: 134, col: 15 }); } else if (_10 === 29) { - rs.panic("not yet implemented", { file: "fixtures/lang/panics/src/hooked.rs", line: 118, col: 15 }); + rs.panic("not yet implemented", { file: "fixtures/lang/panics/src/hooked.rs", line: 135, col: 15 }); } else if (_10 === 30) { if (n === n) { - rs.assertFailed("!=", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(n, f), undefined as rs.Arguments | undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 119, col: 15 }); + rs.assertFailed("!=", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(n, f), undefined as rs.Arguments | undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 136, col: 15 }); } } else if (_10 === 31) { - rs.panicFmt(["not implemented: not ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 120, col: 15 }); + rs.panicFmt(["not implemented: not ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 137, col: 15 }); } else { rs.byteVecPush(out, rs.hashLen(rs.hashWithCapacity(4294967295, 469762048) as rs.HashMap) & 0xff); } @@ -190,9 +213,9 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const captured2 = prev; rs.setHook(rs.closure((info: rs.PanicHookInfo): undefined => { record(info); - const _4: rs.u8 = rs.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 152, col: 15 }); + const _4: rs.u8 = rs.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 169, col: 15 }); if (_4 === 0) { - rs.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 153, col: 18 }); + rs.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 170, col: 18 }); } else if (_4 === 1) { rs.drop(rs.takeHook()); } else { @@ -202,13 +225,13 @@ export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.drop(captured2); }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); rs.byteVecPush(out, n); - const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 159, col: 11 }); + const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 176, col: 11 }); if (_13 === 3 || _13 === 4) { - const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 56 }) === 4 }; + const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 177, col: 56 }) === 4 }; const args6 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Shown.fmt$fmt_Display(_19, f)]; - rs.panicFmt(["first ", args6[0], " ", args6[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 18 }); + rs.panicFmt(["first ", args6[0], " ", args6[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 177, col: 18 }); } else { - rs.panicFmt(["first ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 161, col: 14 }); + rs.panicFmt(["first ", (f: rs.Formatter) => rs.u8Display(n, f)], { file: "fixtures/lang/panics/src/hooked.rs", line: 178, col: 14 }); } } @@ -239,13 +262,13 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _19: rs.u16[] = [n as rs.u16]; const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_19), true, undefined, undefined, 2, true); b0: { - const k: rs.u8 = rs.u8Rem(kind, 70, { file: "fixtures/lang/panics/src/hooked.rs", line: 183, col: 11 }); + const k: rs.u8 = rs.u8Rem(kind, 70, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 11 }); if (k === 0) { - rs.byteVecPush(out, rs.byteVecWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 184, col: 48 })).length & 0xff); + rs.byteVecPush(out, rs.byteVecWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 201, col: 48 })).length & 0xff); } else if (k === 1) { - rs.byteSliceRotateRight(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 185, col: 37 })); + rs.byteSliceRotateRight(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 202, col: 37 })); } else if (k === 2) { - rs.byteVecPush(out, rs.clamp(n, rs.max(n, 1), rs.u8Sub(rs.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 25 })); + rs.byteVecPush(out, rs.clamp(n, rs.max(n, 1), rs.u8Sub(rs.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 203, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 203, col: 25 })); } else if (k === 3) { rs.byteVecPush(out, rs.u8FromF64(rs.f64Clamp(n as rs.f64, 1.0, 0.0))); } else if (k === 4) { @@ -253,7 +276,7 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (k === 5) { rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.charEncodeUtf8(rs.max(n, 128) as rs.char, rs.byteSliceFrom(Uint8Array.of(0))).v)); } else if (k === 6) { - const _62: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(128512, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 191, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 192, col: 18 }); + const _62: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(128512, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 208, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 209, col: 18 }); const _69: rs.u16[] = [0]; rs.byteVecPush(out, rs.charEncodeUtf16(_62, rs.sliceFrom(_69)).length & 0xff); } else if (k === 7) { @@ -262,7 +285,7 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _239[1]; }), "next"); } else if (k === 8) { - const _81: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 35 }), n as rs.u16); + const _81: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 217, col: 35 }), n as rs.u16); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRange(map, _81), (_237: [rs.u16, rs.u8]): rs.u8 => { return _237[1]; }), "next"); @@ -272,29 +295,29 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return _232 & 0xff; }), "next"); } else if (k === 10) { - const _97: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 205, col: 36 }), n as rs.u16); + const _97: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 222, col: 36 }), n as rs.u16); rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(set, _97), (_230: rs.u16): rs.u8 => { return _230 & 0xff; }), "next"); } else if (k === 11) { - rs.dequeInsert(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 206, col: 36 }), n); + rs.dequeInsert(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 223, col: 36 }), n); } else if (k === 12) { - rs.dequeSwap(rs.dequeClone(deque), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 207, col: 34 }), 0); + rs.dequeSwap(rs.dequeClone(deque), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 224, col: 34 }), 0); } else if (k === 13) { - rs.dequeSwap(rs.dequeClone(deque), 0, rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 208, col: 37 })); + rs.dequeSwap(rs.dequeClone(deque), 0, rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 225, col: 37 })); } else if (k === 14) { - rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 209, col: 41 })); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 226, col: 41 })); } else if (k === 15) { - rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 210, col: 42 }), true); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 227, col: 42 }), true); } else if (k === 16) { - rs.iterExtendBytes(out, rs.dequeIntoIter(rs.dequeSplitOff(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 211, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.dequeIntoIter(rs.dequeSplitOff(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 228, col: 50 }))), undefined, true); } else if (k === 17) { const _136: Uint8Array = Uint8Array.of(n); - rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(_136)), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 212, col: 58 }))), undefined, true); + rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(_136)), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 229, col: 58 }))), undefined, true); } else if (k === 18) { const mutex: rs.Mutex = new rs.Mutex(n); const _held: rs.Result, rs.Mutex> = rs.Ok(rs.mutexLock(mutex)); - const _146: rs.Mutex = rs.resultUnwrap(rs.Ok(rs.mutexLock(mutex)), rs.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 216, col: 36 }); + const _146: rs.Mutex = rs.resultUnwrap(rs.Ok(rs.mutexLock(mutex)), rs.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 233, col: 36 }); rs.byteVecPush(out, _146.value); rs.mutexUnlock(_146); drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8(_held); @@ -336,40 +359,40 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, ready2.intoInner()); } else if (k === 23) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 243, col: 48 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 260, col: 48 }))) & 0xff); } else if (k === 24) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 244, col: 44 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 261, col: 44 }))) & 0xff); } else if (k === 25) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 245, col: 45 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 262, col: 45 }))) & 0xff); } else if (k === 26) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 246, col: 62 })))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 263, col: 62 })))) & 0xff); } else if (k === 27) { - rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 247, col: 41 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 264, col: 41 }))) & 0xff); } else if (k === 28) { const _231: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 248, col: 44 }), rs.usizeStep); + const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 44 }), rs.usizeStep); rs.byteVecExtendFromWithin(_231, _233, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3614, col: 21 }); } else if (k === 29) { const _238: rs.VecDeque = rs.dequeClone(deque); - const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 249, col: 46 }), rs.usizeStep); + const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 266, col: 46 }), rs.usizeStep); rs.iterExtendBytes(out, rs.dequeDrain(_238, _240, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1998, col: 36 }), "next"); } else if (k === 30) { - const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 250, col: 38 }), rs.usizeStep); + const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 267, col: 38 }), rs.usizeStep); rs.iterExtendBytes(out, rs.dequeRange(deque, _245, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), undefined, true); } else if (k === 31) { const _251: rs.VecDeque = rs.dequeClone(deque); - const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 251, col: 50 }), rs.usizeStep); + const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 268, col: 50 }), rs.usizeStep); rs.iterExtendBytes(out, rs.iterMap(rs.dequeRangeMut(_251, _253, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), (v5: rs.Place): rs.u8 => { return v5.v; }), undefined, true); } else if (k === 32) { const cell2: rs.RefCell = new rs.RefCell(rs.byteVecFrom(Uint8Array.of(n))); - const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 254, col: 30 }); + const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 30 }); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(cell2, new rs.ByteVec(), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1434, col: 14 })), undefined, true); rs.refRelease(_held2); } else if (k === 33) { ((cell4: rs.RefCell): undefined => { - rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 258, col: 54 }); + rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 275, col: 54 }); })(SHARED.get()); rs.localKeyWithBorrowMutPlace(SHARED, (v4: rs.Place): undefined => { v4.v = n; @@ -385,25 +408,25 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }); } else if (k === 35) { const _277: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 43 }), rs.usizeStep); + const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 282, col: 43 }), rs.usizeStep); const _282: Uint8Array = Uint8Array.of(n); rs.iterExtendBytes(out, rs.spliceFrom(rs.byteVecSplice(_277, _279, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), rs.iterSlice(_282), true), "next"); } else if (k === 36) { - rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 267, col: 44 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/convert.rs", line: 332, col: 9 }), (a0: rs.char): rs.u32 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 284, col: 44 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/convert.rs", line: 332, col: 9 }), (a0: rs.char): rs.u32 => { return a0 as rs.u32; }), (c2: rs.u32): rs.u8 => { return c2 & 0xff; })), undefined, true); } else if (k === 37) { - const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 59 }); + const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 288, col: 59 }); if (!(_294 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _294, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 21 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _294, { file: "fixtures/lang/panics/src/hooked.rs", line: 288, col: 21 }, true); } rs.fence([0, 4][_294], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4822, col: 24 }); } else if (k === 38) { - const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 68 }); + const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 289, col: 68 }); if (!(_301 < 2)) { - rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _301, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 30 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _301, { file: "fixtures/lang/panics/src/hooked.rs", line: 289, col: 30 }, true); } rs.fence([0, 4][_301], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4907, col: 24 }); } else if (k === 39) { @@ -421,45 +444,45 @@ export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (k === 45) { rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1461, col: 9 }))) & 0xff); } else if (k === 46) { - rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 43 }), 0)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1468, col: 9 }))) & 0xff); + rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 303, col: 43 }), 0)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1468, col: 9 }))) & 0xff); } else if (k === 47) { const _365: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); - const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 291, col: 47 }), rs.usizeStep); + const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 308, col: 47 }), rs.usizeStep); rs.iterExtendBytes(out, rs.byteVecExtractIf(_365, _367, (_29: rs.Place): boolean => { return true; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), "next"); } else if (k === 48) { const _374: rs.Vec = rs.vecFrom([n as rs.u16]); - const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 292, col: 56 }) }; + const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 309, col: 56 }) }; rs.byteVecPush(out, rs.ownedCount(rs.vecExtractIfMut(_374, _377, (_2: rs.Place): boolean => { return true; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), undefined, undefined) & 0xff); } else if (k === 49) { - rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 27 }), rs.u8Step), 3), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 310, col: 27 }), rs.u8Step), 3), undefined, true); } else if (k === 50) { - rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 311, col: 50 }))), undefined, true); } else if (k === 51) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 312, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { return rs.u64Low(x) & 0xff; }), undefined, true); } else if (k === 52) { - rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 314, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 314, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 314, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { return c & 0xff; }), undefined, true); } else if (k === 68) { - const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 304, col: 50 })); - rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 306, col: 32 })); + const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 50 })); + rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 323, col: 32 })); rs.byteVecPush(out, v2.length & 0xff); } else { if (53 <= k) { if (k <= 56) { - joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 301, col: 31 }), n, out); + joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 318, col: 31 }), n, out); break b0; } } if (57 <= k) { if (k <= 67) { - rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 302, col: 42 }), n)); + rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 42 }), n)); break b0; } } @@ -477,16 +500,16 @@ export function joined(kind: rs.u8, n: rs.u8, out: rs.ByteVec): void { let joined!: rs.ByteVec; const big: rs.ByteVec = rs.byteVecOf(n, 1 << 16); const refs: (a0: rs.usize) => rs.Vec = (count: rs.usize): rs.Vec => { - return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 40 }), count, undefined); + return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 334, col: 40 }), count, undefined); }; if (kind === 0) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 19 })).items)); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 19 })).items)); } else if (kind === 1) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 320, col: 19 })).items), rs.byteSliceFrom(Uint8Array.of(n))); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 337, col: 19 })).items), rs.byteSliceFrom(Uint8Array.of(n))); } else if (kind === 2) { - joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 19 })).items)); + joined = rs.byteSlicesJoin(rs.sliceFrom(refs(rs.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 338, col: 19 })).items)); } else { - joined = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(rs.vecFromElem(n as rs.u16, 1 << 16, undefined).items), rs.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 42 }), undefined).items), 2, rs.sliceFrom([1])).items), (_2: rs.u16): rs.u8 => { + joined = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.slicesJoin(rs.sliceFrom(rs.vecFromElem(rs.sliceFrom(rs.vecFromElem(n as rs.u16, 1 << 16, undefined).items), rs.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 341, col: 42 }), undefined).items), 2, rs.sliceFrom([1])).items), (_2: rs.u16): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -509,10 +532,10 @@ export function compared(kind: rs.u8, n: rs.u8): rs.u8 { const _5: [rs.RefCell, rs.RefCell] = [new rs.RefCell(n), new rs.RefCell(rs.u8WrappingAdd(n, 1))]; const a: rs.RefCell = _5[0]; const b: rs.RefCell = _5[1]; - if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 20 }) === 0)) { - _held = rs.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 59 }); + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 20 }) === 0)) { + _held = rs.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 59 }); } else { - _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 35 }); + _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 353, col: 35 }); } if (kind === 0) { _0 = rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; @@ -559,29 +582,29 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const at: rs.usize = n as rs.usize; const whole: rs.ByteSlice = rs.bytesFromVec(rs.byteVecOf(n, 4)); b0: { - const k: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 378, col: 24 }); + const k: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 395, col: 24 }); if (0 <= k) { if (k <= 1) { rs.setHook((info: rs.PanicHookInfo): undefined => { - const at2: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 380, col: 38 }); + const at2: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 397, col: 38 }); const _10: string = at2.file; const _126: rs.u32 = at2.line; const _14: rs.u32 = at2.col; const args3 = [(f: rs.Formatter) => rs.fmtPad(f, _10), (f: rs.Formatter) => rs.u32Display(_126, f), (f: rs.Formatter) => rs.u32Display(_14, f)]; - const line: string = rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], "\n"]); - rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { - note.v = note.v + line; + const line: rs.String = rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], "\n"]); + rs.localKeyWithBorrowMut(NOTE, (note: rs.String): undefined => { + rs.stringPushStr(note, line.v); }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); - rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 383, col: 13 }); + rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 400, col: 13 }); }, { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); const subset: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); if (k === 0) { - const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 30 })); + const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 30 })); held = rs.bytesSliceRef(_22, subset); rs.bytesDrop(_22); } else { const _32: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); - const _35: rs.ByteSlice = rs.byteSliceRange(whole, 0, rs.usizeAdd(2, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 51 }); + const _35: rs.ByteSlice = rs.byteSliceRange(whole, 0, rs.usizeAdd(2, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 405, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 405, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 405, col: 51 }); held = rs.bytesSliceRef(_32, _35); rs.bytesDrop(_32); } @@ -593,38 +616,38 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } hook(); - const shared: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 394, col: 44 })); - const _52: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 395, col: 11 }); + const shared: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 411, col: 44 })); + const _52: rs.u8 = rs.u8Rem(kind, 33, { file: "fixtures/lang/panics/src/hooked.rs", line: 412, col: 11 }); if (_52 === 2) { - const _56: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 396, col: 49 }), 2); + const _56: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 413, col: 49 }), 2); rs.byteVecExtendFromSlice(out, _56); rs.bytesDrop(_56); } else if (_52 === 3) { - const _63: rs.ByteSlice = rs.bytesSlice(whole, 0, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 397, col: 51 })); + const _63: rs.ByteSlice = rs.bytesSlice(whole, 0, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 414, col: 51 })); rs.byteVecExtendFromSlice(out, _63); rs.bytesDrop(_63); } else if (_52 === 4) { - const _72: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 49 }), 4294967295, rs.usizeStep); + const _72: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 415, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 415, col: 49 }), 4294967295, rs.usizeStep); const _70: rs.ByteSlice = rs.bytesSliceInclusive(whole, _72); rs.byteVecExtendFromSlice(out, _70); rs.bytesDrop(_70); } else if (_52 === 5) { let _81: rs.ByteSlice = rs.bytesClone(whole); - const _83: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 399, col: 60 }); + const _83: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 416, col: 60 }); const _79: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _81, (value9) => _81 = value9), _83); rs.byteVecExtendFromSlice(out, _79); rs.bytesDrop(_79); rs.bytesDrop(_81); } else if (_52 === 6) { let _89: rs.ByteSlice = rs.bytesClone(whole); - const _91: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 400, col: 61 }); + const _91: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 417, col: 61 }); const _87: rs.ByteSlice = rs.bytesSplitOff(rs.place(() => _89, (value8) => _89 = value8), _91); rs.byteVecExtendFromSlice(out, _87); rs.bytesDrop(_87); rs.bytesDrop(_89); } else if (_52 === 7) { let _94: rs.ByteSlice = rs.bytesClone(whole); - const _96: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 401, col: 36 }); + const _96: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 418, col: 36 }); rs.bytesAdvance(rs.place(() => _94, (value7) => _94 = value7), _96); rs.bytesDrop(_94); } else if (_52 === 8) { @@ -633,12 +656,12 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.bytesDrop(_101); } else if (_52 === 9) { let _107: rs.ByteSlice = rs.bytesClone(whole); - const _109: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 46 }); + const _109: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 420, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 420, col: 46 }); rs.byteVecPush(out, rs.u64Low(rs.u64FromBeBytes(rs.bytesReadInt(rs.place(() => _107, (value5) => _107 = value5), 8, _109, false, false))) & 0xff); rs.bytesDrop(_107); } else if (_52 === 10) { - let _114: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 21 }); - const _116: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 35 }); + let _114: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 421, col: 21 }); + const _116: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 421, col: 35 }); rs.byteSliceAdvance(rs.place(() => _114, (value4) => _114 = value4), _116); } else if (_52 === 11) { let _120: rs.ByteSlice = rs.bytesClone(whole); @@ -647,75 +670,75 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.bytesDrop(_120); } else if (_52 === 12) { let _129: rs.ByteSlice = rs.bytesClone(whole); - const _131: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 406, col: 66 }); + const _131: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 423, col: 66 }); const _127: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _129, (value2) => _129 = value2), _131); rs.byteVecExtendFromSlice(out, _127); rs.bytesDrop(_127); rs.bytesDrop(_129); } else if (_52 === 13) { - let _137: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 44 }); - const _139: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 64 }); + let _137: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 424, col: 44 }); + const _139: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 424, col: 64 }); const _135: rs.ByteSlice = rs.byteSliceCopyToBytes(rs.place(() => _137, (value) => _137 = value), _139); rs.byteVecExtendFromSlice(out, _135); rs.bytesDrop(_135); } else if (_52 === 14) { const _146: rs.BytesMut = rs.bytesMutFrom(data); - const _144: rs.BytesMut = rs.bytesMutSplitTo(_146, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 408, col: 68 })); + const _144: rs.BytesMut = rs.bytesMutSplitTo(_146, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 425, col: 68 })); rs.byteVecExtendFromSlice(out, rs.bytesMutView(_144)); _144[Symbol.dispose](); _146[Symbol.dispose](); } else if (_52 === 15) { const _154: rs.BytesMut = rs.bytesMutWithCapacity(4); - const _152: rs.BytesMut = rs.bytesMutSplitOff(_154, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 409, col: 75 })); + const _152: rs.BytesMut = rs.bytesMutSplitOff(_154, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 426, col: 75 })); rs.byteVecExtendFromSlice(out, rs.bytesMutView(_152)); _152[Symbol.dispose](); _154[Symbol.dispose](); } else if (_52 === 16) { - const b: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 411, col: 49 })); - rs.bytesMutSetLen(b, rs.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 413, col: 32 })); + const b: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 428, col: 49 })); + rs.bytesMutSetLen(b, rs.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 430, col: 32 })); rs.byteVecPush(out, b.length & 0xff); b[Symbol.dispose](); } else if (_52 === 17) { - const b2: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 417, col: 49 })); - rs.bytesMutAdvanceMut(b2, rs.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 419, col: 36 })); + const b2: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 49 })); + rs.bytesMutAdvanceMut(b2, rs.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 436, col: 36 })); rs.byteVecPush(out, b2.length & 0xff); b2[Symbol.dispose](); } else if (_52 === 18) { - const v: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 423, col: 50 })); - rs.byteVecAdvanceMut(v, rs.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 425, col: 36 })); + const v: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 440, col: 50 })); + rs.byteVecAdvanceMut(v, rs.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 36 })); rs.byteVecPush(out, v.length & 0xff); } else if (_52 === 19) { const _197: rs.BytesMut = rs.bytesMutFrom(data); - rs.bytesMutAdvance(_197, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 428, col: 44 })); + rs.bytesMutAdvance(_197, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 445, col: 44 })); _197[Symbol.dispose](); } else if (_52 === 20) { - const _204: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(data, 0, rs.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 429, col: 44 })); + const _204: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(data, 0, rs.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 446, col: 44 })); rs.byteVecPush(out, (rs.bytesMutReadWord(_204, 4, false) as rs.u32) & 0xff); _204[Symbol.dispose](); } else if (_52 === 21) { - const _212: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 430, col: 48 })); + const _212: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 447, col: 48 })); rs.byteVecPush(out, _212.cap & 0xff); _212[Symbol.dispose](); } else if (_52 === 22) { const _tail: rs.BytesMut = rs.bytesMutSplitOff(shared, 4); - rs.bytesMutReserve(shared, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 28 })); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 28 })); _tail[Symbol.dispose](); } else if (_52 === 23) { rs.bytesMutSplitTo(shared, 4)[Symbol.dispose](); - rs.bytesMutReserve(shared, rs.usizeSub(4294967295 - 4, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 28 })); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295 - 4, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 456, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 456, col: 28 })); } else if (_52 === 24) { const _235: rs.u64 = n as rs.u64; - const _236: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 45 }); + const _236: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 458, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 458, col: 45 }); rs.bytesMutPutInt(shared, rs.u64ToBeBytes(_235), _236, false); } else if (_52 === 25) { const _240: rs.i64 = n as rs.i64; - const _241: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 41 }); + const _241: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 459, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 459, col: 41 }); rs.byteVecPutInt(out, rs.i64ToBeBytes(_240), _241, false); } else if (_52 === 26) { - rs.byteVecPutFill(out, n, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 40 })); + rs.byteVecPutFill(out, n, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 460, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 460, col: 40 })); } else if (_52 === 27) { const _253: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesClone(whole), 2); - const _251: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 444, col: 74 })); + const _251: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 461, col: 74 })); rs.byteVecExtendFromSlice(out, _251); rs.bytesDrop(_251); drop$bytes_buf_Take_bytes_Bytes(_253); @@ -725,15 +748,15 @@ export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { drop$bytes_buf_Take_bytes_Bytes(_261); } else if (_52 === 29) { const chunk: rs.ByteSlice = rs.bytesMutChunkMut(shared); - UninitSlice.writeByte(chunk, rs.usizeAdd(UninitSlice.len(chunk), rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 449, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 449, col: 30 }), n); + UninitSlice.writeByte(chunk, rs.usizeAdd(UninitSlice.len(chunk), rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 466, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 466, col: 30 }), n); } else if (_52 === 30) { - UninitSlice.writeByte(UninitSlice.indexMut$ops_IndexMut_ops_RangeFrom_usize(rs.byteVecChunkMut(rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 40 }))), new rs.RangeFrom(rs.usizeAdd(65, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 65 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 60 }), rs.usizeStep), { file: "fixtures/lang/panics/src/hooked.rs", line: 451, col: 59 }), 0, n); + UninitSlice.writeByte(UninitSlice.indexMut$ops_IndexMut_ops_RangeFrom_usize(rs.byteVecChunkMut(rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 40 }))), new rs.RangeFrom(rs.usizeAdd(65, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 65 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 60 }), rs.usizeStep), { file: "fixtures/lang/panics/src/hooked.rs", line: 468, col: 59 }), 0, n); } else if (_52 === 31) { const _287: rs.BytesMut = rs.bytesMutWithCapacity(0); - UninitSlice.copyFromSlice(UninitSlice.indexMut$ops_IndexMut_ops_RangeTo_usize(rs.bytesMutChunkMut(_287), { end: rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 452, col: 45 }) }, { file: "fixtures/lang/panics/src/hooked.rs", line: 452, col: 42 }), rs.byteSliceFrom(rs.bytes(3).fill(n))); + UninitSlice.copyFromSlice(UninitSlice.indexMut$ops_IndexMut_ops_RangeTo_usize(rs.bytesMutChunkMut(_287), { end: rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 469, col: 45 }) }, { file: "fixtures/lang/panics/src/hooked.rs", line: 469, col: 42 }), rs.byteSliceFrom(rs.bytes(3).fill(n))); _287[Symbol.dispose](); } else { - const _297: rs.BytesMut = rs.bytesMutZeroed(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 453, col: 40 })); + const _297: rs.BytesMut = rs.bytesMutZeroed(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 470, col: 40 })); rs.byteVecPush(out, _297.length & 0xff); _297[Symbol.dispose](); } diff --git a/ts/fixtures/lang/panics/hook/expected/lib.ts b/ts/fixtures/lang/panics/hook/expected/lib.ts index 59068410d..48cec75db 100644 --- a/ts/fixtures/lang/panics/hook/expected/lib.ts +++ b/ts/fixtures/lang/panics/hook/expected/lib.ts @@ -33,9 +33,9 @@ export function drop$bytes_buf_Take_bytes_Bytes(_1: Take.Take): vo } export class of$String { - v: string; + v: rs.String; - constructor(v: string) { + constructor(v: rs.String) { this.v = v; } } @@ -108,14 +108,6 @@ export class of$u8 { } } -export class ofPlace$String { - v: rs.Place; - - constructor(v: rs.Place) { - this.v = v; - } -} - export class ofPlace$ref_str { v: rs.Place; @@ -140,18 +132,16 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By return rs.iterToVec(rs.iterChain(rs.vecIntoIter(rs.vecFrom([["panics::wrapped", wrapped as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::called", panics_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::raised", raised as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::called", located_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::read", read as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::panicked", located_panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]])), rs.iterSlice([["hooked::panicked", hooked_panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::aborted", aborted as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::sited", sited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::stock", stock as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]])), undefined, 12, true); } -export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); +export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); -export function NOTE$init(): rs.RefCell { - return new rs.RefCell(""); +export function NOTE$init(): rs.RefCell { + return new rs.RefCell(rs.stringNew()); } /** Take what the hooks wrote since the last call. */ -export function note(): string { - return rs.localKeyWithBorrowMutPlace(NOTE, (a0: rs.Place): string => { - const taken = a0.v; - a0.v = ""; - return taken; +export function note(): rs.String { + return rs.localKeyWithBorrowMut(NOTE, (a0: rs.String): rs.String => { + return rs.replaceIn(a0, rs.stringNew()); }, { file: "fixtures/lang/panics/src/lib.rs", line: 51, col: 5 }); } diff --git a/ts/fixtures/lang/panics/hook/expected/located.ts b/ts/fixtures/lang/panics/hook/expected/located.ts index ffee6f930..d06e68243 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.ts @@ -72,7 +72,7 @@ export function generic$u8(t: rs.u8): rs.Location { /** Each location's `Display`, a line each. */ export function lines(out: rs.ByteVec, at: rs.Slice): void { for (const _5 of rs.sliceItems(at)) { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f), "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f), "\n"]).v)); } } @@ -130,7 +130,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; const args3 = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], args3[1], args3[0], args3[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], args3[1], args3[0], args3[2]]).v)); } } @@ -143,19 +143,15 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); const _9: rs.u8 = rs.u8Rem(kind, 4, { file: "fixtures/lang/panics/src/located.rs", line: 199, col: 11 }); if (_9 === 0) { - let s: string = ""; + const s: rs.String = rs.stringNew(); const _18: string = a.file; const _20: rs.u32 = a.line; const _22: rs.u32 = a.col; const args8 = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; - const written = rs.fmtWriteString(s, [args8[0], "|", args8[1], "|", args8[2], "|"]); - s = written.s; - rs.resultUnwrap(written.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 202, col: 68 }); + rs.resultUnwrap(rs.fmtWriteString(s, [args8[0], "|", args8[1], "|", args8[2], "|"]), rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 202, col: 68 }); const args9 = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; - const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[2]), "|", rs.fmtSpec({ debugHex: "x" }, args9[2])]); - s = written2.s; - rs.resultUnwrap(written2.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 203, col: 54 }); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.resultUnwrap(rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args9[0]), "|", args9[1], "|", rs.fmtSpec({ alternate: true }, args9[2]), "|", rs.fmtSpec({ debugHex: "x" }, args9[2])]), rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 203, col: 54 }); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } else if (_9 === 1) { const copy: rs.Location = a; const same: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); @@ -190,7 +186,7 @@ export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const held: Held$read.Held = { at: a, maybe: _117 }; const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; const args7 = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], "|", args7[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], "|", args7[1]]).v)); } } diff --git a/ts/fixtures/lang/panics/hook/expected/panics.ts b/ts/fixtures/lang/panics/hook/expected/panics.ts index fa2a8dba8..37453b049 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.ts @@ -16,8 +16,8 @@ export function seven(): rs.u8 { } /** What `f` returns, through `catch_unwind`. */ -export function caught$String_panics_called_closure6(f: () => string): string { - const _2: rs.Result = rs.Ok(f()); +export function caught$String_panics_called_closure6(f: () => rs.String): rs.String { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } @@ -131,20 +131,20 @@ export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void } else if (_7 === 3) { const _132: rs.u8 = first; const _134: rs.u8 = first; - const _136: string = text(data); + const _136: rs.String = text(data); const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; const _144: [rs.u8, string] = [first, "a"]; - const args3 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ width: 5 }, args3[3]), "|", args3[4], "|", rs.fmtSpec({ alternate: true }, args3[5])]))); + const args3 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136.v, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", args3[2], "|", rs.fmtSpec({ width: 5 }, args3[3]), "|", args3[4], "|", rs.fmtSpec({ alternate: true }, args3[5])]).v)); } else if (_7 === 4) { const d: rs.u8 = 0; - const s2: string = ""; + const s2: rs.String = rs.stringNew(); const p2: Point.Point = Point.default$Default(); const v3: rs.ByteVec = new rs.ByteVec(); const e: rs.u8 = first; f = rs.byteSliceToByteVec(data); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, rs.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, s2.len & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); } else { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const a2: Logged.Logged = new Logged.Logged(1, log); @@ -230,9 +230,9 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rs.ByteVec => { return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): rs.String => { return rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(first, f)]); - }))); + }).v)); } else if (_10 === 3) { rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { return rs.u8WrappingMul(first, 2); @@ -284,7 +284,7 @@ export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { return n2; }); const args6 = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]).v)); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); @@ -495,9 +495,10 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const _9: rs.u8 = rs.u8Rem(kind, 8, { file: "fixtures/lang/panics/src/panics.rs", line: 288, col: 11 }); if (_9 === 0) { - rs.panic("a payload of text", { file: "fixtures/lang/panics/src/panics.rs", line: 289, col: 14 }, false); + rs.panic("a payload of text", { file: "fixtures/lang/panics/src/panics.rs", line: 289, col: 14 }); } else if (_9 === 1) { - rs.panic(text(data), { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, true); + const _13: rs.String = text(data); + rs.panic(_13.v, { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, _13); } else if (_9 === 2) { rs.panicAny(new of$u8(first), { file: "fixtures/lang/panics/src/panics.rs", line: 291, col: 14 }); } else if (_9 === 3) { @@ -520,9 +521,9 @@ export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else { const boxed: Any.Any = new of$u8(first); new of$u8(first); - const synced: Any.Any = new of$String(""); + const synced: Any.Any = new of$String(rs.stringNew()); const args3 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args3[2]), "|", args3[3]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", rs.fmtSpec({ alternate: true }, args3[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args3[2]), "|", args3[3]]).v)); rs.drop(synced); rs.drop(boxed); } diff --git a/ts/fixtures/lang/panics/src/hooked.rs b/ts/fixtures/lang/panics/src/hooked.rs index 04715c750..9dc8aa149 100644 --- a/ts/fixtures/lang/panics/src/hooked.rs +++ b/ts/fixtures/lang/panics/src/hooked.rs @@ -71,6 +71,17 @@ fn hook() { })); } +/// Have the hook also write a `String` payload's capacity, which `panic!` formats into one +/// from empty and `panic_any` keeps. +fn sized() { + let prev = panic::take_hook(); + panic::set_hook(Box::new(move |info| { + let capacity = info.payload().downcast_ref::().map(String::capacity); + NOTE.with_borrow_mut(|note| note.push_str(&format!("capacity {capacity:?}\n"))); + prev(info); + })); +} + #[track_caller] fn tracked(n: u8) -> u8 { panic!("tracked {n}") @@ -83,7 +94,10 @@ pub fn panicked(kind: u8, data: &[u8], out: &mut Vec) { let v = vec![n, n]; match kind % 32 { 0 => panic!("literal"), - 1 => panic!("formatted {n}"), + 1 => { + sized(); + panic!("formatted {n}") + } 2 => out.push(v[usize::from(n) + 2]), 3 => out.push(n.max(200) + n.max(100)), 4 => out.push(Some(n).filter(|_| false).unwrap()), @@ -102,7 +116,10 @@ pub fn panicked(kind: u8, data: &[u8], out: &mut Vec) { 13 => v.clone().rotate_left(usize::from(n) + 3), 14 => out.push(HashMap::::new()[&n]), 15 => panic::panic_any(u32::from(n)), - 16 => panic::panic_any(format!("any {n}")), + 16 => { + sized(); + panic::panic_any(format!("any {n}")) + } 17 => assert_eq!(n, n.wrapping_add(1), "differ"), 18 => out.push(tracked(n)), 19 => out.push(VecDeque::from(v.clone())[usize::from(n) + 2]), diff --git a/ts/fixtures/lang/pointers/expected/lib.ts b/ts/fixtures/lang/pointers/expected/lib.ts index e38684560..bce77a565 100644 --- a/ts/fixtures/lang/pointers/expected/lib.ts +++ b/ts/fixtures/lang/pointers/expected/lib.ts @@ -176,7 +176,7 @@ export function copy$tuple2_u32_u32(v: [rs.u32, rs.u32]): [rs.u32, rs.u32] { return [v[0], v[1]]; } -export function copy$tuple2_u8_String(v: [rs.u8, string]): [rs.u8, string] { +export function copy$tuple2_u8_String(v: [rs.u8, rs.String]): [rs.u8, rs.String] { return [v[0], v[1]]; } @@ -188,7 +188,7 @@ export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } -export function drop$pointers_List_String(_1: List.List): void { +export function drop$pointers_List_String(_1: List.List): void { List.drop$ops_Drop_String(_1); } diff --git a/ts/fixtures/lang/pointers/expected/pointers.List.ts b/ts/fixtures/lang/pointers/expected/pointers.List.ts index 50e9b6466..b812f3f11 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.List.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.List.ts @@ -21,7 +21,7 @@ export class List { } } -export function new$String(): List { +export function new$String(): List { return new List(undefined, undefined, 0); } @@ -29,13 +29,13 @@ export function new$sync_Arc_u8(): List> { return new List(undefined, undefined, 0); } -export function guard$String(self: List): Node.Node { +export function guard$String(self: List): Node.Node { if (self.guard !== undefined) { return self.guard; } - const guard2: Node.Node = Node.new$String(); - const _8: Links.Links = { next: guard2, prev: guard2 }; - const _11: Node.Node = guard2; + const guard2: Node.Node = Node.new$String(); + const _8: Links.Links = { next: guard2, prev: guard2 }; + const _11: Node.Node = guard2; _11.link.at0 = _8.next; _11.link.at4 = _8.prev; self.guard = guard2; @@ -55,11 +55,11 @@ export function guard$sync_Arc_u8(self: List>): Node.Node): Node.Node { +export function alloc$String(self: List): Node.Node { if (self.free === undefined) { return Node.new$String(); } - const free: Node.Node = self.free; + const free: Node.Node = self.free; self.free = free.link.at0; return free; } @@ -73,10 +73,10 @@ export function alloc$sync_Arc_u8(self: List>): Node.Node, key: rs.u8, value: string): void { - const guard: Node.Node = guard$String(self); - const node: Node.Node = alloc$String(self); - rs.ptrWrite(node.entry, [key, value] as [rs.u8, string]); +export function pushBack$String(self: List, key: rs.u8, value: rs.String): void { + const guard: Node.Node = guard$String(self); + const node: Node.Node = alloc$String(self); + rs.ptrWrite(node.entry, [key, value] as [rs.u8, rs.String]); attachBefore$String(node, guard); self.len = rs.usizeAdd(self.len, 1); } @@ -89,14 +89,14 @@ export function pushBack$sync_Arc_u8(self: List>, key: rs.u8, valu self.len = rs.usizeAdd(self.len, 1); } -export function find$String(self: List, key: rs.u8): Node.Node | undefined { - const _4: Node.Node | undefined = self.guard; +export function find$String(self: List, key: rs.u8): Node.Node | undefined { + const _4: Node.Node | undefined = self.guard; if (_4 !== undefined) { - const guard: Node.Node = _4; - let at: Node.Node = guard.link.at0 as Node.Node; + const guard: Node.Node = _4; + let at: Node.Node = guard.link.at0 as Node.Node; while (at !== guard) { if (!(at.entry[0] === key)) { - at = at.link.at0 as Node.Node; + at = at.link.at0 as Node.Node; } else { return at; } @@ -123,13 +123,13 @@ export function find$sync_Arc_u8(self: List>, key: rs.u8): Node.No return undefined; } -export function remove$String(self: List, key: rs.u8): [rs.u8, string] | undefined { - const _4: Node.Node | undefined = find$String(self, key); +export function remove$String(self: List, key: rs.u8): [rs.u8, rs.String] | undefined { + const _4: Node.Node | undefined = find$String(self, key); if (_4 !== undefined) { - const node: Node.Node = _4; + const node: Node.Node = _4; detach$String(node); - const entry: [rs.u8, string] = copy$tuple2_u8_String(node.entry); - const _16: Free.Free = { next: self.free }; + const entry: [rs.u8, rs.String] = copy$tuple2_u8_String(node.entry); + const _16: Free.Free = { next: self.free }; node.link.at0 = _16.next; self.free = node; self.len = rs.usizeSub(self.len, 1); @@ -153,14 +153,14 @@ export function remove$sync_Arc_u8(self: List>, key: rs.u8): [rs.u return undefined; } -export function toFront$String(self: List, key: rs.u8): boolean { - const _4: Node.Node | undefined = find$String(self, key); +export function toFront$String(self: List, key: rs.u8): boolean { + const _4: Node.Node | undefined = find$String(self, key); if (_4 !== undefined) { - const node: Node.Node = _4; + const node: Node.Node = _4; if (self.guard !== undefined) { - const guard: Node.Node = self.guard; + const guard: Node.Node = self.guard; detach$String(node); - attachBefore$String(node, guard.link.at0 as Node.Node); + attachBefore$String(node, guard.link.at0 as Node.Node); return true; } return false; @@ -183,39 +183,38 @@ export function toFront$sync_Arc_u8(self: List>, key: rs.u8): bool return false; } -export function getMut$String(self: List, key: rs.u8): rs.Place | undefined { - const _3: Node.Node | undefined = find$String(self, key); +export function getMut$String(self: List, key: rs.u8): rs.String | undefined { + const _3: Node.Node | undefined = find$String(self, key); if (_3 !== undefined) { - const _9: [rs.u8, string] = _3.entry; - return rs.place(() => _9[1], (value) => _9[1] = value); + return _3.entry[1]; } return undefined; } -export function each$String(self: List, out: rs.ByteVec): void { +export function each$String(self: List, out: rs.ByteVec): void { b0: { if (self.guard !== undefined) { - const guard: Node.Node = self.guard; - let at: Node.Node = guard.link.at0 as Node.Node; + const guard: Node.Node = self.guard; + let at: Node.Node = guard.link.at0 as Node.Node; while (true) { if (!(at !== guard)) { break b0; } - const _13: [rs.u8, string] = at.entry; + const _13: [rs.u8, rs.String] = at.entry; rs.byteVecPush(out, _13[0]); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_13[1])); - at = at.link.at0 as Node.Node; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_13[1].v)); + at = at.link.at0 as Node.Node; } } } } -export function drop$ops_Drop_String(self: List): void { +export function drop$ops_Drop_String(self: List): void { if (self.guard !== undefined) { - const guard: Node.Node = self.guard; - let at: Node.Node = guard.link.at0 as Node.Node; + const guard: Node.Node = self.guard; + let at: Node.Node = guard.link.at0 as Node.Node; while (at !== guard) { - at = at.link.at0 as Node.Node; + at = at.link.at0 as Node.Node; } } while (self.free !== undefined) { diff --git a/ts/fixtures/lang/pointers/expected/pointers.Named.ts b/ts/fixtures/lang/pointers/expected/pointers.Named.ts index 92a0ccf4c..eba15262f 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Named.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Named.ts @@ -1,16 +1,17 @@ // Generated by rust2-ts. Do not edit. +import * as rs from "./rs.ts"; import { copy$pointers_Spot } from "./lib.ts"; import * as Spot from "./pointers.Spot.ts"; export function clone$Clone(self: Named): Named { - return { spot: copy$pointers_Spot(Spot.clone$Clone(self.spot)), name: self.name }; + return { spot: copy$pointers_Spot(Spot.clone$Clone(self.spot)), name: rs.stringClone(self.name) }; } /** A value of each that holds no copy of its own but is cloned by its parts. */ export interface Named { spot: Spot.Spot; - name: string; + name: rs.String; } //# sourceMappingURL=pointers.Named.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Node.ts b/ts/fixtures/lang/pointers/expected/pointers.Node.ts index 7a3d3504f..bcee03554 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Node.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Node.ts @@ -9,10 +9,10 @@ export interface Node { link: Link.Link; } -export function new$String(): Node { - const _1: [rs.u8, string] = ([undefined, undefined] as unknown) as [rs.u8, string]; - const _3: Links.Links = { next: rs.DANGLING, prev: rs.DANGLING }; - return { entry: _1, link: ({ at0: _3.next, at4: _3.prev } as unknown) as Link.Link }; +export function new$String(): Node { + const _1: [rs.u8, rs.String] = ([undefined, undefined] as unknown) as [rs.u8, rs.String]; + const _3: Links.Links = { next: rs.DANGLING, prev: rs.DANGLING }; + return { entry: _1, link: ({ at0: _3.next, at4: _3.prev } as unknown) as Link.Link }; } export function new$sync_Arc_u8(): Node> { diff --git a/ts/fixtures/lang/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index 27c5d87df..9cd13fea5 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ts @@ -49,13 +49,13 @@ import * as Wrapped from "./pointers.Wrapped.ts"; import type * as Written from "./pointers.Written.ts"; /** Put `node` in the list just before `at`. */ -export function attachBefore$String(node: Node.Node, at: Node.Node): void { - const _3: Links.Links = { next: at, prev: at.link.at4 }; - const _8: Node.Node = node; +export function attachBefore$String(node: Node.Node, at: Node.Node): void { + const _3: Links.Links = { next: at, prev: at.link.at4 }; + const _8: Node.Node = node; _8.link.at0 = _3.next; _8.link.at4 = _3.prev; at.link.at4 = node; - (node.link.at4.link.at0 as Node.Node) = node; + (node.link.at4.link.at0 as Node.Node) = node; } /** Put `node` in the list just before `at`. */ @@ -68,9 +68,9 @@ export function attachBefore$sync_Arc_u8(node: Node.Node>, at: Nod (node.link.at4.link.at0 as Node.Node>) = node; } -export function detach$String(node: Node.Node): void { - (node.link.at4.link.at0 as Node.Node) = node.link.at0 as Node.Node; - (node.link.at0 as Node.Node).link.at4 = node.link.at4; +export function detach$String(node: Node.Node): void { + (node.link.at4.link.at0 as Node.Node) = node.link.at0 as Node.Node; + (node.link.at0 as Node.Node).link.at4 = node.link.at4; } export function detach$sync_Arc_u8(node: Node.Node>): void { @@ -83,7 +83,7 @@ export function detach$sync_Arc_u8(node: Node.Node>): void { * finds and then the list in order. */ export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - const list: List.List = List.new$String(); + const list: List.List = List.new$String(); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; @@ -105,25 +105,26 @@ export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, if (!(_26 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _26); } - List.pushBack$String(list, key2, ["", "v", "vv"][_26]); + const _21: rs.String = rs.stringFrom(["", "v", "vv"][_26]); + List.pushBack$String(list, key2, _21); } else if (_18 === 1) { - const _30: [rs.u8, string] | undefined = List.remove$String(list, key2); + const _30: [rs.u8, rs.String] | undefined = List.remove$String(list, key2); if (_30 === undefined) { rs.byteVecPush(out, 255); } else { const k: rs.u8 = _30[0]; - const v: string = _30[1]; + const v: rs.String = _30[1]; rs.byteVecPush(out, k); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(v)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(v.v)); } } else if (_18 === 2) { rs.byteVecPush(out, List.toFront$String(list, key2) ? 1 : 0); } else { - const _42: rs.Place | undefined = List.getMut$String(list, key2); + const _42: rs.String | undefined = List.getMut$String(list, key2); if (_42 === undefined) { rs.byteVecPush(out, 254); } else { - _42.v = _42.v + "w"; + rs.stringPush(_42, 119); } } } @@ -417,7 +418,7 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { const count: rs.Arc = new rs.Arc(undefined); let num: rs.Cell = new rs.Cell(4294967295 - 1); const pair: rs.Cell = new rs.Cell({ _0: 0, _1: 255 }); - let text: rs.Cell = new rs.Cell(""); + let text: rs.Cell = new rs.Cell(rs.stringNew()); const held: Wrapped.Wrapped = Wrapped.new$pointers_Held(new Held.Held(0, rs.arcClone(count))); for (const op of rs.byteSliceView(data)) { const n: rs.u8 = rs.u8Div(op, 8); @@ -443,11 +444,9 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { _67._1 = _67._1 ^ 128; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(before2._0, before2._1, between._0, between._1, pair.v._0, pair.v._1)), undefined, true); } else if (_23 === 3) { - const _83: rs.Place = text; - _83.v = _83.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(n, 26)) as rs.char); - const _91: rs.Place = text; - _91.v = _91.v + "!"; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); + rs.stringPush(text.v, rs.u8Add(97, rs.u8Rem(n, 26)) as rs.char); + rs.stringPush(text.v, 33); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v.v))), undefined, true); } else if (_23 === 4) { const _99: rs.Arc = rs.arcClone(count); const fresh: Held.Held = new Held.Held(n, _99); @@ -485,10 +484,10 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { const old3 = num; num = _126; rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(old3.v).reverse()), undefined, true); - const _133: rs.Cell = new rs.Cell(rs.fmtToString((f: rs.Formatter) => rs.u8Display(n, f))); + const _133: rs.Cell = new rs.Cell(rs.fmtToString((f: rs.Formatter) => rs.u8Display(n, f), 0)); const old4 = text; text = _133; - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(old4.v))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(old4.v.v))), undefined, true); const _140: Duo.Duo = { _0: n, _1: ~n & 0xff }; Object.assign(pair.v, _140); } else { @@ -507,7 +506,7 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(num.v).reverse()), undefined, true); const _169: Duo.Duo = pair.v; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_169._0, _169._1)), undefined, true); - rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v.v))), undefined, true); held[Symbol.dispose](); rs.byteVecPush(out, count.strong & 0xff); count[Symbol.dispose](); @@ -2453,7 +2452,7 @@ export function distinct(data: rs.ByteSlice, out: rs.ByteVec): void { const _60: [[rs.u16, rs.u8], [rs.u16, rs.u8]] = [[0, 1], [0, 1]]; const origin: [rs.u16, rs.u8] = _60[0]; const other: [rs.u16, rs.u8] = _60[1]; - const _64: string = "a"; + const _64: rs.String = rs.stringFrom("a"); const named: Named.Named = { spot: copy$pointers_Spot(spot), name: _64 }; const renamed: Named.Named = Named.clone$Clone(named); const _69: rs.u8 = x.value === y.value ? 1 : 0; @@ -2491,7 +2490,7 @@ export function distinct(data: rs.ByteSlice, out: rs.ByteVec): void { const arc7 = unwrapped; const _280: [rs.u16, rs.u8] = rs.arcRaw(arc7, arc7.value, "Arc"); const arc8 = y; - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_238, _244, _250, _256, _262, _270, _280 === rs.arcRaw(arc8, arc8.value, "Arc") ? 1 : 0, rewrapped.value === p.value ? 1 : 0, rewrapped.value.at === p.value.at ? 1 : 0, p.strong & 0xff, swapped[1] ^ unwrapped.value[1] ^ rewrapped.value.tag ^ (rs.stringLen(_64) & 0xff))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_238, _244, _250, _256, _262, _270, _280 === rs.arcRaw(arc8, arc8.value, "Arc") ? 1 : 0, rewrapped.value === p.value ? 1 : 0, rewrapped.value.at === p.value.at ? 1 : 0, p.strong & 0xff, swapped[1] ^ unwrapped.value[1] ^ rewrapped.value.tag ^ (_64.len & 0xff))), undefined, true); const item = copy$tuple2_u16_u8(pair); const repeated: rs.Vec<[rs.u16, rs.u8]> = rs.vecFrom(Array.from({ length: 2 }, (): [rs.u16, rs.u8] => { return copy$tuple2_u16_u8(item); @@ -2895,19 +2894,19 @@ export function arrays(data: rs.ByteSlice, out: rs.ByteVec): void { /** Pointers to arrays in a `Vec`, compared where they point. */ export function runs(n: rs.u8): Uint8Array { - const v: rs.Vec = rs.vecFrom([rs.arrayMap(Uint8Array.of(n, n ^ 1), (b: rs.u8): string => { + const v: rs.Vec = rs.vecFrom([rs.arrayMap(Uint8Array.of(n, n ^ 1), (b: rs.u8): rs.String => { const _44: rs.char = b as rs.char; - return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_44, f)); - }), ["", "x"]]); - const first: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 0)]); - const last: rs.Slice = rs.optionUnwrap(rs.optionMap(rs.sliceLast(rs.sliceFrom(v.items)), rs.sliceFrom)); - const _20: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); - _20.data[_20.start] = _20.data[_20.start] + "y"; + return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_44, f), 0); + }), [rs.stringNew(), rs.stringFrom("x")]]); + const first: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 0)]); + const last: rs.Slice = rs.optionUnwrap(rs.optionMap(rs.sliceLast(rs.sliceFrom(v.items)), rs.sliceFrom)); + const _20: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); + rs.stringPush(_20.data[_20.start], 121); const _24: rs.u8 = rs.sliceSame(first, rs.sliceFrom(v.items[rs.idx(v.items, 0)])) ? 1 : 0; const _29: rs.u8 = rs.sliceSame(first, last) ? 1 : 0; const _31: rs.u8 = rs.sliceSame(last, rs.sliceFrom(v.items[rs.idx(v.items, 1)])) ? 1 : 0; - const _39: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); - return Uint8Array.of(_24, _29, _31, rs.stringLen(_39.data[_39.start]) & 0xff); + const _39: rs.Slice = rs.sliceFrom(v.items[rs.idx(v.items, 1)]); + return Uint8Array.of(_24, _29, _31, _39.data[_39.start].len & 0xff); } /** diff --git a/ts/fixtures/lang/refs/expected/core/option.ts b/ts/fixtures/lang/refs/expected/core/option.ts index ec78ea0d7..1bd5eb5e8 100644 --- a/ts/fixtures/lang/refs/expected/core/option.ts +++ b/ts/fixtures/lang/refs/expected/core/option.ts @@ -23,9 +23,9 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function unwrapOrDefault$165pyh5(self: string | undefined): string { +export function unwrapOrDefault$1exlfpa(self: rs.String | undefined): rs.String { if (self === undefined) { - return ""; + return rs.stringNew(); } return self; } @@ -65,7 +65,7 @@ export function mapOr$1rg5gkk(self: rs.u8 | undefined | rs.None, default_: rs.u8 return f(self); } -export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { +export function mapOr$1fzqoua(self: rs.String | undefined, default_: rs.u8, f: (a0: rs.String) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index 9b3e3bde0..0a99ac3b7 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { copy$Option_tuple2_u8_u8, copy$array_u32, out$u8 } from "./lib.ts"; import { thenSome$1c6ozzd, then$17csa2h } from "./core/bool.ts"; -import { unwrapOr$0w1py1w as option_unwrapOr$0w1py1w, unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$0cwxh6b as option_map$0cwxh6b, map$1pv2dfs as option_map$1pv2dfs, map$1yjmt5m as option_map$1yjmt5m, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$14runhi as option_mapOr$14runhi, mapOr$1ldmp8y as option_mapOr$1ldmp8y, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0rvzdvd as option_mapOr$0rvzdvd, mapOr$0vxw5sq as option_mapOr$0vxw5sq, andThen$1x5wmg5 as option_andThen$1x5wmg5, filter$00vpwuf, or$0ar58vy as option_or$0ar58vy } from "./core/option.ts"; +import { unwrapOr$0w1py1w as option_unwrapOr$0w1py1w, unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1exlfpa as option_unwrapOrDefault$1exlfpa, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$0cwxh6b as option_map$0cwxh6b, map$1pv2dfs as option_map$1pv2dfs, map$1yjmt5m as option_map$1yjmt5m, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1fzqoua as option_mapOr$1fzqoua, mapOr$14runhi as option_mapOr$14runhi, mapOr$1ldmp8y as option_mapOr$1ldmp8y, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0rvzdvd as option_mapOr$0rvzdvd, mapOr$0vxw5sq as option_mapOr$0vxw5sq, andThen$1x5wmg5 as option_andThen$1x5wmg5, filter$00vpwuf, or$0ar58vy as option_or$0ar58vy } from "./core/option.ts"; import { err$1igyjfc, asRef$1pwjn59 } from "./core/result.ts"; import * as Counts from "./refs.Counts.ts"; import * as Cursor from "./refs.Cursor.ts"; @@ -54,9 +54,9 @@ export function takeLargest(seen: rs.Place, next: rs.u8): rs. } /** A name replaced through a parameter, its old one returned. */ -export function rename(name: rs.Place, b: rs.u8): string | undefined { +export function rename(name: rs.Place, b: rs.u8): rs.String | undefined { const _5: rs.char = rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char; - const _3: string = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_5, f)); + const _3: rs.String = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_5, f), 0); const old = name.v; name.v = _3; return old; @@ -108,18 +108,16 @@ export function refuse(f: rs.Place): void { f.v = _2; } -export function pushTo(s: rs.Place, c: rs.char): void { - s.v = s.v + String.fromCodePoint(c); +export function pushTo(s: rs.String, c: rs.char): void { + rs.stringPush(s, c); if (c === 122) { - const taken = s.v; - s.v = ""; - const iter: rs.Iter = rs.iterTake(rs.strChars(taken), 2); + const iter: rs.Iter = rs.iterTake(rs.strChars(rs.replaceIn(s, rs.stringNew()).v), 2); while (true) { const _12: rs.char | rs.Done = iter.next(); if (_12 === rs.DONE) { break; } - s.v = s.v + String.fromCodePoint(_12); + rs.stringPush(s, _12); } } } @@ -152,7 +150,7 @@ export function readThrough(a: rs.Place, b: rs.Place, out: rs.By rs.byteVecPush(out, a.v < b.v ? 1 : 0); rs.byteVecPush(out, rs.cmp(a.v, b.v) & 0xff); const args3 = [(f: rs.Formatter) => rs.u32Display(a.v, f), (f: rs.Formatter) => rs.u32Debug(b.v, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", args3[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], "|", args3[1]]).v)); } /** A `&mut Box` dereferenced through `DerefMut`, as generic code over it would. */ @@ -161,11 +159,11 @@ export function derefBox(b: rs.Place, to: rs.u8): void { } /** Methods that take `&self`, called through a `&mut`. */ -export function fill(seen: rs.Place, s: rs.Place, next: rs.u8): rs.u8 { +export function fill(seen: rs.Place, s: rs.String, next: rs.u8): rs.u8 { if (seen.v === undefined) { seen.v = next; } - return rs.u8WrappingAdd(option_unwrapOr$1fr498u(seen.v, 238), rs.stringLen(s.v) & 0xff); + return rs.u8WrappingAdd(option_unwrapOr$1fr498u(seen.v, 238), s.len & 0xff); } export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { @@ -228,13 +226,13 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, option_unwrapOr$1fr498u(slot, 238)); let last = undefined as rs.u8 | undefined; - let name: string | undefined = undefined; + let name: rs.String | undefined = undefined; for (const b2 of rs.byteSliceView(data)) { const old = last; last = b2; rs.byteVecPush(out, option_unwrapOr$1fr498u(old, 238)); - rs.byteVecPush(out, option_mapOr$1nyk1yj(rename(rs.place(() => name, (value7) => name = value7), b2), 238, (n2: string): rs.u8 => { - const _3: rs.ByteSlice = rs.stringAsBytes(n2); + rs.byteVecPush(out, option_mapOr$1fzqoua(rename(rs.place(() => name, (value7) => name = value7), b2), 238, (n2: rs.String): rs.u8 => { + const _3: rs.ByteSlice = rs.stringAsBytes(n2.v); rs.idx(_3, 0); return _3.data[_3.start]; })); @@ -250,13 +248,12 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Pair.Pair = { n: by }; const pair: [rs.u8, rs.u8] = [by, rs.u8WrappingAdd(by, 1)]; let fetch = { tag: "Idle" } as Fetch.Fetch; - let text: string = ""; + const text: rs.String = rs.stringNew(); for (const b3 of rs.byteSliceView(data)) { rebox(rs.place(() => boxed, (value8) => boxed = value8), b3); swapPair(pair); refuse(rs.place(() => fetch, (value9) => fetch = value9)); - const _157: rs.char = rs.u8Add(97, rs.u8Rem(b3, 26)) as rs.char; - pushTo(rs.place(() => text, (value10) => text = value10), _157); + pushTo(text, rs.u8Add(97, rs.u8Rem(b3, 26)) as rs.char); } rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(boxed.n, pair[0], pair[1]))); if (fetch.tag === "Idle") { @@ -267,13 +264,13 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { _170 = 255; } rs.byteVecPush(out, _170); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); let empty: rs.u8 | undefined = undefined; - rs.byteVecPush(out, fill(rs.place(() => empty, (value11) => empty = value11), rs.place(() => text, (value12) => text = value12), by)); + rs.byteVecPush(out, fill(rs.place(() => empty, (value10) => empty = value10), text, by)); const _185: rs.u8 = rs.u8WrappingAdd(by, 1); - rs.byteVecPush(out, fill(rs.place(() => empty, (value13) => empty = value13), rs.place(() => text, (value14) => text = value14), _185)); + rs.byteVecPush(out, fill(rs.place(() => empty, (value11) => empty = value11), text, _185)); let at: rs.usize = 0; - const cursor: Cursor.Cursor = { at: rs.place(() => at, (value15) => at = value15), dataData: data.data, dataStart: data.start, dataLen: data.length }; + const cursor: Cursor.Cursor = { at: rs.place(() => at, (value12) => at = value12), dataData: data.data, dataStart: data.start, dataLen: data.length }; let sum: rs.u8 = 0; while (true) { const _190: rs.u8 | undefined = Cursor.next(cursor); @@ -290,14 +287,14 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, sum); rs.byteVecPush(out, at & 0xff); let remaining: rs.usize = rs.u8Rem(by, 5) as rs.usize; - rs.byteVecPush(out, skip(rs.place(() => remaining, (value16) => remaining = value16), data) & 0xff); + rs.byteVecPush(out, skip(rs.place(() => remaining, (value13) => remaining = value13), data) & 0xff); rs.byteVecPush(out, remaining & 0xff); const _214: [Pair.Pair, Pair.Pair] = [{ n: 1 }, { n: 2 }]; const a: Pair.Pair = _214[0]; const b5: Pair.Pair = _214[1]; let p: Pair.Pair = a; const borrowed = p; - const r: rs.Place = rs.place(() => borrowed.n, (value17) => borrowed.n = value17); + const r: rs.Place = rs.place(() => borrowed.n, (value14) => borrowed.n = value14); p = b5; bumpByte(r); p.n = rs.u8Add(p.n, 10); @@ -328,17 +325,17 @@ export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { } let total: rs.u32 = 0; for (const b7 of rs.byteSliceView(data)) { - _275(rs.place(() => total, (value18) => total = value18), b7); + _275(rs.place(() => total, (value15) => total = value15), b7); } rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(total))); const _293: [rs.u32, rs.u32] = [by as rs.u32, option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 5) as rs.u32]; let x2: rs.u32 = _293[0]; let y: rs.u32 = _293[1]; - readThrough(rs.place(() => x2, (value19) => x2 = value19), rs.place(() => y, (value20) => y = value20), out); + readThrough(rs.place(() => x2, (value16) => x2 = value16), rs.place(() => y, (value17) => y = value17), out); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x2 & 0xff, y & 0xff))); let boxed2: rs.u8 | undefined = undefined as rs.u8 | undefined; const _314: rs.u8 = total & 0xff; - derefBox(rs.place(() => boxed2, (value21) => boxed2 = value21), _314); + derefBox(rs.place(() => boxed2, (value18) => boxed2 = value18), _314); rs.byteVecPush(out, option_unwrapOr$1fr498u(boxed2, 238)); lent(data, out); } @@ -351,7 +348,7 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { let at!: rs.Place; let seen: rs.u32 | undefined = undefined; let last = undefined as [rs.u8, rs.u8] | undefined; - let text = undefined as string | undefined; + let text = undefined as rs.String | undefined; const held: rs.Vec> = new rs.Vec(); const spare: Array = [undefined, 9]; for (const b of rs.byteSliceView(data)) { @@ -418,14 +415,14 @@ export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { return x5.v; })))); if (text === undefined) { - text = ""; + text = rs.stringNew(); } - text = (text as string) + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char); + rs.stringPush(text as rs.String, rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(seen, 61166)))); } const _82: [rs.u8, rs.u8] = option_unwrapOr$0w1py1w(last, [238, 238] as [rs.u8, rs.u8]); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_82[0], _82[1]))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$165pyh5(text))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$1exlfpa(text).v)); const counts: Pair2.Pair2 = { a: undefined, b: undefined }; const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { @@ -526,7 +523,7 @@ export function defaulted(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPop((_31.v as Listing.Listing).listed); } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(listing, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(listing, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]).v)); } export function list$defaulted(listing: rs.Place, b: rs.u8): void { @@ -578,7 +575,7 @@ export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { return held.length === 0; }) as rs.u32))); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(held)); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(wide.items, f, rs.u32Debug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(wide.items, f, rs.u32Debug)]).v)); const pair: [rs.ByteVec, Listing.Listing] = [rs.byteSliceToByteVec(data), Listing.default$Default()]; const swap: (a0: rs.u8) => rs.ByteVec = (b5: rs.u8): rs.ByteVec => { const _36: rs.ByteVec = rs.byteVecOf(b5, rs.u8Rem(b5, 4) as rs.usize); @@ -608,7 +605,7 @@ export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { pair[1].stale = new rs.ByteVec(); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(taken3)); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(swapped)); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair[0]), f, rs.u8Debug), (f: rs.Formatter) => Listing.fmt$fmt_Debug(pair[1], f)], f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair[0]), f, rs.u8Debug), (f: rs.Formatter) => Listing.fmt$fmt_Debug(pair[1], f)], f)]).v)); } export function poll$taken_refs_taken_closure1(data: rs.ByteSlice, f: (a0: rs.u8) => boolean): rs.usize { @@ -1263,11 +1260,11 @@ export function toRefs(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(tail2.data[tail2.start]))); tail2 = rs.sliceRange(tail2, 1); } - let text: string = ""; + const text: rs.String = rs.stringNew(); for (const _59 of rs.byteSliceView(rs.byteSliceRange(data, 1))) { - text = text + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(_59, 26)) as rs.char); + rs.stringPush(text, rs.u8Add(97, rs.u8Rem(_59, 26)) as rs.char); } - let s: string = text; + let s: string = text.v; s = rs.strSlice(s, rs.min(rs.usizeRem(n, 3), rs.stringLen(s))); rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); const part2 = rs.usizeDiv(rs.byteSliceRange(data, 1).length, 2); diff --git a/ts/fixtures/lang/rings/expected/rings.ts b/ts/fixtures/lang/rings/expected/rings.ts index 2e3fa956f..5fce6f4a6 100644 --- a/ts/fixtures/lang/rings/expected/rings.ts +++ b/ts/fixtures/lang/rings/expected/rings.ts @@ -20,13 +20,13 @@ export function bump$rings_Item_u32(self: rs.Place): void { self.v = rs.u32Add(self.v, 1); } -export function make$rings_Item_String(b: rs.u8): string { +export function make$rings_Item_String(b: rs.u8): rs.String { const part = rs.u8Rem(b, 16); return rs.fmtFormat(["s", (f: rs.Formatter) => rs.u8Display(part, f)]); } -export function bump$rings_Item_String(self: rs.Place): void { - self.v = self.v + "!"; +export function bump$rings_Item_String(self: rs.String): void { + rs.stringPush(self, 33); } export function make$rings_Item_unit(_1: rs.u8): void { @@ -57,183 +57,183 @@ export function put(out: rs.ByteVec, n: rs.usize): void { } /** What `{:?}` writes of `value`. */ -export function text$Option_ref_String(out: rs.ByteVec, value: string | undefined): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr)]))); +export function text$Option_ref_String(out: rs.ByteVec, value: rs.String | undefined): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_rings_Big(out: rs.ByteVec, value: Big.Big | undefined): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_u32(out: rs.ByteVec, value: rs.u32 | undefined): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_u8(out: rs.ByteVec, value: rs.u8 | undefined): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$Option_ref_unit(out: rs.ByteVec, value: undefined | rs.None): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None)]).v)); } /** What `{:?}` writes of `value`. */ export function text$Result_usize_usize(out: rs.ByteVec, value: rs.Result): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(value, f, rs.usizeDebug, rs.usizeDebug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(value, f, rs.usizeDebug, rs.usizeDebug)]).v)); } /** What `{:?}` writes of `value`. */ -export function text$String(out: rs.ByteVec, value: string): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(value, f)]))); +export function text$String(out: rs.ByteVec, value: rs.String): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(value.v, f)]).v)); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Drain_String(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); +export function text$collections_vec_deque_Drain_String(out: rs.ByteVec, value: rs.Iter): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_rings_Big(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_u32(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_u8(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Drain_unit(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]).v)); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_IterMut_String(out: rs.ByteVec, value: rs.Iter>): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "IterMut")]))); +export function text$collections_vec_deque_IterMut_String(out: rs.ByteVec, value: rs.Iter): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), "IterMut")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_rings_Big(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_u32(out: rs.ByteVec, value: rs.Iter>): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "IterMut")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "IterMut")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_u8(out: rs.ByteVec, value: rs.Iter>): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "IterMut")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "IterMut")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_IterMut_unit(out: rs.ByteVec, value: rs.Iter>): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "IterMut")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "IterMut")]).v)); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Iter_String(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "Iter")]))); +export function text$collections_vec_deque_Iter_String(out: rs.ByteVec, value: rs.Iter): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), "Iter")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_rings_Big(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_u32(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "Iter")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "Iter")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_u8(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "Iter")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "Iter")]).v)); } /** What `{:?}` writes of `value`. */ export function text$collections_vec_deque_Iter_unit(out: rs.ByteVec, value: rs.Iter): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "Iter")]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "Iter")]).v)); } /** What `{:?}` writes of `value`. */ -export function text$mut_slice_String(out: rs.ByteVec, value: rs.Slice): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtStr)]))); +export function text$mut_slice_String(out: rs.ByteVec, value: rs.Slice): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_rings_Big(out: rs.ByteVec, value: rs.Slice): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_u32(out: rs.ByteVec, value: rs.Slice): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u32Debug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u32Debug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_u8(out: rs.ByteVec, value: rs.ByteSlice): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug)]).v)); } /** What `{:?}` writes of `value`. */ export function text$mut_slice_unit(out: rs.ByteVec, value: rs.Slice): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtUnit)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.fmtUnit)]).v)); } /** What `{:?}` writes of `value`. */ export function text$rings_Big(out: rs.ByteVec, value: Big.Big): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)]).v)); } /** What `{:?}` writes of `value`. */ -export function text$tuple2_ref_slice_String_ref_slice_String(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtStr)], f)]))); +export function text$tuple2_ref_slice_String_ref_slice_String(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))], f)]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_u32_ref_slice_u32(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.u32Debug)], f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.u32Debug)], f)]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_u8_ref_slice_u8(out: rs.ByteVec, value: [rs.ByteSlice, rs.ByteSlice]): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[1]), f, rs.u8Debug)], f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[1]), f, rs.u8Debug)], f)]).v)); } /** What `{:?}` writes of `value`. */ export function text$tuple2_ref_slice_unit_ref_slice_unit(out: rs.ByteVec, value: [rs.Slice, rs.Slice]): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtUnit)], f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[0]), f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(value[1]), f, rs.fmtUnit)], f)]).v)); } /** What `{:?}` writes of `value`. */ export function text$u32(out: rs.ByteVec, value: rs.u32): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(value, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(value, f)]).v)); } /** What `{:?}` writes of `value`. */ export function text$u8(out: rs.ByteVec, value: rs.u8): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(value, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(value, f)]).v)); } /** What `{:?}` writes of `value`. */ export function text$unit(out: rs.ByteVec, _value: undefined): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]).v)); } /** @@ -241,7 +241,7 @@ export function text$unit(out: rs.ByteVec, _value: undefined): void { * each pair after it steps: after each, its length, capacity, and two slices. */ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { - let q!: rs.VecDeque; + let q!: rs.VecDeque; const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; @@ -250,11 +250,13 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n const n: rs.usize = rs.usizeRem(first >> 2 as rs.usize, 12); const _17: rs.u8 = rs.u8Rem(first, 3); if (_17 === 0) { - q = rs.dequeNew(12) as rs.VecDeque; + q = rs.dequeNew(12) as rs.VecDeque; } else if (_17 === 1) { - q = rs.dequeWithCapacity(n, 12) as rs.VecDeque; + q = rs.dequeWithCapacity(n, 12) as rs.VecDeque; } else { - q = rs.dequeFromVec(rs.vecFromElem(make$rings_Item_String(first), n, undefined), 12) as rs.VecDeque; + q = rs.dequeFromVec(rs.vecFromElem(make$rings_Item_String(first), n, (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }), 12) as rs.VecDeque; } const iter: rs.Iter = rs.byteSliceChunks(_5[1], 2); while (true) { @@ -293,7 +295,7 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n rs.dequeTruncate(q, rs.usizeRem(arg as rs.usize, 8)); } else if (_46 === 13) { let kept: rs.u8 = arg; - rs.dequeRetain(q, (_25: string): boolean => { + rs.dequeRetain(q, (_25: rs.String): boolean => { kept = rs.intRotateLeft(kept, 1, 8, false); return (kept & 1) === 1; }); @@ -322,31 +324,33 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n } else if (_46 === 24) { appended$String(q, arg, out); } else if (_46 === 25) { - rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), make$rings_Item_String(arg), undefined); + rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), make$rings_Item_String(arg), (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); } else if (_46 === 26) { - rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): string => { + rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): rs.String => { return make$rings_Item_String(arg); }); } else if (_46 === 27) { - const tail: rs.VecDeque = rs.dequeSplitOff(q, at); + const tail: rs.VecDeque = rs.dequeSplitOff(q, at); put(out, rs.dequeCapacity(tail)); text$tuple2_ref_slice_String_ref_slice_String(out, rs.dequeAsSlices(tail)); } else if (_46 === 28) { const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(q.n, 1)); - const it: rs.Iter> = rs.dequeRangeMut(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); - const _151: rs.Place | rs.Done = it.next(); + const it: rs.Iter = rs.dequeRange(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); + const _151: rs.String | rs.Done = it.next(); if (_151 !== rs.DONE) { bump$rings_Item_String(_151); } - const _156: rs.Place | undefined = rs.iterToOption(it.nextBack()); + const _156: rs.String | undefined = rs.iterToOption(it.nextBack()); if (_156 !== undefined) { bump$rings_Item_String(_156); } text$collections_vec_deque_IterMut_String(out, it); } else if (_46 === 29) { - const v: rs.Vec = rs.dequeToVec(q); + const v: rs.Vec = rs.dequeToVec(q); put(out, rs.vecCapacity(v, 12)); - q = rs.dequeFromVec(v, 12) as rs.VecDeque; + q = rs.dequeFromVec(v, 12) as rs.VecDeque; } else if (_46 === 30) { rs.dequeRotate(q, at); } else if (_46 === 31) { @@ -356,12 +360,12 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n rs.dequeSwap(q, rs.usizeRem(arg as rs.usize, q.n), rs.usizeRem(arg >> 4 as rs.usize, q.n)); } } else if (_46 === 33) { - const s: rs.Slice = rs.dequeMakeContiguous(q); - const _190: rs.Place | undefined = rs.sliceFirstMut(s); + const s: rs.Slice = rs.dequeMakeContiguous(q); + const _190: rs.String | undefined = rs.sliceFirst(s); if (_190 !== undefined) { bump$rings_Item_String(_190); } - const _194: rs.Place | undefined = rs.sliceLastMut(s); + const _194: rs.String | undefined = rs.sliceLast(s); if (_194 !== undefined) { bump$rings_Item_String(_194); } @@ -957,62 +961,70 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num * 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: rs.VecDeque, arg: rs.u8): rs.VecDeque { - let _0!: rs.VecDeque; +export function remade$String(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { + let _0!: rs.VecDeque; const skip: rs.usize = rs.usizeRem(rs.u8Div(arg, 5) as rs.usize, 4); const _8: rs.u8 = rs.u8Rem(arg, 5); if (_8 === 0) { if (!((arg & 32) === 0)) { - const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 12) as rs.VecDeque; - const _18: string = make$rings_Item_String(arg); + const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 12) as rs.VecDeque; + const _18: rs.String = make$rings_Item_String(arg); rs.dequePushFront(own, _18); if ((arg & 64) === 0) { - rs.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, (a04: rs.String): rs.String => { + return rs.stringClone(a04); + }); } else { - rs.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, (a03: rs.String): rs.String => { + return rs.stringClone(a03); + }); } return own; } - return rs.dequeClone(q); + return rs.dequeClone(q, (a02: rs.String): rs.String => { + return rs.stringClone(a02); + }); } if (_8 === 1) { - const it: rs.Iter = rs.dequeIntoIter(q); + const it: rs.Iter = rs.dequeIntoIter(q); let iterStart: rs.usize = 0; const iterEnd: rs.usize = skip; while (iterStart++ < iterEnd) { rs.iterToOption(it.next()); } rs.iterToOption(it.nextBack()); - return rs.dequeFromIntoIter(it, 12) as rs.VecDeque; + return rs.dequeFromIntoIter(it, 12) as rs.VecDeque; } if (_8 === 2) { - const it2: rs.Iter = rs.dequeIntoIter(q); + const it2: rs.Iter = rs.dequeIntoIter(q); rs.iterNth(it2, skip); - return rs.dequeFromIntoIter(it2, 12) as rs.VecDeque; + return rs.dequeFromIntoIter(it2, 12) as rs.VecDeque; } if (_8 === 3) { if (!((arg & 32) === 0)) { - const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); + const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); let kept: boolean = false; - return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: string): boolean => { + return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: rs.String): boolean => { kept = !kept; return kept; - }), "next", 12, false, 12), 12) as rs.VecDeque; + }), "next", 12, false, 12), 12) as rs.VecDeque; } - return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true), 12) as rs.VecDeque; + return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true), 12) as rs.VecDeque; } - const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); + const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); rs.vecReserve(v2, skip, 12); - const it3: rs.Iter = rs.vecIntoIter(v2); + const it3: rs.Iter = rs.vecIntoIter(v2); let iterStart2: rs.usize = 0; const iterEnd2: rs.usize = skip; while (iterStart2++ < iterEnd2) { rs.iterToOption(it3.next()); } if ((arg & 64) === 0) { - _0 = rs.dequeFromIntoIter(it3, 12) as rs.VecDeque; + _0 = rs.dequeFromIntoIter(it3, 12) as rs.VecDeque; } else { - _0 = rs.dequeFromIntoIter(it3.clone({ v: rs.itself }), 12) as rs.VecDeque; + _0 = rs.dequeFromIntoIter(it3.clone({ v: (a0: rs.String): rs.String => { + return rs.stringClone(a0); + } }), 12) as rs.VecDeque; } return _0; } @@ -1285,27 +1297,27 @@ export function remade$unit(q: rs.VecDeque, arg: rs.u8): rs.VecDeque< * Another deque's items, wrapped as `arg` picks, moved to `q`'s back, and what that leaves * it, which shows where its head is once pushed at both ends. */ -export function appended$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { +export function appended$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { let _16!: rs.u8; - const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 12) as rs.VecDeque; + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 12) as rs.VecDeque; const _10: rs.u8 = (arg >> 2) & 7; let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _10; while ((_16 = iterStart++) < iterEnd) { const i: rs.u8 = _16; if (rs.u8Rem(i, 3) === 2) { - const _23: string = make$rings_Item_String(i); + const _23: rs.String = make$rings_Item_String(i); rs.dequePushFront(other, _23); } else { - const _25: string = make$rings_Item_String(i); + const _25: rs.String = make$rings_Item_String(i); rs.dequePushBack(other, _25); } } rs.dequeAppend(q, other); put(out, rs.dequeCapacity(other)); - const _33: string = make$rings_Item_String(arg); + const _33: rs.String = make$rings_Item_String(arg); rs.dequePushFront(other, _33); - const _36: string = make$rings_Item_String(arg); + const _36: rs.String = make$rings_Item_String(arg); rs.dequePushBack(other, _36); text$tuple2_ref_slice_String_ref_slice_String(out, rs.dequeAsSlices(other)); } @@ -1427,10 +1439,10 @@ export function appended$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byt } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ -export function drained$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { +export function drained$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { const len: rs.usize = q.n; const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(len, 1)); - const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); + const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); text$collections_vec_deque_Drain_String(out, d); if ((arg & 64) !== 0) { rs.iterToOption(d.next()); @@ -1507,27 +1519,27 @@ export function drained$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byte } /** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ -export function mutated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { - const _6: [rs.Slice, rs.Slice] = rs.dequeAsSlices(q); - const _7: rs.Place | undefined = rs.sliceFirstMut(_6[0]); +export function mutated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const _6: [rs.Slice, rs.Slice] = rs.dequeAsSlices(q); + const _7: rs.String | undefined = rs.sliceFirst(_6[0]); if (_7 !== undefined) { bump$rings_Item_String(_7); } - const _11: rs.Place | undefined = rs.sliceLastMut(_6[1]); + const _11: rs.String | undefined = rs.sliceLast(_6[1]); if (_11 !== undefined) { bump$rings_Item_String(_11); } - const it: rs.Iter> = rs.dequeIterMut(q); + const it: rs.Iter = rs.dequeIter(q); const _18: rs.u8 = rs.u8Rem(arg, 4); let iterStart: rs.u8 = 0; const iterEnd: rs.u8 = _18; while (iterStart++ < iterEnd) { - const _24: rs.Place | rs.Done = it.next(); + const _24: rs.String | rs.Done = it.next(); if (_24 !== rs.DONE) { bump$rings_Item_String(_24); } } - const _29: rs.Place | undefined = rs.iterToOption(it.nextBack()); + const _29: rs.String | undefined = rs.iterToOption(it.nextBack()); if (_29 !== undefined) { bump$rings_Item_String(_29); } @@ -1650,18 +1662,18 @@ export function mutated$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byte * Where each binary search finds an item `arg` makes, of items that need not be sorted, * and each item it probes. */ -export function searched$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { - const x: string = make$rings_Item_String(arg); +export function searched$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const x: rs.String = make$rings_Item_String(arg); text$Result_usize_usize(out, rs.dequeBinarySearch(q, x, rs.cmpStr)); - text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: string): rs.Ordering => { + text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: rs.String): rs.Ordering => { text$String(out, y); return rs.cmpStr(y, x); })); - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(x, f)]), (y2: string): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(x.v, f)]), (y2: rs.String): rs.String => { text$String(out, y2); - return rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(y2, f)]); + return rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(y2.v, f)]); }, rs.cmpStr)); - put(out, rs.dequePartitionPoint(q, (y3: string): boolean => { + put(out, rs.dequePartitionPoint(q, (y3: rs.String): boolean => { text$String(out, y3); return rs.cmpStr(y3, x) === -1; })); @@ -1678,7 +1690,7 @@ export function searched$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs. text$rings_Big(out, y); return Big.cmp$cmp_Ord(y, x); })); - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(x, f)]), (y2: Big.Big): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(x, f)]), (y2: Big.Big): rs.String => { text$rings_Big(out, y2); return rs.fmtFormat([(f: rs.Formatter) => Big.fmt$fmt_Debug(y2, f)]); }, rs.cmpStr)); @@ -1699,7 +1711,7 @@ export function searched$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec text$u32(out, y); return rs.cmp(y, x); })); - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(x, f)]), (y2: rs.u32): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(x, f)]), (y2: rs.u32): rs.String => { text$u32(out, y2); return rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(y2, f)]); }, rs.cmpStr)); @@ -1720,7 +1732,7 @@ export function searched$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): text$u8(out, y); return rs.cmp(y, x); })); - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(x, f)]), (y2: rs.u8): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(x, f)]), (y2: rs.u8): rs.String => { text$u8(out, y2); return rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(y2, f)]); }, rs.cmpStr)); @@ -1741,7 +1753,7 @@ export function searched$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byt text$unit(out, y); return rs.cmpNothing(y, undefined); })); - text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]), (y2: undefined): string => { + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]), (y2: undefined): rs.String => { text$unit(out, y2); return rs.fmtFormat([(f: rs.Formatter) => rs.fmtUnit(undefined, f)]); }, rs.cmpStr)); @@ -1752,10 +1764,10 @@ export function searched$unit(q: rs.VecDeque, arg: rs.u8, out: rs.Byt } /** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ -export function iterated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { +export function iterated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { let _10!: rs.u32; - let read!: string | undefined; - const it: rs.Iter = rs.dequeIter(q); + let read!: rs.String | undefined; + const it: rs.Iter = rs.dequeIter(q); text$collections_vec_deque_Iter_String(out, it); let iterStart: rs.u32 = 0; const iterEnd: rs.u32 = 3; @@ -1772,12 +1784,12 @@ export function iterated$String(q: rs.VecDeque, arg: rs.u8, out: rs.Byte } else if (_22 === 3) { read = rs.iterNthBack(it, count as rs.usize); } else if (_22 === 4) { - read = rs.iterFind(it, (_24: string): boolean => { + read = rs.iterFind(it, (_24: rs.String): boolean => { count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else if (_22 === 5) { - read = rs.iterRfind(it, (_2: string): boolean => { + read = rs.iterRfind(it, (_2: rs.String): boolean => { count = rs.u8SaturatingSub(count, 1); return count === 0; }); diff --git a/ts/fixtures/lang/saturates/expected/saturates.ts b/ts/fixtures/lang/saturates/expected/saturates.ts index 43ecab97a..f307c7bcf 100644 --- a/ts/fixtures/lang/saturates/expected/saturates.ts +++ b/ts/fixtures/lang/saturates/expected/saturates.ts @@ -365,7 +365,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { const all: rs.u8[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u8SaturatingAdd, 0); @@ -390,7 +390,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u8(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u8(x7), hashed$num_Saturating_u8(a)) ? 1 : 0); @@ -563,7 +563,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { const all: rs.u16[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u16SaturatingAdd, 0); @@ -588,7 +588,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u16(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u16(x7), hashed$num_Saturating_u16(a)) ? 1 : 0); @@ -761,7 +761,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { const all: rs.u32[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u32SaturatingAdd, 0); @@ -786,7 +786,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u32(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u32(x7), hashed$num_Saturating_u32(a)) ? 1 : 0); @@ -959,7 +959,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { const all: rs.u64[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u64SaturatingAdd, 0); @@ -984,7 +984,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u64(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u64(x7), hashed$num_Saturating_u64(a)) ? 1 : 0); @@ -1157,7 +1157,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { const all: rs.u128[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.u128SaturatingAdd, 0); @@ -1182,7 +1182,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_u128(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u128(x7), hashed$num_Saturating_u128(a)) ? 1 : 0); @@ -1355,7 +1355,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { const all: rs.usize[] = [a, b, c]; const part8 = rs.iterSum(rs.iterSlice(all), rs.usizeSaturatingAdd, 0); @@ -1380,7 +1380,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _370[1]; const _378: Gauge.Gauge = Gauge.default$Default_usize(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(_378, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_usize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_usize(x7), hashed$num_Saturating_usize(a)) ? 1 : 0); @@ -1560,7 +1560,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1573,7 +1573,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i8(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i8(x7), hashed$num_Saturating_i8(a)) ? 1 : 0); @@ -1754,7 +1754,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1767,7 +1767,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i16(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i16(x7), hashed$num_Saturating_i16(a)) ? 1 : 0); @@ -1948,7 +1948,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -1961,7 +1961,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i32(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i32(x7), hashed$num_Saturating_i32(a)) ? 1 : 0); @@ -2142,7 +2142,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2155,7 +2155,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i64(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i64(x7), hashed$num_Saturating_i64(a)) ? 1 : 0); @@ -2336,7 +2336,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2349,7 +2349,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_i128(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i128(x7), hashed$num_Saturating_i128(a)) ? 1 : 0); @@ -2530,7 +2530,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { const args6 = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_21 === 19) { rs.byteVecPush(out, 0); } else if (_21 === 20) { @@ -2543,7 +2543,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Gauge.Gauge = _344[1]; const _352: Gauge.Gauge = Gauge.default$Default_isize(); const args5 = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(_352, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); rs.byteVecPush(out, Gauge.cmp$cmp_Ord_isize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_isize(x7), hashed$num_Saturating_isize(a)) ? 1 : 0); diff --git a/ts/fixtures/lang/searches/expected/harness.ts b/ts/fixtures/lang/searches/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/searches/expected/harness.ts +++ b/ts/fixtures/lang/searches/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/searches/expected/searches.ts b/ts/fixtures/lang/searches/expected/searches.ts index 7d69a5ddd..ef028f3dd 100644 --- a/ts/fixtures/lang/searches/expected/searches.ts +++ b/ts/fixtures/lang/searches/expected/searches.ts @@ -3615,8 +3615,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); const pick: rs.u8 = _6[0]; - const s: string = text(_6[1]); - const alphabet: rs.Vec = rs.iterToVec(rs.strChars(text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(pick, 16), rs.u8Div(pick, 16))))), "next", 4); + const s: rs.String = text(_6[1]); + const alphabet: rs.Vec = rs.iterToVec(rs.strChars(text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(pick, 16), rs.u8Div(pick, 16)))).v), "next", 4); const _25: rs.char = alphabet.items[rs.idx(alphabet.items, 0)]; const _24: [rs.char, rs.char] = [_25, alphabet.items[rs.idx(alphabet.items, 1)]]; const c: rs.char = _25; @@ -3635,7 +3635,7 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }; const _42: rs.u8 = rs.u8Rem(rs.u8Div(kind, 17), 5); if (_42 === 0) { - const _50: string = s; + const _50: string = s.v; const part4 = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_50, String.fromCodePoint(c))); @@ -3662,8 +3662,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_50, String.fromCodePoint(c))); putOption(out, rs.strStripSuffix(_50, String.fromCodePoint(c))); } else if (m === 2) { - harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "<>")); - harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "é", n)); + harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "<>", true).v); + harness_put(out, rs.strReplacen(_50, String.fromCodePoint(c), "é", n).v); } else if (m === 3) { front$ref_str_str_Split_char(rs.strSplit(_50, String.fromCodePoint(c)), out); front$ref_str_str_RSplit_char(rs.strRsplit(_50, String.fromCodePoint(c)), out); @@ -3683,37 +3683,39 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void front$tuple2_usize_ref_str_str_RMatchIndices_char(rs.strRmatchIndices(_50, String.fromCodePoint(c)), out); } } else if (_42 === 1) { - const needle: string = rs.stringExtendChars("", rs.iterTake(rs.iterSkip(rs.strChars(s), rs.u8Div(pick, 64) as rs.usize), rs.u8Rem(rs.u8Div(pick, 16), 4) as rs.usize)); + const _109: rs.Iter = rs.iterTake(rs.iterSkip(rs.strChars(s.v), rs.u8Div(pick, 64) as rs.usize), rs.u8Rem(rs.u8Div(pick, 16), 4) as rs.usize); + const needle: rs.String = rs.stringExtendChars(rs.stringNew(), _109); + const _125: string = s.v; const _127: rs.u8 = rs.u8Rem(m, 9); if (_127 === 0) { - putOffset(out, rs.strFind(s, needle)); - putOffset(out, rs.strRfind(s, needle)); + putOffset(out, rs.strFind(_125, needle.v)); + putOffset(out, rs.strRfind(_125, needle.v)); } else if (_127 === 1) { - putOption(out, rs.strStripPrefix(s, needle)); - putOption(out, rs.strStripSuffix(s, needle)); + putOption(out, rs.strStripPrefix(_125, needle.v)); + putOption(out, rs.strStripSuffix(_125, needle.v)); } else if (_127 === 2) { - harness_put(out, rs.strReplace(s, needle, "<>")); - harness_put(out, rs.strReplace(s, needle, "é", n)); + harness_put(out, rs.strReplace(_125, needle.v, "<>", true).v); + harness_put(out, rs.strReplacen(_125, needle.v, "é", n).v); } else if (_127 === 3) { - front$ref_str_str_Split_ref_str(rs.strSplit(s, needle), out); - front$ref_str_str_RSplit_ref_str(rs.strRsplit(s, needle), out); + front$ref_str_str_Split_ref_str(rs.strSplit(_125, needle.v), out); + front$ref_str_str_RSplit_ref_str(rs.strRsplit(_125, needle.v), out); } else if (_127 === 4) { - front$ref_str_str_SplitTerminator_ref_str(rs.strSplitTerminator(s, needle), out); - front$ref_str_str_RSplitTerminator_ref_str(rs.strRsplitTerminator(s, needle), out); + front$ref_str_str_SplitTerminator_ref_str(rs.strSplitTerminator(_125, needle.v), out); + front$ref_str_str_RSplitTerminator_ref_str(rs.strRsplitTerminator(_125, needle.v), out); } else if (_127 === 5) { - front$ref_str_str_SplitN_ref_str(rs.strSplitn(s, n, needle), out); - front$ref_str_str_RSplitN_ref_str(rs.strRsplitn(s, n, needle), out); + front$ref_str_str_SplitN_ref_str(rs.strSplitn(_125, n, needle.v), out); + front$ref_str_str_RSplitN_ref_str(rs.strRsplitn(_125, n, needle.v), out); } else if (_127 === 6) { - front$ref_str_str_SplitInclusive_ref_str(rs.strSplitInclusive(s, needle), out); + front$ref_str_str_SplitInclusive_ref_str(rs.strSplitInclusive(_125, needle.v), out); } else if (_127 === 7) { - front$ref_str_str_Matches_ref_str(rs.strMatches(s, needle), out); - front$ref_str_str_RMatches_ref_str(rs.strRmatches(s, needle), out); + front$ref_str_str_Matches_ref_str(rs.strMatches(_125, needle.v), out); + front$ref_str_str_RMatches_ref_str(rs.strRmatches(_125, needle.v), out); } else { - front$tuple2_usize_ref_str_str_MatchIndices_ref_str(rs.strMatchIndices(s, needle), out); - front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(rs.strRmatchIndices(s, needle), out); + front$tuple2_usize_ref_str_str_MatchIndices_ref_str(rs.strMatchIndices(_125, needle.v), out); + front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(rs.strRmatchIndices(_125, needle.v), out); } } else if (_42 === 2) { - const _206: string = s; + const _206: string = s.v; const part3 = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_206, rs.patternChars([c, d]))); @@ -3740,8 +3742,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_206, rs.patternChars([c, d]))); putOption(out, rs.strStripSuffix(_206, rs.patternChars([c, d]))); } else if (m === 2) { - harness_put(out, rs.strReplace(_206, rs.patternChars([c, d]), "<>")); - harness_put(out, rs.strReplace(_206, rs.patternChars([c, d]), "é", n)); + harness_put(out, rs.strReplace(_206, rs.patternChars([c, d]), "<>", false).v); + harness_put(out, rs.strReplacen(_206, rs.patternChars([c, d]), "é", n).v); } else if (m === 3) { front$ref_str_str_Split_ref_slice_char(rs.strSplit(_206, rs.patternChars([c, d])), out); front$ref_str_str_RSplit_ref_slice_char(rs.strRsplit(_206, rs.patternChars([c, d])), out); @@ -3761,7 +3763,7 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(rs.strRmatchIndices(_206, rs.patternChars([c, d])), out); } } else if (_42 === 3) { - const _349: string = s; + const _349: string = s.v; const part2 = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_349, rs.patternChars([c, d]))); @@ -3788,8 +3790,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_349, rs.patternChars([c, d]))); putOption(out, rs.strStripSuffix(_349, rs.patternChars([c, d]))); } else if (m === 2) { - harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "<>")); - harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "é", n)); + harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "<>", false).v); + harness_put(out, rs.strReplacen(_349, rs.patternChars([c, d]), "é", n).v); } else if (m === 3) { front$ref_str_str_Split_array2_char(rs.strSplit(_349, rs.patternChars([c, d])), out); front$ref_str_str_RSplit_array2_char(rs.strRsplit(_349, rs.patternChars([c, d])), out); @@ -3809,7 +3811,7 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(rs.strRmatchIndices(_349, rs.patternChars([c, d])), out); } } else { - const _438: string = s; + const _438: string = s.v; const part = _6[1]; if (m === 9) { harness_put(out, rs.strTrimMatches(_438, p)); @@ -3836,8 +3838,8 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void putOption(out, rs.strStripPrefix(_438, p)); putOption(out, rs.strStripSuffix(_438, p)); } else if (m === 2) { - harness_put(out, rs.strReplace(_438, p, "<>")); - harness_put(out, rs.strReplace(_438, p, "é", n)); + harness_put(out, rs.strReplace(_438, p, "<>", false).v); + harness_put(out, rs.strReplacen(_438, p, "é", n).v); } else if (m === 3) { front$ref_str_str_Split_searches_searches_closure1(rs.strSplit(_438, p), out); front$ref_str_str_RSplit_searches_searches_closure1(rs.strRsplit(_438, p), out); @@ -3874,27 +3876,28 @@ export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void * low bits of each byte, read from the end each byte's high bit picks. */ export function texts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _5: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { const _52: rs.usize = rs.u8Rem(_2, 16) as rs.usize; if (!(_52 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _52); } return [10, 13, 97, 32, 9, 11, 133, 160, 5760, 8202, 8203, 8232, 12288, 65279, 233, 128512][_52]; - })); + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _5); const _7: rs.u8 = rs.u8Rem(kind, 5); if (_7 === 0) { - both$tuple2_usize_char_str_CharIndices(rs.strCharIndices(s), data, out); + both$tuple2_usize_char_str_CharIndices(rs.strCharIndices(s.v), data, out); } else if (_7 === 1) { - both$ref_str_str_Lines(rs.strLines(s), data, out); + both$ref_str_str_Lines(rs.strLines(s.v), data, out); } else if (_7 === 2) { - both$ref_str_str_SplitWhitespace(rs.strSplitWhitespace(s), data, out); + both$ref_str_str_SplitWhitespace(rs.strSplitWhitespace(s.v), data, out); } else if (_7 === 3) { - both$ref_str_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(s), data, out); + both$ref_str_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(s.v), data, out); } else { - harness_put(out, rs.strTrimMatches(s, rs.charIsWhitespace)); - harness_put(out, rs.strTrimStartMatches(s, rs.charIsWhitespace)); - harness_put(out, rs.strTrimEndMatches(s, rs.charIsWhitespace)); - for (const _40 of rs.iterToVec(rs.iterMap(rs.strChars(s), (a0: rs.char): boolean => { + harness_put(out, rs.strTrimMatches(s.v, rs.charIsWhitespace)); + harness_put(out, rs.strTrimStartMatches(s.v, rs.charIsWhitespace)); + harness_put(out, rs.strTrimEndMatches(s.v, rs.charIsWhitespace)); + for (const _40 of rs.iterToVec(rs.iterMap(rs.strChars(s.v), (a0: rs.char): boolean => { return rs.charIsWhitespace(a0); }), "next", 1).items) { rs.byteVecPush(out, _40 ? 1 : 0); diff --git a/ts/fixtures/lang/separated/expected/core/option.ts b/ts/fixtures/lang/separated/expected/core/option.ts index 505b0482a..550101f69 100644 --- a/ts/fixtures/lang/separated/expected/core/option.ts +++ b/ts/fixtures/lang/separated/expected/core/option.ts @@ -4,7 +4,7 @@ import * as rs from "../rs.ts"; import { sum, sumWords, sumPairs, sumTexts, sumTwos } from "../separated.ts"; import type * as Pair from "../separated.Pair.ts"; -export function map$13p7ywa(self: rs.Slice | undefined, _: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { +export function map$0k3subg(self: rs.Slice | undefined, _: (a0: rs.Slice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } @@ -39,7 +39,7 @@ export function map$0x0c7ki(self: rs.ByteSlice | undefined, _: (a0: rs.ByteSlice return sum(self); } -export function mapOr$1dcbyoa(self: rs.Slice | undefined, default_: rs.u8, _: (a0: rs.Slice) => rs.u8): rs.u8 { +export function mapOr$1jad7d1(self: rs.Slice | undefined, default_: rs.u8, _: (a0: rs.Slice) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/separated/expected/separated.ts b/ts/fixtures/lang/separated/expected/separated.ts index 43146b0a5..0d7631729 100644 --- a/ts/fixtures/lang/separated/expected/separated.ts +++ b/ts/fixtures/lang/separated/expected/separated.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { map$13p7ywa as option_map$13p7ywa, map$1fgo7n1 as option_map$1fgo7n1, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1dcbyoa as option_mapOr$1dcbyoa, mapOr$1bxom2b as option_mapOr$1bxom2b, mapOr$1khlwl8 as option_mapOr$1khlwl8, mapOr$0r061yq as option_mapOr$0r061yq, mapOr$0ckb6jj as option_mapOr$0ckb6jj, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; +import { map$0k3subg as option_map$0k3subg, map$1fgo7n1 as option_map$1fgo7n1, map$1mzp47n as option_map$1mzp47n, map$1qolnv4 as option_map$1qolnv4, map$0x0c7ki as option_map$0x0c7ki, mapOr$1jad7d1 as option_mapOr$1jad7d1, mapOr$1bxom2b as option_mapOr$1bxom2b, mapOr$1khlwl8 as option_mapOr$1khlwl8, mapOr$0r061yq as option_mapOr$0r061yq, mapOr$0ckb6jj as option_mapOr$0ckb6jj, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; import * as Below from "./separated.Below.ts"; import * as Pair from "./separated.Pair.ts"; @@ -41,9 +41,9 @@ export function sumPairs(part: rs.Slice): rs.u8 { }); } -export function sumTexts(part: rs.Slice): rs.u8 { - return rs.iterFold(rs.iterSlice(rs.sliceItems(part)), part.length & 0xff, (acc: rs.u8, s: string): rs.u8 => { - return rs.u8WrappingAdd(rs.u8WrappingMul(acc, 31), rs.stringLen(s) & 0xff); +export function sumTexts(part: rs.Slice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.sliceItems(part)), part.length & 0xff, (acc: rs.u8, s: rs.String): rs.u8 => { + return rs.u8WrappingAdd(rs.u8WrappingMul(acc, 31), s.len & 0xff); }); } @@ -130,9 +130,9 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi let _151!: rs.Slice | undefined; let _184!: rs.i32; let p4!: rs.Slice | undefined; - let _262!: rs.Slice | undefined; + let _262!: rs.Slice | undefined; let _295!: rs.i32; - let p6!: rs.Slice | undefined; + let p6!: rs.Slice | undefined; let _360!: rs.i32; let _425!: rs.ByteSlice | undefined; let _456!: rs.i32; @@ -140,9 +140,9 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi let _524!: rs.Slice | undefined; let _557!: rs.i32; let p10!: rs.Slice | undefined; - let _635!: rs.Slice | undefined; + let _635!: rs.Slice | undefined; let _668!: rs.i32; - let p12!: rs.Slice | undefined; + let p12!: rs.Slice | undefined; let _751!: rs.Slice | undefined; let _784!: rs.i32; let p14!: rs.Slice | undefined; @@ -192,12 +192,12 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi const b2: rs.u8 = _24; return { a: b2, b: rs.u16Mul(b2 as rs.u16, 3) }; }), undefined, 4, true); - const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): string => { + const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.String => { const _7: rs.usize = rs.usizeRem(_27 as rs.usize, 3); if (!(_7 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _7); } - return ["", "a", "ab"][_7]; + return rs.stringFrom(["", "a", "ab"][_7]); }), undefined, 12, true); const test: (a0: rs.u8) => boolean = (_28: rs.u8): boolean => { const b4: rs.u8 = _28; @@ -219,12 +219,11 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi rs.refMutRelease(_63); return (p35.a as rs.u16) < bound; }; - const testTexts: (a0: string) => boolean = (s: string): boolean => { + const testTexts: (a0: rs.String) => boolean = (s: rs.String): boolean => { const _67: rs.RefCell = rs.refCellBorrowMut(log); - const _79: rs.u8 = (rs.stringLen(s) & 0xff) | 128; - rs.byteVecPush(_67.value, _79); + rs.byteVecPush(_67.value, (s.len & 0xff) | 128); rs.refMutRelease(_67); - return rs.stringLen(s) < rs.usizeRem(bound as rs.usize, 3); + return s.len < rs.usizeRem(bound as rs.usize, 3); }; b2: { const _35: rs.u8 = rs.u8Rem(kind, 8); @@ -336,7 +335,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back3: boolean = _251; - const it5: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); + const it5: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); hint(it5.sizeHint(), out); flush(log, out); while (true) { @@ -356,7 +355,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it6: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); + const it6: rs.Iter> = rs.sliceSplit(rs.sliceFrom(texts.items), testTexts); let iterStart3: rs.i32 = 0; const iterEnd3: rs.i32 = 12; while ((_295 = iterStart3++) < iterEnd3) { @@ -365,15 +364,15 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else { p6 = rs.iterToOption(it6.nextBack()); } - rs.byteVecPush(out, option_mapOr$1dcbyoa(p6, 252, sumTexts)); + rs.byteVecPush(out, option_mapOr$1jad7d1(p6, 252, sumTexts)); hint(it6.sizeHint(), out); flush(log, out); } - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNth(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNth(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNthBack(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNthBack(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterLast(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterLast(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); flush(log, out); rs.byteVecPush(out, rs.iterCount(rs.sliceSplit(rs.sliceFrom(texts.items), testTexts)) & 0xff); flush(log, out); @@ -510,7 +509,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break; } const back6: boolean = _624; - const it13: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); + const it13: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); hint(it13.sizeHint(), out); flush(log, out); while (true) { @@ -530,7 +529,7 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } } } - const it14: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); + const it14: rs.Iter> = rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts); let iterStart7: rs.i32 = 0; const iterEnd7: rs.i32 = 12; while ((_668 = iterStart7++) < iterEnd7) { @@ -539,15 +538,15 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi } else { p12 = rs.iterToOption(it14.nextBack()); } - rs.byteVecPush(out, option_mapOr$1dcbyoa(p12, 252, sumTexts)); + rs.byteVecPush(out, option_mapOr$1jad7d1(p12, 252, sumTexts)); hint(it14.sizeHint(), out); flush(log, out); } - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNth(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNth(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterNthBack(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterNthBack(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rs.iterExtendBytes(out, rs.iterOption(option_map$13p7ywa(rs.iterLast(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0k3subg(rs.iterLast(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts)), sumTexts)), undefined, true); flush(log, out); rs.byteVecPush(out, rs.iterCount(rs.sliceRsplit(rs.sliceFrom(texts.items), testTexts)) & 0xff); flush(log, out); @@ -910,10 +909,10 @@ export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): voi break b2; } const n5: rs.usize = _1447; - const it29: rs.Iter> = rs.sliceSplitn(rs.sliceFrom(texts.items), n5, testTexts); + const it29: rs.Iter> = rs.sliceSplitn(rs.sliceFrom(texts.items), n5, testTexts); hint(it29.sizeHint(), out); while (true) { - const _1457: rs.Slice | rs.Done = it29.next(); + const _1457: rs.Slice | rs.Done = it29.next(); if (_1457 !== rs.DONE) { rs.byteVecPush(out, sumTexts(_1457)); hint(it29.sizeHint(), out); diff --git a/ts/fixtures/lang/shapes/caller.ts b/ts/fixtures/lang/shapes/caller.ts index 1ad079026..2de8cfdf6 100644 --- a/ts/fixtures/lang/shapes/caller.ts +++ b/ts/fixtures/lang/shapes/caller.ts @@ -23,7 +23,7 @@ export function run(input: rs.ByteSlice): rs.ByteVec { "|", rs.fmtSpec({ alternate: true }, debug), ]); - return rs.byteVecFrom(new TextEncoder().encode(text)); + return rs.byteVecFrom(new TextEncoder().encode(text.v)); } /** `shapes::loops` with each first byte that one of its cases of `!` takes, with one more byte and without. */ diff --git a/ts/fixtures/lang/shapes/expected/fmt.Capped.ts b/ts/fixtures/lang/shapes/expected/fmt.Capped.ts index 738829a72..6c778ed33 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Capped.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Capped.ts @@ -4,21 +4,21 @@ import * as rs from "./rs.ts"; /** A writer of the crate's own that fails a `write_str` past `cap` bytes, and counts each. */ export interface Capped { - text: string; + text: rs.String; calls: rs.u8; cap: rs.usize; } export function writeStr$fmt_Write(self: Capped, s: string): rs.Result { self.calls = rs.u8Add(self.calls, 1); - if (!(rs.usizeAdd(rs.stringLen(self.text), rs.stringLen(s)) > self.cap)) { + if (!(rs.usizeAdd(self.text.len, rs.stringLen(s)) > self.cap)) { const iter: rs.Iter = rs.strChars(s); while (true) { const _14: rs.char | rs.Done = iter.next(); if (_14 === rs.DONE) { break; } - self.text = self.text + String.fromCodePoint(_14); + rs.stringPush(self.text, _14); } return rs.OK; } diff --git a/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts b/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts index 7058e9bf5..a59d9188e 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Dropper.ts @@ -24,7 +24,7 @@ export function fmt$fmt_Debug(self: Dropper, f: rs.Formatter): rs.Result { const arg = self.tag; - return rs.fmtPad(f, rs.fmtFormat(["n", (f: rs.Formatter) => rs.u8Display(arg, f)])); + return rs.fmtPad(f, rs.fmtFormat(["n", (f: rs.Formatter) => rs.u8Display(arg, f)]).v); } export function drop$ops_Drop(self: Dropper): void { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Log.ts b/ts/fixtures/lang/shapes/expected/fmt.Log.ts index f410c4458..04e3bfbb3 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Log.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Log.ts @@ -7,28 +7,28 @@ import * as rs from "./rs.ts"; * a `write_char` by `c` before its text, and fails each call past its `budget` with `!`. */ export interface Log { - text: string; + text: rs.String; budget: rs.usize; } function new_(budget: rs.usize): Log { - return { text: "", budget }; + return { text: rs.stringNew(), budget }; } export function open(self: Log, kind: rs.char): rs.Result { if (!(self.budget === 0)) { self.budget = rs.usizeSub(self.budget, 1); - self.text = self.text + String.fromCodePoint(kind); + rs.stringPush(self.text, kind); return rs.OK; } - self.text = self.text + "!"; + rs.stringPush(self.text, 33); return rs.Err(new rs.FmtError()); } export function writeStr$fmt_Write(self: Log, s: string): rs.Result { if (open(self, 115).ok) { - self.text = self.text + s; - self.text = self.text + "\u0001"; + rs.stringPushStr(self.text, s); + rs.stringPush(self.text, 1); return rs.OK; } return rs.Err(new rs.FmtError()); @@ -36,8 +36,8 @@ export function writeStr$fmt_Write(self: Log, s: string): rs.Result { if (open(self, 99).ok) { - self.text = self.text + String.fromCodePoint(c); - self.text = self.text + "\u0001"; + rs.stringPush(self.text, c); + rs.stringPush(self.text, 1); return rs.OK; } return rs.Err(new rs.FmtError()); diff --git a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts index 47181b96b..f005b7c64 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts @@ -8,28 +8,28 @@ import * as Shape from "./shapes.Shape.ts"; export function fmt$fmt_Debug(self: Nested, f: rs.Formatter): rs.Result { const names: rs.Slice = rs.sliceFrom(["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]); - const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.name, f); + const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.name.v, f); const _9: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.point, f); const _11: rs.Fmt = (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.shape, f); const _13: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.tags), f, rs.u8Debug); const _15: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.pairs.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)); const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.maybe, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)); const _19: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.none, f, rs.u8Debug); - const _21: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, rs.fmtStr); + const _21: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)); const _24: rs.Slice = rs.sliceFrom(self.list); const values: rs.Slice = rs.sliceFrom([_7, _9, _11, _13, _15, _17, _19, _21, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_24), f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]); return rs.fmtDebugStructFields(f, "Nested", rs.sliceItems(names), rs.sliceItems(values)); } export interface Nested { - name: string; + name: rs.String; point: Point.Point; shape: Shape.Shape; tags: rs.ByteVec; pairs: rs.Vec; maybe: Pair.Pair | undefined; none: rs.u8 | undefined; - result: rs.Result; + result: rs.Result; list: rs.i16[]; tuple: [rs.u8, boolean, string]; single: [rs.u8]; diff --git a/ts/fixtures/lang/shapes/expected/fmt.Twice.ts b/ts/fixtures/lang/shapes/expected/fmt.Twice.ts index 170f4857d..052d92ae7 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Twice.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Twice.ts @@ -4,7 +4,7 @@ import * as rs from "./rs.ts"; /** A writer of the crate's own that writes each `char` twice through its own `write_char`. */ export interface Twice { - _0: string; + _0: rs.String; } export function writeStr$fmt_Write(self: Twice, s: string): rs.Result { @@ -14,14 +14,14 @@ export function writeStr$fmt_Write(self: Twice, s: string): rs.Result { - self._0 = self._0 + String.fromCodePoint(c); - self._0 = self._0 + String.fromCodePoint(c); + rs.stringPush(self._0, c); + rs.stringPush(self._0, c); return rs.OK; } diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index ca6999aae..c256f882c 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -44,144 +44,144 @@ export function ints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); const v: rs.u8 = rs.u8FromBeBytes(buf); const args106 = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8Debug(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8UpperHex(v, f)]; - put(out, rs.fmtFormat([args106[0], " ", args106[1], " ", rs.fmtSpec({ width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args106[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args106[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args106[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args106[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args106[0]), "|", args106[2], " ", args106[3], " ", rs.fmtSpec({ alternate: true }, args106[2]), " ", rs.fmtSpec({ alternate: true }, args106[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args106[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args106[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args106[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args106[3]), "|", rs.fmtSpec({ alternate: true }, args106[1]), " ", rs.fmtSpec({ width: 3 }, args106[1])])); + put(out, rs.fmtFormat([args106[0], " ", args106[1], " ", rs.fmtSpec({ width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args106[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args106[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args106[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args106[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args106[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args106[0]), "|", args106[2], " ", args106[3], " ", rs.fmtSpec({ alternate: true }, args106[2]), " ", rs.fmtSpec({ alternate: true }, args106[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args106[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args106[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args106[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args106[3]), "|", rs.fmtSpec({ alternate: true }, args106[1]), " ", rs.fmtSpec({ width: 3 }, args106[1])]).v); const args107 = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8Binary(v, f), (f: rs.Formatter) => rs.u8Octal(v, f), (f: rs.Formatter) => rs.u8Debug(v, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args107[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args107[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args107[1]), " ", args107[0], " ", rs.fmtSpec({ precision: 3 }, args107[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args107[0]), "|", args107[2], " ", rs.fmtSpec({ alternate: true }, args107[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args107[2]), " ", args107[3], " ", rs.fmtSpec({ alternate: true }, args107[3]), " ", rs.fmtSpec({ plus: true }, args107[3]), "|", rs.fmtSpec({ debugHex: "x" }, args107[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args107[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args107[4]), " ", rs.fmtSpec({ plus: true }, args107[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args107[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args107[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args107[1]), " ", args107[0], " ", rs.fmtSpec({ precision: 3 }, args107[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args107[0]), "|", args107[2], " ", rs.fmtSpec({ alternate: true }, args107[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args107[2]), " ", args107[3], " ", rs.fmtSpec({ alternate: true }, args107[3]), " ", rs.fmtSpec({ plus: true }, args107[3]), "|", rs.fmtSpec({ debugHex: "x" }, args107[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args107[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args107[4]), " ", rs.fmtSpec({ plus: true }, args107[4])]).v); const args108 = [(f: rs.Formatter) => rs.u8LowerExp(v, f), (f: rs.Formatter) => rs.u8UpperExp(v, f)]; - put(out, rs.fmtFormat([args108[0], " ", args108[1], " ", rs.fmtSpec({ precision: 0 }, args108[0]), " ", rs.fmtSpec({ precision: 1 }, args108[0]), " ", rs.fmtSpec({ precision: 3 }, args108[0]), " ", rs.fmtSpec({ precision: 45 }, args108[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args108[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args108[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args108[0]), "| ", rs.fmtSpec({ alternate: true }, args108[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args108[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(v, f))); + put(out, rs.fmtFormat([args108[0], " ", args108[1], " ", rs.fmtSpec({ precision: 0 }, args108[0]), " ", rs.fmtSpec({ precision: 1 }, args108[0]), " ", rs.fmtSpec({ precision: 3 }, args108[0]), " ", rs.fmtSpec({ precision: 45 }, args108[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args108[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args108[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args108[0]), "| ", rs.fmtSpec({ alternate: true }, args108[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args108[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(v, f), 0).v); } else if (_4 === 1) { const buf2: Uint8Array = rs.bytes(2); const n2: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf2).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(data, 0, n2)); const v2: rs.u16 = rs.u16FromBeBytes(buf2); const args103 = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16UpperHex(v2, f)]; - put(out, rs.fmtFormat([args103[0], " ", args103[1], " ", rs.fmtSpec({ width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args103[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args103[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args103[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args103[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args103[0]), "|", args103[2], " ", args103[3], " ", rs.fmtSpec({ alternate: true }, args103[2]), " ", rs.fmtSpec({ alternate: true }, args103[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args103[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args103[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args103[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args103[3]), "|", rs.fmtSpec({ alternate: true }, args103[1]), " ", rs.fmtSpec({ width: 3 }, args103[1])])); + put(out, rs.fmtFormat([args103[0], " ", args103[1], " ", rs.fmtSpec({ width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args103[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args103[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args103[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args103[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args103[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args103[0]), "|", args103[2], " ", args103[3], " ", rs.fmtSpec({ alternate: true }, args103[2]), " ", rs.fmtSpec({ alternate: true }, args103[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args103[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args103[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args103[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args103[3]), "|", rs.fmtSpec({ alternate: true }, args103[1]), " ", rs.fmtSpec({ width: 3 }, args103[1])]).v); const args104 = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16Binary(v2, f), (f: rs.Formatter) => rs.u16Octal(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args104[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args104[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args104[1]), " ", args104[0], " ", rs.fmtSpec({ precision: 3 }, args104[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args104[0]), "|", args104[2], " ", rs.fmtSpec({ alternate: true }, args104[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args104[2]), " ", args104[3], " ", rs.fmtSpec({ alternate: true }, args104[3]), " ", rs.fmtSpec({ plus: true }, args104[3]), "|", rs.fmtSpec({ debugHex: "x" }, args104[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args104[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args104[4]), " ", rs.fmtSpec({ plus: true }, args104[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args104[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args104[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args104[1]), " ", args104[0], " ", rs.fmtSpec({ precision: 3 }, args104[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args104[0]), "|", args104[2], " ", rs.fmtSpec({ alternate: true }, args104[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args104[2]), " ", args104[3], " ", rs.fmtSpec({ alternate: true }, args104[3]), " ", rs.fmtSpec({ plus: true }, args104[3]), "|", rs.fmtSpec({ debugHex: "x" }, args104[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args104[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args104[4]), " ", rs.fmtSpec({ plus: true }, args104[4])]).v); const args105 = [(f: rs.Formatter) => rs.u16LowerExp(v2, f), (f: rs.Formatter) => rs.u16UpperExp(v2, f)]; - put(out, rs.fmtFormat([args105[0], " ", args105[1], " ", rs.fmtSpec({ precision: 0 }, args105[0]), " ", rs.fmtSpec({ precision: 1 }, args105[0]), " ", rs.fmtSpec({ precision: 3 }, args105[0]), " ", rs.fmtSpec({ precision: 45 }, args105[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args105[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args105[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args105[0]), "| ", rs.fmtSpec({ alternate: true }, args105[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args105[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u16Display(v2, f))); + put(out, rs.fmtFormat([args105[0], " ", args105[1], " ", rs.fmtSpec({ precision: 0 }, args105[0]), " ", rs.fmtSpec({ precision: 1 }, args105[0]), " ", rs.fmtSpec({ precision: 3 }, args105[0]), " ", rs.fmtSpec({ precision: 45 }, args105[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args105[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args105[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args105[0]), "| ", rs.fmtSpec({ alternate: true }, args105[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args105[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u16Display(v2, f), 0).v); } else if (_4 === 2) { const buf3: Uint8Array = rs.bytes(4); const n3: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf3).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(data, 0, n3)); const v3: rs.u32 = rs.u32FromBeBytes(buf3); const args100 = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32UpperHex(v3, f)]; - put(out, rs.fmtFormat([args100[0], " ", args100[1], " ", rs.fmtSpec({ width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args100[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args100[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args100[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args100[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args100[0]), "|", args100[2], " ", args100[3], " ", rs.fmtSpec({ alternate: true }, args100[2]), " ", rs.fmtSpec({ alternate: true }, args100[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args100[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args100[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args100[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args100[3]), "|", rs.fmtSpec({ alternate: true }, args100[1]), " ", rs.fmtSpec({ width: 3 }, args100[1])])); + put(out, rs.fmtFormat([args100[0], " ", args100[1], " ", rs.fmtSpec({ width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args100[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args100[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args100[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args100[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args100[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args100[0]), "|", args100[2], " ", args100[3], " ", rs.fmtSpec({ alternate: true }, args100[2]), " ", rs.fmtSpec({ alternate: true }, args100[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args100[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args100[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args100[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args100[3]), "|", rs.fmtSpec({ alternate: true }, args100[1]), " ", rs.fmtSpec({ width: 3 }, args100[1])]).v); const args101 = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32Binary(v3, f), (f: rs.Formatter) => rs.u32Octal(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args101[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args101[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args101[1]), " ", args101[0], " ", rs.fmtSpec({ precision: 3 }, args101[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args101[0]), "|", args101[2], " ", rs.fmtSpec({ alternate: true }, args101[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args101[2]), " ", args101[3], " ", rs.fmtSpec({ alternate: true }, args101[3]), " ", rs.fmtSpec({ plus: true }, args101[3]), "|", rs.fmtSpec({ debugHex: "x" }, args101[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args101[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args101[4]), " ", rs.fmtSpec({ plus: true }, args101[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args101[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args101[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args101[1]), " ", args101[0], " ", rs.fmtSpec({ precision: 3 }, args101[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args101[0]), "|", args101[2], " ", rs.fmtSpec({ alternate: true }, args101[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args101[2]), " ", args101[3], " ", rs.fmtSpec({ alternate: true }, args101[3]), " ", rs.fmtSpec({ plus: true }, args101[3]), "|", rs.fmtSpec({ debugHex: "x" }, args101[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args101[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args101[4]), " ", rs.fmtSpec({ plus: true }, args101[4])]).v); const args102 = [(f: rs.Formatter) => rs.u32LowerExp(v3, f), (f: rs.Formatter) => rs.u32UpperExp(v3, f)]; - put(out, rs.fmtFormat([args102[0], " ", args102[1], " ", rs.fmtSpec({ precision: 0 }, args102[0]), " ", rs.fmtSpec({ precision: 1 }, args102[0]), " ", rs.fmtSpec({ precision: 3 }, args102[0]), " ", rs.fmtSpec({ precision: 45 }, args102[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args102[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args102[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args102[0]), "| ", rs.fmtSpec({ alternate: true }, args102[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args102[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u32Display(v3, f))); + put(out, rs.fmtFormat([args102[0], " ", args102[1], " ", rs.fmtSpec({ precision: 0 }, args102[0]), " ", rs.fmtSpec({ precision: 1 }, args102[0]), " ", rs.fmtSpec({ precision: 3 }, args102[0]), " ", rs.fmtSpec({ precision: 45 }, args102[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args102[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args102[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args102[0]), "| ", rs.fmtSpec({ alternate: true }, args102[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args102[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u32Display(v3, f), 0).v); } else if (_4 === 3) { const buf4: Uint8Array = rs.bytes(8); const n4: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf4).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf4), 0, n4), rs.byteSliceRange(data, 0, n4)); const v4: rs.u64 = rs.u64FromBeBytes(buf4); const args97 = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64UpperHex(v4, f)]; - put(out, rs.fmtFormat([args97[0], " ", args97[1], " ", rs.fmtSpec({ width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args97[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args97[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args97[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args97[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args97[0]), "|", args97[2], " ", args97[3], " ", rs.fmtSpec({ alternate: true }, args97[2]), " ", rs.fmtSpec({ alternate: true }, args97[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args97[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args97[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args97[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args97[3]), "|", rs.fmtSpec({ alternate: true }, args97[1]), " ", rs.fmtSpec({ width: 3 }, args97[1])])); + put(out, rs.fmtFormat([args97[0], " ", args97[1], " ", rs.fmtSpec({ width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args97[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args97[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args97[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args97[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args97[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args97[0]), "|", args97[2], " ", args97[3], " ", rs.fmtSpec({ alternate: true }, args97[2]), " ", rs.fmtSpec({ alternate: true }, args97[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args97[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args97[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args97[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args97[3]), "|", rs.fmtSpec({ alternate: true }, args97[1]), " ", rs.fmtSpec({ width: 3 }, args97[1])]).v); const args98 = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64Binary(v4, f), (f: rs.Formatter) => rs.u64Octal(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args98[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args98[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args98[1]), " ", args98[0], " ", rs.fmtSpec({ precision: 3 }, args98[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args98[0]), "|", args98[2], " ", rs.fmtSpec({ alternate: true }, args98[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args98[2]), " ", args98[3], " ", rs.fmtSpec({ alternate: true }, args98[3]), " ", rs.fmtSpec({ plus: true }, args98[3]), "|", rs.fmtSpec({ debugHex: "x" }, args98[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args98[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args98[4]), " ", rs.fmtSpec({ plus: true }, args98[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args98[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args98[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args98[1]), " ", args98[0], " ", rs.fmtSpec({ precision: 3 }, args98[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args98[0]), "|", args98[2], " ", rs.fmtSpec({ alternate: true }, args98[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args98[2]), " ", args98[3], " ", rs.fmtSpec({ alternate: true }, args98[3]), " ", rs.fmtSpec({ plus: true }, args98[3]), "|", rs.fmtSpec({ debugHex: "x" }, args98[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args98[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args98[4]), " ", rs.fmtSpec({ plus: true }, args98[4])]).v); const args99 = [(f: rs.Formatter) => rs.u64LowerExp(v4, f), (f: rs.Formatter) => rs.u64UpperExp(v4, f)]; - put(out, rs.fmtFormat([args99[0], " ", args99[1], " ", rs.fmtSpec({ precision: 0 }, args99[0]), " ", rs.fmtSpec({ precision: 1 }, args99[0]), " ", rs.fmtSpec({ precision: 3 }, args99[0]), " ", rs.fmtSpec({ precision: 45 }, args99[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args99[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args99[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args99[0]), "| ", rs.fmtSpec({ alternate: true }, args99[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args99[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u64Display(v4, f))); + put(out, rs.fmtFormat([args99[0], " ", args99[1], " ", rs.fmtSpec({ precision: 0 }, args99[0]), " ", rs.fmtSpec({ precision: 1 }, args99[0]), " ", rs.fmtSpec({ precision: 3 }, args99[0]), " ", rs.fmtSpec({ precision: 45 }, args99[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args99[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args99[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args99[0]), "| ", rs.fmtSpec({ alternate: true }, args99[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args99[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u64Display(v4, f), 0).v); } else if (_4 === 4) { const buf5: Uint8Array = rs.bytes(16); const n5: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf5).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf5), 0, n5), rs.byteSliceRange(data, 0, n5)); const v5: rs.u128 = rs.u128FromBeBytes(buf5); const args94 = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128UpperHex(v5, f)]; - put(out, rs.fmtFormat([args94[0], " ", args94[1], " ", rs.fmtSpec({ width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args94[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args94[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args94[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args94[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args94[0]), "|", args94[2], " ", args94[3], " ", rs.fmtSpec({ alternate: true }, args94[2]), " ", rs.fmtSpec({ alternate: true }, args94[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args94[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args94[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args94[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args94[3]), "|", rs.fmtSpec({ alternate: true }, args94[1]), " ", rs.fmtSpec({ width: 3 }, args94[1])])); + put(out, rs.fmtFormat([args94[0], " ", args94[1], " ", rs.fmtSpec({ width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args94[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args94[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args94[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args94[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args94[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args94[0]), "|", args94[2], " ", args94[3], " ", rs.fmtSpec({ alternate: true }, args94[2]), " ", rs.fmtSpec({ alternate: true }, args94[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args94[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args94[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args94[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args94[3]), "|", rs.fmtSpec({ alternate: true }, args94[1]), " ", rs.fmtSpec({ width: 3 }, args94[1])]).v); const args95 = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128Binary(v5, f), (f: rs.Formatter) => rs.u128Octal(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args95[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args95[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args95[1]), " ", args95[0], " ", rs.fmtSpec({ precision: 3 }, args95[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args95[0]), "|", args95[2], " ", rs.fmtSpec({ alternate: true }, args95[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args95[2]), " ", args95[3], " ", rs.fmtSpec({ alternate: true }, args95[3]), " ", rs.fmtSpec({ plus: true }, args95[3]), "|", rs.fmtSpec({ debugHex: "x" }, args95[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args95[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args95[4]), " ", rs.fmtSpec({ plus: true }, args95[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args95[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args95[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args95[1]), " ", args95[0], " ", rs.fmtSpec({ precision: 3 }, args95[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args95[0]), "|", args95[2], " ", rs.fmtSpec({ alternate: true }, args95[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args95[2]), " ", args95[3], " ", rs.fmtSpec({ alternate: true }, args95[3]), " ", rs.fmtSpec({ plus: true }, args95[3]), "|", rs.fmtSpec({ debugHex: "x" }, args95[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args95[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args95[4]), " ", rs.fmtSpec({ plus: true }, args95[4])]).v); const args96 = [(f: rs.Formatter) => rs.u128LowerExp(v5, f), (f: rs.Formatter) => rs.u128UpperExp(v5, f)]; - put(out, rs.fmtFormat([args96[0], " ", args96[1], " ", rs.fmtSpec({ precision: 0 }, args96[0]), " ", rs.fmtSpec({ precision: 1 }, args96[0]), " ", rs.fmtSpec({ precision: 3 }, args96[0]), " ", rs.fmtSpec({ precision: 45 }, args96[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args96[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args96[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args96[0]), "| ", rs.fmtSpec({ alternate: true }, args96[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args96[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u128Display(v5, f))); + put(out, rs.fmtFormat([args96[0], " ", args96[1], " ", rs.fmtSpec({ precision: 0 }, args96[0]), " ", rs.fmtSpec({ precision: 1 }, args96[0]), " ", rs.fmtSpec({ precision: 3 }, args96[0]), " ", rs.fmtSpec({ precision: 45 }, args96[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args96[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args96[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args96[0]), "| ", rs.fmtSpec({ alternate: true }, args96[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args96[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u128Display(v5, f), 0).v); } else if (_4 === 5) { const buf6: Uint8Array = rs.bytes(4); const n6: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf6).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf6), 0, n6), rs.byteSliceRange(data, 0, n6)); const v6: rs.usize = rs.usizeFromBeBytes(buf6); const args91 = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeUpperHex(v6, f)]; - put(out, rs.fmtFormat([args91[0], " ", args91[1], " ", rs.fmtSpec({ width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args91[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args91[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args91[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args91[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args91[0]), "|", args91[2], " ", args91[3], " ", rs.fmtSpec({ alternate: true }, args91[2]), " ", rs.fmtSpec({ alternate: true }, args91[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args91[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args91[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args91[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args91[3]), "|", rs.fmtSpec({ alternate: true }, args91[1]), " ", rs.fmtSpec({ width: 3 }, args91[1])])); + put(out, rs.fmtFormat([args91[0], " ", args91[1], " ", rs.fmtSpec({ width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args91[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args91[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args91[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args91[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args91[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args91[0]), "|", args91[2], " ", args91[3], " ", rs.fmtSpec({ alternate: true }, args91[2]), " ", rs.fmtSpec({ alternate: true }, args91[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args91[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args91[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args91[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args91[3]), "|", rs.fmtSpec({ alternate: true }, args91[1]), " ", rs.fmtSpec({ width: 3 }, args91[1])]).v); const args92 = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeBinary(v6, f), (f: rs.Formatter) => rs.usizeOctal(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args92[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args92[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args92[1]), " ", args92[0], " ", rs.fmtSpec({ precision: 3 }, args92[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args92[0]), "|", args92[2], " ", rs.fmtSpec({ alternate: true }, args92[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args92[2]), " ", args92[3], " ", rs.fmtSpec({ alternate: true }, args92[3]), " ", rs.fmtSpec({ plus: true }, args92[3]), "|", rs.fmtSpec({ debugHex: "x" }, args92[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args92[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args92[4]), " ", rs.fmtSpec({ plus: true }, args92[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args92[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args92[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args92[1]), " ", args92[0], " ", rs.fmtSpec({ precision: 3 }, args92[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args92[0]), "|", args92[2], " ", rs.fmtSpec({ alternate: true }, args92[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args92[2]), " ", args92[3], " ", rs.fmtSpec({ alternate: true }, args92[3]), " ", rs.fmtSpec({ plus: true }, args92[3]), "|", rs.fmtSpec({ debugHex: "x" }, args92[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args92[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args92[4]), " ", rs.fmtSpec({ plus: true }, args92[4])]).v); const args93 = [(f: rs.Formatter) => rs.usizeLowerExp(v6, f), (f: rs.Formatter) => rs.usizeUpperExp(v6, f)]; - put(out, rs.fmtFormat([args93[0], " ", args93[1], " ", rs.fmtSpec({ precision: 0 }, args93[0]), " ", rs.fmtSpec({ precision: 1 }, args93[0]), " ", rs.fmtSpec({ precision: 3 }, args93[0]), " ", rs.fmtSpec({ precision: 45 }, args93[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args93[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args93[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args93[0]), "| ", rs.fmtSpec({ alternate: true }, args93[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args93[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v6, f))); + put(out, rs.fmtFormat([args93[0], " ", args93[1], " ", rs.fmtSpec({ precision: 0 }, args93[0]), " ", rs.fmtSpec({ precision: 1 }, args93[0]), " ", rs.fmtSpec({ precision: 3 }, args93[0]), " ", rs.fmtSpec({ precision: 45 }, args93[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args93[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args93[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args93[0]), "| ", rs.fmtSpec({ alternate: true }, args93[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args93[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v6, f), 0).v); } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); const n7: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf7).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf7), 0, n7), rs.byteSliceRange(data, 0, n7)); const v7: rs.i8 = rs.i8FromBeBytes(buf7); const args88 = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8UpperHex(v7, f)]; - put(out, rs.fmtFormat([args88[0], " ", args88[1], " ", rs.fmtSpec({ width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args88[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args88[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args88[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args88[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args88[0]), "|", args88[2], " ", args88[3], " ", rs.fmtSpec({ alternate: true }, args88[2]), " ", rs.fmtSpec({ alternate: true }, args88[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args88[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args88[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args88[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args88[3]), "|", rs.fmtSpec({ alternate: true }, args88[1]), " ", rs.fmtSpec({ width: 3 }, args88[1])])); + put(out, rs.fmtFormat([args88[0], " ", args88[1], " ", rs.fmtSpec({ width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args88[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args88[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args88[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args88[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args88[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args88[0]), "|", args88[2], " ", args88[3], " ", rs.fmtSpec({ alternate: true }, args88[2]), " ", rs.fmtSpec({ alternate: true }, args88[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args88[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args88[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args88[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args88[3]), "|", rs.fmtSpec({ alternate: true }, args88[1]), " ", rs.fmtSpec({ width: 3 }, args88[1])]).v); const args89 = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8Binary(v7, f), (f: rs.Formatter) => rs.i8Octal(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args89[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args89[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args89[1]), " ", args89[0], " ", rs.fmtSpec({ precision: 3 }, args89[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args89[0]), "|", args89[2], " ", rs.fmtSpec({ alternate: true }, args89[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args89[2]), " ", args89[3], " ", rs.fmtSpec({ alternate: true }, args89[3]), " ", rs.fmtSpec({ plus: true }, args89[3]), "|", rs.fmtSpec({ debugHex: "x" }, args89[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args89[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args89[4]), " ", rs.fmtSpec({ plus: true }, args89[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args89[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args89[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args89[1]), " ", args89[0], " ", rs.fmtSpec({ precision: 3 }, args89[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args89[0]), "|", args89[2], " ", rs.fmtSpec({ alternate: true }, args89[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args89[2]), " ", args89[3], " ", rs.fmtSpec({ alternate: true }, args89[3]), " ", rs.fmtSpec({ plus: true }, args89[3]), "|", rs.fmtSpec({ debugHex: "x" }, args89[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args89[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args89[4]), " ", rs.fmtSpec({ plus: true }, args89[4])]).v); const args90 = [(f: rs.Formatter) => rs.i8LowerExp(v7, f), (f: rs.Formatter) => rs.i8UpperExp(v7, f)]; - put(out, rs.fmtFormat([args90[0], " ", args90[1], " ", rs.fmtSpec({ precision: 0 }, args90[0]), " ", rs.fmtSpec({ precision: 1 }, args90[0]), " ", rs.fmtSpec({ precision: 3 }, args90[0]), " ", rs.fmtSpec({ precision: 45 }, args90[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args90[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args90[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args90[0]), "| ", rs.fmtSpec({ alternate: true }, args90[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args90[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i8Display(v7, f))); + put(out, rs.fmtFormat([args90[0], " ", args90[1], " ", rs.fmtSpec({ precision: 0 }, args90[0]), " ", rs.fmtSpec({ precision: 1 }, args90[0]), " ", rs.fmtSpec({ precision: 3 }, args90[0]), " ", rs.fmtSpec({ precision: 45 }, args90[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args90[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args90[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args90[0]), "| ", rs.fmtSpec({ alternate: true }, args90[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args90[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i8Display(v7, f), 3).v); } else if (_4 === 7) { const buf8: Uint8Array = rs.bytes(2); const n8: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf8).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf8), 0, n8), rs.byteSliceRange(data, 0, n8)); const v8: rs.i16 = rs.i16FromBeBytes(buf8); const args85 = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16UpperHex(v8, f)]; - put(out, rs.fmtFormat([args85[0], " ", args85[1], " ", rs.fmtSpec({ width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args85[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args85[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args85[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args85[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args85[0]), "|", args85[2], " ", args85[3], " ", rs.fmtSpec({ alternate: true }, args85[2]), " ", rs.fmtSpec({ alternate: true }, args85[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args85[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args85[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args85[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args85[3]), "|", rs.fmtSpec({ alternate: true }, args85[1]), " ", rs.fmtSpec({ width: 3 }, args85[1])])); + put(out, rs.fmtFormat([args85[0], " ", args85[1], " ", rs.fmtSpec({ width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args85[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args85[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args85[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args85[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args85[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args85[0]), "|", args85[2], " ", args85[3], " ", rs.fmtSpec({ alternate: true }, args85[2]), " ", rs.fmtSpec({ alternate: true }, args85[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args85[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args85[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args85[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args85[3]), "|", rs.fmtSpec({ alternate: true }, args85[1]), " ", rs.fmtSpec({ width: 3 }, args85[1])]).v); const args86 = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16Binary(v8, f), (f: rs.Formatter) => rs.i16Octal(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args86[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args86[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args86[1]), " ", args86[0], " ", rs.fmtSpec({ precision: 3 }, args86[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args86[0]), "|", args86[2], " ", rs.fmtSpec({ alternate: true }, args86[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args86[2]), " ", args86[3], " ", rs.fmtSpec({ alternate: true }, args86[3]), " ", rs.fmtSpec({ plus: true }, args86[3]), "|", rs.fmtSpec({ debugHex: "x" }, args86[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args86[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args86[4]), " ", rs.fmtSpec({ plus: true }, args86[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args86[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args86[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args86[1]), " ", args86[0], " ", rs.fmtSpec({ precision: 3 }, args86[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args86[0]), "|", args86[2], " ", rs.fmtSpec({ alternate: true }, args86[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args86[2]), " ", args86[3], " ", rs.fmtSpec({ alternate: true }, args86[3]), " ", rs.fmtSpec({ plus: true }, args86[3]), "|", rs.fmtSpec({ debugHex: "x" }, args86[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args86[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args86[4]), " ", rs.fmtSpec({ plus: true }, args86[4])]).v); const args87 = [(f: rs.Formatter) => rs.i16LowerExp(v8, f), (f: rs.Formatter) => rs.i16UpperExp(v8, f)]; - put(out, rs.fmtFormat([args87[0], " ", args87[1], " ", rs.fmtSpec({ precision: 0 }, args87[0]), " ", rs.fmtSpec({ precision: 1 }, args87[0]), " ", rs.fmtSpec({ precision: 3 }, args87[0]), " ", rs.fmtSpec({ precision: 45 }, args87[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args87[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args87[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args87[0]), "| ", rs.fmtSpec({ alternate: true }, args87[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args87[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i16Display(v8, f))); + put(out, rs.fmtFormat([args87[0], " ", args87[1], " ", rs.fmtSpec({ precision: 0 }, args87[0]), " ", rs.fmtSpec({ precision: 1 }, args87[0]), " ", rs.fmtSpec({ precision: 3 }, args87[0]), " ", rs.fmtSpec({ precision: 45 }, args87[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args87[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args87[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args87[0]), "| ", rs.fmtSpec({ alternate: true }, args87[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args87[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i16Display(v8, f), 5).v); } else if (_4 === 8) { const buf9: Uint8Array = rs.bytes(4); const n9: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf9).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf9), 0, n9), rs.byteSliceRange(data, 0, n9)); const v9: rs.i32 = rs.i32FromBeBytes(buf9); const args82 = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32UpperHex(v9, f)]; - put(out, rs.fmtFormat([args82[0], " ", args82[1], " ", rs.fmtSpec({ width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args82[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args82[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args82[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args82[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args82[0]), "|", args82[2], " ", args82[3], " ", rs.fmtSpec({ alternate: true }, args82[2]), " ", rs.fmtSpec({ alternate: true }, args82[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args82[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args82[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args82[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args82[3]), "|", rs.fmtSpec({ alternate: true }, args82[1]), " ", rs.fmtSpec({ width: 3 }, args82[1])])); + put(out, rs.fmtFormat([args82[0], " ", args82[1], " ", rs.fmtSpec({ width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args82[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args82[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args82[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args82[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args82[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args82[0]), "|", args82[2], " ", args82[3], " ", rs.fmtSpec({ alternate: true }, args82[2]), " ", rs.fmtSpec({ alternate: true }, args82[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args82[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args82[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args82[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args82[3]), "|", rs.fmtSpec({ alternate: true }, args82[1]), " ", rs.fmtSpec({ width: 3 }, args82[1])]).v); const args83 = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32Binary(v9, f), (f: rs.Formatter) => rs.i32Octal(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args83[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args83[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args83[1]), " ", args83[0], " ", rs.fmtSpec({ precision: 3 }, args83[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args83[0]), "|", args83[2], " ", rs.fmtSpec({ alternate: true }, args83[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args83[2]), " ", args83[3], " ", rs.fmtSpec({ alternate: true }, args83[3]), " ", rs.fmtSpec({ plus: true }, args83[3]), "|", rs.fmtSpec({ debugHex: "x" }, args83[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args83[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args83[4]), " ", rs.fmtSpec({ plus: true }, args83[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args83[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args83[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args83[1]), " ", args83[0], " ", rs.fmtSpec({ precision: 3 }, args83[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args83[0]), "|", args83[2], " ", rs.fmtSpec({ alternate: true }, args83[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args83[2]), " ", args83[3], " ", rs.fmtSpec({ alternate: true }, args83[3]), " ", rs.fmtSpec({ plus: true }, args83[3]), "|", rs.fmtSpec({ debugHex: "x" }, args83[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args83[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args83[4]), " ", rs.fmtSpec({ plus: true }, args83[4])]).v); const args84 = [(f: rs.Formatter) => rs.i32LowerExp(v9, f), (f: rs.Formatter) => rs.i32UpperExp(v9, f)]; - put(out, rs.fmtFormat([args84[0], " ", args84[1], " ", rs.fmtSpec({ precision: 0 }, args84[0]), " ", rs.fmtSpec({ precision: 1 }, args84[0]), " ", rs.fmtSpec({ precision: 3 }, args84[0]), " ", rs.fmtSpec({ precision: 45 }, args84[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args84[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args84[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args84[0]), "| ", rs.fmtSpec({ alternate: true }, args84[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args84[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i32Display(v9, f))); + put(out, rs.fmtFormat([args84[0], " ", args84[1], " ", rs.fmtSpec({ precision: 0 }, args84[0]), " ", rs.fmtSpec({ precision: 1 }, args84[0]), " ", rs.fmtSpec({ precision: 3 }, args84[0]), " ", rs.fmtSpec({ precision: 45 }, args84[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args84[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args84[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args84[0]), "| ", rs.fmtSpec({ alternate: true }, args84[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args84[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i32Display(v9, f), 10).v); } else if (_4 === 9) { const buf10: Uint8Array = rs.bytes(8); const n10: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf10).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf10), 0, n10), rs.byteSliceRange(data, 0, n10)); const v10: rs.i64 = rs.i64FromBeBytes(buf10); const args79 = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64UpperHex(v10, f)]; - put(out, rs.fmtFormat([args79[0], " ", args79[1], " ", rs.fmtSpec({ width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args79[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args79[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args79[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args79[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args79[0]), "|", args79[2], " ", args79[3], " ", rs.fmtSpec({ alternate: true }, args79[2]), " ", rs.fmtSpec({ alternate: true }, args79[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args79[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args79[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args79[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args79[3]), "|", rs.fmtSpec({ alternate: true }, args79[1]), " ", rs.fmtSpec({ width: 3 }, args79[1])])); + put(out, rs.fmtFormat([args79[0], " ", args79[1], " ", rs.fmtSpec({ width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args79[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args79[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args79[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args79[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args79[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args79[0]), "|", args79[2], " ", args79[3], " ", rs.fmtSpec({ alternate: true }, args79[2]), " ", rs.fmtSpec({ alternate: true }, args79[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args79[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args79[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args79[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args79[3]), "|", rs.fmtSpec({ alternate: true }, args79[1]), " ", rs.fmtSpec({ width: 3 }, args79[1])]).v); const args80 = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64Binary(v10, f), (f: rs.Formatter) => rs.i64Octal(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args80[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args80[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args80[1]), " ", args80[0], " ", rs.fmtSpec({ precision: 3 }, args80[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args80[0]), "|", args80[2], " ", rs.fmtSpec({ alternate: true }, args80[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args80[2]), " ", args80[3], " ", rs.fmtSpec({ alternate: true }, args80[3]), " ", rs.fmtSpec({ plus: true }, args80[3]), "|", rs.fmtSpec({ debugHex: "x" }, args80[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args80[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args80[4]), " ", rs.fmtSpec({ plus: true }, args80[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args80[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args80[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args80[1]), " ", args80[0], " ", rs.fmtSpec({ precision: 3 }, args80[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args80[0]), "|", args80[2], " ", rs.fmtSpec({ alternate: true }, args80[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args80[2]), " ", args80[3], " ", rs.fmtSpec({ alternate: true }, args80[3]), " ", rs.fmtSpec({ plus: true }, args80[3]), "|", rs.fmtSpec({ debugHex: "x" }, args80[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args80[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args80[4]), " ", rs.fmtSpec({ plus: true }, args80[4])]).v); const args81 = [(f: rs.Formatter) => rs.i64LowerExp(v10, f), (f: rs.Formatter) => rs.i64UpperExp(v10, f)]; - put(out, rs.fmtFormat([args81[0], " ", args81[1], " ", rs.fmtSpec({ precision: 0 }, args81[0]), " ", rs.fmtSpec({ precision: 1 }, args81[0]), " ", rs.fmtSpec({ precision: 3 }, args81[0]), " ", rs.fmtSpec({ precision: 45 }, args81[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args81[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args81[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args81[0]), "| ", rs.fmtSpec({ alternate: true }, args81[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args81[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i64Display(v10, f))); + put(out, rs.fmtFormat([args81[0], " ", args81[1], " ", rs.fmtSpec({ precision: 0 }, args81[0]), " ", rs.fmtSpec({ precision: 1 }, args81[0]), " ", rs.fmtSpec({ precision: 3 }, args81[0]), " ", rs.fmtSpec({ precision: 45 }, args81[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args81[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args81[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args81[0]), "| ", rs.fmtSpec({ alternate: true }, args81[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args81[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i64Display(v10, f), 19).v); } else if (_4 === 10) { const buf11: Uint8Array = rs.bytes(16); const n11: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf11).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf11), 0, n11), rs.byteSliceRange(data, 0, n11)); const v11: rs.i128 = rs.i128FromBeBytes(buf11); const args76 = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128UpperHex(v11, f)]; - put(out, rs.fmtFormat([args76[0], " ", args76[1], " ", rs.fmtSpec({ width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args76[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args76[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args76[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args76[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args76[0]), "|", args76[2], " ", args76[3], " ", rs.fmtSpec({ alternate: true }, args76[2]), " ", rs.fmtSpec({ alternate: true }, args76[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args76[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args76[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args76[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args76[3]), "|", rs.fmtSpec({ alternate: true }, args76[1]), " ", rs.fmtSpec({ width: 3 }, args76[1])])); + put(out, rs.fmtFormat([args76[0], " ", args76[1], " ", rs.fmtSpec({ width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args76[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args76[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args76[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args76[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args76[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args76[0]), "|", args76[2], " ", args76[3], " ", rs.fmtSpec({ alternate: true }, args76[2]), " ", rs.fmtSpec({ alternate: true }, args76[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args76[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args76[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args76[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args76[3]), "|", rs.fmtSpec({ alternate: true }, args76[1]), " ", rs.fmtSpec({ width: 3 }, args76[1])]).v); const args77 = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128Binary(v11, f), (f: rs.Formatter) => rs.i128Octal(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args77[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args77[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args77[1]), " ", args77[0], " ", rs.fmtSpec({ precision: 3 }, args77[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args77[0]), "|", args77[2], " ", rs.fmtSpec({ alternate: true }, args77[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args77[2]), " ", args77[3], " ", rs.fmtSpec({ alternate: true }, args77[3]), " ", rs.fmtSpec({ plus: true }, args77[3]), "|", rs.fmtSpec({ debugHex: "x" }, args77[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args77[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args77[4]), " ", rs.fmtSpec({ plus: true }, args77[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args77[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args77[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args77[1]), " ", args77[0], " ", rs.fmtSpec({ precision: 3 }, args77[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args77[0]), "|", args77[2], " ", rs.fmtSpec({ alternate: true }, args77[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args77[2]), " ", args77[3], " ", rs.fmtSpec({ alternate: true }, args77[3]), " ", rs.fmtSpec({ plus: true }, args77[3]), "|", rs.fmtSpec({ debugHex: "x" }, args77[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args77[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args77[4]), " ", rs.fmtSpec({ plus: true }, args77[4])]).v); const args78 = [(f: rs.Formatter) => rs.i128LowerExp(v11, f), (f: rs.Formatter) => rs.i128UpperExp(v11, f)]; - put(out, rs.fmtFormat([args78[0], " ", args78[1], " ", rs.fmtSpec({ precision: 0 }, args78[0]), " ", rs.fmtSpec({ precision: 1 }, args78[0]), " ", rs.fmtSpec({ precision: 3 }, args78[0]), " ", rs.fmtSpec({ precision: 45 }, args78[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args78[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args78[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args78[0]), "| ", rs.fmtSpec({ alternate: true }, args78[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args78[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.i128Display(v11, f))); + put(out, rs.fmtFormat([args78[0], " ", args78[1], " ", rs.fmtSpec({ precision: 0 }, args78[0]), " ", rs.fmtSpec({ precision: 1 }, args78[0]), " ", rs.fmtSpec({ precision: 3 }, args78[0]), " ", rs.fmtSpec({ precision: 45 }, args78[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args78[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args78[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args78[0]), "| ", rs.fmtSpec({ alternate: true }, args78[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args78[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i128Display(v11, f), 39).v); } else { const buf12: Uint8Array = rs.bytes(4); const n12: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf12).length); rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf12), 0, n12), rs.byteSliceRange(data, 0, n12)); const v12: rs.isize = rs.isizeFromBeBytes(buf12); const args73 = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeUpperHex(v12, f)]; - put(out, rs.fmtFormat([args73[0], " ", args73[1], " ", rs.fmtSpec({ width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args73[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args73[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args73[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args73[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args73[0]), "|", args73[2], " ", args73[3], " ", rs.fmtSpec({ alternate: true }, args73[2]), " ", rs.fmtSpec({ alternate: true }, args73[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args73[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args73[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args73[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args73[3]), "|", rs.fmtSpec({ alternate: true }, args73[1]), " ", rs.fmtSpec({ width: 3 }, args73[1])])); + put(out, rs.fmtFormat([args73[0], " ", args73[1], " ", rs.fmtSpec({ width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args73[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args73[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args73[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args73[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args73[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args73[0]), "|", args73[2], " ", args73[3], " ", rs.fmtSpec({ alternate: true }, args73[2]), " ", rs.fmtSpec({ alternate: true }, args73[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args73[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args73[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args73[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args73[3]), "|", rs.fmtSpec({ alternate: true }, args73[1]), " ", rs.fmtSpec({ width: 3 }, args73[1])]).v); const args74 = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeBinary(v12, f), (f: rs.Formatter) => rs.isizeOctal(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args74[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args74[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args74[1]), " ", args74[0], " ", rs.fmtSpec({ precision: 3 }, args74[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args74[0]), "|", args74[2], " ", rs.fmtSpec({ alternate: true }, args74[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args74[2]), " ", args74[3], " ", rs.fmtSpec({ alternate: true }, args74[3]), " ", rs.fmtSpec({ plus: true }, args74[3]), "|", rs.fmtSpec({ debugHex: "x" }, args74[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args74[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args74[4]), " ", rs.fmtSpec({ plus: true }, args74[4])])); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args74[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args74[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args74[1]), " ", args74[0], " ", rs.fmtSpec({ precision: 3 }, args74[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args74[0]), "|", args74[2], " ", rs.fmtSpec({ alternate: true }, args74[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args74[2]), " ", args74[3], " ", rs.fmtSpec({ alternate: true }, args74[3]), " ", rs.fmtSpec({ plus: true }, args74[3]), "|", rs.fmtSpec({ debugHex: "x" }, args74[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args74[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args74[4]), " ", rs.fmtSpec({ plus: true }, args74[4])]).v); const args75 = [(f: rs.Formatter) => rs.isizeLowerExp(v12, f), (f: rs.Formatter) => rs.isizeUpperExp(v12, f)]; - put(out, rs.fmtFormat([args75[0], " ", args75[1], " ", rs.fmtSpec({ precision: 0 }, args75[0]), " ", rs.fmtSpec({ precision: 1 }, args75[0]), " ", rs.fmtSpec({ precision: 3 }, args75[0]), " ", rs.fmtSpec({ precision: 45 }, args75[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args75[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args75[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args75[0]), "| ", rs.fmtSpec({ alternate: true }, args75[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args75[1]), "|"])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v12, f))); + put(out, rs.fmtFormat([args75[0], " ", args75[1], " ", rs.fmtSpec({ precision: 0 }, args75[0]), " ", rs.fmtSpec({ precision: 1 }, args75[0]), " ", rs.fmtSpec({ precision: 3 }, args75[0]), " ", rs.fmtSpec({ precision: 45 }, args75[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args75[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args75[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args75[0]), "| ", rs.fmtSpec({ alternate: true }, args75[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args75[1]), "|"]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v12, f), 10).v); } } @@ -195,22 +195,22 @@ export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_15]; const args17 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args17[0], "|", rs.fmtSpec({ width: 8 }, args17[0]), "|", rs.fmtSpec({ align: ">", width: 8 }, args17[0]), "|", rs.fmtSpec({ align: "^", width: 8 }, args17[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args17[0]), "|", args17[1], "|", rs.fmtSpec({ width: 12 }, args17[1]), "|", rs.fmtSpec({ alternate: true }, args17[1]), "|{", args17[0], "}"])); + put(out, rs.fmtFormat([args17[0], "|", rs.fmtSpec({ width: 8 }, args17[0]), "|", rs.fmtSpec({ align: ">", width: 8 }, args17[0]), "|", rs.fmtSpec({ align: "^", width: 8 }, args17[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args17[0]), "|", args17[1], "|", rs.fmtSpec({ width: 12 }, args17[1]), "|", rs.fmtSpec({ alternate: true }, args17[1]), "|{", args17[0], "}"]).v); const args18 = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 2 }, args18[0]), "|", rs.fmtSpec({ width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: 6, precision: 1 }, args18[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args18[0]), "|", rs.fmtSpec({ precision: 0 }, args18[0]), "|", rs.fmtSpec({ precision: 20 }, args18[0]), "|", rs.fmtSpec({ precision: 2 }, args18[1]), "|", rs.fmtSpec({ width: 10, precision: 2 }, args18[1]), "|", rs.fmtSpec({ plus: true }, args18[0])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 2 }, args18[0]), "|", rs.fmtSpec({ width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: 6, precision: 1 }, args18[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args18[0]), "|", rs.fmtSpec({ precision: 0 }, args18[0]), "|", rs.fmtSpec({ precision: 20 }, args18[0]), "|", rs.fmtSpec({ precision: 2 }, args18[1]), "|", rs.fmtSpec({ width: 10, precision: 2 }, args18[1]), "|", rs.fmtSpec({ plus: true }, args18[0])]).v); } const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.u32, 257)), 63); const args19 = [(f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f)]; - put(out, rs.fmtFormat([args19[0], "|", rs.fmtSpec({ precision: 0 }, args19[0]), "|", rs.fmtSpec({ width: 3, precision: 1 }, args19[0]), "|", rs.fmtSpec({ precision: 0 }, args19[1]), "|", rs.fmtSpec({ align: ">", width: 4 }, args19[1])])); - const _70: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); + put(out, rs.fmtFormat([args19[0], "|", rs.fmtSpec({ precision: 0 }, args19[0]), "|", rs.fmtSpec({ width: 3, precision: 1 }, args19[0]), "|", rs.fmtSpec({ precision: 0 }, args19[1]), "|", rs.fmtSpec({ align: ">", width: 4 }, args19[1])]).v); + const _70: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_70.ok) { - const s2: string = _70.value; - const args21 = [(f: rs.Formatter) => rs.fmtStr(s2, f), (f: rs.Formatter) => rs.fmtPad(f, s2)]; - put(out, rs.fmtFormat([args21[0], " ", rs.fmtSpec({ align: ">", width: 4 }, args21[1]), " ", rs.fmtSpec({ precision: 1 }, args21[1])])); + const s2: rs.String = _70.value; + const args21 = [(f: rs.Formatter) => rs.fmtStr(s2.v, f), (f: rs.Formatter) => rs.fmtPad(f, s2.v)]; + put(out, rs.fmtFormat([args21[0], " ", rs.fmtSpec({ align: ">", width: 4 }, args21[1]), " ", rs.fmtSpec({ precision: 1 }, args21[1])]).v); } else { const e: rs.FromUtf8Error = _70.error; const args20 = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(e, f)]; - put(out, rs.fmtFormat([args20[0], " ", args20[1], " ", rs.fmtSpec({ alternate: true }, args20[1]), " ", rs.fmtSpec({ align: ">", width: 80 }, args20[0]), " ", rs.fmtSpec({ precision: 4 }, args20[0]), " ", rs.fmtSpec({ debugHex: "x" }, args20[1]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args20[1])])); + put(out, rs.fmtFormat([args20[0], " ", args20[1], " ", rs.fmtSpec({ alternate: true }, args20[1]), " ", rs.fmtSpec({ align: ">", width: 80 }, args20[0]), " ", rs.fmtSpec({ precision: 4 }, args20[0]), " ", rs.fmtSpec({ debugHex: "x" }, args20[1]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args20[1])]).v); } const _100: rs.u8 | undefined = rs.byteSliceFirst(data); b3: { @@ -223,24 +223,24 @@ export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { flag = false; } const args22 = [(f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; - put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ align: ">", width: 6 }, args22[0]), " ", rs.fmtSpec({ precision: 2 }, args22[0]), " ", rs.fmtSpec({ align: ">", width: 4, precision: 1 }, args22[1]), " ", args22[2], " ", rs.fmtSpec({ alternate: true }, args22[3]), " ", rs.fmtSpec({ precision: 1 }, args22[4])])); + put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ align: ">", width: 6 }, args22[0]), " ", rs.fmtSpec({ precision: 2 }, args22[0]), " ", rs.fmtSpec({ align: ">", width: 4, precision: 1 }, args22[1]), " ", args22[2], " ", rs.fmtSpec({ alternate: true }, args22[3]), " ", rs.fmtSpec({ precision: 1 }, args22[4])]).v); const _130: boolean = flag; - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_130, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_130, f), 0).v); const _131: rs.Result = rs.u8TryFrom(rs.i32Sub(data.length | 0, 3)); if (_131.ok) { const arg = _131.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg, f)]).v); } else { const e2: rs.TryFromIntError = _131.error; const args23 = [(f: rs.Formatter) => rs.fmtTryFromIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtTryFromIntErrorDebug(e2, f)]; - put(out, rs.fmtFormat([args23[0], " ", args23[1], " ", rs.fmtSpec({ align: ">", width: 40 }, args23[0]), "| ", rs.fmtSpec({ precision: 6 }, args23[0]), "|", rs.fmtSpec({ width: 10, precision: 3 }, args23[0]), "|"])); + put(out, rs.fmtFormat([args23[0], " ", args23[1], " ", rs.fmtSpec({ align: ">", width: 40 }, args23[0]), "| ", rs.fmtSpec({ precision: 6 }, args23[0]), "|", rs.fmtSpec({ width: 10, precision: 3 }, args23[0]), "|"]).v); } } export function nested(data: rs.ByteSlice): Nested.Nested { let _22!: Shape.Shape; let _49!: Pair.Pair | undefined; - let _61!: rs.Result; + let _61!: rs.Result; let _90!: Kind.Kind; const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); @@ -249,7 +249,7 @@ export function nested(data: rs.ByteSlice): Nested.Nested { if (!(_5 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); } - const _3: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_5]; + const _3: rs.String = rs.stringFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_5]); const _15: Point.Point = { x: rs.i32Sub(at(1) as rs.i32, 128), y: -7 }; const _23: rs.u8 = rs.u8Rem(at(2), 3); if (_23 === 0) { @@ -268,7 +268,7 @@ export function nested(data: rs.ByteSlice): Nested.Nested { } const _60: rs.u8 | undefined = undefined; if (!(rs.u8Rem(at(6), 2) === 0)) { - _61 = rs.Err("no"); + _61 = rs.Err(rs.stringFrom("no")); } else { _61 = rs.Ok(at(6)); } @@ -293,43 +293,43 @@ export function derived(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; const value: Nested.Nested = nested(data); - put(out, rs.fmtFormat([(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true, debugHex: "X" }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); - put(out, rs.fmtFormat([rs.fmtSpec({ plus: true, precision: 1 }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true, debugHex: "X" }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true, precision: 1 }, (f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f))]).v); const wide: fmt_Wide.Wide = { a: at(0), b: 300, c: 70000, d: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, e: -1, f: at(1) > 10 }; const six: Six.Six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; const _87: Unit.Unit = {}; const _88: Unit.Unit = {}; const args30 = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_88, f)]; - put(out, rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " ", rs.fmtSpec({ alternate: true }, args30[3])])); + put(out, rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " ", rs.fmtSpec({ alternate: true }, args30[3])]).v); const args31 = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args31[0]), " ", rs.fmtSpec({ alternate: true }, args31[1])])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args31[0]), " ", rs.fmtSpec({ alternate: true }, args31[1])]).v); const point: Point.Point = { x: at(2) as rs.i32, y: -1 }; const _125: Pair.Pair = { _0: at(3), _1: -9 }; const args32 = [(f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_125, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args32[0]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args32[1])])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args32[0]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args32[1])]).v); const kinds: Kind.Kind[] = [{ tag: "Empty" } as Kind.Kind, { tag: "One", _0: at(4) } as Kind.Kind, { tag: "Braced" } as Kind.Kind, { tag: "Bare" } as Kind.Kind, { tag: "Many", count: 0, items: new rs.ByteVec() } as Kind.Kind]; const _154: Kind.Kind = kinds[1]; [_154, rs.sliceFrom(kinds)] as [Kind.Kind, rs.Slice]; const arg = rs.sliceFrom(kinds); const args33 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => Kind.fmt$fmt_Debug(_154, f)]; - put(out, rs.fmtFormat([args33[0], " ", args33[1]])); + put(out, rs.fmtFormat([args33[0], " ", args33[1]]).v); const arg2 = rs.sliceFrom(kinds); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg2), f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)))]).v); const words: rs.u16[] = [at(5) as rs.u16, 65535]; const _189: rs.u8 | undefined = rs.byteSliceFirst(data); const _191: rs.u8 | undefined = rs.byteSliceGet(data, 100); const _193: rs.Slice = rs.sliceFrom(words); const args35 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(data), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_193), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(_189, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_191, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", args35[3]])); + put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", args35[3]]).v); const _208: Braced.Braced = {}; const _209: Braced.Braced = {}; const _210: Bare.Bare = {}; const _211: Bare.Bare = {}; const args36 = [(f: rs.Formatter) => Braced.fmt$fmt_Debug(_208, f), (f: rs.Formatter) => Braced.fmt$fmt_Debug(_209, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_210, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_211, f)]; - put(out, rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[1]), " ", args36[2], " ", rs.fmtSpec({ alternate: true }, args36[3])])); + put(out, rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[1]), " ", args36[2], " ", rs.fmtSpec({ alternate: true }, args36[3])]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(Braced.eq$cmp_PartialEq({}, {}) ? 1 : 0, Bare.eq$cmp_PartialEq({}, {}) ? 1 : 0))); } @@ -340,7 +340,7 @@ export function note(log: rs.ByteVec, v: rs.u8): rs.u8 { } /** Arguments that read `log` before and after one changes it, through a reference. */ -export function logged(log: rs.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): string { +export function logged(log: rs.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): rs.String { const _7: rs.usize = log.length; if (0 >= dataLen) { rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + 0); @@ -364,21 +364,21 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { }; const hex: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; const args27 = [(f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f)]; - put(out, rs.fmtFormat([args27[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args27[0]), "|", rs.fmtSpec({ alternate: true }, args27[0]), "|", args27[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args27[1]), "|", rs.fmtSpec({ alternate: true }, args27[1])])); + put(out, rs.fmtFormat([args27[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args27[0]), "|", rs.fmtSpec({ alternate: true }, args27[0]), "|", args27[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args27[1]), "|", rs.fmtSpec({ alternate: true }, args27[1])]).v); const args28 = [(f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Binary(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Octal(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_LowerExp(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_UpperExp(hex, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args28[0]), "|", rs.fmtSpec({ alternate: true }, args28[1]), "|", rs.fmtSpec({ align: ">", width: 8 }, args28[2]), "|", rs.fmtSpec({ precision: 2 }, args28[3]), "|", args28[4], "|", rs.fmtSpec({ plus: true, precision: 1 }, args28[0])])); - put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f))); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args28[0]), "|", rs.fmtSpec({ alternate: true }, args28[1]), "|", rs.fmtSpec({ align: ">", width: 8 }, args28[2]), "|", rs.fmtSpec({ precision: 2 }, args28[3]), "|", args28[4], "|", rs.fmtSpec({ plus: true, precision: 1 }, args28[0])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f)).v); const arg = { _0: "pad" }; const args29 = [(f: rs.Formatter) => Padded.fmt$fmt_Display(arg, f)]; - put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args29[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 9 }, args29[0]), "|", rs.fmtSpec({ width: 30 }, args29[0]), "|"])); + put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args29[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 9 }, args29[0]), "|", rs.fmtSpec({ width: 30 }, args29[0]), "|"]).v); const manual: Manual.Manual = { id: at(1), list: rs.vecFrom([1, at(2) as rs.u16].slice()) }; const empty: Manual.Manual = { id: 0, list: new rs.Vec() }; const args30 = [(f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(empty, f)]; - put(out, rs.fmtFormat([args30[0], " ", rs.fmtSpec({ alternate: true }, args30[0]), " ", args30[1]])); + put(out, rs.fmtFormat([args30[0], " ", rs.fmtSpec({ alternate: true }, args30[0]), " ", args30[1]]).v); const seq: Seq.Seq = { _0: rs.vecFrom([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice()) }; const none: Seq.Seq = { _0: new rs.Vec() }; const args31 = [(f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(none, f)]; - put(out, rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", args31[1], " ", rs.fmtSpec({ alternate: true }, args31[1])])); + put(out, rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", args31[1], " ", rs.fmtSpec({ alternate: true }, args31[1])]).v); const _113: rs.u8 = at(4); if (!(rs.u8Rem(at(5), 2) === 0)) { _116 = undefined; @@ -387,14 +387,14 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { } const arg2 = { _0: _113, _1: _116 }; const args32 = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(arg2, f)]; - put(out, rs.fmtFormat([args32[0], " ", rs.fmtSpec({ alternate: true }, args32[0])])); + put(out, rs.fmtFormat([args32[0], " ", rs.fmtSpec({ alternate: true }, args32[0])]).v); const part = { _0: at(6) & (~1 & 0xff) }; const args33 = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part, f)]; - put(out, rs.fmtFormat([args33[0], " ", rs.fmtSpec({ align: ">", width: 9 }, args33[0])])); + put(out, rs.fmtFormat([args33[0], " ", rs.fmtSpec({ align: ">", width: 9 }, args33[0])]).v); const _164: rs.u8 = at(7); const _168: rs.u8 = at(8); const args34 = [(f: rs.Formatter) => rs.u8Display(_168, f), (f: rs.Formatter) => rs.u8Display(_164, f), (f: rs.Formatter) => rs.u8Debug(_164, f), (f: rs.Formatter) => rs.fmtPad(f, "named")]; - put(out, rs.fmtFormat([args34[0], " ", args34[1], " ", args34[2], " named ", rs.fmtSpec({ align: ">", width: 5 }, args34[3])])); + put(out, rs.fmtFormat([args34[0], " ", args34[1], " ", args34[2], " named ", rs.fmtSpec({ align: ">", width: 5 }, args34[3])]).v); const log: rs.ByteVec = new rs.ByteVec(); const _187: rs.u8 = at(9); const _185: rs.u8 = note(log, _187); @@ -402,20 +402,20 @@ export function written(data: rs.ByteSlice, out: rs.ByteVec): void { const _191: boolean = note(log, _194) === 3; const _198: rs.usize = log.length; const args35 = [(f: rs.Formatter) => rs.fmtBool(_191, f), (f: rs.Formatter) => rs.u8Display(_185, f), (f: rs.Formatter) => rs.u8Debug(_185, f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; - put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", args35[3], " ", args35[1]])); + put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", args35[3], " ", args35[1]]).v); const _218: Noted.Noted = { _0: at(11) }; const _222: Noted.Noted = { _0: 2 }; const args36 = [(f: rs.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rs.Formatter) => Noted.fmt$fmt_Display(_222, f)]; - put(out, rs.fmtFormat([args36[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args36[1])])); + put(out, rs.fmtFormat([args36[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args36[1])]).v); if (!(data.length === 0)) { - put(out, logged(log, data.data, data.start, data.length)); + put(out, logged(log, data.data, data.start, data.length).v); } const _241: rs.u8 = at(13); const part2 = note(log, _241); - const once: string = rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(part2, f)]); + const once: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(part2, f)]); const _257: rs.usize = log.length; - const args38 = [(f: rs.Formatter) => rs.fmtPad(f, once), (f: rs.Formatter) => rs.usizeDisplay(_257, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1]])); + const args38 = [(f: rs.Formatter) => rs.fmtPad(f, once.v), (f: rs.Formatter) => rs.usizeDisplay(_257, f)]; + put(out, rs.fmtFormat([args38[0], " ", args38[1]]).v); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); if (at(12) > 250) { const _277: rs.u8 = at(12); @@ -448,17 +448,17 @@ export function counts(data: rs.ByteSlice, out: rs.ByteVec): void { } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_39]; const args7 = [(f: rs.Formatter) => rs.i64Display(v, f), rs.fmtCount(w), (f: rs.Formatter) => rs.i64LowerExp(v, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(p), (f: rs.Formatter) => rs.usizeDisplay(w, f), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: rs.fmtCountOf(args7[1]) }, args7[0]), "|", rs.fmtSpec({ align: "<", width: rs.fmtCountOf(args7[1]) }, args7[2]), "|", rs.fmtSpec({ plus: true, zero: true, width: rs.fmtCountOf(args7[1]), precision: rs.fmtCountOf(args7[3]) }, args7[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args7[3]) }, args7[4]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args7[1]), precision: rs.fmtCountOf(args7[3]) }, args7[4]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args7[6]) }, args7[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args7[6]) }, args7[7]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args7[8]), precision: rs.fmtCountOf(args7[6]) }, args7[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args7[3]) }, args7[9])])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: rs.fmtCountOf(args7[1]) }, args7[0]), "|", rs.fmtSpec({ align: "<", width: rs.fmtCountOf(args7[1]) }, args7[2]), "|", rs.fmtSpec({ plus: true, zero: true, width: rs.fmtCountOf(args7[1]), precision: rs.fmtCountOf(args7[3]) }, args7[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args7[3]) }, args7[4]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args7[1]), precision: rs.fmtCountOf(args7[3]) }, args7[4]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args7[6]) }, args7[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args7[6]) }, args7[7]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args7[8]), precision: rs.fmtCountOf(args7[6]) }, args7[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args7[3]) }, args7[9])]).v); const log: rs.ByteVec = new rs.ByteVec(); const _87: rs.u8 = at(4); const _85: rs.u8 = note(log, _87); const _91: rs.usize = note(log, 6) as rs.usize; const args8 = [(f: rs.Formatter) => rs.u8Display(_85, f), rs.fmtCount(_91), (f: rs.Formatter) => rs.fmtPad(f, s)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args8[1]) }, args8[0]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args8[1]) }, args8[2])])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args8[1]) }, args8[0]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args8[1]) }, args8[2])]).v); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); const big: rs.usize = rs.usizeAdd(65535 as rs.usize, rs.u8Rem(at(5), 2) as rs.usize); const args9 = [(f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(big)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args9[1]) }, args9[0]), "|"])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args9[1]) }, args9[0]), "|"]).v); } /** `{:e}` at each rounding: below, above, and ties to even, which may carry a digit. */ @@ -470,10 +470,10 @@ export function rounding(out: rs.ByteVec): void { break; } const args5 = [(f: rs.Formatter) => rs.u32LowerExp(_5, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args5[0]), " ", rs.fmtSpec({ precision: 1 }, args5[0]), " ", rs.fmtSpec({ precision: 2 }, args5[0]), " ", args5[0]])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args5[0]), " ", rs.fmtSpec({ precision: 1 }, args5[0]), " ", rs.fmtSpec({ precision: 2 }, args5[0]), " ", args5[0]]).v); } const args6 = [(f: rs.Formatter) => rs.u128LowerExp({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, f), (f: rs.Formatter) => rs.i128LowerExp({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, f), (f: rs.Formatter) => rs.i64UpperExp({ hi: -0x80000000, lo: 0 } as rs.i64, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args6[0]), " ", args6[1], " ", rs.fmtSpec({ precision: 3 }, args6[2])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args6[0]), " ", args6[1], " ", rs.fmtSpec({ precision: 3 }, args6[2])]).v); } /** Panics, each with the message native Rust formats. */ @@ -523,7 +523,7 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { r = rs.Err({ tag: "Many", count: 1, items: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(n))) } as Kind.Kind); } const _100: rs.u8 = rs.resultUnwrap(r, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_100, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_100, f), 0).v); } else if (_7 === 8) { if (!(n > 128)) { r2 = rs.Err({ _0: n, _1: -2 }); @@ -531,19 +531,19 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { r2 = rs.Ok(n); } const _110: rs.u8 = rs.resultExpect(r2, "expected a byte", (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_110, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_110, f), 0).v); } else if (_7 === 9) { const _121: rs.u8 = rs.resultUnwrapErr(rs.Ok({ x: n as rs.i32, y: 0 }), (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f)); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_121, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_121, f), 0).v); } else if (_7 === 10) { - const _129: rs.u8 = rs.optionExpect(rs.byteSliceGet(rest, 200), rs.fmtFormat(["missing ", (f: rs.Formatter) => rs.u8Display(n, f)])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_129, f))); + const _129: rs.u8 = rs.optionExpect(rs.byteSliceGet(rest, 200), rs.fmtFormat(["missing ", (f: rs.Formatter) => rs.u8Display(n, f)]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_129, f), 0).v); } else if (_7 === 11) { const part3 = { _0: n }; - put(out, rs.fmtFormat([(f: rs.Formatter) => Fails.fmt$fmt_Display(part3, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => Fails.fmt$fmt_Display(part3, f)]).v); } else if (_7 === 12) { const _157: Fails.Fails = { _0: n }; - put(out, rs.fmtToString((f: rs.Formatter) => Fails.fmt$fmt_Display(_157, f))); + put(out, rs.fmtToString((f: rs.Formatter) => Fails.fmt$fmt_Display(_157, f)).v); } else if (_7 === 13) { const _162: Hex.Hex = { _0: n as rs.u32 }; const _165: Fails.Fails = { _0: n }; @@ -556,21 +556,21 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { const _189: rs.ByteSlice = rs.byteSliceRange(rest, start); const _193: rs.ByteSlice = rs.byteSliceRange(rest, start, end); const args26 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_189), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_193), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args26[0], " ", args26[1]])); + put(out, rs.fmtFormat([args26[0], " ", args26[1]]).v); } else if (_7 === 15) { const buf: Uint8Array = rs.bytes(3); rs.byteSliceCopyFromSlice(rs.byteSliceFrom(buf), rs.byteSliceRange(rest, 0, rs.min(rest.length, 4))); const arg3 = rs.byteSliceFrom(buf); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg3), f, rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg3), f, rs.u8Debug)]).v); } else if (_7 === 16) { - const _221: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rest)); + const _221: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rest)); if (_221.ok) { - r4 = rs.Ok(rs.stringLen(_221.value) & 0xff); + r4 = rs.Ok(_221.value.len & 0xff); } else { r4 = _221 as rs.Result; } const _234: rs.u8 = rs.resultUnwrap(r4, rs.fmtFromUtf8ErrorDebug); - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_234, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_234, f), 0).v); } else if (_7 === 17) { const buf2: Uint8Array = Uint8Array.of(1, 2, 3, 4); const dest: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(rest, 1), 0) as rs.usize, 4); @@ -578,12 +578,12 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { const _246: rs.Range = new rs.Range(rs.u8Rem(n, 6) as rs.usize, rs.u8Rem(rs.u8Div(n, 6), 6) as rs.usize); rs.byteSliceCopyWithin(_244, _246.start, _246.end, dest); const arg2 = rs.byteSliceFrom(buf2); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]).v); } else if (_7 === 18) { const _271: rs.usize = rs.u8Rem(n, 8) as rs.usize; rs.idx(rest, _271); const arg = rest.data[rest.start + _271]; - put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f), 0).v); } else { if (!(rs.u8Rem(n, 2) === 0)) { r5 = rs.Ok(n); @@ -591,7 +591,7 @@ export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { r5 = rs.Err(n); } const part = rs.resultUnwrapErr(r5, rs.u8Debug); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(part, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(part, f)]).v); } } @@ -613,7 +613,7 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _39: { end: rs.i32 } = { end: b }; const _41: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; const args27 = [(f: rs.Formatter) => rs.fmtRange(_33, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_35, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_37, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_39, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_41, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f)]; - put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2], " ", args27[3], " ", args27[4], " ", args27[5]])); + put(out, rs.fmtFormat([args27[0], " ", args27[1], " ", args27[2], " ", args27[3], " ", args27[4], " ", args27[5]]).v); const _60: rs.Range = new rs.Range(a, b); const _62: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); const _72: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); @@ -624,7 +624,7 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _74: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; const _77: rs.Range = new rs.Range(a, b); const args28 = [(f: rs.Formatter) => rs.fmtRange(_60, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_62, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_64, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_66, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_68, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRange(_70, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_72, f, rs.i32Debug), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_74, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f), (f: rs.Formatter) => rs.fmtRange(_77, f, rs.i32Debug)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args28[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args28[1]), "|", rs.fmtSpec({ plus: true }, args28[2]), "|", rs.fmtSpec({ zero: true, width: 5 }, args28[3]), "|", rs.fmtSpec({ debugHex: "x" }, args28[4]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args28[5]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args28[7]) }, args28[6]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args28[7]) }, args28[8]), "|", rs.fmtSpec({ align: ">", width: 3 }, args28[9]), "|", rs.fmtSpec({ alternate: true }, args28[10])])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args28[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args28[1]), "|", rs.fmtSpec({ plus: true }, args28[2]), "|", rs.fmtSpec({ zero: true, width: 5 }, args28[3]), "|", rs.fmtSpec({ debugHex: "x" }, args28[4]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args28[5]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args28[7]) }, args28[6]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args28[7]) }, args28[8]), "|", rs.fmtSpec({ align: ">", width: 3 }, args28[9]), "|", rs.fmtSpec({ alternate: true }, args28[10])]).v); const _96: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_96 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _96); @@ -641,7 +641,7 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _133: rs.RangeFrom = new rs.RangeFrom(lo); const _135: { end: Clip.Clip; inclusive: true } = { end: lo, inclusive: true }; const args29 = [(f: rs.Formatter) => rs.fmtRange(_127, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_129, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_131, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeFrom(_133, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_135, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ width: 8, precision: 2 }, args29[1]), "|", rs.fmtSpec({ alternate: true }, args29[2]), "|", rs.fmtSpec({ fill: "_", align: ">", width: rs.fmtCountOf(args29[4]), precision: 1 }, args29[3]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args29[5])])); + put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ width: 8, precision: 2 }, args29[1]), "|", rs.fmtSpec({ alternate: true }, args29[2]), "|", rs.fmtSpec({ fill: "_", align: ">", width: rs.fmtCountOf(args29[4]), precision: 1 }, args29[3]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args29[5])]).v); const _148: [rs.u32, rs.u32] = [rs.u32Mul(at(5) as rs.u32, 257), at(6) as rs.u32]; const x: rs.u32 = _148[0]; const y: rs.u32 = _148[1]; @@ -649,10 +649,10 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { const _171: rs.RangeInclusive = new rs.RangeInclusive({ _0: x }, { _0: y }); const _175: { end: Hex.Hex } = { end: { _0: y } }; const args30 = [(f: rs.Formatter) => rs.fmtRange(_167, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_171, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_175, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ align: ">", width: 9 }, args30[1]), "|", rs.fmtSpec({ alternate: true }, args30[2])])); + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ align: ">", width: 9 }, args30[1]), "|", rs.fmtSpec({ alternate: true }, args30[2])]).v); const part3 = new rs.Range({ _0: at(7), _1: -1 }, { _0: 1, _1: { hi: -0x80000000, lo: 0 } as rs.i64 }); const args31 = [(f: rs.Formatter) => rs.fmtRange(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args31[0], "|", rs.fmtSpec({ alternate: true }, args31[0]), "|", rs.fmtSpec({ debugHex: "x" }, args31[0]), "|", rs.fmtSpec({ plus: true }, args31[0])])); + put(out, rs.fmtFormat([args31[0], "|", rs.fmtSpec({ alternate: true }, args31[0]), "|", rs.fmtSpec({ debugHex: "x" }, args31[0]), "|", rs.fmtSpec({ plus: true }, args31[0])]).v); const drained: rs.RangeInclusive = new rs.RangeInclusive(rs.u8Rem(at(8), 4), rs.u8Rem(at(9), 4), rs.u8Step); while (rs.iterToOption(drained.next()) !== undefined) { } @@ -667,40 +667,40 @@ export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterNth(far, _244); const _257: rs.RangeInclusive = new rs.RangeInclusive(0, 0, rs.i32Step); const args32 = [(f: rs.Formatter) => rs.fmtRangeInclusive(drained, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(top, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(back, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(far, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_257, f, rs.i32Debug)]; - put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " ", args32[3], " ", args32[4]])); + put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " ", args32[3], " ", args32[4]]).v); const arc: rs.Arc = new rs.Arc({ _0: x }); const args33 = [(f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(arc.value, f)]; - put(out, rs.fmtFormat([args33[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args33[0]), "|", rs.fmtSpec({ alternate: true }, args33[0]), "|", args33[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args33[1]), "|", rs.fmtSpec({ alternate: true }, args33[1])])); - put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f))); + put(out, rs.fmtFormat([args33[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args33[0]), "|", rs.fmtSpec({ alternate: true }, args33[0]), "|", args33[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args33[1]), "|", rs.fmtSpec({ alternate: true }, args33[1])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f)).v); const nested: rs.Arc> = new rs.Arc(new rs.Arc(a)); const args34 = [(f: rs.Formatter) => rs.i32Display(nested.value.value, f), (f: rs.Formatter) => rs.i32Debug(nested.value.value, f), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ plus: true, zero: true, width: 5 }, args34[0]), "|", args34[1], "|", rs.fmtSpec({ debugHex: "x" }, args34[1]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args34[1]), "|", rs.fmtSpec({ align: "<", width: 6 }, args34[1]), "|", rs.fmtSpec({ align: "^", plus: true, width: rs.fmtCountOf(args34[2]) }, args34[0])])); + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ plus: true, zero: true, width: 5 }, args34[0]), "|", args34[1], "|", rs.fmtSpec({ debugHex: "x" }, args34[1]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args34[1]), "|", rs.fmtSpec({ align: "<", width: 6 }, args34[1]), "|", rs.fmtSpec({ align: "^", plus: true, width: rs.fmtCountOf(args34[2]) }, args34[0])]).v); const _310: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_310 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _310); } - const rc: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310]); - const args35 = [(f: rs.Formatter) => rs.fmtPad(f, rc.value), (f: rs.Formatter) => rs.fmtStr(rc.value, f)]; - put(out, rs.fmtFormat([args35[0], "|", rs.fmtSpec({ align: ">", width: 8, precision: 2 }, args35[0]), "|", args35[1]])); + const rc: rs.Arc = new rs.Arc(rs.stringFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310])); + const args35 = [(f: rs.Formatter) => rs.fmtPad(f, rc.value.v), (f: rs.Formatter) => rs.fmtStr(rc.value.v, f)]; + put(out, rs.fmtFormat([args35[0], "|", rs.fmtSpec({ align: ">", width: 8, precision: 2 }, args35[0]), "|", args35[1]]).v); const list: rs.Arc> = new rs.Arc(rs.vecFrom([{ _0: at(7), _1: 2 }, { _0: 3, _1: -4 }].slice())); const args36 = [(f: rs.Formatter) => rs.fmtList(list.value.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0])])); + put(out, rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0])]).v); const held: rs.Range> = new rs.Range(new rs.Arc(a), new rs.Arc(b)); const _366: rs.Range> = new rs.Range(new rs.Arc(lo), new rs.Arc(hi)); const args37 = [(f: rs.Formatter) => rs.fmtRange(held, f, (value: rs.Arc, f: rs.Formatter) => rs.i32Debug(value.value, f)), (f: rs.Formatter) => rs.fmtRange(_366, f, (value: rs.Arc, f: rs.Formatter) => Clip.fmt$fmt_Debug(value.value, f))]; - const _362: string = rs.fmtFormat([args37[0], " ", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args37[0]), " ", args37[1]]); + const _362: rs.String = rs.fmtFormat([args37[0], " ", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args37[0]), " ", args37[1]]); rs.dropAll([_366.start, _366.end]); - put(out, _362); + put(out, _362.v); const shared: Shared.Shared = new Shared.Shared(new rs.Arc({ _0: at(7), _1: 5 }), new rs.Range(at(8) as rs.u16, 300), { end: at(9), inclusive: true }); const args38 = [(f: rs.Formatter) => Shared.fmt$fmt_Debug(shared, f)]; - put(out, rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0])])); + put(out, rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0])]).v); const _405: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_405 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _405); } const t: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_405]); const args39 = [(f: rs.Formatter) => rs.fmtPad(f, t.value), (f: rs.Formatter) => rs.fmtStr(t.value, f)]; - put(out, rs.fmtFormat([args39[0], " ", args39[1], " ", rs.fmtSpec({ align: ">", width: 9, precision: 2 }, args39[0])])); + put(out, rs.fmtFormat([args39[0], " ", args39[1], " ", rs.fmtSpec({ align: ">", width: 9, precision: 2 }, args39[0])]).v); t[Symbol.dispose](); shared[Symbol.dispose](); rs.dropAll([held.start, held.end]); @@ -735,7 +735,7 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { } } const args17 = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(q), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args17[0], "|", rs.fmtSpec({ alternate: true }, args17[0]), "|", rs.fmtSpec({ debugHex: "x" }, args17[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args17[0])])); + put(out, rs.fmtFormat([args17[0], "|", rs.fmtSpec({ alternate: true }, args17[0]), "|", rs.fmtSpec({ debugHex: "x" }, args17[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args17[0])]).v); const wrapped: rs.VecDeque = rs.dequeWithCapacity(4, 4) as rs.VecDeque; rs.dequeExtend(wrapped, rs.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, true); const _48: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; @@ -743,24 +743,24 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { const _57: Hex.Hex = { _0: at(1) as rs.u32 }; rs.dequePushFront(wrapped, _57); rs.dequePopBack(wrapped); - const mid: string = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]); + const mid: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]); rs.dequePopBack(wrapped); - const args19 = [(f: rs.Formatter) => rs.fmtPad(f, mid), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args19[0], "|", args19[1], "|", rs.fmtSpec({ alternate: true }, args19[1]), "|", rs.fmtSpec({ width: 6 }, args19[1])])); + const args19 = [(f: rs.Formatter) => rs.fmtPad(f, mid.v), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args19[0], "|", args19[1], "|", rs.fmtSpec({ alternate: true }, args19[1]), "|", rs.fmtSpec({ width: 6 }, args19[1])]).v); const empty: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; const units: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(2), 3)), (_2: rs.u8): undefined => {}), undefined, 0, true), 0) as rs.VecDeque; const args20 = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(units), f, rs.fmtUnit)]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0]), "|", args20[1]])); + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0]), "|", args20[1]]).v); const part = rs.dequeFromArray([rs.dequeNew(16) as rs.VecDeque, rs.dequeFromArray([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rs.VecDeque], 16) as rs.VecDeque>; const args21 = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(part), f, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args21[0], "|", rs.fmtSpec({ alternate: true }, args21[0])])); + put(out, rs.fmtFormat([args21[0], "|", rs.fmtSpec({ alternate: true }, args21[0])]).v); const _135: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.u8 | undefined => { const b5: rs.u8 = _25; return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, rs.u8Rem(b5, 8)); }); const part2 = rs.btreeExtendKeys(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, _135, true, undefined, undefined, 2, true); const args22 = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(part2), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args22[0])])); + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args22[0])]).v); const map: rs.BTreeMap> = rs.btreeNew(rs.cmp) as rs.BTreeMap>; const iter2: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); while (true) { @@ -776,7 +776,7 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { const _176: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const _178: rs.BTreeSet = rs.btreeNew(rs.cmp) as rs.BTreeSet; const args23 = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(_176), f, rs.u8Debug, rs.u8Debug), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(_178), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args23[0], "|", rs.fmtSpec({ alternate: true }, args23[0]), "|", args23[1], "|", rs.fmtSpec({ alternate: true }, args23[2])])); + put(out, rs.fmtFormat([args23[0], "|", rs.fmtSpec({ alternate: true }, args23[0]), "|", args23[1], "|", rs.fmtSpec({ alternate: true }, args23[2])]).v); const _188: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew() as rs.HashSet]; const one: rs.HashMap = _188[0]; const set: rs.HashSet = _188[1]; @@ -792,7 +792,7 @@ export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { rs.hashAdd(set, _202); } const args24 = [(f: rs.Formatter) => rs.fmtMap(rs.hashIter(one), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtSet(rs.hashKeys(set), f, rs.u8Debug)]; - put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args24[0]), "|", args24[1], "|", rs.fmtSpec({ alternate: true }, args24[1]), "|", rs.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args24[1])])); + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args24[0]), "|", args24[1], "|", rs.fmtSpec({ alternate: true }, args24[1]), "|", rs.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args24[1])]).v); } /** @@ -812,7 +812,7 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const w: rs.usize = rs.u8Rem(at(0), 10) as rs.usize; const n: rs.RangeBound = pick$enums_u8(at(1), at(2)); const args29 = [(f: rs.Formatter) => rs.fmtBound(n, f, rs.u8Debug), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ alternate: true }, args29[0]), "|", rs.fmtSpec({ debugHex: "x" }, args29[0]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args29[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args29[1]) }, args29[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7 }, args29[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args29[0])])); + put(out, rs.fmtFormat([args29[0], "|", rs.fmtSpec({ alternate: true }, args29[0]), "|", rs.fmtSpec({ debugHex: "x" }, args29[0]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args29[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args29[1]) }, args29[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7 }, args29[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args29[0])]).v); const _32: rs.u8 = at(3); const _37: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_37 < 14)) { @@ -820,16 +820,16 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { } const s: rs.RangeBound = pick$enums_ref_str(_32, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_37]); const args30 = [(f: rs.Formatter) => rs.fmtBound(s, f, rs.fmtStr), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args30[0]), "|", rs.fmtSpec({ fill: "*", align: "<", width: rs.fmtCountOf(args30[1]), precision: 2 }, args30[0])])); + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args30[0]), "|", rs.fmtSpec({ fill: "*", align: "<", width: rs.fmtCountOf(args30[1]), precision: 2 }, args30[0])]).v); const part = pick$enums_char(at(5), at(6) as rs.char); const args31 = [(f: rs.Formatter) => rs.fmtBound(part, f, rs.fmtCharDebug)]; - put(out, rs.fmtFormat([args31[0], "|", rs.fmtSpec({ alternate: true }, args31[0]), "|", rs.fmtSpec({ align: "^", width: 6 }, args31[0])])); + put(out, rs.fmtFormat([args31[0], "|", rs.fmtSpec({ alternate: true }, args31[0]), "|", rs.fmtSpec({ align: "^", width: 6 }, args31[0])]).v); const part2 = pick$enums_Option_u8(at(7), thenSome$0quywni(rs.u8Rem(at(8), 2) === 0, at(9))); const args32 = [(f: rs.Formatter) => rs.fmtBound(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args32[0], "|", rs.fmtSpec({ alternate: true }, args32[0]), "|", rs.fmtSpec({ debugHex: "x" }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args32[0])])); + put(out, rs.fmtFormat([args32[0], "|", rs.fmtSpec({ alternate: true }, args32[0]), "|", rs.fmtSpec({ debugHex: "x" }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args32[0])]).v); const part4 = pick$enums_ref_slice_u8(at(10), rs.byteSliceRange(data, 0, rs.min(data.length, 3))); const args33 = [(f: rs.Formatter) => rs.fmtBound(part4, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug))]; - put(out, rs.fmtFormat([args33[0], "|", rs.fmtSpec({ alternate: true }, args33[0]), "|", rs.fmtSpec({ debugHex: "x" }, args33[0]), "|", rs.fmtSpec({ width: 3 }, args33[0])])); + put(out, rs.fmtFormat([args33[0], "|", rs.fmtSpec({ alternate: true }, args33[0]), "|", rs.fmtSpec({ debugHex: "x" }, args33[0]), "|", rs.fmtSpec({ width: 3 }, args33[0])]).v); const _128: rs.u8 = at(11); const _134: rs.usize = rs.usizeRem(at(12) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_134 < 14)) { @@ -840,7 +840,7 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const _155: rs.RangeBound | undefined = clip; const _157: [rs.RangeBound, rs.RangeBound] = [n, s]; const args34 = [(f: rs.Formatter) => rs.fmtBound(_152, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(_155, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBound(_157[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_157[1], f, rs.fmtStr)], f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", rs.fmtSpec({ alternate: true }, args34[1]), "|", args34[2]])); + put(out, rs.fmtFormat([rs.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", rs.fmtSpec({ alternate: true }, args34[1]), "|", args34[2]]).v); const r: rs.RangeInclusive = new rs.RangeInclusive(at(1), at(2), rs.u8Step); const _179: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; const _182: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; @@ -849,11 +849,11 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { const _192: rs.RangeBound = { tag: "Excluded", _0: { end: at(2) }.end } as rs.RangeBound; const _199: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; const args35 = [(f: rs.Formatter) => rs.fmtBound(_179, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_182, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_185, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_192, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_199, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", rs.fmtSpec({ debugHex: "x" }, args35[3]), " ", rs.fmtSpec({ alternate: true }, args35[4])])); + put(out, rs.fmtFormat([args35[0], " ", args35[1], " ", args35[2], " ", rs.fmtSpec({ debugHex: "x" }, args35[3]), " ", rs.fmtSpec({ alternate: true }, args35[4])]).v); const ord: rs.Ordering = rs.cmp(at(1), at(2)); const _230: rs.Slice = rs.sliceFrom([-1, 0, 1]); const args36 = [(f: rs.Formatter) => rs.fmtOrdering(ord, f), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_230), f, rs.fmtOrdering)]; - put(out, rs.fmtFormat([args36[0], "|", rs.fmtSpec({ align: ">", width: 8 }, args36[0]), "|", rs.fmtSpec({ alternate: true }, args36[0]), "|", args36[1], "|", rs.fmtSpec({ alternate: true }, args36[1])])); + put(out, rs.fmtFormat([args36[0], "|", rs.fmtSpec({ align: ">", width: 8 }, args36[0]), "|", rs.fmtSpec({ alternate: true }, args36[0]), "|", args36[1], "|", rs.fmtSpec({ alternate: true }, args36[1])]).v); const rev: rs.u8 = at(1); const _244: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_244 < 14)) { @@ -861,7 +861,7 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { } const nested: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_244]; const args37 = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.u8Debug(rev, f)]), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtStr(nested, f)])])]; - put(out, rs.fmtFormat([args37[0], "|", rs.fmtSpec({ alternate: true }, args37[0]), "|", rs.fmtSpec({ debugHex: "x" }, args37[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args37[1]) }, args37[0]), "|", args37[2], "|", rs.fmtSpec({ alternate: true }, args37[2])])); + put(out, rs.fmtFormat([args37[0], "|", rs.fmtSpec({ alternate: true }, args37[0]), "|", rs.fmtSpec({ debugHex: "x" }, args37[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args37[1]) }, args37[0]), "|", args37[2], "|", rs.fmtSpec({ alternate: true }, args37[2])]).v); const _272: rs.usize = rs.usizeRem(at(4) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_272 < 14)) { rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _272); @@ -873,21 +873,21 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { flow = rs.Ok(rs.u16Mul(at(2) as rs.u16, 300)); } const args38 = [(f: rs.Formatter) => rs.fmtControlFlow(flow, f, rs.u16Debug, rs.fmtStr), rs.fmtCount(w)]; - put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0]), "|", rs.fmtSpec({ debugHex: "x" }, args38[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args38[1]) }, args38[0])])); + put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0]), "|", rs.fmtSpec({ debugHex: "x" }, args38[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args38[1]) }, args38[0])]).v); if (rs.u8Rem(at(1), 2) === 0) { unit = rs.Err(at(2)); } else { unit = rs.OK; } const args39 = [(f: rs.Formatter) => rs.fmtControlFlow(unit, f, rs.fmtUnit, rs.u8Debug)]; - put(out, rs.fmtFormat([args39[0], "|", rs.fmtSpec({ alternate: true }, args39[0]), "|", rs.fmtSpec({ zero: true, width: 3 }, args39[0])])); + put(out, rs.fmtFormat([args39[0], "|", rs.fmtSpec({ alternate: true }, args39[0]), "|", rs.fmtSpec({ zero: true, width: 3 }, args39[0])]).v); if (rs.u8Rem(at(1), 2) === 0) { erred = rs.Err(at(2)); } else { erred = rs.Ok(at(2) as rs.u16); } const args40 = [(f: rs.Formatter) => rs.fmtControlFlow(erred, f, rs.u16Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value), rs.u8Debug), true)]; - put(out, rs.fmtFormat([args40[0], "|", rs.fmtSpec({ alternate: true }, args40[0]), "|", rs.fmtSpec({ align: ">", width: 5 }, args40[0])])); + put(out, rs.fmtFormat([args40[0], "|", rs.fmtSpec({ alternate: true }, args40[0]), "|", rs.fmtSpec({ align: ">", width: 5 }, args40[0])]).v); if (rs.u8Rem(at(1), 2) === 0) { none = undefined; } else { @@ -899,10 +899,10 @@ export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { unitNone = undefined; } const args41 = [(f: rs.Formatter) => rs.fmtControlFlowOption(none, f, rs.u8Debug, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value))), (f: rs.Formatter) => rs.fmtControlFlowOption(unitNone, f, rs.fmtUnit, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value)), rs.None)]; - put(out, rs.fmtFormat([args41[0], "|", rs.fmtSpec({ alternate: true }, args41[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args41[0]), "|", args41[1], "|", rs.fmtSpec({ alternate: true }, args41[1])])); + put(out, rs.fmtFormat([args41[0], "|", rs.fmtSpec({ alternate: true }, args41[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args41[0]), "|", args41[1], "|", rs.fmtSpec({ alternate: true }, args41[1])]).v); const part5 = rs.Ok(at(2)); const args42 = [(f: rs.Formatter) => rs.fmtResult(part5, f, rs.u8Debug, (value: never, _f: rs.Formatter) => rs.unreachable(value))]; - put(out, rs.fmtFormat([args42[0], "|", rs.fmtSpec({ alternate: true }, args42[0])])); + put(out, rs.fmtFormat([args42[0], "|", rs.fmtSpec({ alternate: true }, args42[0])]).v); } export function pick$enums_Option_u8(by: rs.u8, x: rs.u8 | undefined): rs.RangeBound { @@ -985,29 +985,29 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const back: rs.usize = _6[1]; const part = ends$iters_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data)), front, back); const args81 = [(f: rs.Formatter) => rs.fmtIter(part, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args81[0], "|", rs.fmtSpec({ alternate: true }, args81[0]), "|", rs.fmtSpec({ debugHex: "x" }, args81[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args81[0])])); + put(out, rs.fmtFormat([args81[0], "|", rs.fmtSpec({ alternate: true }, args81[0]), "|", rs.fmtSpec({ debugHex: "x" }, args81[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args81[0])]).v); const part2 = ends$iters_slice_IterMut_u8(rs.iterSliceMut(rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), undefined, true))), front, back); const args82 = [(f: rs.Formatter) => rs.fmtIter(part2, f, rs.u8Debug, ["IterMut"])]; - put(out, rs.fmtFormat([args82[0], "|", rs.fmtSpec({ alternate: true }, args82[0])])); + put(out, rs.fmtFormat([args82[0], "|", rs.fmtSpec({ alternate: true }, args82[0])]).v); const part3 = ends$iters_vec_IntoIter_fmt_Pair(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Pair.Pair => { const b2: rs.u8 = _2; return { _0: b2, _1: rs.i64Neg(b2 as rs.i64) }; }), undefined, 16, true)), front, back); const args83 = [(f: rs.Formatter) => rs.fmtIter(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rs.fmtFormat([args83[0], "|", rs.fmtSpec({ alternate: true }, args83[0])])); + put(out, rs.fmtFormat([args83[0], "|", rs.fmtSpec({ alternate: true }, args83[0])]).v); const part4 = ends$iters_vec_IntoIter_u8(rs.byteVecIntoIter(rs.byteSliceToByteVec(data)), front, back); - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtIter(part4, f, rs.u8Debug, ["IntoIter"]))])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtIter(part4, f, rs.u8Debug, ["IntoIter"]))]).v); const it4: rs.Iter = ends$iters_vec_Drain_fmt_Hex(rs.vecDrain(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), (_23: rs.u8): Hex.Hex => { return { _0: rs.u32Mul(_23 as rs.u32, 257) }; }), undefined, 4, true), new rs.RangeFrom(1, rs.usizeStep)), front, back); const args85 = [(f: rs.Formatter) => rs.fmtIter(it4, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f), ["Drain"])]; - put(out, rs.fmtFormat([args85[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args85[0])])); + put(out, rs.fmtFormat([args85[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args85[0])]).v); rs.drop(it4); const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); const _111: { end: rs.usize } = { end: rs.usizeDiv(data.length, 2) }; const it5: rs.Iter = ends$iters_vec_Drain_u8(rs.byteVecDrain(bytes, _111), front, back); const args86 = [(f: rs.Formatter) => rs.fmtIter(it5, f, rs.u8Debug, ["Drain"])]; - put(out, rs.fmtFormat([args86[0], "|", rs.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args86[0])])); + put(out, rs.fmtFormat([args86[0], "|", rs.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args86[0])]).v); rs.drop(it5); const arrays: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); @@ -1017,47 +1017,48 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true); const part5 = ends$iters_slice_Iter_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), front, back); const args87 = [(f: rs.Formatter) => rs.fmtIter(part5, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"])]; - put(out, rs.fmtFormat([args87[0], "|", rs.fmtSpec({ alternate: true }, args87[0])])); + put(out, rs.fmtFormat([args87[0], "|", rs.fmtSpec({ alternate: true }, args87[0])]).v); const part6 = ends$iters_slice_IterMut_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), back, front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part6, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["IterMut"])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part6, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["IterMut"])]).v); const _174: rs.Iter = rs.iterSlice([]); const _176: rs.Iter = rs.byteVecIntoIter(new rs.ByteVec()); const args89 = [(f: rs.Formatter) => rs.fmtIter(_174, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["Iter"]), (f: rs.Formatter) => rs.fmtIter(_176, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args89[0], "|", rs.fmtSpec({ alternate: true }, args89[1])])); + put(out, rs.fmtFormat([args89[0], "|", rs.fmtSpec({ alternate: true }, args89[1])]).v); const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), rs.le, rs.ge, rs.lt); const part7 = ends$iters_collections_binary_heap_Iter_u8(rs.heapIter(heap), front, back); const args90 = [(f: rs.Formatter) => rs.fmtIter(part7, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); + put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])]).v); const part8 = ends$iters_collections_binary_heap_IntoIter_u8(rs.heapIter(rs.heapClone(heap, undefined)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part8, f, rs.u8Debug, ["IntoIter"])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part8, f, rs.u8Debug, ["IntoIter"])]).v); const it8: rs.Iter = ends$iters_collections_binary_heap_Drain_u8(rs.heapDrain(rs.heapClone(heap, undefined)), front, back); const args92 = [(f: rs.Formatter) => rs.fmtIter(it8, f, rs.u8Debug, [["Drain", "iter"], "Drain"])]; - put(out, rs.fmtFormat([args92[0], "|", rs.fmtSpec({ alternate: true }, args92[0])])); + put(out, rs.fmtFormat([args92[0], "|", rs.fmtSpec({ alternate: true }, args92[0])]).v); rs.drop(it8); const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rs.dequeIntoIter(rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.u8 | undefined => { const b4: rs.u8 = _27; return thenSome$0quywni(rs.u8Rem(b4, 3) !== 0, b4); }), undefined, 2, true), 2) as rs.VecDeque), front, back); const args93 = [(f: rs.Formatter) => rs.fmtIter(part9, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["IntoIter"])]; - put(out, rs.fmtFormat([args93[0], "|", rs.fmtSpec({ alternate: true }, args93[0])])); - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { + put(out, rs.fmtFormat([args93[0], "|", rs.fmtSpec({ alternate: true }, args93[0])]).v); + const _253: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { const _510: rs.usize = rs.u8Rem(_28, 6) as rs.usize; if (!(_510 < 6)) { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _510); } return [97, 233, 20013, 129408, 10, 39][_510]; - })); - const part10 = ends$iters_str_Chars(rs.strChars(text), front, back); + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _253); + const part10 = ends$iters_str_Chars(rs.strChars(text.v), front, back); const args94 = [(f: rs.Formatter) => rs.fmtChars(part10, f)]; - put(out, rs.fmtFormat([args94[0], "|", rs.fmtSpec({ alternate: true }, args94[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args94[0])])); - const part11 = ends$iters_str_Bytes(rs.strBytes(text), front, back); + put(out, rs.fmtFormat([args94[0], "|", rs.fmtSpec({ alternate: true }, args94[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args94[0])]).v); + const part11 = ends$iters_str_Bytes(rs.strBytes(text.v), front, back); const args95 = [(f: rs.Formatter) => rs.fmtIter(part11, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rs.fmtFormat([args95[0], "|", rs.fmtSpec({ alternate: true }, args95[0]), "|", rs.fmtSpec({ debugHex: "x" }, args95[0])])); + put(out, rs.fmtFormat([args95[0], "|", rs.fmtSpec({ alternate: true }, args95[0]), "|", rs.fmtSpec({ debugHex: "x" }, args95[0])]).v); const _295: rs.Iter = rs.strChars(""); const _298: rs.Iter = rs.strChars(""); const _301: rs.Iter = rs.strBytes(""); const args96 = [(f: rs.Formatter) => rs.fmtChars(_295, f), (f: rs.Formatter) => rs.fmtChars(_298, f), (f: rs.Formatter) => rs.fmtIter(_301, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rs.fmtFormat([args96[0], "|", rs.fmtSpec({ alternate: true }, args96[1]), "|", args96[2]])); + put(out, rs.fmtFormat([args96[0], "|", rs.fmtSpec({ alternate: true }, args96[1]), "|", args96[2]]).v); const _310: rs.Iter<[rs.u8, rs.u8 | undefined]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): [rs.u8, rs.u8 | undefined] => { const b6: rs.u8 = _29; return [rs.u8Rem(b6, 16), thenSome$0quywni(rs.u8Rem(b6, 3) !== 0, b6)] as [rs.u8, rs.u8 | undefined]; @@ -1065,28 +1066,28 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _310, true, undefined, undefined, undefined, 3, true); const part12 = ends$iters_collections_btree_map_Iter_u8_Option_u8(rs.btreeIter(map), front, back); const args97 = [(f: rs.Formatter) => rs.fmtIter(part12, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args97[0], "|", rs.fmtSpec({ alternate: true }, args97[0]), "|", rs.fmtSpec({ debugHex: "x" }, args97[0])])); + put(out, rs.fmtFormat([args97[0], "|", rs.fmtSpec({ alternate: true }, args97[0]), "|", rs.fmtSpec({ debugHex: "x" }, args97[0])]).v); const _335: rs.Iter = ends$iters_collections_btree_map_Keys_u8_Option_u8(rs.btreeKeys(map), front, back); const _339: rs.Iter = ends$iters_collections_btree_map_Values_u8_Option_u8(rs.btreeValues(map), front, back); const args98 = [(f: rs.Formatter) => rs.fmtIter(_335, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIter(_339, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args98[0], "|", args98[1]])); + put(out, rs.fmtFormat([args98[0], "|", args98[1]]).v); const lo: rs.u8 = rs.u8Rem(at(2), 16); const _360: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); const _365: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, { end: lo, inclusive: true }), front, back); const args99 = [(f: rs.Formatter) => rs.fmtIter(_360, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f)), (f: rs.Formatter) => rs.fmtIter(_365, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; - put(out, rs.fmtFormat([args99[0], "|", args99[1]])); + put(out, rs.fmtFormat([args99[0], "|", args99[1]]).v); const part13 = ends$iters_collections_btree_map_IterMut_u8_Option_u8(rs.btreeIterMut(map), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part13, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part13, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]).v); const part14 = ends$iters_collections_btree_map_ValuesMut_u8_Option_u8(rs.btreeValuesMut(map), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part14, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part14, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]).v); const part15 = ends$iters_collections_btree_map_RangeMut_u8_Option_u8(rs.btreeRangeMut(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part15, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part15, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]).v); const part16 = ends$iters_collections_btree_map_IntoIter_u8_Option_u8(rs.btreeIter(rs.btreeClone(map, undefined, undefined)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part16, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part16, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]).v); const part17 = ends$iters_collections_btree_map_IntoKeys_u8_Option_u8(rs.btreeKeys(rs.btreeClone(map, undefined, undefined)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part17, f, rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part17, f, rs.u8Debug)]).v); const part18 = ends$iters_collections_btree_map_IntoValues_u8_Option_u8(rs.btreeValues(map), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part18, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part18, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]).v); const _468: rs.Iter<[Uint8Array, Hex.Hex]> = rs.iterMap(rs.byteSliceChunksExact(data, 2), (c2: rs.ByteSlice): [Uint8Array, Hex.Hex] => { rs.idx(c2, 0); const _411: rs.u8 = c2.data[c2.start]; @@ -1101,27 +1102,27 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { }), front, back); const _481: rs.Iter = ends$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(rs.iterLend(rs.btreeKeys(keyed), rs.byteSliceFrom), back, front); const args106 = [(f: rs.Formatter) => rs.fmtIter(it13, f, (value: [Uint8Array, Hex.Hex], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.u8Debug), (f: rs.Formatter) => Hex.fmt$fmt_Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_481, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args106[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args106[0]), "|", args106[1]])); + put(out, rs.fmtFormat([args106[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args106[0]), "|", args106[1]]).v); const _491: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): rs.u8 => { return rs.u8Rem(_212, 16); }); const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _491, true, undefined, undefined, 1, true); const part19 = ends$iters_collections_btree_set_Iter_u8(rs.btreeKeys(set), front, back); const args107 = [(f: rs.Formatter) => rs.fmtIter(part19, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args107[0], "|", rs.fmtSpec({ alternate: true }, args107[0])])); + put(out, rs.fmtFormat([args107[0], "|", rs.fmtSpec({ alternate: true }, args107[0])]).v); const part20 = ends$iters_collections_btree_set_Range_u8(rs.btreeRangeKeys(set, new rs.RangeFrom(lo, rs.u8Step)), front, back); const args108 = [(f: rs.Formatter) => rs.fmtIter(part20, f, rs.fmtSetVal(rs.u8Debug), [["Range", "iter"]])]; - put(out, rs.fmtFormat([args108[0], "|", rs.fmtSpec({ alternate: true }, args108[0]), "|", rs.fmtSpec({ debugHex: "x" }, args108[0])])); + put(out, rs.fmtFormat([args108[0], "|", rs.fmtSpec({ alternate: true }, args108[0]), "|", rs.fmtSpec({ debugHex: "x" }, args108[0])]).v); const part21 = ends$iters_collections_btree_set_IntoIter_u8(rs.btreeKeys(set), front, back); const args109 = [(f: rs.Formatter) => rs.fmtIter(part21, f, rs.fmtSetVal(rs.u8Debug), [["IntoIter", "iter"]])]; - put(out, rs.fmtFormat([args109[0], "|", rs.fmtSpec({ alternate: true }, args109[0])])); + put(out, rs.fmtFormat([args109[0], "|", rs.fmtSpec({ alternate: true }, args109[0])]).v); const empty2: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const _547: rs.Iter<[rs.u8, rs.u8]> = rs.btreeIter(empty2); const _550: rs.Iter = rs.btreeKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet); const args110 = [(f: rs.Formatter) => rs.fmtIter(_547, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_550, f, rs.u8Debug, ["Iter"])]; - put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[1])])); + put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[1])]).v); const part22 = rs.btreeKeys(empty2); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part22, f, rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part22, f, rs.u8Debug)]).v); const _573: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet]; const one: rs.HashMap = _573[0]; const keys: rs.HashSet = _573[1]; @@ -1137,30 +1138,30 @@ export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { const _608: rs.Iter<[rs.u8 | undefined, rs.u16]> = rs.hashIter(one); const _611: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Iter_Option_u8_u16(rs.hashIter(one), n); const args112 = [(f: rs.Formatter) => rs.fmtIter(_608, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_611, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args112[0], "|", rs.fmtSpec({ alternate: true }, args112[1])])); + put(out, rs.fmtFormat([args112[0], "|", rs.fmtSpec({ alternate: true }, args112[1])]).v); const _627: rs.Iter = skip$iters_collections_hash_map_Keys_Option_u8_u16(rs.hashKeys(one), n); const _631: rs.Iter = skip$iters_collections_hash_map_Values_Option_u8_u16(rs.hashValues(one), n); const args113 = [(f: rs.Formatter) => rs.fmtIter(_627, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_631, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args113[0], "|", args113[1]])); + put(out, rs.fmtFormat([args113[0], "|", args113[1]]).v); const part23 = skip$iters_collections_hash_map_IterMut_Option_u8_u16(rs.hashIterMut(one), n); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part23, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part23, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]).v); const part24 = skip$iters_collections_hash_map_ValuesMut_Option_u8_u16(rs.hashValuesMut(one), rs.usizeSub(1, n)); - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtIter(part24, f, rs.u16Debug))])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtIter(part24, f, rs.u16Debug))]).v); const part25 = skip$iters_collections_hash_map_IntoIter_Option_u8_u16(rs.hashIter(rs.hashClone(one, undefined, undefined)), n); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part25, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part25, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]).v); const _695: rs.Iter = rs.hashKeys(rs.hashClone(one, undefined, undefined)); const _699: rs.Iter = skip$iters_collections_hash_map_IntoValues_Option_u8_u16(rs.hashValues(rs.hashClone(one, undefined, undefined)), n); const args117 = [(f: rs.Formatter) => rs.fmtIter(_695, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_699, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args117[0], "|", args117[1]])); + put(out, rs.fmtFormat([args117[0], "|", args117[1]]).v); const it17: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Drain_Option_u8_u16(rs.hashDrain(one), n); const args118 = [(f: rs.Formatter) => rs.fmtIter(it17, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; - put(out, rs.fmtFormat([args118[0], "|", rs.fmtSpec({ alternate: true }, args118[0])])); + put(out, rs.fmtFormat([args118[0], "|", rs.fmtSpec({ alternate: true }, args118[0])]).v); const _732: rs.Iter = skip$iters_collections_hash_set_Iter_array2_u8(rs.iterLend(rs.hashKeys(keys), rs.byteSliceFrom), n); const _736: rs.Iter = rs.hashKeys(rs.hashClone(keys, copy$array_u8, undefined)); const args119 = [(f: rs.Formatter) => rs.fmtIter(_732, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_736, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args119[0], "|", rs.fmtSpec({ alternate: true }, args119[1])])); + put(out, rs.fmtFormat([args119[0], "|", rs.fmtSpec({ alternate: true }, args119[1])]).v); const part26 = skip$iters_collections_hash_set_Drain_array2_u8(rs.hashDrainKeys(keys), rs.usizeSub(1, n)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part26, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part26, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]).v); } export function skip$iters_collections_binary_heap_Drain_u8(it: rs.Iter, n: rs.usize): rs.Iter { @@ -1841,177 +1842,180 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u8Add(b, 1); }), front, back); const args139 = [(f: rs.Formatter) => rs.fmtAdaptor(part2, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args139[0], "|", rs.fmtSpec({ alternate: true }, args139[0]), "|", rs.fmtSpec({ debugHex: "x" }, args139[0])])); + put(out, rs.fmtFormat([args139[0], "|", rs.fmtSpec({ alternate: true }, args139[0]), "|", rs.fmtSpec({ debugHex: "x" }, args139[0])]).v); const part3 = ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(rs.iterFilter(rs.iterSlice(rs.byteSliceView(bytes)), (_2: rs.u8): boolean => { return rs.u8Rem(_2, 2) === 0; }), front, back); const args140 = [(f: rs.Formatter) => rs.fmtAdaptor(part3, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args140[0], "|", rs.fmtSpec({ alternate: true }, args140[0])])); + put(out, rs.fmtFormat([args140[0], "|", rs.fmtSpec({ alternate: true }, args140[0])]).v); const part4 = ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_23: rs.u8): rs.u8 | undefined => { return rs.u8CheckedSub(_23, 9); }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part4, f, "FilterMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part4, f, "FilterMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); const part5 = ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(rs.iterInspect(rs.iterSlice(rs.byteSliceView(bytes)), (_26: rs.u8): undefined => {}), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part5, f, "Inspect", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part5, f, "Inspect", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); const part6 = fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_28: rs.u8): rs.u8 | undefined => { return rs.u8CheckedSub(_28, 3); }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part6, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part6, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); const part7 = ends$adaptors_iter_Rev_slice_Iter_u8(rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), front, back); const args144 = [(f: rs.Formatter) => rs.fmtAdaptor(part7, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args144[0], "|", rs.fmtSpec({ alternate: true }, args144[0])])); + put(out, rs.fmtFormat([args144[0], "|", rs.fmtSpec({ alternate: true }, args144[0])]).v); const part8 = ends$adaptors_iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(bytes)), front, back); const args145 = [(f: rs.Formatter) => rs.fmtAround(part8, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args145[0], "|", rs.fmtSpec({ alternate: true }, args145[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args145[0])])); + put(out, rs.fmtFormat([args145[0], "|", rs.fmtSpec({ alternate: true }, args145[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args145[0])]).v); const part9 = ends$adaptors_iter_Cloned_slice_Iter_u8(rs.iterCloned(rs.iterSlice(rs.byteSliceView(bytes))), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part9, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), "it")])); - const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rs.iterCloned(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b5: rs.u8): string => { - return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b5, f)); - }), undefined, 12, true).items)), front, back); - const args147 = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.fmtStr, ["Iter"]), "it")]; - put(out, rs.fmtFormat([args147[0], "|", rs.fmtSpec({ alternate: true }, args147[0])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part9, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), "it")]).v); + const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b5: rs.u8): rs.String => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b5, f), 0); + }), undefined, 12, true).items), (a0: rs.String): rs.String => { + return rs.stringClone(a0); + }), front, back); + const args147 = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), ["Iter"]), "it")]; + put(out, rs.fmtFormat([args147[0], "|", rs.fmtSpec({ alternate: true }, args147[0])]).v); const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunksExact(data, 2), 3), (c: rs.ByteSlice): Uint8Array => { rs.idx(c, 0); const _32: rs.u8 = c.data[c.start]; rs.idx(c, 1); return Uint8Array.of(_32, c.data[c.start + 1]); }), undefined, 2, true).items), rs.byteSliceFrom), rs.byteSliceToArray), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part11, f, "Copied", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"]), "it")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part11, f, "Copied", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"]), "it")]).v); const part12 = ends$adaptors_iter_Enumerate_slice_Iter_u8(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(bytes))), front, back); const args149 = [(f: rs.Formatter) => rs.fmtEnumerate(part12, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args149[0], "|", rs.fmtSpec({ alternate: true }, args149[0]), "|", rs.fmtSpec({ debugHex: "x" }, args149[0])])); + put(out, rs.fmtFormat([args149[0], "|", rs.fmtSpec({ alternate: true }, args149[0]), "|", rs.fmtSpec({ debugHex: "x" }, args149[0])]).v); const it12: rs.Iter = rs.iterSkip(rs.iterSlice(rs.byteSliceView(bytes)), at(2) as rs.usize); const args150 = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args150[0], "|", rs.fmtSpec({ alternate: true }, args150[0])])); + put(out, rs.fmtFormat([args150[0], "|", rs.fmtSpec({ alternate: true }, args150[0])]).v); rs.iterToOption(it12.nextBack()); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); it12.next(); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); const part13 = ends$adaptors_iter_Take_slice_Iter_u8(rs.iterTake(rs.iterSlice(rs.byteSliceView(bytes)), rs.u8Rem(at(2), 8) as rs.usize), front, back); const args153 = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args153[0], "|", rs.fmtSpec({ alternate: true }, args153[0])])); + put(out, rs.fmtFormat([args153[0], "|", rs.fmtSpec({ alternate: true }, args153[0])]).v); const it14: rs.Iter = rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_211: rs.u8): boolean => { return rs.u8Rem(_211, 3) !== 0; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); it14.next(); const args155 = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args155[0], "|", rs.fmtSpec({ alternate: true }, args155[0])])); + put(out, rs.fmtFormat([args155[0], "|", rs.fmtSpec({ alternate: true }, args155[0])]).v); const it15: rs.Iter = rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): boolean => { return rs.u8Rem(_212, 5) !== 0; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); let iterStart: rs.usize = 0; const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { it15.next(); } const args157 = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args157[0], "|", rs.fmtSpec({ alternate: true }, args157[0])])); + put(out, rs.fmtFormat([args157[0], "|", rs.fmtSpec({ alternate: true }, args157[0])]).v); const part14 = fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), 0, (sum: rs.Place, _33: rs.u8): rs.u32 | undefined => { sum.v = rs.u32Add(sum.v, _33 as rs.u32); return sum.v; }, true), front); const args158 = [(f: rs.Formatter) => rs.fmtScan(part14, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u32Debug)]; - put(out, rs.fmtFormat([args158[0], "|", rs.fmtSpec({ alternate: true }, args158[0]), "|", rs.fmtSpec({ debugHex: "x" }, args158[0])])); - const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), "", (s: rs.Place, _34: rs.u8): rs.usize | undefined => { + put(out, rs.fmtFormat([args158[0], "|", rs.fmtSpec({ alternate: true }, args158[0]), "|", rs.fmtSpec({ debugHex: "x" }, args158[0])]).v); + const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), rs.stringNew(), (s: rs.String, _34: rs.u8): rs.usize | undefined => { const b9: rs.u8 = _34; - s.v = s.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(b9, 26)) as rs.char); + rs.stringPush(s, rs.u8Add(97, rs.u8Rem(b9, 26)) as rs.char); return then$1uoo7un(rs.u8Rem(b9, 7) !== 0, (): rs.usize => { - return rs.stringLen(s.v); + return s.len; }); - }, true), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtScan(part15, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.fmtStr)])); + }), front); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtScan(part15, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]).v); const it18: rs.Peekable = ends$adaptors_iter_Peekable_slice_Iter_u8(rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]).v); rs.peekablePeek(it18); const args161 = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args161[0], "|", rs.fmtSpec({ alternate: true }, args161[0])])); + put(out, rs.fmtFormat([args161[0], "|", rs.fmtSpec({ alternate: true }, args161[0])]).v); it18.next(); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]).v); const it19: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(bytes.length, 1))))); it19.next(); rs.peekablePeek(it19); const args163 = [(f: rs.Formatter) => rs.fmtPeekable(it19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; - put(out, rs.fmtFormat([args163[0], "|", rs.fmtSpec({ alternate: true }, args163[0])])); + put(out, rs.fmtFormat([args163[0], "|", rs.fmtSpec({ alternate: true }, args163[0])]).v); const part19 = ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(2, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, rs.min(2, bytes.length))))), front, back); const args164 = [(f: rs.Formatter) => rs.fmtChain(part19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args164[0], "|", rs.fmtSpec({ alternate: true }, args164[0])])); + put(out, rs.fmtFormat([args164[0], "|", rs.fmtSpec({ alternate: true }, args164[0])]).v); const it21: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(1, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(7, 8))))); rs.iterToOption(it21.nextBack()); rs.iterToOption(it21.nextBack()); rs.iterToOption(it21.nextBack()); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtChain(it21, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtChain(it21, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); const part21 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b10: rs.u8): rs.u8 => { return b10 ^ 1; }), [false, true]), front, back); const args166 = [(f: rs.Formatter) => rs.fmtZip(part21, f)]; - put(out, rs.fmtFormat([args166[0], "|", rs.fmtSpec({ alternate: true }, args166[0])])); + put(out, rs.fmtFormat([args166[0], "|", rs.fmtSpec({ alternate: true }, args166[0])]).v); const part22 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), "len"), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtZip(part22, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))])); - const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtZip(part22, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]).v); + const _509: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { const _515: rs.usize = rs.u8Rem(_213, 4) as rs.usize; if (!(_515 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _515); } return [97, 233, 20013, 129408][_515]; - }))), rs.iterSlice(rs.byteSliceView(bytes))), front); + }); + const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringExtendChars(rs.stringNew(), _509).v), rs.iterSlice(rs.byteSliceView(bytes))), front); const args168 = [(f: rs.Formatter) => rs.fmtZip(part23, f, rs.fmtChars, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args168[0], "|", rs.fmtSpec({ alternate: true }, args168[0])])); + put(out, rs.fmtFormat([args168[0], "|", rs.fmtSpec({ alternate: true }, args168[0])]).v); const part24 = fronts$adaptors_iter_Cycle_slice_Iter_u8(rs.iterCycle(rs.iterSlice(rs.byteSliceView(bytes))), rs.usizeAdd(front, rs.u8Rem(at(2), 8) as rs.usize)); const args169 = [(f: rs.Formatter) => rs.fmtCycle(part24, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args169[0], "|", rs.fmtSpec({ alternate: true }, args169[0])])); + put(out, rs.fmtFormat([args169[0], "|", rs.fmtSpec({ alternate: true }, args169[0])]).v); const part25 = fronts$adaptors_iter_Fuse_slice_Iter_u8(rs.iterFuse(rs.iterSlice(rs.byteSliceView(bytes)), true), rs.usizeAdd(front, 6)); const args170 = [(f: rs.Formatter) => rs.fmtFuse(part25, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args170[0], "|", rs.fmtSpec({ alternate: true }, args170[0])])); + put(out, rs.fmtFormat([args170[0], "|", rs.fmtSpec({ alternate: true }, args170[0])]).v); const part26 = fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(rs.iterFuse(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), 2), true), rs.usizeAdd(front, 2)); const args171 = [(f: rs.Formatter) => rs.fmtFuse(part26, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtStepBy(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args171[0], "|", rs.fmtSpec({ alternate: true }, args171[0])])); + put(out, rs.fmtFormat([args171[0], "|", rs.fmtSpec({ alternate: true }, args171[0])]).v); const part27 = fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(rs.iterFuse(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_218: rs.u8): rs.u8 | undefined => { const b12: rs.u8 = _218; return thenSome$0quywni(rs.u8Rem(b12, 4) !== 0, b12); })), rs.usizeMul(front, 2)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFuse(part27, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFuse(part27, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]).v); const step: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); const part28 = ends$adaptors_iter_StepBy_slice_Iter_u8(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), step), front, back); const args173 = [(f: rs.Formatter) => rs.fmtStepBy(part28, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args173[0], "|", rs.fmtSpec({ alternate: true }, args173[0])])); + put(out, rs.fmtFormat([args173[0], "|", rs.fmtSpec({ alternate: true }, args173[0])]).v); const _630: [rs.u8, rs.u8] = [rs.u8Rem(at(4), 16), at(5)]; const lo: rs.u8 = _630[0]; const hi: rs.u8 = _630[1]; const part29 = ends$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(lo, hi), step, undefined, 255), front, back); const args174 = [(f: rs.Formatter) => rs.fmtStepBy(part29, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; - put(out, rs.fmtFormat([args174[0], "|", rs.fmtSpec({ alternate: true }, args174[0])])); + put(out, rs.fmtFormat([args174[0], "|", rs.fmtSpec({ alternate: true }, args174[0])]).v); const part30 = fronts$adaptors_iter_StepBy_ops_Range_u32(rs.iterStepBy(new rs.Range(lo as rs.u32, hi as rs.u32), step, undefined, 4294967295), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part30, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u32Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part30, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u32Debug))]).v); const part31 = ends$adaptors_iter_StepBy_ops_Range_usize(rs.iterStepBy(new rs.Range(lo as rs.usize, hi as rs.usize), step, undefined, 4294967295), front, back); const args176 = [(f: rs.Formatter) => rs.fmtStepBy(part31, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.usizeDebug))]; - put(out, rs.fmtFormat([args176[0], "|", rs.fmtSpec({ debugHex: "x" }, args176[0])])); + put(out, rs.fmtFormat([args176[0], "|", rs.fmtSpec({ debugHex: "x" }, args176[0])]).v); const part32 = ends$adaptors_iter_StepBy_ops_Range_u16(rs.iterStepBy(new rs.Range(lo as rs.u16, hi as rs.u16), step, undefined, 65535), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part32, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u16Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part32, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u16Debug))]).v); const part33 = ends$adaptors_iter_StepBy_ops_Range_i32(rs.iterStepBy(new rs.Range(lo as rs.i32, hi as rs.i32), step), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part33, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.i32Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part33, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.i32Debug))]).v); const part34 = fronts$adaptors_iter_StepBy_ops_Range_u64(rs.iterStepBy(new rs.Range(lo as rs.u64, hi as rs.u64, rs.u64Step), step), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part34, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u64Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part34, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u64Debug))]).v); const part35 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), 300, undefined, 255), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part35, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part35, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]).v); const part36 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), rs.usizeAdd(at(3) as rs.usize, 1), undefined, 255), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part36, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part36, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]).v); const part37 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(hi, 255), rs.usizeAdd(step, 200), undefined, 255), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part37, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))])); - const lists: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(bytes, 2), (a0: rs.ByteSlice): rs.ByteVec => { - return rs.byteSliceToByteVec(a0); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStepBy(part37, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]).v); + const lists: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(bytes, 2), (a02: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(a02); }), undefined, 12, true); const part38 = ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), front, back); const args183 = [(f: rs.Formatter) => rs.fmtFlatten(part38, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args183[0], "|", rs.fmtSpec({ alternate: true }, args183[0])])); + put(out, rs.fmtFormat([args183[0], "|", rs.fmtSpec({ alternate: true }, args183[0])]).v); const part39 = ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(rs.iterFlatMap(rs.iterSlice(lists.items), (v: rs.ByteVec): rs.Iter => { return rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))); }, undefined, true), front, back); const args184 = [(f: rs.Formatter) => rs.fmtFlatten(part39, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args184[0], "|", rs.fmtSpec({ alternate: true }, args184[0])])); + put(out, rs.fmtFormat([args184[0], "|", rs.fmtSpec({ alternate: true }, args184[0])]).v); const part40 = fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(rs.iterFuse(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), true), rs.usizeAdd(front, 6)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFuse(part40, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtFuse(part40, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]).v); const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_219: rs.u8): rs.u16 => { const _519: rs.usize = rs.u8Rem(_219, 5) as rs.usize; if (!(_519 < 5)) { @@ -2021,49 +2025,50 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true); const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterSlice(units.items)), front); const args186 = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part41, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args186[0], "|", rs.fmtSpec({ alternate: true }, args186[0]), "|", rs.fmtSpec({ debugHex: "x" }, args186[0])])); + put(out, rs.fmtFormat([args186[0], "|", rs.fmtSpec({ alternate: true }, args186[0]), "|", rs.fmtSpec({ debugHex: "x" }, args186[0])]).v); const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rs.charDecodeUtf16(rs.vecIntoIter(rs.vecFrom([55296, 97, 98]))), rs.u8Rem(at(2), 3) as rs.usize); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtDecodeUtf16(part42, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["IntoIter"]))])); - const quoted: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): rs.char => { + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtDecodeUtf16(part42, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["IntoIter"]))]).v); + const _893: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): rs.char => { const _523: rs.usize = rs.u8Rem(_221, 6) as rs.usize; if (!(_523 < 6)) { rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _523); } return [97, 34, 10, 769, 233, 39][_523]; - })); - const part43 = fronts$adaptors_str_EscapeDebug(rs.strEscapeDebug(quoted), rs.usizeMul(front, 2)); + }); + const quoted: rs.String = rs.stringExtendChars(rs.stringNew(), _893); + const part43 = fronts$adaptors_str_EscapeDebug(rs.strEscapeDebug(quoted.v), rs.usizeMul(front, 2)); const args188 = [(f: rs.Formatter) => rs.fmtAround(part43, f, "EscapeDebug", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDebug")))]; - put(out, rs.fmtFormat([args188[0], "|", rs.fmtSpec({ alternate: true }, args188[0])])); - const part44 = fronts$adaptors_str_EscapeDefault(rs.strEscapeDefault(quoted), rs.usizeMul(front, 3)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAround(part44, f, "EscapeDefault", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDefault")))])); - const part45 = fronts$adaptors_str_EscapeUnicode(rs.strEscapeUnicode(quoted), rs.usizeMul(front, 5)); + put(out, rs.fmtFormat([args188[0], "|", rs.fmtSpec({ alternate: true }, args188[0])]).v); + const part44 = fronts$adaptors_str_EscapeDefault(rs.strEscapeDefault(quoted.v), rs.usizeMul(front, 3)); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAround(part44, f, "EscapeDefault", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDefault")))]).v); + const part45 = fronts$adaptors_str_EscapeUnicode(rs.strEscapeUnicode(quoted.v), rs.usizeMul(front, 5)); const args190 = [(f: rs.Formatter) => rs.fmtAround(part45, f, "EscapeUnicode", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeUnicode")))]; - put(out, rs.fmtFormat([args190[0], "|", rs.fmtSpec({ alternate: true }, args190[0])])); + put(out, rs.fmtFormat([args190[0], "|", rs.fmtSpec({ alternate: true }, args190[0])]).v); const base: rs.Iter = rs.iterSlice(rs.byteSliceView(bytes)); base.next(); const part46 = rs.iterSkip(rs.iterMap(rs.iterBorrow(base), (b15: rs.u8): rs.u8 => { return rs.u8Add(b15, 1); }), 1); const args191 = [(f: rs.Formatter) => rs.fmtCounted(part46, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; - put(out, rs.fmtFormat([args191[0], "|", rs.fmtSpec({ alternate: true }, args191[0])])); + put(out, rs.fmtFormat([args191[0], "|", rs.fmtSpec({ alternate: true }, args191[0])]).v); const part47 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterBorrow(rs.iterSlice(units.items))), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtDecodeUtf16(part47, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtDecodeUtf16(part47, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]).v); const part48 = fronts$adaptors_iter_Copied_mut_slice_Iter_u8(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(bytes))), front); const args193 = [(f: rs.Formatter) => rs.fmtAround(part48, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; - put(out, rs.fmtFormat([args193[0], "|", rs.fmtSpec({ alternate: true }, args193[0])])); + put(out, rs.fmtFormat([args193[0], "|", rs.fmtSpec({ alternate: true }, args193[0])]).v); const part49 = fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(rs.iterMap(rs.iterBox(rs.iterSlice(rs.byteSliceView(bytes))), (b16: rs.u8): rs.u8 => { return rs.u8Add(b16, 1); }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part49, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part49, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]).v); const boxed: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))); const _1027: Countdown.Countdown = { _0: 4 }; const part50 = fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(rs.iterZip(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed))), rs.iterBox(rs.iterFrom(_1027, Countdown.next$iter_Iterator))), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtZip(part50, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtZip(part50, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]).v); const part51 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(rs.iterEnumerate(rs.iterMap(rs.iterFrom({ _0: rs.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rs.u8): rs.u8 => { return rs.u8Mul(n, 2); })), front); const args196 = [(f: rs.Formatter) => rs.fmtEnumerate(part51, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; - put(out, rs.fmtFormat([args196[0], "|", rs.fmtSpec({ alternate: true }, args196[0])])); + put(out, rs.fmtFormat([args196[0], "|", rs.fmtSpec({ alternate: true }, args196[0])]).v); if (!(rs.u8Rem(at(3), 2) === 0)) { toggle = "Done" as Toggle.Toggle; } else { @@ -2073,53 +2078,53 @@ export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { return x; }); const args197 = [(f: rs.Formatter) => rs.fmtAdaptor(part52, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args197[0], "|", rs.fmtSpec({ alternate: true }, args197[0])])); + put(out, rs.fmtFormat([args197[0], "|", rs.fmtSpec({ alternate: true }, args197[0])]).v); const part53 = rs.iterMap(rs.iterFrom(rs.place(() => toggle, (value3) => toggle = value3), Toggle.next$iter_Iterator), (x2: rs.u8): rs.u8 => { return x2; }); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part53, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part53, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]).v); let boxed2: Toggle.Toggle = toggle; const part54 = fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value5) => boxed2 = value5), Toggle.next$iter_Iterator))), (x3: rs.u8): rs.u8 => { return x3; }), front); const args199 = [(f: rs.Formatter) => rs.fmtAdaptor(part54, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rs.fmtFormat([args199[0], "|", rs.fmtSpec({ alternate: true }, args199[0])])); + put(out, rs.fmtFormat([args199[0], "|", rs.fmtSpec({ alternate: true }, args199[0])]).v); const part55 = fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(rs.iterMap(rs.iterBox(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value6) => boxed2 = value6), Toggle.next$iter_Iterator)))), (x4: rs.u8): rs.u8 => { return x4; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part55, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part55, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]).v); const part56 = fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(rs.iterMap(rs.iterBox(rs.iterFrom(rs.place(() => toggle, (value7) => toggle = value7), Toggle.next$iter_Iterator)), (x5: rs.u8): rs.u8 => { return x5; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part56, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part56, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]).v); let nested: Countdown.Countdown = { _0: rs.u8Rem(at(4), 5) }; const part57 = fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(nested, Countdown.next$iter_Iterator))), (n2: rs.u8): rs.u8 => { return n2; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]).v); const part58 = fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(rs.iterMap(rs.iterBox(rs.iterFrom({ _0: rs.u8Rem(at(5), 5) }, Countdown.next$iter_Iterator)), (n3: rs.u8): rs.u8 => { return n3; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]).v); const own: Countdown.Countdown = { _0: rs.u8Rem(at(3), 5) }; const part59 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rs.iterPeekable(rs.iterFrom(own, Countdown.next$iter_Iterator)), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f), rs.u8Debug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f), rs.u8Debug)]).v); const part60 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(rs.iterChain(rs.iterFlatMap(rs.iterSlice(lists.items), (v2: rs.ByteVec): Countdown.Countdown => { return { _0: rs.u8Rem(v2.data[rs.idx(v2, 0)], 3) }; }, (value: Countdown.Countdown) => rs.iterFrom(value, Countdown.next$iter_Iterator), true), rs.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtChain(part60, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtChain(part60, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]).v); const part61 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(rs.iterTake(rs.iterRev(rs.iterSkip(rs.iterEnumerate(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_225: rs.u8): Pair.Pair => { return { _0: _225, _1: -1 }; })), 1)), 3), front, back); const args206 = [(f: rs.Formatter) => rs.fmtCounted(part61, f, "Take", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtCounted(value, f, "Skip", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtEnumerate(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; - put(out, rs.fmtFormat([args206[0], "|", rs.fmtSpec({ alternate: true }, args206[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args206[0])])); + put(out, rs.fmtFormat([args206[0], "|", rs.fmtSpec({ alternate: true }, args206[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args206[0])]).v); const it63: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))); rs.peekablePeek(it63); const part62 = rs.iterChain(rs.iterFilter(rs.iterZip(it63, new rs.RangeFrom(1, rs.u8Step), "len"), (p: [rs.u8, rs.u8]): boolean => { return p[0] !== 0; }), rs.vecIntoIter(rs.vecFrom(copy$array_tuple2_u8_u8([[9, 9] as [rs.u8, rs.u8]]).map(copy$tuple2_u8_u8)))); const args207 = [(f: rs.Formatter) => rs.fmtChain(part62, f, (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtZip(value, f, (value: rs.Peekable, f: rs.Formatter) => rs.fmtPeekable(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), rs.u8Debug), (value: rs.RangeFrom, f: rs.Formatter) => rs.fmtRangeFrom(value, f, rs.u8Debug))), (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtIter(value, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f), ["IntoIter"]))]; - put(out, rs.fmtFormat([args207[0], "|", rs.fmtSpec({ alternate: true }, args207[0])])); + put(out, rs.fmtFormat([args207[0], "|", rs.fmtSpec({ alternate: true }, args207[0])]).v); } export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { @@ -2138,7 +2143,7 @@ export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rs.Iter } } -export function ends$adaptors_iter_Cloned_slice_Iter_String(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { +export function ends$adaptors_iter_Cloned_slice_Iter_String(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { let iterStart: rs.usize = 0; const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { @@ -2813,26 +2818,26 @@ export function fronts$adaptors_str_EscapeUnicode(it: rs.Iter, front: r * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. */ -export function literals$mut_String(w: rs.Place, c: rs.char): rs.Result { - w.v = w.v + "ab"; +export function literals$mut_String(w: rs.String, c: rs.char): rs.Result { + rs.stringPushStr(w, "ab"); if (rs.OK.ok) { - w.v = w.v + ""; + rs.stringPushStr(w, ""); if (rs.OK.ok) { - w.v = w.v + ""; + rs.stringPushStr(w, ""); if (rs.OK.ok) { - w.v = w.v + String.fromCodePoint(c); + rs.stringPush(w, c); if (rs.OK.ok) { - w.v = w.v + "cxd"; + rs.stringPushStr(w, "cxd"); if (rs.OK.ok) { - w.v = w.v + "😀"; + rs.stringPush(w, 128512); if (rs.OK.ok) { - w.v = w.v + "\n"; + rs.stringPushStr(w, "\n"); if (rs.OK.ok) { - w.v = w.v + "{}"; + rs.stringPushStr(w, "{}"); if (rs.OK.ok) { - w.v = w.v + ""; + rs.stringPushStr(w, ""); if (rs.OK.ok) { - w.v = w.v + "end\n"; + rs.stringPushStr(w, "end\n"); return rs.OK; } return rs.Err(new rs.FmtError()); @@ -2963,26 +2968,26 @@ export function literals$mut_fmt_Twice(w: Twice.Twice, c: rs.char): rs.Result>, c: rs.char): rs.Result { - w.v.v = w.v.v + "ab"; +export function literals$mut_mut_String(w: rs.Place, c: rs.char): rs.Result { + rs.stringPushStr(w.v, "ab"); if (rs.OK.ok) { - w.v.v = w.v.v + ""; + rs.stringPushStr(w.v, ""); if (rs.OK.ok) { - w.v.v = w.v.v + ""; + rs.stringPushStr(w.v, ""); if (rs.OK.ok) { - w.v.v = w.v.v + String.fromCodePoint(c); + rs.stringPush(w.v, c); if (rs.OK.ok) { - w.v.v = w.v.v + "cxd"; + rs.stringPushStr(w.v, "cxd"); if (rs.OK.ok) { - w.v.v = w.v.v + "😀"; + rs.stringPush(w.v, 128512); if (rs.OK.ok) { - w.v.v = w.v.v + "\n"; + rs.stringPushStr(w.v, "\n"); if (rs.OK.ok) { - w.v.v = w.v.v + "{}"; + rs.stringPushStr(w.v, "{}"); if (rs.OK.ok) { - w.v.v = w.v.v + ""; + rs.stringPushStr(w.v, ""); if (rs.OK.ok) { - w.v.v = w.v.v + "end\n"; + rs.stringPushStr(w.v, "end\n"); return rs.OK; } return rs.Err(new rs.FmtError()); @@ -3040,20 +3045,16 @@ export function literals$mut_mut_fmt_Capped(w: rs.Place, c: rs.ch } /** Placeholders with options, through a writer std's impl forwards to. */ -export function placed$mut_String(w: rs.Place, n: rs.u8): rs.Result { +export function placed$mut_String(w: rs.String, n: rs.u8): rs.Result { const _8: string = "q\"é"; const _9: rs.char = 223; const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); const args5 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; - const written = rs.fmtWriteString(w.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args5[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args5[1]), "|", args5[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args5[3]), "|", rs.fmtSpec({ plus: true }, args5[4])]); - w.v = written.s; - if (written.result.ok) { - w.v = w.v + "é"; + if (rs.fmtWriteString(w, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args5[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args5[1]), "|", args5[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args5[3]), "|", rs.fmtSpec({ plus: true }, args5[4])]).ok) { + rs.stringPush(w, 233); if (rs.OK.ok) { const args6 = [(f: rs.Formatter) => rs.u8Binary(n, f)]; - const written2 = rs.fmtWriteString(w.v, [rs.fmtSpec({ alternate: true }, args6[0]), "\n"]); - w.v = written2.s; - return written2.result; + return rs.fmtWriteString(w, [rs.fmtSpec({ alternate: true }, args6[0]), "\n"]); } return rs.Err(new rs.FmtError()); } @@ -3077,20 +3078,16 @@ export function placed$mut_fmt_Formatter(w: rs.Formatter, n: rs.u8): rs.Result>>, n: rs.u8): rs.Result { +export function placed$mut_mut_mut_String(w: rs.Place>, n: rs.u8): rs.Result { const _8: string = "q\"é"; const _9: rs.char = 223; const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); const args5 = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; - const written = rs.fmtWriteString(w.v.v.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args5[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args5[1]), "|", args5[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args5[3]), "|", rs.fmtSpec({ plus: true }, args5[4])]); - w.v.v.v = written.s; - if (written.result.ok) { - w.v.v.v = w.v.v.v + "é"; + if (rs.fmtWriteString(w.v.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args5[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args5[1]), "|", args5[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args5[3]), "|", rs.fmtSpec({ plus: true }, args5[4])]).ok) { + rs.stringPush(w.v.v, 233); if (rs.OK.ok) { const args6 = [(f: rs.Formatter) => rs.u8Binary(n, f)]; - const written2 = rs.fmtWriteString(w.v.v.v, [rs.fmtSpec({ alternate: true }, args6[0]), "\n"]); - w.v.v.v = written2.s; - return written2.result; + return rs.fmtWriteString(w.v.v, [rs.fmtSpec({ alternate: true }, args6[0]), "\n"]); } return rs.Err(new rs.FmtError()); } @@ -3111,39 +3108,35 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(at(0) as rs.u32, 257)), 63); - let s: string = ""; + const s: rs.String = rs.stringNew(); const _19: rs.u8 = at(1); const _25: rs.u8 = at(2); const args9 = [(f: rs.Formatter) => rs.u8Display(_19, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"é", f), (f: rs.Formatter) => rs.u8LowerHex(_25, f)]; - const written = rs.fmtWriteString(s, ["a", args9[0], "b", rs.fmtSpec({ align: ">", width: 5 }, args9[1]), "|", args9[2], "|", args9[3]]); - s = written.s; - result(out, written.result); - s = s + "\n"; + result(out, rs.fmtWriteString(s, ["a", args9[0], "b", rs.fmtSpec({ align: ">", width: 5 }, args9[1]), "|", args9[2], "|", args9[3]])); + rs.stringPushStr(s, "\n"); result(out, rs.OK); - s = s + String.fromCodePoint(c); + rs.stringPush(s, c); result(out, rs.OK); - s = s + "tail"; + rs.stringPushStr(s, "tail"); result(out, rs.OK); const _52: Fails.Fails = { _0: at(3) }; const _57: rs.u8 = at(4); const args10 = [(f: rs.Formatter) => Fails.fmt$fmt_Display(_52, f), (f: rs.Formatter) => rs.u8Display(_57, f)]; - const written2 = rs.fmtWriteString(s, ["x", args10[0], "y", args10[1]]); - s = written2.s; - result(out, written2.result); - result(out, literals$mut_String(rs.place(() => s, (value) => s = value), c)); + result(out, rs.fmtWriteString(s, ["x", args10[0], "y", args10[1]])); + result(out, literals$mut_String(s, c)); const _71: rs.u8 = at(5); - result(out, placed$mut_String(rs.place(() => s, (value2) => s = value2), _71)); - let inner: rs.Place = rs.place(() => s, (value3) => s = value3); - result(out, literals$mut_mut_String(rs.place(() => inner, (value4) => inner = value4), 223)); - let _81: rs.Place> = rs.place(() => inner, (value5) => inner = value5); + result(out, placed$mut_String(s, _71)); + let inner: rs.String = s; + result(out, literals$mut_mut_String(rs.place(() => inner, (value) => inner = value), 223)); + let _81: rs.Place = rs.place(() => inner, (value2) => inner = value2); const _82: rs.u8 = at(6); - result(out, placed$mut_mut_mut_String(rs.place(() => _81, (value6) => _81 = value6), _82)); - put(out, s); + result(out, placed$mut_mut_mut_String(rs.place(() => _81, (value3) => _81 = value3), _82)); + put(out, s.v); const _96: Placed.Placed = { _0: at(7) }; const _101: Placed.Placed = { _0: at(8) }; const args11 = [(f: rs.Formatter) => Placed.fmt$fmt_Display(_96, f), (f: rs.Formatter) => Placed.fmt$fmt_Display(_101, f)]; - put(out, rs.fmtFormat([args11[0], "|", rs.fmtSpec({ align: ">", width: 30 }, args11[1])])); - const capped: Capped.Capped = { text: "", calls: 0, cap: rs.u8Rem(at(9), 40) as rs.usize }; + put(out, rs.fmtFormat([args11[0], "|", rs.fmtSpec({ align: ">", width: 30 }, args11[1])]).v); + const capped: Capped.Capped = { text: rs.stringNew(), calls: 0, cap: rs.u8Rem(at(9), 40) as rs.usize }; result(out, literals$mut_fmt_Capped(capped, c)); result(out, Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c))); result(out, Capped.writeStr$fmt_Write(capped, "z")); @@ -3152,28 +3145,28 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { const args12 = [(f: rs.Formatter) => rs.u8Display(_134, f), (f: rs.Formatter) => rs.i16Display(_138, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"b", f)]; result(out, rs.fmtWrite((s2) => Capped.writeStr$fmt_Write(capped, s2), (c2) => Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c2)), [rs.fmtSpec({ align: ">", width: 4 }, args12[0]), "|", args12[1], "|", rs.fmtSpec({ align: "^", width: 5 }, args12[2]), "|", args12[3]])); let _156: Capped.Capped = capped; - result(out, literals$mut_mut_fmt_Capped(rs.place(() => _156, (value7) => _156 = value7), 233)); + result(out, literals$mut_mut_fmt_Capped(rs.place(() => _156, (value4) => _156 = value4), 233)); rs.byteVecPush(out, capped.calls); - put(out, capped.text); - const twice: Twice.Twice = { _0: "" }; + put(out, capped.text.v); + const twice: Twice.Twice = { _0: rs.stringNew() }; result(out, literals$mut_fmt_Twice(twice, c)); result(out, Twice.writeChar$fmt_Write(twice, 223)); - put(out, twice._0); + put(out, twice._0.v); named(out, at(12), at(13)); } /** Placeholders into writers named as the translation's own callback parameters might be. */ export function named(out: rs.ByteVec, first: rs.u8, second: rs.u8): void { - const s: Twice.Twice = { _0: "" }; - const c: Capped.Capped = { text: "", calls: 0, cap: 64 }; + const s: Twice.Twice = { _0: rs.stringNew() }; + const c: Capped.Capped = { text: rs.stringNew(), calls: 0, cap: 64 }; const args5 = [(f: rs.Formatter) => rs.u8Display(first, f), (f: rs.Formatter) => rs.fmtCharDisplay(120, f)]; result(out, rs.fmtWrite((s2) => Twice.writeStr$fmt_Write(s, s2), (c2) => Twice.writeChar$fmt_Write(s, c2), [args5[0], rs.fmtSpec({ align: ">", width: 3 }, args5[1])])); const _28: rs.Fmt = (f: rs.Formatter) => rs.u8Display(second, f); const arg = s._0; - const args6 = [_28, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + const args6 = [_28, (f: rs.Formatter) => rs.fmtPad(f, arg.v)]; result(out, rs.fmtWrite((s3) => Capped.writeStr$fmt_Write(c, s3), (c3) => Capped.writeStr$fmt_Write(c, String.fromCodePoint(c3)), [rs.fmtSpec({ align: "<", width: 3 }, args6[0]), args6[1]])); - put(out, s._0); - put(out, c.text); + put(out, s._0.v); + put(out, c.text.v); rs.byteVecPush(out, c.calls); } @@ -3189,7 +3182,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { _6.value = new rs.ByteVec(); const tags: rs.ByteVec = taken; rs.refMutRelease(_6); - put(out2, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(tags), f, rs.u8Debug), " "])); + put(out2, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(tags), f, rs.u8Debug), " "]).v); }; const shown: rs.Vec = new rs.Vec(); const written: rs.Vec = new rs.Vec(); @@ -3212,20 +3205,20 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const _35: rs.Fmt = rs.fmtOwned(dropper(x), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Display(value, f), rs.drop); written.items.push(_35); } else { - const _41: rs.Fmt = rs.fmtOwned(rs.fmtFormat(["s", (f: rs.Formatter) => rs.u8Display(x, f)]), (value: string, f: rs.Formatter) => rs.fmtPad(f, value)); + const _41: rs.Fmt = rs.fmtOwned(rs.fmtFormat(["s", (f: rs.Formatter) => rs.u8Display(x, f)]), (value: rs.String, f: rs.Formatter) => rs.fmtPad(f, value.v)); written.items.push(_41); } } for (const _55 of shown.items) { const args35 = [(f: rs.Formatter) => _55(f)]; - put(out, rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0]), " "])); + put(out, rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0]), " "]).v); } for (const _74 of written.items) { const args36 = [(f: rs.Formatter) => _74(f)]; - put(out, rs.fmtFormat([args36[0], " [", rs.fmtSpec({ align: ">", width: 6 }, args36[0]), "] [", rs.fmtSpec({ align: "^", width: 7 }, args36[0]), "] "])); + put(out, rs.fmtFormat([args36[0], " [", rs.fmtSpec({ align: ">", width: 6 }, args36[0]), "] [", rs.fmtSpec({ align: "^", width: 7 }, args36[0]), "] "]).v); } const up: rs.Fmt = rs.fmtOwned(data.length, rs.usizeDebug); - put(out, rs.fmtFormat([(f: rs.Formatter) => up(f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => up(f), " "]).v); rs.dropVec(written); dropped(out); rs.vecTruncate(shown, 1, rs.drop); @@ -3241,7 +3234,7 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const kept: rs.Arc = rs.arcClone(shared); const _135: rs.usize = kept.strong; const args38 = [(f: rs.Formatter) => shared.value(f), (f: rs.Formatter) => rs.usizeDisplay(_135, f)]; - put(out, rs.fmtFormat([args38[0], " ", args38[1], " "])); + put(out, rs.fmtFormat([args38[0], " ", args38[1], " "]).v); const counted: rs.Arc = new rs.Arc(dropper(data.data[data.start])); const _149: rs.Arc = rs.arcClone(counted); const asDisplay: rs.Arc = new rs.ArcDyn(_149, rs.fmtOwned(_149.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Display(value, f), rs.drop)); @@ -3249,33 +3242,32 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { const asDebug: rs.Arc = new rs.ArcDyn(counted, rs.fmtOwned(counted.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop)); const _160: rs.usize = asDebug.strong; const args39 = [(f: rs.Formatter) => asDisplay.value(f), (f: rs.Formatter) => rs.usizeDisplay(_160, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ align: "<", width: 5 }, args39[0]), "| ", args39[1], " "])); + put(out, rs.fmtFormat([rs.fmtSpec({ align: "<", width: 5 }, args39[0]), "| ", args39[1], " "]).v); asDisplay[Symbol.dispose](); dropped(out); if (rs.u8Rem(b, 2) === 0) { _372 = false; asDebug[Symbol.dispose](); } else { - put(out, rs.fmtFormat([(f: rs.Formatter) => asDebug.value(f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => asDebug.value(f), " "]).v); } dropped(out); shared[Symbol.dispose](); const _198: rs.usize = kept.strong; const args41 = [(f: rs.Formatter) => kept.value(f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; - put(out, rs.fmtFormat([args41[0], " ", args41[1], " "])); + put(out, rs.fmtFormat([args41[0], " ", args41[1], " "]).v); let n: rs.u8 = rs.u8WrappingMul(data.data[data.start], 3); - let text: string = rs.fmtFormat(["t", (f: rs.Formatter) => rs.u8Display(b, f)]); + const text: rs.String = rs.fmtFormat(["t", (f: rs.Formatter) => rs.u8Display(b, f)]); const owned: Dropper.Dropper = dropper(b); const part5 = rs.u8WrappingAdd(b, 1); let boxed: rs.Fmt = rs.fmtOwned(dropper(part5), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop); const cell: rs.Cell = new rs.Cell(data.data[data.start]); const pair: [fmt_Gauge.Gauge, rs.u8] = [{ _0: cell }, b]; const _237: rs.Place = rs.place(() => n, (value) => n = value); - const arg = rs.place(() => text, (value2) => text = value2); - const _238: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(arg.v, f); + const _238: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(text.v, f); const _240: rs.Fmt = (f: rs.Formatter) => Dropper.fmt$fmt_Debug(owned, f); - const arg2 = rs.place(() => boxed, (value3) => boxed = value3); - const objects: rs.Vec = rs.vecFrom([(f: rs.Formatter) => rs.u8Debug(_237.v, f), _238, _240, (f: rs.Formatter) => arg2.v(f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => fmt_Gauge.fmt$fmt_Debug(pair[0], f), (f: rs.Formatter) => rs.u8Debug(pair[1], f)], f)]); + const arg = rs.place(() => boxed, (value2) => boxed = value2); + const objects: rs.Vec = rs.vecFrom([(f: rs.Formatter) => rs.u8Debug(_237.v, f), _238, _240, (f: rs.Formatter) => arg.v(f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => fmt_Gauge.fmt$fmt_Debug(pair[0], f), (f: rs.Formatter) => rs.u8Debug(pair[1], f)], f)]); const iter4: rs.Iter> = rs.iterSliceMut(rs.sliceFrom(objects.items)); while (true) { const _251: rs.Place | rs.Done = iter4.next(); @@ -3283,23 +3275,22 @@ export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { break; } const args43 = [(f: rs.Formatter) => _251.v(f)]; - put(out, rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[0]), " "])); + put(out, rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[0]), " "]).v); } const _269: rs.u8 = rs.u8WrappingAdd(cell.v, 1); rs.cellSet(cell, _269); const again: rs.Fmt = objects.items[rs.idx(objects.items, 4)]; - put(out, rs.fmtFormat([(f: rs.Formatter) => again(f), " "])); - put(out, rs.fmtFormat([(f: rs.Formatter) => again(f), " "])); + put(out, rs.fmtFormat([(f: rs.Formatter) => again(f), " "]).v); + put(out, rs.fmtFormat([(f: rs.Formatter) => again(f), " "]).v); n = rs.u8WrappingAdd(n, 1); - const _304: rs.Place = rs.place(() => n, (value4) => n = value4); + const _304: rs.Place = rs.place(() => n, (value3) => n = value3); const part6 = (f: rs.Formatter) => rs.u8Display(_304.v, f); - put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: ">", width: 5 }, (f: rs.Formatter) => part6(f)), "] "])); + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: ">", width: 5 }, (f: rs.Formatter) => part6(f)), "] "]).v); const part7 = (f: rs.Formatter) => Dropper.fmt$fmt_Display(owned, f); - put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: "^", width: 6 }, (f: rs.Formatter) => part7(f)), "] "])); - text = text + "!"; - const arg3 = rs.place(() => text, (value5) => text = value5); - const part8 = (f: rs.Formatter) => rs.fmtPad(f, arg3.v); - put(out, rs.fmtFormat([(f: rs.Formatter) => part8(f), " "])); + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: "^", width: 6 }, (f: rs.Formatter) => part7(f)), "] "]).v); + rs.stringPush(text, 33); + const part8 = (f: rs.Formatter) => rs.fmtPad(f, text.v); + put(out, rs.fmtFormat([(f: rs.Formatter) => part8(f), " "]).v); rs.drop(boxed); dropped(out); owned[Symbol.dispose](); @@ -3332,22 +3323,22 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const bytes: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 7)); const part2 = fronts$sources_iter_Once_u8(rs.iterOnce(b), rs.usizeRem(front, 2)); const args111 = [(f: rs.Formatter) => rs.fmtIterOption(part2, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args111[0], "|", rs.fmtSpec({ alternate: true }, args111[0]), "|", rs.fmtSpec({ debugHex: "x" }, args111[0])])); + put(out, rs.fmtFormat([args111[0], "|", rs.fmtSpec({ alternate: true }, args111[0]), "|", rs.fmtSpec({ debugHex: "x" }, args111[0])]).v); const part3 = rs.iterOnce(thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: -1 })); const args112 = [(f: rs.Formatter) => rs.fmtIterOption(part3, f, (value: Pair.Pair | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args112[0], "|", rs.fmtSpec({ alternate: true }, args112[0])])); + put(out, rs.fmtFormat([args112[0], "|", rs.fmtSpec({ alternate: true }, args112[0])]).v); const maybe: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b, 3) !== 0, b); const _72: rs.Iter = rs.iterOption(maybe); const _75: rs.Iter = rs.iterOption(maybe); const args113 = [(f: rs.Formatter) => rs.fmtIterOption(_72, f, rs.u8Debug, [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_75, f, rs.u8Debug, [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args113[0], "|", rs.fmtSpec({ alternate: true }, args113[1])])); + put(out, rs.fmtFormat([args113[0], "|", rs.fmtSpec({ alternate: true }, args113[1])]).v); const pair: Pair.Pair | undefined = thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: 2 }); const part4 = fronts$sources_option_Iter_fmt_Pair(rs.iterOption(pair), rs.usizeRem(front, 2)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part4, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["Iter", "inner"], ["Item", "opt"]])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part4, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["Iter", "inner"], ["Item", "opt"]])]).v); const part5 = rs.iterOption(pair); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part5, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"], ["Item", "opt"]])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part5, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"], ["Item", "opt"]])]).v); const part6 = rs.iterOption(pair); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part6, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"], ["Item", "opt"]])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part6, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"], ["Item", "opt"]])]).v); const _132: Array = [rs.None, undefined, b]; const _138: rs.usize = rs.u8Rem(b, 3) as rs.usize; if (!(_138 < 3)) { @@ -3357,10 +3348,10 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const _150: rs.Iter = rs.iterOption(nested, undefined, rs.None); const _153: rs.Iter = rs.iterOption(nested, undefined, rs.None); const args117 = [(f: rs.Formatter) => rs.fmtIterOption(_150, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_153, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rs.fmtFormat([args117[0], "|", rs.fmtSpec({ debugHex: "x" }, args117[1])])); + put(out, rs.fmtFormat([args117[0], "|", rs.fmtSpec({ debugHex: "x" }, args117[1])]).v); let mine: rs.u8 | undefined = maybe; const part7 = fronts$sources_option_IterMut_u8(rs.iterOption(mine === undefined ? undefined : rs.place(() => mine as rs.u8, (value) => mine = value)), rs.usizeRem(front, 2)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part7, f, (value: rs.Place, f: rs.Formatter) => rs.u8Debug(value.v, f), [["IterMut", "inner"], ["Item", "opt"]])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part7, f, (value: rs.Place, f: rs.Formatter) => rs.u8Debug(value.v, f), [["IterMut", "inner"], ["Item", "opt"]])]).v); if (!(rs.u8Rem(b, 2) === 0)) { result = rs.Err({ _0: b, _1: 3 }); } else { @@ -3369,48 +3360,48 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const _190: rs.Iter = rs.iterResult(result); const _193: rs.Iter = rs.iterResult(result); const args119 = [(f: rs.Formatter) => rs.fmtIterOption(_190, f, rs.u8Debug, [["Iter", "inner"]]), (f: rs.Formatter) => rs.fmtIterOption(_193, f, rs.u8Debug, [["IntoIter", "inner"]])]; - put(out, rs.fmtFormat([args119[0], "|", rs.fmtSpec({ alternate: true }, args119[1])])); + put(out, rs.fmtFormat([args119[0], "|", rs.fmtSpec({ alternate: true }, args119[1])]).v); if (!(rs.u8Rem(b, 3) === 0)) { held = rs.Ok({ _0: b, _1: 4 }); } else { held = rs.Err(b); } const part8 = fronts$sources_result_IterMut_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"]])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"]])]).v); const part9 = fronts$sources_result_IntoIter_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part9, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"]])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIterOption(part9, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"]])]).v); const _243: rs.u8 = at(3); const _246: rs.u8 = at(4); const _249: rs.u8 = at(5); const part10 = ends$sources_array_IntoIter_u8_4(rs.iterSlice(Uint8Array.of(b, _243, _246, _249)), front, back); const args122 = [(f: rs.Formatter) => rs.fmtIter(part10, f, rs.u8Debug, ["IntoIter"])]; - put(out, rs.fmtFormat([args122[0], "|", rs.fmtSpec({ alternate: true }, args122[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args122[0])])); + put(out, rs.fmtFormat([args122[0], "|", rs.fmtSpec({ alternate: true }, args122[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args122[0])]).v); const part11 = ends$sources_array_IntoIter_fmt_Pair_2(rs.iterSlice([{ _0: b, _1: 5 }, { _0: at(3), _1: 6 }]), rs.usizeRem(front, 3), rs.usizeRem(back, 2)); const args123 = [(f: rs.Formatter) => rs.fmtIter(part11, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rs.fmtFormat([args123[0], "|", rs.fmtSpec({ alternate: true }, args123[0])])); + put(out, rs.fmtFormat([args123[0], "|", rs.fmtSpec({ alternate: true }, args123[0])]).v); const part12 = rs.iterSlice(Uint8Array.of()); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part12, f, rs.u8Debug, ["IntoIter"])])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtIter(part12, f, rs.u8Debug, ["IntoIter"])]).v); let n: rs.i32 = 0; const it5: rs.Iter = rs.iterFromFn((): rs.i32 | undefined => { n = rs.i32Add(n, 1); return thenSome$05ku0zn(n < 3, n); }); const args125 = [(f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn")]; - put(out, rs.fmtFormat([args125[0], "|", rs.fmtSpec({ alternate: true }, args125[0])])); + put(out, rs.fmtFormat([args125[0], "|", rs.fmtSpec({ alternate: true }, args125[0])]).v); const part13 = rs.iterTake(it5, 2); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (_value: rs.Iter, f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn"))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (_value: rs.Iter, f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn"))]).v); const it6: rs.Iter = rs.iterRepeatWith((): rs.u8 => { return b; }); const args127 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; - put(out, rs.fmtFormat([args127[0], "|", rs.fmtSpec({ alternate: true }, args127[0])])); + put(out, rs.fmtFormat([args127[0], "|", rs.fmtSpec({ alternate: true }, args127[0])]).v); const part14 = rs.iterSkip(it6, 1); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtCounted(part14, f, "Skip", (_value: rs.Iter, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtCounted(part14, f, "Skip", (_value: rs.Iter, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))))]).v); const part15 = fronts$sources_iter_Successors_u8_fmt_sources_closure3(rs.iterSuccessors(b, (_22: rs.u8): rs.u8 | undefined => { return rs.u8CheckedAdd(_22, 100); }), front); const args129 = [(f: rs.Formatter) => rs.fmtSuccessors(part15, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args129[0], "|", rs.fmtSpec({ alternate: true }, args129[0]), "|", rs.fmtSpec({ debugHex: "x" }, args129[0])])); + put(out, rs.fmtFormat([args129[0], "|", rs.fmtSpec({ alternate: true }, args129[0]), "|", rs.fmtSpec({ debugHex: "x" }, args129[0])]).v); const part16 = fronts$sources_iter_Successors_Option_u8_fmt_sources_closure4(rs.iterSuccessors(b as rs.u8 | undefined | rs.None, (_26: rs.u8 | undefined): rs.u8 | undefined | rs.None => { return option_andThen$0jc4o0i(_26, (x3: rs.u8): rs.u8 | undefined | rs.None => { return option_map$02rrcvu(rs.u8CheckedSub(x3, 100), (a0: rs.u8): rs.u8 | undefined => { @@ -3418,143 +3409,143 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { }); }); }, undefined, rs.None), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSuccessors(part16, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSuccessors(part16, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]).v); const part17 = rs.iterMap(rs.iterChain(rs.iterOnce(b), rs.iterSlice(Uint8Array.of(at(3), at(4)))), (x4: rs.u8): rs.u8 => { return rs.u8Div(x4, 2); }); const args131 = [(f: rs.Formatter) => rs.fmtAdaptor(part17, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtChain(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIterOption(value, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"])))]; - put(out, rs.fmtFormat([args131[0], "|", rs.fmtSpec({ alternate: true }, args131[0])])); + put(out, rs.fmtFormat([args131[0], "|", rs.fmtSpec({ alternate: true }, args131[0])]).v); const part18 = rs.iterRepeat(b); const args132 = [(f: rs.Formatter) => rs.fmtRepeat(part18, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args132[0], "|", rs.fmtSpec({ alternate: true }, args132[0]), "|", rs.fmtSpec({ debugHex: "x" }, args132[0])])); + put(out, rs.fmtFormat([args132[0], "|", rs.fmtSpec({ alternate: true }, args132[0]), "|", rs.fmtSpec({ debugHex: "x" }, args132[0])]).v); const part19 = ends$sources_iter_Take_iter_Repeat_fmt_Pair(rs.iterTake(rs.iterRepeat({ _0: b, _1: 7 }), 3), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(part19, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtRepeat(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCounted(part19, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtRepeat(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]).v); const n2: rs.usize = rs.u8Rem(at(3), 4) as rs.usize; const part20 = ends$sources_iter_RepeatN_u8(rs.iterRepeatN(b, n2), front, back); const args134 = [(f: rs.Formatter) => rs.fmtRepeatN(part20, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args134[0], "|", rs.fmtSpec({ alternate: true }, args134[0])])); + put(out, rs.fmtFormat([args134[0], "|", rs.fmtSpec({ alternate: true }, args134[0])]).v); const it12: rs.Iter = rs.iterRepeatN({ _0: b, _1: 8 }, n2); const _464: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; rs.iterNth(it12, _464); const args135 = [(f: rs.Formatter) => rs.fmtRepeatN(it12, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args135[0], "|", rs.fmtSpec({ alternate: true }, args135[0])])); + put(out, rs.fmtFormat([args135[0], "|", rs.fmtSpec({ alternate: true }, args135[0])]).v); const part21 = ends$sources_iter_OnceWith_fmt_sources_closure6(rs.iterOnceWith((): rs.u8 => { return b; }), rs.usizeRem(front, 2), rs.usizeRem(back, 2)); const args136 = [(f: rs.Formatter) => rs.fmtOnceWith(part21, f)]; - put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args136[0])])); - const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { + put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args136[0])]).v); + const _503: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { const _54: rs.usize = rs.u8Rem(_212, 5) as rs.usize; if (!(_54 < 5)) { rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _54); } return [97, 233, 20013, 129408, 10][_54]; - })); - const part22 = ends$sources_str_CharIndices(rs.strCharIndices(text), front, back); + }); + const text: rs.String = rs.stringExtendChars(rs.stringNew(), _503); + const part22 = ends$sources_str_CharIndices(rs.strCharIndices(text.v), front, back); const args137 = [(f: rs.Formatter) => rs.fmtCharIndices(part22, f)]; - put(out, rs.fmtFormat([args137[0], "|", rs.fmtSpec({ alternate: true }, args137[0]), "|", rs.fmtSpec({ debugHex: "x" }, args137[0])])); - let drained: string = text; - const it15: rs.Iter = ends$sources_string_Drain(rs.stringDrain(rs.place(() => drained, (value3) => drained = value3), undefined), front, back); + put(out, rs.fmtFormat([args137[0], "|", rs.fmtSpec({ alternate: true }, args137[0]), "|", rs.fmtSpec({ debugHex: "x" }, args137[0])]).v); + const it15: rs.Iter = ends$sources_string_Drain(rs.stringDrain(rs.stringClone(text), undefined), front, back); const args138 = [(f: rs.Formatter) => rs.fmtStringDrain(it15, f)]; - put(out, rs.fmtFormat([args138[0], "|", rs.fmtSpec({ alternate: true }, args138[0])])); + put(out, rs.fmtFormat([args138[0], "|", rs.fmtSpec({ alternate: true }, args138[0])]).v); rs.drop(it15); const size: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); const part23 = ends$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), front, back); const args139 = [(f: rs.Formatter) => rs.fmtParts(part23, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; - put(out, rs.fmtFormat([args139[0], "|", rs.fmtSpec({ alternate: true }, args139[0]), "|", rs.fmtSpec({ debugHex: "x" }, args139[0])])); + put(out, rs.fmtFormat([args139[0], "|", rs.fmtSpec({ alternate: true }, args139[0]), "|", rs.fmtSpec({ debugHex: "x" }, args139[0])]).v); const it17: rs.Iter = rs.byteSliceWindows(bytes, size); const _564: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; rs.iterNth(it17, _564); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it17, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it17, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]).v); const it18: rs.Iter = fronts$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), 8); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]).v); rs.iterToOption(it18.nextBack()); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]).v); const it19: rs.Iter = rs.byteSliceWindows(bytes, size); const _613: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; rs.iterNthBack(it19, _613); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it19, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it19, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]).v); const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.u16 => { return rs.u16Mul(_213 as rs.u16, 257); }), undefined, 2, true); const part24 = ends$sources_slice_Windows_u16(rs.sliceWindows(rs.sliceFrom(wide.items), size), front, back); const args144 = [(f: rs.Formatter) => rs.fmtParts(part24, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Windows")]; - put(out, rs.fmtFormat([args144[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args144[0])])); + put(out, rs.fmtFormat([args144[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args144[0])]).v); const part25 = ends$sources_slice_Chunks_u8(rs.byteSliceChunks(bytes, size), front, back); const args145 = [(f: rs.Formatter) => rs.fmtParts(part25, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Chunks")]; - put(out, rs.fmtFormat([args145[0], "|", rs.fmtSpec({ alternate: true }, args145[0])])); + put(out, rs.fmtFormat([args145[0], "|", rs.fmtSpec({ alternate: true }, args145[0])]).v); const part26 = ends$sources_slice_ChunksExact_u16(rs.sliceChunksExact(rs.sliceFrom(wide.items), size), front, back); const args146 = [(f: rs.Formatter) => rs.fmtParts(part26, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "ChunksExact")]; - put(out, rs.fmtFormat([args146[0], "|", rs.fmtSpec({ alternate: true }, args146[0])])); + put(out, rs.fmtFormat([args146[0], "|", rs.fmtSpec({ alternate: true }, args146[0])]).v); const part27 = ends$sources_slice_ChunksExact_u8(rs.byteSliceChunksExact(bytes, size), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part27, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "ChunksExact")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part27, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "ChunksExact")]).v); const part28 = ends$sources_slice_RChunks_u16(rs.sliceRchunks(rs.sliceFrom(wide.items), size), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part28, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunks")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part28, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunks")]).v); const part29 = ends$sources_slice_RChunks_u8(rs.byteSliceRchunks(bytes, size), front, back); const args149 = [(f: rs.Formatter) => rs.fmtParts(part29, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunks")]; - put(out, rs.fmtFormat([args149[0], "|", rs.fmtSpec({ alternate: true }, args149[0])])); + put(out, rs.fmtFormat([args149[0], "|", rs.fmtSpec({ alternate: true }, args149[0])]).v); const part30 = ends$sources_slice_RChunksExact_u8(rs.byteSliceRchunksExact(bytes, size), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part30, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunksExact")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(part30, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunksExact")]).v); const it27: rs.Iter> = rs.sliceRchunksExact(rs.sliceFrom(wide.items), size); const _743: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; rs.iterNth(it27, _743); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it27, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunksExact")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtParts(it27, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "RChunksExact")]).v); const part31 = ends$sources_slice_Split_u8_fmt_sources_closure9(rs.byteSliceSplit(bytes, (x5: rs.u8): boolean => { return rs.u8Rem(x5, 3) === 0; }), front, back); const args152 = [(f: rs.Formatter) => rs.fmtSplit(part31, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false)]; - put(out, rs.fmtFormat([args152[0], "|", rs.fmtSpec({ alternate: true }, args152[0]), "|", rs.fmtSpec({ debugHex: "x" }, args152[0])])); + put(out, rs.fmtFormat([args152[0], "|", rs.fmtSpec({ alternate: true }, args152[0]), "|", rs.fmtSpec({ debugHex: "x" }, args152[0])]).v); const part32 = ends$sources_slice_SplitInclusive_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(bytes, (x6: rs.u8): boolean => { return rs.u8Rem(x6, 3) === 0; }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part32, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusive", false)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part32, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusive", false)]).v); const part33 = ends$sources_slice_RSplit_u8_fmt_sources_closure9(rs.byteSliceRsplit(bytes, (x7: rs.u8): boolean => { return rs.u8Rem(x7, 3) === 0; }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part33, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part33, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false)]).v); const part34 = fronts$sources_slice_SplitN_u8_fmt_sources_closure9(rs.byteSliceSplitn(bytes, rs.u8Rem(at(4), 4) as rs.usize, (x8: rs.u8): boolean => { return rs.u8Rem(x8, 3) === 0; }), front); const args155 = [(f: rs.Formatter) => rs.fmtSplit(part34, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false, "SplitN")]; - put(out, rs.fmtFormat([args155[0], "|", rs.fmtSpec({ alternate: true }, args155[0])])); + put(out, rs.fmtFormat([args155[0], "|", rs.fmtSpec({ alternate: true }, args155[0])]).v); const part35 = fronts$sources_slice_RSplitN_u8_fmt_sources_closure9(rs.byteSliceRsplitn(bytes, 2, (x9: rs.u8): boolean => { return rs.u8Rem(x9, 3) === 0; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part35, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false, "RSplitN")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part35, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false, "RSplitN")]).v); const part36 = ends$sources_slice_Split_u16_fmt_sources_closure10(rs.sliceSplit(rs.sliceFrom(wide.items), (x10: rs.u16): boolean => { return rs.u16Rem(x10, 3) === 0; }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part36, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part36, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false)]).v); const part37 = fronts$sources_slice_SplitN_u16_fmt_sources_closure10(rs.sliceSplitn(rs.sliceFrom(wide.items), 2, (x11: rs.u16): boolean => { return rs.u16Rem(x11, 3) === 0; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part37, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false, "SplitN")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part37, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "Split", false, "SplitN")]).v); const owned: rs.ByteVec = rs.byteSliceToByteVec(bytes); const part38 = ends$sources_slice_SplitMut_u8_fmt_sources_closure9(rs.byteSliceSplit(rs.byteVecSlice(owned), (x12: rs.u8): boolean => { return rs.u8Rem(x12, 3) === 0; }), front, back); const args159 = [(f: rs.Formatter) => rs.fmtSplit(part38, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true)]; - put(out, rs.fmtFormat([args159[0], "|", rs.fmtSpec({ alternate: true }, args159[0])])); + put(out, rs.fmtFormat([args159[0], "|", rs.fmtSpec({ alternate: true }, args159[0])]).v); const part39 = ends$sources_slice_SplitInclusiveMut_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(rs.byteVecSlice(owned), (x13: rs.u8): boolean => { return rs.u8Rem(x13, 3) === 0; }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part39, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusiveMut", true)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part39, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusiveMut", true)]).v); const part40 = ends$sources_slice_RSplitMut_u8_fmt_sources_closure9(rs.byteSliceRsplit(rs.byteVecSlice(owned), (x14: rs.u8): boolean => { return rs.u8Rem(x14, 3) === 0; }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part40, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part40, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true)]).v); const part41 = fronts$sources_slice_SplitNMut_u8_fmt_sources_closure9(rs.byteSliceSplitn(rs.byteVecSlice(owned), 2, (x15: rs.u8): boolean => { return rs.u8Rem(x15, 3) === 0; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part41, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true, "SplitNMut")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part41, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true, "SplitNMut")]).v); const part42 = fronts$sources_slice_RSplitNMut_u8_fmt_sources_closure9(rs.byteSliceRsplitn(rs.byteVecSlice(owned), rs.u8Rem(at(4), 4) as rs.usize, (x16: rs.u8): boolean => { return rs.u8Rem(x16, 3) === 0; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part42, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true, "RSplitNMut")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part42, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true, "RSplitNMut")]).v); const part43 = ends$sources_slice_SplitMut_u16_fmt_sources_closure10(rs.sliceSplit(rs.sliceFrom(rs.vecFrom(wide.items.slice()).items), (x17: rs.u16): boolean => { return rs.u16Rem(x17, 3) === 0; }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part43, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "SplitMut", true)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtSplit(part43, f, (value: rs.Slice, f: rs.Formatter) => rs.fmtList(rs.sliceItems(value), f, rs.u16Debug), "SplitMut", true)]).v); const _976: [rs.HashSet, rs.HashSet] = [rs.hashNew() as rs.HashSet, rs.hashNew() as rs.HashSet]; const one: rs.HashSet = _976[0]; const other: rs.HashSet = _976[1]; @@ -3569,7 +3560,7 @@ export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { const _1005: rs.Iter = rs.hashSymmetricDifference(one, other); const _1009: rs.Iter = rs.hashUnion(one, other); const args165 = [(f: rs.Formatter) => rs.fmtIterClone(_997, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1001, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1005, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1009, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args165[0], "|", rs.fmtSpec({ alternate: true }, args165[1]), "|", args165[2], "|", args165[3]])); + put(out, rs.fmtFormat([args165[0], "|", rs.fmtSpec({ alternate: true }, args165[1]), "|", args165[2], "|", args165[3]]).v); } export function ends$sources_array_IntoIter_fmt_Pair_2(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { @@ -4115,16 +4106,16 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { } const part = fronts$sets_collections_btree_set_Difference_u8(rs.btreeDifference(_69[0], _69[1]), front); const args19 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part, f, rs.u8Debug, "Difference")]; - put(out, rs.fmtFormat([args19[0], "|", rs.fmtSpec({ alternate: true }, args19[0])])); + put(out, rs.fmtFormat([args19[0], "|", rs.fmtSpec({ alternate: true }, args19[0])]).v); const part2 = fronts$sets_collections_btree_set_Intersection_u8(rs.btreeIntersection(_69[0], _69[1]), front); const args20 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part2, f, rs.u8Debug, "Intersection")]; - put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0])])); + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0])]).v); const part3 = fronts$sets_collections_btree_set_Union_u8(rs.btreeUnion(_69[0], _69[1]), front); const args21 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part3, f, rs.u8Debug, "Union")]; - put(out, rs.fmtFormat([args21[0], "|", rs.fmtSpec({ alternate: true }, args21[0])])); + put(out, rs.fmtFormat([args21[0], "|", rs.fmtSpec({ alternate: true }, args21[0])]).v); const part4 = fronts$sets_collections_btree_set_SymmetricDifference_u8(rs.btreeSymmetricDifference(_69[0], _69[1]), front); const args22 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part4, f, rs.u8Debug, "SymmetricDifference")]; - put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0])])); + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0])]).v); } const _131: rs.Iter<[rs.u8, rs.char]> = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_23: rs.u8): [rs.u8, rs.char] => { return [rs.u8Rem(_23, 4), 112] as [rs.u8, rs.char]; @@ -4136,22 +4127,22 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { const more: rs.BTreeSet<[rs.u8, rs.char]> = rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.char], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.char]>, _135, true, undefined, undefined, 8, true); const part5 = fronts$sets_collections_btree_set_Union_tuple2_u8_char(rs.btreeUnion(pairs, more), front); const args23 = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part5, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Union")]; - put(out, rs.fmtFormat([args23[0], "|", rs.fmtSpec({ debugHex: "x" }, args23[0])])); + put(out, rs.fmtFormat([args23[0], "|", rs.fmtSpec({ debugHex: "x" }, args23[0])]).v); const part6 = fronts$sets_collections_btree_set_Difference_tuple2_u8_char(rs.btreeDifference(pairs, more), front); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtBTreeSetOp(part6, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Difference"))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtBTreeSetOp(part6, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Difference"))]).v); const _172: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); const it7: rs.Iter = fronts$sets_collections_linked_list_ExtractIf_u8_fmt_sets_closure5(rs.listExtractIfMut(rs.listExtend(rs.listNew() as rs.LinkedList, _172), (x4: rs.Place): boolean => { return rs.u8Rem(x4.v, 2) === 0; }), front); const args25 = [(f: rs.Formatter) => rs.fmtListExtractIf(it7, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args25[0], "|", rs.fmtSpec({ alternate: true }, args25[0]), "|", rs.fmtSpec({ debugHex: "x" }, args25[0])])); + put(out, rs.fmtFormat([args25[0], "|", rs.fmtSpec({ alternate: true }, args25[0]), "|", rs.fmtSpec({ debugHex: "x" }, args25[0])]).v); const _192: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_210: rs.u8): Pair.Pair => { return { _0: _210, _1: 2 }; }); const it8: rs.Iter = fronts$sets_collections_linked_list_ExtractIf_fmt_Pair_fmt_sets_closure7(rs.listExtractIf(rs.listExtend(rs.listNew() as rs.LinkedList, _192), (p: Pair.Pair): boolean => { return rs.u8Rem(p._0, 3) === 0; }), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtListExtractIf(it8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtListExtractIf(it8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]).v); const _212: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): [rs.u8, rs.u8] => { const x6: rs.u8 = _211; return [x6, x6] as [rs.u8, rs.u8]; @@ -4166,7 +4157,7 @@ export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { return k2 > 9; }); const args27 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf"))]; - put(out, rs.fmtFormat([args27[0], "|", rs.fmtSpec({ alternate: true }, args27[1])])); + put(out, rs.fmtFormat([args27[0], "|", rs.fmtSpec({ alternate: true }, args27[1])]).v); } export function fronts$sets_collections_btree_set_Difference_tuple2_u8_char(it: rs.Iter<[rs.u8, rs.char]>, front: rs.usize): rs.Iter<[rs.u8, rs.char]> { @@ -4274,8 +4265,8 @@ export function passed(out: rs.ByteVec, budget: rs.usize, args: rs.Arguments): v } else { _23 = 43; } - log.text = log.text + String.fromCodePoint(_23); - put(out, log.text); + rs.stringPush(log.text, _23); + put(out, log.text.v); } const log2: Log.Log = Log.new(budget); if (!rs.fmtWrite((s2) => Log.writeStr$fmt_Write(log2, s2), (c2) => Log.writeChar$fmt_Write(log2, c2), args).ok) { @@ -4283,8 +4274,8 @@ export function passed(out: rs.ByteVec, budget: rs.usize, args: rs.Arguments): v } else { _34 = 43; } - log2.text = log2.text + String.fromCodePoint(_34); - put(out, log2.text); + rs.stringPush(log2.text, _34); + put(out, log2.text.v); } /** @@ -4328,8 +4319,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _56 = 43; } - log.text = log.text + String.fromCodePoint(_56); - put(out, log.text); + rs.stringPush(log.text, _56); + put(out, log.text.v); } const w: rs.u64 = rs.u64FromBeBytes(Uint8Array.of(at(6), at(7), at(8), at(9), at(1), at(2), at(3), at(4))); const n: rs.i128 = rs.i128Mul(v as rs.i128, rs.i128Neg(rs.i128Shl(1, 70))); @@ -4348,8 +4339,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _132 = 43; } - log2.text = log2.text + String.fromCodePoint(_132); - put(out, log2.text); + rs.stringPush(log2.text, _132); + put(out, log2.text.v); } const _139: rs.u8 = rs.u8Rem(at(10), 9); if (_139 === 0) { @@ -4384,8 +4375,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _166 = 43; } - log3.text = log3.text + String.fromCodePoint(_166); - put(out, log3.text); + rs.stringPush(log3.text, _166); + put(out, log3.text.v); } const y: rs.f32 = Math.fround(x); const iter4: rs.Iter = rs.iterSlice([4294967295, budget]); @@ -4401,8 +4392,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _198 = 43; } - log4.text = log4.text + String.fromCodePoint(_198); - put(out, log4.text); + rs.stringPush(log4.text, _198); + put(out, log4.text.v); } const _206: rs.usize = rs.usizeRem(at(11) as rs.usize, rs.sliceFrom(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]).length); if (!(_206 < 14)) { @@ -4424,8 +4415,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _265 = 43; } - log5.text = log5.text + String.fromCodePoint(_265); - put(out, log5.text); + rs.stringPush(log5.text, _265); + put(out, log5.text.v); } const value: Nested.Nested = nested(data); const iter6: rs.Iter = rs.iterSlice([4294967295, budget]); @@ -4441,8 +4432,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _291 = 43; } - log6.text = log6.text + String.fromCodePoint(_291); - put(out, log6.text); + rs.stringPush(log6.text, _291); + put(out, log6.text.v); } const iter7: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { @@ -4457,8 +4448,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _316 = 43; } - log7.text = log7.text + String.fromCodePoint(_316); - put(out, log7.text); + rs.stringPush(log7.text, _316); + put(out, log7.text.v); } const manual: Manual.Manual = { id: at(14), list: rs.vecFrom([1, 2].slice()) }; const seq: Seq.Seq = { _0: rs.vecFrom([{ _0: at(15), _1: -2 }].slice()) }; @@ -4480,8 +4471,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _378 = 43; } - log8.text = log8.text + String.fromCodePoint(_378); - put(out, log8.text); + rs.stringPush(log8.text, _378); + put(out, log8.text.v); } const _385: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_2: rs.u8): [rs.u8, string] => { return [rs.u8Rem(_2, 8), "v"] as [rs.u8, string]; @@ -4513,8 +4504,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _450 = 43; } - log9.text = log9.text + String.fromCodePoint(_450); - put(out, log9.text); + rs.stringPush(log9.text, _450); + put(out, log9.text.v); } const bytes: rs.Iter = rs.byteSliceEscapeAscii(data); if (rs.u8Rem(at(21), 2) === 0) { @@ -4546,8 +4537,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _524 = 43; } - log10.text = log10.text + String.fromCodePoint(_524); - put(out, log10.text); + rs.stringPush(log10.text, _524); + put(out, log10.text.v); } const d: rs.Duration = rs.durationNew(rs.u64Mul(rs.u8Rem(at(23), 3) as rs.u64, at(24) as rs.u64), rs.u32Rem((at(25) << 16) | (at(26) << 8) | at(27), 1000000000)); const iter12: rs.Iter = rs.iterSlice([4294967295, budget]); @@ -4563,8 +4554,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _575 = 43; } - log11.text = log11.text + String.fromCodePoint(_575); - put(out, log11.text); + rs.stringPush(log11.text, _575); + put(out, log11.text.v); } const _581: rs.Result = rs.strFromUtf8(data); if (_581.ok) { @@ -4582,8 +4573,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _603 = 43; } - log12.text = log12.text + String.fromCodePoint(_603); - put(out, log12.text); + rs.stringPush(log12.text, _603); + put(out, log12.text.v); } } else { const e: rs.Utf8Error = _581.error; @@ -4601,8 +4592,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _633 = 43; } - log13.text = log13.text + String.fromCodePoint(_633); - put(out, log13.text); + rs.stringPush(log13.text, _633); + put(out, log13.text.v); } } const _643: rs.Result = rs.strFromUtf8(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(97, 230, 151, at(32))), 0, rs.usizeAdd(3, rs.u8Rem(at(32), 2) as rs.usize))); @@ -4621,8 +4612,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _676 = 43; } - log14.text = log14.text + String.fromCodePoint(_676); - put(out, log14.text); + rs.stringPush(log14.text, _676); + put(out, log14.text.v); } } const layout: rs.Layout = rs.resultUnwrap(rs.layoutFromSizeAlign(at(28) as rs.usize, rs.usizeShl(1, rs.u8Rem(at(29), 8))), rs.fmtLayoutErrorDebug); @@ -4646,8 +4637,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _740 = 43; } - log15.text = log15.text + String.fromCodePoint(_740); - put(out, log15.text); + rs.stringPush(log15.text, _740); + put(out, log15.text.v); } const iter17: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { @@ -4665,8 +4656,8 @@ export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _775 = 43; } - log16.text = log16.text + String.fromCodePoint(_775); - put(out, log16.text); + rs.stringPush(log16.text, _775); + put(out, log16.text.v); } const _785: Pair.Pair = { _0: at(31), _1: 1 }; const args51 = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_785, f), (f: rs.Formatter) => rs.fmtStr(s, f)]; @@ -4699,8 +4690,8 @@ export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _48 = 43; } - setter.log.text = setter.log.text + String.fromCodePoint(_48); - put(out, setter.log.text); + rs.stringPush(setter.log.text, _48); + put(out, setter.log.text.v); } /** @@ -4716,13 +4707,14 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { const front: rs.usize = _6[0]; const back: rs.usize = _6[1]; const rest: rs.ByteSlice = option_unwrapOrDefault$0avqj0t(rs.byteSliceGetRange(data, 4)); - const text2: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 10), (_2: rs.u8): rs.char => { + const _23: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 10), (_2: rs.u8): rs.char => { const _5: rs.usize = rs.u8Rem(_2, 9) as rs.usize; if (!(_5 < 9)) { rs.panic("index out of bounds: the len is " + 9 + " but the index is " + _5); } return [97, 98, 233, 129408, 32, 10, 13, 12288, 9][_5]; - })); + }); + const text2: string = rs.stringExtendChars(rs.stringNew(), _23).v; const _30: rs.usize = rs.u8Rem(at(2), 4) as rs.usize; if (!(_30 < 4)) { rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); @@ -4730,49 +4722,50 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { const c: rs.char = [97, 233, 129408, 32][_30]; const part = ends$searches_str_Split_char(rs.strSplit(text2, String.fromCodePoint(c)), front, back); const args67 = [(f: rs.Formatter) => rs.fmtStrSearch(part, f, "Split", "CharSearcher")]; - put(out, rs.fmtFormat([args67[0], "|", rs.fmtSpec({ alternate: true }, args67[0]), "|", rs.fmtSpec({ debugHex: "x" }, args67[0])])); + put(out, rs.fmtFormat([args67[0], "|", rs.fmtSpec({ alternate: true }, args67[0]), "|", rs.fmtSpec({ debugHex: "x" }, args67[0])]).v); const part2 = ends$searches_str_RSplit_char(rs.strRsplit(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part2, f, "RSplit", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part2, f, "RSplit", "CharSearcher")]).v); const part3 = ends$searches_str_SplitTerminator_char(rs.strSplitTerminator(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part3, f, "SplitTerminator", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part3, f, "SplitTerminator", "CharSearcher")]).v); const part4 = ends$searches_str_RSplitTerminator_char(rs.strRsplitTerminator(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part4, f, "RSplitTerminator", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part4, f, "RSplitTerminator", "CharSearcher")]).v); const part5 = fronts$searches_str_SplitN_char(rs.strSplitn(text2, rs.u8Rem(at(3), 4) as rs.usize, String.fromCodePoint(c)), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part5, f, "SplitN", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part5, f, "SplitN", "CharSearcher")]).v); const part6 = fronts$searches_str_RSplitN_char(rs.strRsplitn(text2, 2, String.fromCodePoint(c)), front); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part6, f, "RSplitN", "CharSearcher"))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part6, f, "RSplitN", "CharSearcher"))]).v); const part7 = ends$searches_str_SplitInclusive_char(rs.strSplitInclusive(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part7, f, "SplitInclusive", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part7, f, "SplitInclusive", "CharSearcher")]).v); const part8 = ends$searches_str_Matches_char(rs.strMatches(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part8, f, "Matches", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part8, f, "Matches", "CharSearcher")]).v); const part9 = ends$searches_str_RMatches_char(rs.strRmatches(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part9, f, "RMatches", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part9, f, "RMatches", "CharSearcher")]).v); const part10 = ends$searches_str_MatchIndices_char(rs.strMatchIndices(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtStrSearch(part10, f, "MatchIndices", "CharSearcher"))])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtStrSearch(part10, f, "MatchIndices", "CharSearcher"))]).v); const part11 = ends$searches_str_RMatchIndices_char(rs.strRmatchIndices(text2, String.fromCodePoint(c)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part11, f, "RMatchIndices", "CharSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part11, f, "RMatchIndices", "CharSearcher")]).v); const set: rs.char[] = [c, 98]; const part12 = ends$searches_str_Split_array2_char(rs.strSplit(text2, rs.patternChars(set)), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part12, f, "Split", "CharArraySearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part12, f, "Split", "CharArraySearcher")]).v); const part13 = ends$searches_str_Matches_ref_array2_char(rs.strMatches(text2, rs.patternChars(set)), front, back); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part13, f, "Matches", "CharArrayRefSearcher"))])); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part13, f, "Matches", "CharArrayRefSearcher"))]).v); const part14 = ends$searches_str_RSplit_ref_slice_char(rs.strRsplit(text2, rs.patternChars(rs.sliceItems(rs.sliceRange(rs.sliceFrom(set), 0, 1)))), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part14, f, "RSplit", "CharSliceSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part14, f, "RSplit", "CharSliceSearcher")]).v); const part15 = ends$searches_str_Split_fmt_searches_closure3(rs.strSplit(text2, (x: rs.char): boolean => { return x === c; }), front, back); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part15, f, "Split", "CharPredicateSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part15, f, "Split", "CharPredicateSearcher")]).v); const part16 = ends$searches_str_MatchIndices_char_is_whitespace(rs.strMatchIndices(text2, (a0: rs.char): boolean => { return rs.charIsWhitespace(a0); }), front, back); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher"))])); - const few2: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => rs.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher"))]).v); + const _275: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { const _53: rs.usize = rs.u8Rem(_22, 3) as rs.usize; if (!(_53 < 3)) { rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _53); } return [97, 98, 233][_53]; - })); + }); + const few2: string = rs.stringExtendChars(rs.stringNew(), _275).v; const _291: rs.usize = rs.u8Rem(at(2), 10) as rs.usize; if (!(_291 < 10)) { rs.panic("index out of bounds: the len is " + 10 + " but the index is " + _291); @@ -4780,47 +4773,47 @@ export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { const _281: string[] = ["", "a", "aa", "ab", "aab", "aba", "abab", "bé", "aaba", "éaé"]; const part17 = fronts$searches_str_Split_ref_str(rs.strSplit(few2, _281[_291]), front); const args83 = [(f: rs.Formatter) => rs.fmtStrSearch(part17, f, "Split", "StrSearcher")]; - put(out, rs.fmtFormat([args83[0], "|", rs.fmtSpec({ alternate: true }, args83[0]), "|", rs.fmtSpec({ debugHex: "x" }, args83[0])])); + put(out, rs.fmtFormat([args83[0], "|", rs.fmtSpec({ alternate: true }, args83[0]), "|", rs.fmtSpec({ debugHex: "x" }, args83[0])]).v); const part18 = fronts$searches_str_RSplit_ref_str(rs.strRsplit(few2, _281[_291]), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part18, f, "RSplit", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part18, f, "RSplit", "StrSearcher")]).v); const part19 = fronts$searches_str_SplitTerminator_ref_str(rs.strSplitTerminator(few2, _281[_291]), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part19, f, "SplitTerminator", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part19, f, "SplitTerminator", "StrSearcher")]).v); const part20 = fronts$searches_str_SplitN_ref_str(rs.strSplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part20, f, "SplitN", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part20, f, "SplitN", "StrSearcher")]).v); const part21 = fronts$searches_str_RSplitN_ref_str(rs.strRsplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part21, f, "RSplitN", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part21, f, "RSplitN", "StrSearcher")]).v); const part22 = fronts$searches_str_SplitInclusive_ref_str(rs.strSplitInclusive(few2, _281[_291]), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part22, f, "SplitInclusive", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part22, f, "SplitInclusive", "StrSearcher")]).v); const part23 = fronts$searches_str_Matches_ref_str(rs.strMatches(few2, _281[_291]), rs.usizeMul(front, 2)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part23, f, "Matches", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part23, f, "Matches", "StrSearcher")]).v); const part24 = fronts$searches_str_RMatches_ref_str(rs.strRmatches(few2, _281[_291]), rs.usizeMul(front, 2)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part24, f, "RMatches", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part24, f, "RMatches", "StrSearcher")]).v); const part25 = fronts$searches_str_MatchIndices_ref_str(rs.strMatchIndices(few2, _281[_291]), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part25, f, "MatchIndices", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part25, f, "MatchIndices", "StrSearcher")]).v); const part26 = fronts$searches_str_RMatchIndices_ref_str(rs.strRmatchIndices(few2, _281[_291]), front); - put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtStrSearch(part26, f, "RMatchIndices", "StrSearcher"))])); - const part27 = fronts$searches_str_Split_ref_String(rs.strSplit(text2, _281[_291]), front); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part27, f, "Split", "StrSearcher")])); + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, (f: rs.Formatter) => rs.fmtStrSearch(part26, f, "RMatchIndices", "StrSearcher"))]).v); + const part27 = fronts$searches_str_Split_ref_String(rs.strSplit(text2, rs.stringFrom(_281[_291]).v), front); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(part27, f, "Split", "StrSearcher")]).v); const it3: rs.Iter = rs.strMatches(few2, _281[_291]); while (rs.iterToOption(it3.next()) !== undefined) { } - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]).v); it3.next(); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]).v); const it4: rs.Iter<[rs.usize, string]> = rs.strRmatchIndices(few2, _281[_291]); while (rs.iterToOption(it4.next()) !== undefined) { } - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it4, f, "RMatchIndices", "StrSearcher")])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStrSearch(it4, f, "RMatchIndices", "StrSearcher")]).v); const part28 = ends$searches_str_Lines(rs.strLines(text2), front, back); const args97 = [(f: rs.Formatter) => rs.fmtStrSearch(part28, f, "Lines")]; - put(out, rs.fmtFormat([args97[0], "|", rs.fmtSpec({ alternate: true }, args97[0])])); + put(out, rs.fmtFormat([args97[0], "|", rs.fmtSpec({ alternate: true }, args97[0])]).v); const part29 = ends$searches_str_SplitWhitespace(rs.strSplitWhitespace(text2), front, back); const args98 = [(f: rs.Formatter) => rs.fmtStrSearch(part29, f, "SplitWhitespace")]; - put(out, rs.fmtFormat([args98[0], "|", rs.fmtSpec({ alternate: true }, args98[0])])); + put(out, rs.fmtFormat([args98[0], "|", rs.fmtSpec({ alternate: true }, args98[0])]).v); const it7: rs.Iter = ends$searches_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(text2), front, back); const _556: [rs.usize, rs.usize | undefined] = it7.sizeHint(); const args99 = [(f: rs.Formatter) => rs.fmtStrSearch(it7, f, "SplitAsciiWhitespace"), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_556[0], f), (f: rs.Formatter) => rs.fmtOption(_556[1], f, rs.usizeDebug)], f)]; - put(out, rs.fmtFormat([args99[0], "|", rs.fmtSpec({ alternate: true }, args99[0]), "|", rs.fmtSpec({ debugHex: "x" }, args99[0]), "|", args99[1]])); + put(out, rs.fmtFormat([args99[0], "|", rs.fmtSpec({ alternate: true }, args99[0]), "|", rs.fmtSpec({ debugHex: "x" }, args99[0]), "|", args99[1]]).v); } export function ends$searches_str_Lines(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index 5b1dbe873..c22a6b67a 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -34,8 +34,8 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const meters: Wrap.Wrap = new Wrap.Wrap({ _0: at(3) as rs.u64 }, at(4)); const shape: Wrap.Wrap = Wrap.new$shapes_Shape({ tag: "Rect", corner: Wrap.intoInner$shapes_Point(point), width: at(5) as rs.u16, height: 3 } as Shape.Shape); const args13 = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Point(point, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_u8(byte, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Shape(shape, f)]; - put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2], " ", args13[3]])); - put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f))])); + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2], " ", args13[3]]).v); + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f))]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(Wrap.double$u8(byte)))); rs.byteVecPush(out, Wrap.get$u8(byte)); rs.byteVecPush(out, Wrap.get$fmt_Pair(Wrap.get$generics_Wrap_fmt_Pair(nested))._0); @@ -49,7 +49,7 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const _119: Wrap.Wrap = Wrap.new$fmt_Pair({ _0: at(1), _1: 0 }); const _116: boolean = Wrap.eq$cmp_PartialEq_fmt_Pair(mapped, _119); const args15 = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_fmt_Pair(mapped, f), (f: rs.Formatter) => rs.fmtBool(_116, f)]; - put(out, rs.fmtFormat([args15[0], " ", args15[1]])); + put(out, rs.fmtFormat([args15[0], " ", args15[1]]).v); const iter: rs.Iter> = rs.iterSlice(copy$array_generics_Either_u8_shapes_Point([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either])); while (true) { const _140: Either.Either | rs.Done = iter.next(); @@ -61,7 +61,7 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const _153: rs.u8 | undefined = Either.left$u8_shapes_Point(either); const _156: Point.Point | undefined = Either.left$shapes_Point_u8(flipped); const args16 = [(f: rs.Formatter) => Either.fmt$fmt_Debug_u8_shapes_Point(either, f), (f: rs.Formatter) => Either.fmt$fmt_Debug_shapes_Point_u8(flipped, f), (f: rs.Formatter) => rs.fmtOption(_153, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_156, f, (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f))]; - put(out, rs.fmtFormat([args16[0], " ", rs.fmtSpec({ alternate: true }, args16[1]), " ", args16[2], " ", args16[3]])); + put(out, rs.fmtFormat([args16[0], " ", rs.fmtSpec({ alternate: true }, args16[1]), " ", args16[2], " ", args16[3]]).v); } const list: Wrap.Wrap> = new Wrap.Wrap(new rs.Vec(), 1); const _171: rs.u16 = at(10) as rs.u16; @@ -72,11 +72,11 @@ export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { const err: Wrap.Wrap> = new Wrap.Wrap(rs.Err({ tag: "Dot" } as Shape.Shape), 2); const _193: rs.u8 = option_unwrapOr$1fr498u(Wrap.get$Option_u8(none), some.count); const args17 = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_Vec_u16(list, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(none, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(some, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Result_u8_shapes_Shape(err, f), (f: rs.Formatter) => rs.u8Debug(_193, f)]; - put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", args17[4]])); + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", args17[4]]).v); const tagged: Tagged.Tagged, rs.i16> = new Tagged.Tagged({ tag: "Right", value: 500 } as Either.Either, Wrap.new$i16(rs.i16Sub(at(8) as rs.i16, 100)), rs.vecFrom([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rs.i16)].slice())); const _237: Wrap.Wrap | undefined = Tagged.first$generics_Either_u8_u16_i16(tagged); const args18 = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_generics_Either_u8_u16_i16(tagged, f), (f: rs.Formatter) => rs.fmtOption(_237, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]; - put(out, rs.fmtFormat([args18[0], " ", args18[1]])); + put(out, rs.fmtFormat([args18[0], " ", args18[1]]).v); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(tagged.inner.value))); rs.byteVecPush(out, option_unwrapOr$1fr498u(Either.left$u8_u16(tagged.key), 0)); } @@ -193,7 +193,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { const _91: boolean = Runs.eq$cmp_PartialEq_u8(runs, before); const _95: rs.u8 | undefined = Run.first$u8(run); const args5 = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(runs, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(before, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(taken), f, rs.u8Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u8(run, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(fixed, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(copy, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(swapped, f), (f: rs.Formatter) => rs.usizeDisplay(_88, f), (f: rs.Formatter) => rs.fmtBool(_91, f), (f: rs.Formatter) => rs.fmtOption(_95, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; - put(out, rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7], " ", args5[8], " ", args5[9], " ", args5[10]])); + put(out, rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4], " ", args5[5], " ", args5[6], " ", args5[7], " ", args5[8], " ", args5[9], " ", args5[10]]).v); const data3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u16 => { return _22 as rs.u16; }), undefined, 2, true); @@ -239,7 +239,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { const _207: boolean = Runs.eq$cmp_PartialEq_u16(runs2, before2); const _211: rs.u16 | undefined = Run.first$u16(run2); const args6 = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(runs2, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(before2, f), (f: rs.Formatter) => rs.fmtList(taken2.items, f, rs.u16Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u16(run2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(fixed2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(copy2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(swapped2, f), (f: rs.Formatter) => rs.usizeDisplay(_204, f), (f: rs.Formatter) => rs.fmtBool(_207, f), (f: rs.Formatter) => rs.fmtOption(_211, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.u16Debug)]; - put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", args6[6], " ", args6[7], " ", args6[8], " ", args6[9], " ", args6[10]])); + put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", args6[6], " ", args6[7], " ", args6[8], " ", args6[9], " ", args6[10]]).v); const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); const tick: (a0: rs.u8) => Ticked.Ticked = (id: rs.u8): Ticked.Ticked => { return new Ticked.Ticked(id, rs.arcClone(log)); diff --git a/ts/fixtures/lang/shapes/expected/shapes.ts b/ts/fixtures/lang/shapes/expected/shapes.ts index 3a096cfb2..358fe7c80 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.ts @@ -594,7 +594,7 @@ export function order(data: rs.ByteSlice, out: rs.ByteVec): void { const _82: rs.ByteSlice = rs.byteSliceRange(_83, rs.usizeDiv(rs.min(mark(out, 15), len), 2), _85); const _103: rs.usize = sum; const args3 = [(f: rs.Formatter) => Shape.fmt$fmt_Debug(rect, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(line, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(pair, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(read, f), (f: rs.Formatter) => Moved.fmt$fmt_Debug(updated, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(taken, f), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.usizeDisplay(_63, f), (f: rs.Formatter) => rs.usizeDisplay(_103, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_82), f, rs.u8Debug)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " ", args3[5], " ", args3[6], " ", args3[7], " ", args3[8], " ", args3[9]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3], " ", args3[4], " ", args3[5], " ", args3[6], " ", args3[7], " ", args3[8], " ", args3[9]]).v)); const _125: rs.usize = mark(out, 16); const _127: rs.usize = out.length; rs.byteVecPush(out, _125 & 0xff); @@ -1388,7 +1388,7 @@ export function patterns(data: rs.ByteSlice, out: rs.ByteVec): void { const parsed: rs.Result = rs.Ok(data.length & 0xff); const a2: rs.u8 = (parsed as { ok: true; value: rs.u8 }).value; rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rs.u8 }).value, (parsed as { ok: true; value: rs.u8 }).value, early(a2)))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(parsed, f, rs.u8Debug, (value: Void.Void, f: rs.Formatter) => Void.fmt$fmt_Debug(value, f))]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(parsed, f, rs.u8Debug, (value: Void.Void, f: rs.Formatter) => Void.fmt$fmt_Debug(value, f))]).v)); payloads(data.data, data.start, data.length, out); known(data.data, data.start, data.length, out); rematched(data, out); @@ -1478,12 +1478,12 @@ export function payloads(_dataData: Uint8Array, _dataStart: number, dataLen: num replaced = { ok: true, value: 66 }; rs.byteVecPush(out, old); } - let named: rs.Result = rs.Ok(""); + const named: rs.Result = rs.Ok(rs.stringNew()); if (named.ok) { - named = { ok: true, value: named.value + "r" }; + rs.stringPush(named.value, 114); } if (named.ok) { - _86 = rs.stringLen(named.value) & 0xff; + _86 = named.value.len & 0xff; } else { _86 = named.error; } @@ -2305,12 +2305,12 @@ export function library(data: rs.ByteSlice, out: rs.ByteVec): void { } else { rs.byteVecPush(out, 4); } - const _46: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); + const _46: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_46.ok) { - const s: string = _46.value; + const s: rs.String = _46.value; rs.byteVecPush(out, 1); - rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.stringLen(s) as rs.u32))); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(s.len as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s.v)); } else { rs.byteVecPush(out, 0); } diff --git a/ts/fixtures/lang/shares/expected/harness.ts b/ts/fixtures/lang/shares/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/shares/expected/harness.ts +++ b/ts/fixtures/lang/shares/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/shares/expected/shares.ts b/ts/fixtures/lang/shares/expected/shares.ts index d24b63954..828b6b9a4 100644 --- a/ts/fixtures/lang/shares/expected/shares.ts +++ b/ts/fixtures/lang/shares/expected/shares.ts @@ -167,7 +167,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putBytes(borrowed.value, out); const owned: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteCowIntoOwned(rs.byteSliceToByteVec(data2)))); putBytes(owned.value, out); - const s: rs.Arc = new rs.Arc(text(data2)); + const s: rs.Arc = new rs.Arc(text(data2).v); const twin: rs.Arc = rs.arcClone(s); const ofStr: rs.Arc = rs.arcStrBytes(s); counts$slice_u8(ofStr, out); @@ -177,7 +177,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { ofTwin[Symbol.dispose](); counts$slice_u8(ofStr, out); putBytes(ofStr.value, out); - const s2: rs.Arc = new rs.Arc(text(data2)); + const s2: rs.Arc = new rs.Arc(text(data2).v); rs.arcStrBytes(rs.arcClone(s2))[Symbol.dispose](); const _121: rs.Place | undefined = rs.arcGetMutPlace(s2); if (_121 !== undefined) { @@ -192,7 +192,7 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const same2: rs.Arc = rs.arcClone(n); rs.byteVecPush(out, same2 === n ? 1 : 0); rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(same2.value).reverse()), undefined, true); - const arcOfStr: rs.Arc = rs.arcStrBytes(new rs.Arc(text(data2))); + const arcOfStr: rs.Arc = rs.arcStrBytes(new rs.Arc(text(data2).v)); putBytes(arcOfStr.value, out); const v: rs.ByteVec = rs.byteSliceToByteVec(fromVec.value); rs.byteVecPush(v, 238); @@ -242,9 +242,9 @@ export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.u64Eq(hash$sync_Arc_slice_u8(arc), hash$Rc_slice_u8(a)) ? 1 : 0); const _285: rs.Arc = new rs.Arc(rs.byteSliceFrom(new Uint8Array(0))); const args3 = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arc.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_285.value), f, rs.u8Debug)]; - const _281: string = rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3]]); + const _281: rs.String = rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2], "|", args3[3]]); _285[Symbol.dispose](); - put(out, _281); + put(out, _281.v); arc[Symbol.dispose](); b2[Symbol.dispose](); a[Symbol.dispose](); @@ -369,7 +369,7 @@ export function wides(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.cmpArc(rs.cmpSlice(rs.cmp))(collected, fromRef) & 0xff); rs.byteVecPush(out, rs.u64Eq(hash$Rc_slice_u16(collected), hash$slice_u16(collected.value)) ? 1 : 0); const args3 = [(f: rs.Formatter) => rs.fmtList(rs.sliceItems(collected.value), f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(fromVec.value), f, rs.u16Debug)]; - put(out, rs.fmtFormat([args3[0], "|", args3[1]])); + put(out, rs.fmtFormat([args3[0], "|", args3[1]]).v); let shared: rs.Arc> = rs.arcClone(fromRef); counts$slice_u16(fromRef, out); if (rs.u8Rem(kind, 2) === 0) { @@ -563,23 +563,24 @@ export function drops(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { /** `Rc` and `Arc`, each way, read, counted, and written. */ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = text(data); - const fromRef: rs.Arc = new rs.Arc(s); - const fromString: rs.Arc = new rs.Arc(s); - const fromBox: rs.Arc = new rs.Arc(s); - let source: string = s; - const fromMut: rs.Arc = new rs.Arc(source); - source = rs.strToAsciiUppercase(source); - const borrowed: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s))); - const owned: rs.Arc = new rs.Arc(rs.strCowStr(s)); - const into: rs.Arc = new rs.Arc(s); + const s: rs.String = text(data); + const fromRef: rs.Arc = new rs.Arc(s.v); + const fromString: rs.Arc = new rs.Arc(rs.stringClone(s).v); + const fromBox: rs.Arc = new rs.Arc(rs.stringClone(s).v); + const source: rs.String = rs.stringClone(s); + const fromMut: rs.Arc = new rs.Arc(source.v); + const _21: rs.Place = source; + _21.v = rs.strToAsciiUppercase(_21.v); + const borrowed: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s.v))); + const owned: rs.Arc = new rs.Arc(rs.strCowStr(rs.stringClone(s))); + const into: rs.Arc = new rs.Arc(rs.stringClone(s).v); const empty: rs.Arc = new rs.Arc(""); const arcEmpty: rs.Arc = new rs.Arc(""); put(out, fromRef.value); put(out, fromString.value); put(out, fromBox.value); put(out, fromMut.value); - put(out, source); + put(out, source.v); put(out, borrowed.value); put(out, owned.value); put(out, into.value); @@ -587,11 +588,11 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, arcEmpty.value); rs.byteVecPush(out, rs.eqArc(rs.same, true)(fromRef, into) ? 1 : 0); rs.byteVecPush(out, rs.cmpArc(rs.cmpStr)(fromRef, empty) & 0xff); - rs.byteVecPush(out, rs.u64Eq(hash$Rc_str(fromRef), hash$str(s)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(hash$Rc_str(fromRef), hash$str(s.v)) ? 1 : 0); rs.byteVecPush(out, rs.stringLen(fromRef.value) & 0xff); rs.byteVecPush(out, rs.iterCount(rs.strChars(fromRef.value)) & 0xff); const args3 = [(f: rs.Formatter) => rs.fmtPad(f, fromRef.value), (f: rs.Formatter) => rs.fmtStr(fromString.value, f), (f: rs.Formatter) => rs.fmtStr(empty.value, f)]; - put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2]])); + put(out, rs.fmtFormat([args3[0], "|", args3[1], "|", args3[2]]).v); const twin: rs.Arc = rs.arcClone(fromRef); counts$str(twin, out); rs.byteVecPush(out, twin === fromRef ? 1 : 0); @@ -604,12 +605,12 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } else { let _137: rs.Arc = rs.arcClone(twin); - const _135: rs.Place = rs.arcMakeMutPlace(rs.place(() => _137, (value2) => _137 = value2), undefined, rs.drop); + const _135: rs.Place = rs.arcMakeMutPlace(rs.place(() => _137, (value) => _137 = value), undefined, rs.drop); _135.v = rs.strToAsciiLowercase(_135.v); _137[Symbol.dispose](); } let shared: rs.Arc = twin; - const _141: rs.Place = rs.arcMakeMutPlace(rs.place(() => shared, (value3) => shared = value3), undefined, rs.drop); + const _141: rs.Place = rs.arcMakeMutPlace(rs.place(() => shared, (value2) => shared = value2), undefined, rs.drop); _141.v = rs.strToAsciiUppercase(_141.v); counts$str(shared, out); counts$str(fromRef, out); @@ -617,12 +618,12 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, shared.value); put(out, fromRef.value); let arc: rs.Arc = rs.arcClone(fromString); - const _159: rs.Place = rs.arcMakeMutPlace(rs.place(() => arc, (value4) => arc = value4), undefined, rs.drop); + const _159: rs.Place = rs.arcMakeMutPlace(rs.place(() => arc, (value3) => arc = value3), undefined, rs.drop); _159.v = rs.strToAsciiUppercase(_159.v); put(out, arc.value); put(out, fromString.value); - put(out, arc.value); - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtPad(f, fromBox.value))); + put(out, rs.stringFrom(arc.value).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtPad(f, fromBox.value)).v); arc[Symbol.dispose](); shared[Symbol.dispose](); mine[Symbol.dispose](); @@ -687,15 +688,15 @@ export function generics(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void */ export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); - const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data2, 2), text), undefined, 12, true); - const _19: rs.Iter> = rs.iterMap(rs.iterSlice(words.items), (w: string): rs.Arc => { - return new rs.Arc(w); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data2, 2), text), undefined, 12, true); + const _19: rs.Iter> = rs.iterMap(rs.iterSlice(words.items), (w: rs.String): rs.Arc => { + return new rs.Arc(w.v); }); const interned: rs.HashSet> = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashArc(rs.hashStr), rs.eqArc(rs.same, true))) as rs.HashSet>, _19, rs.drop, undefined, 117440512); rs.byteVecPush(out, rs.hashLen(interned) & 0xff); for (const _30 of words.items) { - rs.byteVecPush(out, rs.hashContains(interned, new rs.Arc(_30)) ? 1 : 0); - rs.byteVecPush(out, option_mapOr$00xrvtw(rs.hashKey(interned, new rs.Arc(_30)), 0, (k: rs.Arc): rs.u8 => { + rs.byteVecPush(out, rs.hashContains(interned, new rs.Arc(_30.v)) ? 1 : 0); + rs.byteVecPush(out, option_mapOr$00xrvtw(rs.hashKey(interned, new rs.Arc(_30.v)), 0, (k: rs.Arc): rs.u8 => { return k.strong & 0xff; })); } @@ -726,7 +727,7 @@ export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }), undefined, 2, true).items)); putWides(fromIter.value, out); putWides(fromIter.value, out); - const text_: rs.Arc = new rs.Arc(rs.strsJoin(words.items, "")); + const text_: rs.Arc = new rs.Arc(rs.strsJoin(words.items, "").v); put(out, text_.value); put(out, text_.value); let slot: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); diff --git a/ts/fixtures/lang/singles/expected/singles.ts b/ts/fixtures/lang/singles/expected/singles.ts index 264bfa397..2702ad34c 100644 --- a/ts/fixtures/lang/singles/expected/singles.ts +++ b/ts/fixtures/lang/singles/expected/singles.ts @@ -54,7 +54,7 @@ export function putSecs(out: rs.ByteVec, d: rs.Result rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rs.fmtFormat([args3[0], "|", args3[1]])); + put(out, rs.fmtFormat([args3[0], "|", args3[1]]).v); } } @@ -397,13 +397,13 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { const args17 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(p)]; - put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])])); + put(out, rs.fmtFormat([args17[0], " ", args17[1], " ", args17[2], " ", args17[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args17[4]) }, args17[3]), " ", rs.fmtSpec({ plus: true }, args17[0]), " ", rs.fmtSpec({ plus: true }, args17[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args17[4]) }, args17[2])]).v); const args18 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; - put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0])])); - put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f))); + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args18[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args18[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args18[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args18[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args18[0]), "|", rs.fmtSpec({ alternate: true }, args18[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args18[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[4]), precision: rs.fmtCountOf(args18[5]) }, args18[0])]).v); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f)).v); } else if (_13 === 1) { const args16 = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f)]; - put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args16[0]), " ", rs.fmtSpec({ precision: 120 }, args16[1]), " ", rs.fmtSpec({ precision: 160 }, args16[2])])); + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args16[0]), " ", rs.fmtSpec({ precision: 120 }, args16[1]), " ", rs.fmtSpec({ precision: 160 }, args16[2])]).v); } else if (_13 === 2) { const _72: [rs.f32, rs.ByteSlice] = take(_6[1]); const b: rs.f32 = _72[0]; @@ -413,7 +413,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _78: rs.Vec = rs.vecFrom([Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]); const part = { level: a, history: _78 }; const args15 = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])])); + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ precision: 2 }, args15[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args15[0])]).v); } else { let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rs.i32 = 0; @@ -421,7 +421,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void while (iterStart++ < iterEnd) { const x: rs.f32 = rs.f32FromBits(step(rs.place(() => state, (value) => state = value))); const args13 = [(f: rs.Formatter) => rs.f32Display(x, f), (f: rs.Formatter) => rs.f32Debug(x, f), (f: rs.Formatter) => rs.f32LowerExp(x, f)]; - put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]])); + put(out, rs.fmtFormat([args13[0], " ", args13[1], " ", args13[2]]).v); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 64; @@ -432,7 +432,7 @@ export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const r2: rs.u32 = step(rs.place(() => state, (value2) => state = value2)); const x2: rs.f32 = Math.fround(Math.fround(r2 >>> 8) / Math.fround(rs.u32Shl(1, rs.u32Add(rs.u32Rem(r2, 16), 1)))); const args14 = [(f: rs.Formatter) => rs.f32Debug(x2, f), (f: rs.Formatter) => rs.f32LowerExp(x2, f)]; - put(out, rs.fmtFormat([args14[0], " ", args14[1]])); + put(out, rs.fmtFormat([args14[0], " ", args14[1]]).v); } } } @@ -452,14 +452,14 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { one(_6.value, out); } } else if (_4 === 1) { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(data)) { const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); rs.idx(_21, _22); - s = s + String.fromCodePoint(_21.data[_21.start + _22] as rs.char); + rs.stringPush(s, _21.data[_21.start + _22] as rs.char); } - one(s, out); + one(s.v, out); } else { let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; let iterStart: rs.i32 = 0; @@ -469,8 +469,8 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const half: rs.f64 = ((x as rs.f64) + (rs.f32NextUp(x) as rs.f64)) / 2.0; const p: rs.usize = rs.u32Add(rs.u32Rem(step(rs.place(() => state, (value2) => state = value2)), 30), 8) as rs.usize; const args7 = [(f: rs.Formatter) => rs.f64LowerExp(half, f), rs.fmtCount(p)]; - one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args7[1]) }, args7[0])]), out); - one(rs.fmtFormat([(f: rs.Formatter) => rs.f64LowerExp(half, f)]), out); + one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args7[1]) }, args7[0])]).v, out); + one(rs.fmtFormat([(f: rs.Formatter) => rs.f64LowerExp(half, f)]).v, out); } let iterStart2: rs.i32 = 0; const iterEnd2: rs.i32 = 16; @@ -481,19 +481,19 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const r: rs.u32 = step(rs.place(() => state, (value3) => state = value3)); const len: rs.usize = rs.u32Add(rs.u32Rem(r, 20), 1) as rs.usize; const point: rs.usize = rs.usizeRem(r >>> 8 as rs.usize, rs.usizeAdd(len, 1)); - let s2: string = ""; + const s2: rs.String = rs.stringNew(); let iterStart3: rs.usize = 0; const iterEnd3: rs.usize = len; while ((_108 = iterStart3++) < iterEnd3) { if (_108 === point) { - s2 = s2 + "."; + rs.stringPush(s2, 46); } const _117: rs.char = rs.u8Add(48, rs.u32Rem(step(rs.place(() => state, (value4) => state = value4)), 10) & 0xff) as rs.char; - s2 = s2 + String.fromCodePoint(_117); + rs.stringPush(s2, _117); } const _133: rs.i64 = rs.i64Sub(rs.u32Rem(r >>> 16, 100) as rs.i64, 50); - const args9 = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_133, f)]; - one(rs.fmtFormat([args9[0], "e", args9[1]]), out); + const args9 = [(f: rs.Formatter) => rs.fmtPad(f, s2.v), (f: rs.Formatter) => rs.i64Display(_133, f)]; + one(rs.fmtFormat([args9[0], "e", args9[1]]).v, out); } } } @@ -505,11 +505,11 @@ export function one(s: string, out: rs.ByteVec): void { if (_4.ok) { const v: rs.f32 = _4.value; putF32(out, v); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.f32Debug(v, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.f32Debug(v, f)]).v); } else { const e: rs.ParseFloatError = _4.error; const args5 = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; - put(out, rs.fmtFormat([args5[0], "|", args5[1]])); + put(out, rs.fmtFormat([args5[0], "|", args5[1]]).v); } rs.byteVecPush(out, rs.f32FromStr(s).ok ? 1 : 0); } diff --git a/ts/fixtures/lang/statics/expected/statics.ts b/ts/fixtures/lang/statics/expected/statics.ts index 013c99401..e934c34f5 100644 --- a/ts/fixtures/lang/statics/expected/statics.ts +++ b/ts/fixtures/lang/statics/expected/statics.ts @@ -9,7 +9,7 @@ import * as Dropped from "./statics.Dropped.ts"; import * as Lock from "./statics.Lock.ts"; import type * as Node from "./statics.Node.ts"; import type * as Raw from "./statics.Raw.ts"; -import { withBorrow$03hv9ge, take$1ni7uux, take$1snv7rd } from "./std/thread/local.ts"; +import { withBorrow$15t368r, take$1o1xmz7, take$1snv7rd } from "./std/thread/local.ts"; export const COUNT: rs.Atomic = /* @__PURE__ */ new rs.Atomic({ hi: 0xffffffff, lo: 0xfffffffd } as rs.u64); @@ -338,17 +338,17 @@ export function onces(data: rs.ByteSlice, out: rs.ByteVec): void { owned[Symbol.dispose](); } -export const SHOWN: rs.LazyLock = /* @__PURE__ */ new rs.LazyLock(shown); +export const SHOWN: rs.LazyLock = /* @__PURE__ */ new rs.LazyLock(shown); -export function shown(): string { - const args3 = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; +export function shown(): rs.String { + const args3 = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; return rs.fmtFormat([args3[0], " ", rs.fmtSpec({ alternate: true }, args3[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args3[0])]); } -export const FORCING: rs.LocalKey> | undefined>> = /* @__PURE__ */ new rs.LocalKey(FORCING$init, false); +export const FORCING: rs.LocalKey> | undefined>> = /* @__PURE__ */ new rs.LocalKey(FORCING$init, false); -export function FORCING$init(): rs.RefCell> | undefined> { - return new rs.RefCell(undefined as rs.Arc> | undefined); +export function FORCING$init(): rs.RefCell> | undefined> { + return new rs.RefCell(undefined as rs.Arc> | undefined); } /** @@ -357,7 +357,7 @@ export function FORCING$init(): rs.RefCell> | undefin * forces neither; then its value, padded and pretty as its own `Debug` writes it. */ export function lazies(data: rs.ByteSlice, out: rs.ByteVec): void { - let text!: string; + let text!: rs.String; for (const _5 of rs.byteSliceView(data)) { const _10: rs.u8 = rs.u8Rem(_5, 6); if (_10 === 0) { @@ -365,70 +365,70 @@ export function lazies(data: rs.ByteSlice, out: rs.ByteVec): void { return rs.u8Add(rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0), 10); }); const args49 = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; - const before: string = rs.fmtFormat([args49[0], " ", rs.fmtSpec({ alternate: true }, args49[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args49[0]), "|"]); + const before: rs.String = rs.fmtFormat([args49[0], " ", rs.fmtSpec({ alternate: true }, args49[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args49[0]), "|"]); const forced: rs.u8 = rs.atomicLoad(FORCED, 0); cell.force(); rs.atomicSwap(FORCED, 0, 0); const args50 = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; - const _34: string = rs.fmtFormat([args50[0], " ", rs.fmtSpec({ alternate: true }, args50[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args50[0]), "|"]); - const args51 = [(f: rs.Formatter) => rs.fmtPad(f, before), (f: rs.Formatter) => rs.u8Display(forced, f), (f: rs.Formatter) => rs.fmtPad(f, _34)]; + const _34: rs.String = rs.fmtFormat([args50[0], " ", rs.fmtSpec({ alternate: true }, args50[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args50[0]), "|"]); + const args51 = [(f: rs.Formatter) => rs.fmtPad(f, before.v), (f: rs.Formatter) => rs.u8Display(forced, f), (f: rs.Formatter) => rs.fmtPad(f, _34.v)]; text = rs.fmtFormat([args51[0], args51[1], args51[2]]); } else if (_10 === 1) { const cell2: rs.LazyCell = new rs.LazyCell((): undefined => {}); const args46 = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; - const before2: string = rs.fmtFormat([args46[0], " ", rs.fmtSpec({ alternate: true }, args46[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args46[0]), "|"]); + const before2: rs.String = rs.fmtFormat([args46[0], " ", rs.fmtSpec({ alternate: true }, args46[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args46[0]), "|"]); cell2.force(); const args47 = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; - const _67: string = rs.fmtFormat([args47[0], " ", rs.fmtSpec({ alternate: true }, args47[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args47[0]), "|"]); - const args48 = [(f: rs.Formatter) => rs.fmtPad(f, before2), (f: rs.Formatter) => rs.fmtPad(f, _67)]; + const _67: rs.String = rs.fmtFormat([args47[0], " ", rs.fmtSpec({ alternate: true }, args47[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args47[0]), "|"]); + const args48 = [(f: rs.Formatter) => rs.fmtPad(f, before2.v), (f: rs.Formatter) => rs.fmtPad(f, _67.v)]; text = rs.fmtFormat([args48[0], args48[1]]); } else if (_10 === 2) { const lock: rs.LazyLock = new rs.LazyLock((): rs.u8 | undefined => { return undefined; }); const args43 = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - const before3: string = rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args43[0]), "|"]); + const before3: rs.String = rs.fmtFormat([args43[0], " ", rs.fmtSpec({ alternate: true }, args43[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args43[0]), "|"]); lock.force(); const args44 = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; - const _98: string = rs.fmtFormat([args44[0], " ", rs.fmtSpec({ alternate: true }, args44[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args44[0]), "|"]); - const args45 = [(f: rs.Formatter) => rs.fmtPad(f, before3), (f: rs.Formatter) => rs.fmtPad(f, _98)]; + const _98: rs.String = rs.fmtFormat([args44[0], " ", rs.fmtSpec({ alternate: true }, args44[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args44[0]), "|"]); + const args45 = [(f: rs.Formatter) => rs.fmtPad(f, before3.v), (f: rs.Formatter) => rs.fmtPad(f, _98.v)]; text = rs.fmtFormat([args45[0], args45[1]]); } else if (_10 === 3) { const lock2: rs.LazyLock> = new rs.LazyLock((): rs.Vec => { return rs.vecFrom(["a", "bc"]); }); const args40 = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; - const before4: string = rs.fmtFormat([args40[0], " ", rs.fmtSpec({ alternate: true }, args40[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args40[0]), "|"]); + const before4: rs.String = rs.fmtFormat([args40[0], " ", rs.fmtSpec({ alternate: true }, args40[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args40[0]), "|"]); lock2.force().items.length; const args41 = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; - const _130: string = rs.fmtFormat([args41[0], " ", rs.fmtSpec({ alternate: true }, args41[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args41[0]), "|"]); - const args42 = [(f: rs.Formatter) => rs.fmtPad(f, before4), (f: rs.Formatter) => rs.fmtPad(f, _130)]; + const _130: rs.String = rs.fmtFormat([args41[0], " ", rs.fmtSpec({ alternate: true }, args41[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args41[0]), "|"]); + const args42 = [(f: rs.Formatter) => rs.fmtPad(f, before4.v), (f: rs.Formatter) => rs.fmtPad(f, _130.v)]; text = rs.fmtFormat([args42[0], args42[1]]); } else if (_10 === 4) { - const _148: string = SHOWN.force(); - const args38 = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; - const _151: string = rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args38[0]), "|"]); - const args39 = [(f: rs.Formatter) => rs.fmtPad(f, _148), (f: rs.Formatter) => rs.fmtPad(f, _151)]; + const _148: rs.String = SHOWN.force(); + const args38 = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + const _151: rs.String = rs.fmtFormat([args38[0], " ", rs.fmtSpec({ alternate: true }, args38[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args38[0]), "|"]); + const args39 = [(f: rs.Formatter) => rs.fmtPad(f, _148.v), (f: rs.Formatter) => rs.fmtPad(f, _151.v)]; text = rs.fmtFormat([args39[0], " ", args39[1]]); } else { - const cell3: rs.Arc> = new rs.Arc(new rs.LazyCell((): string => { - return withBorrow$03hv9ge(FORCING, (me: rs.Arc> | undefined): string => { + const cell3: rs.Arc> = new rs.Arc(new rs.LazyCell((): rs.String => { + return withBorrow$15t368r(FORCING, (me: rs.Arc> | undefined): rs.String => { const part = rs.optionUnwrap(me); - const args35 = [(f: rs.Formatter) => part.value.debug(f, "LazyCell", rs.fmtStr)]; + const args35 = [(f: rs.Formatter) => part.value.debug(f, "LazyCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; return rs.fmtFormat([args35[0], " ", rs.fmtSpec({ alternate: true }, args35[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args35[0]), "|"]); }); })); rs.localKeyRefCellSet(FORCING, rs.arcClone(cell3), rs.drop); - const _175: string = cell3.value.force(); - const args36 = [(f: rs.Formatter) => cell3.value.debug(f, "LazyCell", rs.fmtStr)]; - const _179: string = rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args36[0]), "|"]); - const args37 = [(f: rs.Formatter) => rs.fmtPad(f, _175), (f: rs.Formatter) => rs.fmtPad(f, _179)]; - const text2: string = rs.fmtFormat([args37[0], " ", args37[1]]); - rs.drop(take$1ni7uux(FORCING)); + const _175: rs.String = cell3.value.force(); + const args36 = [(f: rs.Formatter) => cell3.value.debug(f, "LazyCell", (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + const _179: rs.String = rs.fmtFormat([args36[0], " ", rs.fmtSpec({ alternate: true }, args36[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args36[0]), "|"]); + const args37 = [(f: rs.Formatter) => rs.fmtPad(f, _175.v), (f: rs.Formatter) => rs.fmtPad(f, _179.v)]; + const text2: rs.String = rs.fmtFormat([args37[0], " ", args37[1]]); + rs.drop(take$1o1xmz7(FORCING)); text = text2; cell3[Symbol.dispose](); } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); } } @@ -500,7 +500,7 @@ export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { } export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyCell, out: rs.ByteVec): void { - const _18: (a0: rs.LazyCell) => string = (l: rs.LazyCell): string => { + const _18: (a0: rs.LazyCell) => rs.String = (l: rs.LazyCell): rs.String => { return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); }; let _103: boolean = false; @@ -522,17 +522,17 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: const _28: rs.LazyCell = a; _103 = false; const old: rs.LazyCell = rs.replaceIn(_28, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old).v)); rs.lazyDrop(old, rs.drop); } else if (_20 === 2) { b = rs.replaceIn(a, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b).v)); rs.byteVecPush(out, b.force()._0); } else if (_20 === 3) { const _52: rs.Cell> = rs.cellIn(a); _103 = false; const old2: rs.LazyCell = rs.cellReplace(_52, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2).v)); rs.lazyDrop(old2, rs.drop); } else if (_20 === 4) { const _62: rs.Cell> = rs.cellIn(a); @@ -555,9 +555,9 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rs.refMutRelease(_78); a = held.value[1]; } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); rs.byteVecPush(out, a.force()._0); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); if (_103) { rs.lazyDrop(b, rs.drop); } @@ -566,7 +566,7 @@ export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: } export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyLock, out: rs.ByteVec): void { - const _18: (a0: rs.LazyLock) => string = (l: rs.LazyLock): string => { + const _18: (a0: rs.LazyLock) => rs.String = (l: rs.LazyLock): rs.String => { return rs.fmtFormat([(f: rs.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f)), "|"]); }; let _103: boolean = false; @@ -588,17 +588,17 @@ export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: const _28: rs.LazyLock = a; _103 = false; const old: rs.LazyLock = rs.replaceIn(_28, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old).v)); rs.lazyDrop(old, rs.drop); } else if (_20 === 2) { b = rs.replaceIn(a, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b).v)); rs.byteVecPush(out, b.force()._0); } else if (_20 === 3) { const _52: rs.Cell> = rs.cellIn(a); _103 = false; const old2: rs.LazyLock = rs.cellReplace(_52, b); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2).v)); rs.lazyDrop(old2, rs.drop); } else if (_20 === 4) { const _62: rs.Cell> = rs.cellIn(a); @@ -621,9 +621,9 @@ export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rs.refMutRelease(_78); a = held.value[1]; } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); rs.byteVecPush(out, a.force()._0); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a).v)); if (_103) { rs.lazyDrop(b, rs.drop); } diff --git a/ts/fixtures/lang/statics/expected/std/thread/local.ts b/ts/fixtures/lang/statics/expected/std/thread/local.ts index 7be29cc62..1a052c859 100644 --- a/ts/fixtures/lang/statics/expected/std/thread/local.ts +++ b/ts/fixtures/lang/statics/expected/std/thread/local.ts @@ -2,19 +2,19 @@ import * as rs from "../../rs.ts"; -export function withBorrow$03hv9ge(self: rs.LocalKey> | undefined>>, f: (a0: rs.Arc> | undefined) => string): string { +export function withBorrow$15t368r(self: rs.LocalKey> | undefined>>, f: (a0: rs.Arc> | undefined) => rs.String): rs.String { const captured = f; - return ((cell: rs.RefCell> | undefined>): string => { - const _32: (a0: rs.Arc> | undefined) => string = captured; - const _7: rs.RefCell> | undefined> = rs.refCellBorrow(cell); - const _02: string = _32(_7.value); + return ((cell: rs.RefCell> | undefined>): rs.String => { + const _32: (a0: rs.Arc> | undefined) => rs.String = captured; + const _7: rs.RefCell> | undefined> = rs.refCellBorrow(cell); + const _02: rs.String = _32(_7.value); rs.refRelease(_7); return _02; })(self.get()); } -export function take$1ni7uux(self: rs.LocalKey> | undefined>>): rs.Arc> | undefined { - return ((a0: rs.RefCell> | undefined>): rs.Arc> | undefined => { +export function take$1o1xmz7(self: rs.LocalKey> | undefined>>): rs.Arc> | undefined { + return ((a0: rs.RefCell> | undefined>): rs.Arc> | undefined => { return rs.refCellReplace(a0, undefined); })(self.get()); } diff --git a/ts/fixtures/lang/strs/expected/harness.ts b/ts/fixtures/lang/strs/expected/harness.ts index 4bb0dfa08..b3134e568 100644 --- a/ts/fixtures/lang/strs/expected/harness.ts +++ b/ts/fixtures/lang/strs/expected/harness.ts @@ -42,8 +42,8 @@ export function put(out: rs.ByteVec, s: string): void { } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rs.ByteSlice): string { - let s: string = ""; +export function text(data: rs.ByteSlice): rs.String { + const s: rs.String = rs.stringNew(); const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { @@ -55,7 +55,7 @@ export function text(data: rs.ByteSlice): string { if (!(_13 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } - s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } } diff --git a/ts/fixtures/lang/strs/expected/strs.Counted.ts b/ts/fixtures/lang/strs/expected/strs.Counted.ts index 4d6dfb4f9..0a88b4bd7 100644 --- a/ts/fixtures/lang/strs/expected/strs.Counted.ts +++ b/ts/fixtures/lang/strs/expected/strs.Counted.ts @@ -8,13 +8,13 @@ export interface Counted { nexts: rs.Cell; } -export function next$iter_Iterator_String(self: Counted): string | rs.Done { +export function next$iter_Iterator_String(self: Counted): rs.String | rs.Done { rs.cellSet(self.nexts, rs.u8Add(self.nexts.v, 1)); - const _8: [string, rs.Slice] | undefined = rs.sliceSplitFirst(self.items as rs.Slice); + const _8: [rs.String, rs.Slice] | undefined = rs.sliceSplitFirst(self.items as rs.Slice); if (_8 !== undefined) { - const val: [string, rs.Slice] = _8; - (self.items as rs.Slice) = val[1]; - return val[0]; + const val: [rs.String, rs.Slice] = _8; + (self.items as rs.Slice) = val[1]; + return rs.stringClone(val[0]); } return rs.DONE; } diff --git a/ts/fixtures/lang/strs/expected/strs.Named.ts b/ts/fixtures/lang/strs/expected/strs.Named.ts index 029969cd5..bcb0e2dad 100644 --- a/ts/fixtures/lang/strs/expected/strs.Named.ts +++ b/ts/fixtures/lang/strs/expected/strs.Named.ts @@ -3,11 +3,11 @@ import * as rs from "./rs.ts"; export interface Named { - name: string; + name: rs.String; } export function add(self: Named, c: rs.char): void { - self.name = self.name + String.fromCodePoint(c); + rs.stringPush(self.name, c); } //# sourceMappingURL=strs.Named.ts.map diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index 942dbf242..3a564bd1e 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -52,7 +52,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let part5!: string | undefined; let item!: [rs.usize, string] | undefined; let _260!: rs.char; - const s: string = text(data); + const s: rs.String = text(data); const _7: rs.usize = rs.u8Rem(rs.u8Div(kind, 8), 16) as rs.usize; if (!(_7 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _7); @@ -61,7 +61,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { b0: { const _13: rs.u8 = rs.u8Rem(kind, 8); if (_13 === 0) { - const it: rs.Iter = rs.strChars(s); + const it: rs.Iter = rs.strChars(s.v); let i: rs.usize = 0; while (true) { if (!fromBack(data, i)) { @@ -73,8 +73,8 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (!(c === undefined)) { i = rs.usizeAdd(i, 1); } else { - rs.byteVecPush(out, rs.iterCount(rs.strChars(s)) & 0xff); - const iter: rs.Iter = rs.iterRev(rs.strChars(s)); + rs.byteVecPush(out, rs.iterCount(rs.strChars(s.v)) & 0xff); + const iter: rs.Iter = rs.iterRev(rs.strChars(s.v)); while (true) { const _41: rs.char | rs.Done = iter.next(); if (_41 === rs.DONE) { @@ -82,14 +82,14 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, rs.isAsciiDigit(_41) ? 1 : 0); } - rs.byteVecPush(out, s.length === 0 ? 1 : 0); - rs.byteVecPush(out, s.length === 0 ? 1 : 0); + rs.byteVecPush(out, s.len === 0 ? 1 : 0); + rs.byteVecPush(out, s.v.length === 0 ? 1 : 0); break b0; } } } if (_13 === 1) { - const parts: rs.Iter = rs.strSplit(s, String.fromCodePoint(sep)); + const parts: rs.Iter = rs.strSplit(s.v, String.fromCodePoint(sep)); let i2: rs.usize = 0; while (true) { if (!fromBack(data, i2)) { @@ -104,8 +104,8 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { i2 = rs.usizeAdd(i2, 1); } else { rs.byteVecPush(out, i2 & 0xff); - put(out, option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, String.fromCodePoint(sep)).next()), "none")); - const parts2: rs.Iter = rs.strSplitTerminator(s, String.fromCodePoint(sep)); + put(out, option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s.v, String.fromCodePoint(sep)).next()), "none")); + const parts2: rs.Iter = rs.strSplitTerminator(s.v, String.fromCodePoint(sep)); let i3: rs.usize = 0; while (true) { if (!fromBack(data, i3)) { @@ -126,7 +126,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } if (_13 === 2) { const seen: rs.Vec = new rs.Vec(); - const parts3: rs.Iter = rs.strSplit(s, (c9: rs.char): boolean => { + const parts3: rs.Iter = rs.strSplit(s.v, (c9: rs.char): boolean => { seen.items.push(c9); if (!(c9 === sep)) { return rs.isAsciiDigit(c9); @@ -150,12 +150,12 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } if (_13 === 3) { - put(out, rs.strTrimStartMatches(s, String.fromCodePoint(sep))); - put(out, rs.strTrimEndMatches(s, String.fromCodePoint(sep))); - put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s, String.fromCodePoint(sep)), String.fromCodePoint(sep))); - rs.byteVecPush(out, rs.strStartsWith(s, String.fromCodePoint(sep)) ? 1 : 0); - putOffset(out, rs.strRfind(s, String.fromCodePoint(sep))); - const _143: [string, string] | undefined = rs.strRsplitOnce(s, String.fromCodePoint(sep)); + put(out, rs.strTrimStartMatches(s.v, String.fromCodePoint(sep))); + put(out, rs.strTrimEndMatches(s.v, String.fromCodePoint(sep))); + put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s.v, String.fromCodePoint(sep)), String.fromCodePoint(sep))); + rs.byteVecPush(out, rs.strStartsWith(s.v, String.fromCodePoint(sep)) ? 1 : 0); + putOffset(out, rs.strRfind(s.v, String.fromCodePoint(sep))); + const _143: [string, string] | undefined = rs.strRsplitOnce(s.v, String.fromCodePoint(sep)); if (_143 === undefined) { rs.byteVecPush(out, 253); } else { @@ -164,28 +164,28 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } else if (_13 === 4) { const seen2: rs.Vec = new rs.Vec(); - put(out, rs.strTrimStartMatches(s, (c5: rs.char): boolean => { + put(out, rs.strTrimStartMatches(s.v, (c5: rs.char): boolean => { seen2.items.push(c5); return c5 === sep; })); putSeen(out, rs.sliceFrom(seen2.items)); - put(out, rs.strTrimEndMatches(s, (c6: rs.char): boolean => { + put(out, rs.strTrimEndMatches(s.v, (c6: rs.char): boolean => { seen2.items.push(c6); return c6 !== sep; })); putSeen(out, rs.sliceFrom(seen2.items)); - rs.byteVecPush(out, rs.strStartsWith(s, (c7: rs.char): boolean => { + rs.byteVecPush(out, rs.strStartsWith(s.v, (c7: rs.char): boolean => { return rs.isAsciiDigit(c7); }) ? 1 : 0); - put(out, rs.strTrimStartMatches(s, digit)); - putOffset(out, rs.strRfind(s, (c8: rs.char): boolean => { + put(out, rs.strTrimStartMatches(s.v, digit)); + putOffset(out, rs.strRfind(s.v, (c8: rs.char): boolean => { seen2.items.push(c8); return c8 === sep; })); putSeen(out, rs.sliceFrom(seen2.items)); } else { if (_13 === 5) { - const found2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s, String.fromCodePoint(sep)); + const found2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s.v, String.fromCodePoint(sep)); let i5: rs.usize = 0; while (true) { if (!fromBack(data, i5)) { @@ -200,7 +200,7 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, matched); i5 = rs.usizeAdd(i5, 1); } else { - for (const _214 of rs.iterToVec(rs.iterMap(rs.strMatchIndices(s, "/"), (_2: [rs.usize, string]): rs.usize => { + for (const _214 of rs.iterToVec(rs.iterMap(rs.strMatchIndices(s.v, "/"), (_2: [rs.usize, string]): rs.usize => { return _2[0]; }), "next", 4).items) { putOffset(out, _214); @@ -210,16 +210,16 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } if (_13 === 6) { - const parts4: rs.Vec = unescape(s); + const parts4: rs.Vec = unescape(s.v); for (const _226 of parts4.items) { - put(out, _226); + put(out, _226.v); } - put(out, escape(rs.sliceFrom(parts4.items))); + put(out, escape(rs.sliceFrom(parts4.items)).v); } else { - let built: string = ""; - const named: Named.Named = { name: "" }; - const each: rs.Vec = rs.vecFrom(["", ""]); - const iter4: rs.Iter<[rs.usize, rs.char]> = rs.iterEnumerate(rs.strChars(s)); + let built: rs.String = rs.stringNew(); + const named: Named.Named = { name: rs.stringNew() }; + const each: rs.Vec = rs.vecFrom([rs.stringNew(), rs.stringNew()]); + const iter4: rs.Iter<[rs.usize, rs.char]> = rs.iterEnumerate(rs.strChars(s.v)); while (true) { const _251: [rs.usize, rs.char] | rs.Done = iter4.next(); if (_251 === rs.DONE) { @@ -227,37 +227,36 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } const i6: rs.usize = _251[0]; const c3: rs.char = _251[1]; - built = built + String.fromCodePoint(c3); + rs.stringPush(built, c3); if (!(rs.usizeRem(i6, 2) === 0)) { _260 = sep; } else { _260 = c3; } - named.name = named.name + String.fromCodePoint(_260); + rs.stringPush(named.name, _260); Named.add(named, c3); - const at2 = rs.idx(each.items, rs.usizeRem(i6, 2)); - each.items[at2] = each.items[at2] + String.fromCodePoint(c3); + rs.stringPush(each.items[rs.idx(each.items, rs.usizeRem(i6, 2))], c3); const _271: rs.char | undefined = rs.charFromU32(rs.u32Add(c3 as rs.u32, 1)); if (_271 !== undefined) { - built = built + String.fromCodePoint(_271); + rs.stringPush(built, _271); } } - named.name = named.name + "􏿿"; - put(out, built); - put(out, named.name); - put(out, each.items[rs.idx(each.items, 0)]); - put(out, each.items[rs.idx(each.items, 1)]); - const before: string = built; - const len: rs.usize = rs.stringLen(built); - const empty: boolean = built.length === 0; - built = built + String.fromCodePoint(sep); - put(out, before); + rs.stringPush(named.name, 1114111); + put(out, built.v); + put(out, named.name.v); + put(out, each.items[rs.idx(each.items, 0)].v); + put(out, each.items[rs.idx(each.items, 1)].v); + const before: rs.String = rs.stringClone(built); + const len: rs.usize = built.len; + const empty: boolean = built.len === 0; + rs.stringPush(built, sep); + put(out, before.v); rs.byteVecPush(out, len & 0xff); rs.byteVecPush(out, empty ? 1 : 0); const taken2 = built; - built = ""; - put(out, taken2); - rs.byteVecPush(out, built.length === 0 ? 1 : 0); + built = rs.stringNew(); + put(out, taken2.v); + rs.byteVecPush(out, built.len === 0 ? 1 : 0); } } } @@ -267,15 +266,15 @@ export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * Up to three chars of `s`, from the char the kind's high bits pick: empty a quarter of * the time, and otherwise found at least once unless the text is shorter. */ -export function pattern(kind: rs.u8, s: string): string { - let p: string = ""; +export function pattern(kind: rs.u8, s: string): rs.String { + const p: rs.String = rs.stringNew(); const iter: rs.Iter = rs.iterTake(rs.iterSkip(rs.strChars(s), rs.u8Div(kind, 32) as rs.usize), rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize); while (true) { const _17: rs.char | rs.Done = iter.next(); if (_17 === rs.DONE) { return p; } - p = p + String.fromCodePoint(_17); + rs.stringPush(p, _17); } } @@ -286,13 +285,13 @@ export function pattern(kind: rs.u8, s: string): string { export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _219!: [rs.usize, rs.usize]; let sliced!: string; - const s: string = text(data); - const p: string = pattern(kind, s); + const s: rs.String = text(data); + const p: rs.String = pattern(kind, s.v); b0: { const _8: rs.u8 = rs.u8Rem(kind, 8); if (_8 === 0) { let n: rs.i32 = 0; - const iter: rs.Iter = rs.strSplit(s, p); + const iter: rs.Iter = rs.strSplit(s.v, p.v); while (true) { const _18: string | rs.Done = iter.next(); if (_18 === rs.DONE) { @@ -302,10 +301,10 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { n = rs.i32Add(n, 1); } rs.byteVecPush(out, n & 0xff); - put(out, option_unwrapOr$1iemzn8(rs.iterLast(rs.strSplit(s, p)), "none")); + put(out, option_unwrapOr$1iemzn8(rs.iterLast(rs.strSplit(s.v, p.v)), "none")); } else { if (_8 === 1) { - const iter2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s, p); + const iter2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s.v, p.v); while (true) { const _42: [rs.usize, string] | rs.Done = iter2.next(); if (_42 === rs.DONE) { @@ -314,26 +313,26 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const at: rs.usize = _42[0]; putOffset(out, at); put(out, _42[1]); - put(out, rs.strSlice(s, 0, at)); + put(out, rs.strSlice(s.v, 0, at)); const part6 = rs.usizeAdd(at, rs.stringLen(_42[1])); - put(out, rs.strSlice(s, part6)); + put(out, rs.strSlice(s.v, part6)); const part7 = rs.usizeAdd(at, rs.stringLen(_42[1])); - put(out, rs.strSlice(s, at, part7)); + put(out, rs.strSlice(s.v, at, part7)); } } if (_8 === 2) { - put(out, rs.strTrimStartMatches(s, p)); - put(out, rs.strTrimEndMatches(s, p)); - put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s, p), p)); - rs.byteVecPush(out, rs.strStartsWith(s, p) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, p) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, p) ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, "/") ? 1 : 0); - rs.byteVecPush(out, rs.strContains(s, (c: rs.char): boolean => { + put(out, rs.strTrimStartMatches(s.v, p.v)); + put(out, rs.strTrimEndMatches(s.v, p.v)); + put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s.v, p.v), p.v)); + rs.byteVecPush(out, rs.strStartsWith(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, p.v) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, "/") ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s.v, (c: rs.char): boolean => { return rs.isAsciiDigit(c); }) ? 1 : 0); - putOffset(out, rs.strRfind(s, p)); - const _123: [string, string] | undefined = rs.strRsplitOnce(s, p); + putOffset(out, rs.strRfind(s.v, p.v)); + const _123: [string, string] | undefined = rs.strRsplitOnce(s.v, p.v); if (_123 === undefined) { rs.byteVecPush(out, 253); } else { @@ -342,7 +341,7 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } } else { if (_8 === 3) { - const iter3: rs.Iter = rs.iterSuccessors(s, (path: string): string | undefined => { + const iter3: rs.Iter = rs.iterSuccessors(s.v, (path: string): string | undefined => { const _73: string = path; return then$0havnzo(!(path.length === 0), (): string => { return option_mapOr$19xt0tb(rs.strRfind(_73, "/"), "", (slash: rs.usize): string => { @@ -360,30 +359,30 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } if (_8 === 4) { const keep: rs.usize = rs.usizeAdd(rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize, 1); - put(out, option_unwrapOr$1iemzn8(option_map$0h0w6xi(rs.iterNth(rs.strMatchIndices(s, "/"), rs.usizeSub(keep, 1)), (_2: [rs.usize, string]): string => { - return rs.strSlice(s, 0, _2[0]); + put(out, option_unwrapOr$1iemzn8(option_map$0h0w6xi(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), (_2: [rs.usize, string]): string => { + return rs.strSlice(s.v, 0, _2[0]); }), "none")); - const part5 = option_mapOr$1wbabuw(rs.iterNth(rs.strMatchIndices(s, "/"), rs.usizeSub(keep, 1)), rs.stringLen(s), (_22: [rs.usize, string]): rs.usize => { + const part5 = option_mapOr$1wbabuw(rs.iterNth(rs.strMatchIndices(s.v, "/"), rs.usizeSub(keep, 1)), s.len, (_22: [rs.usize, string]): rs.usize => { return rs.usizeAdd(_22[0], 1); }); - put(out, rs.strSlice(s, part5)); + put(out, rs.strSlice(s.v, part5)); } else if (_8 === 5) { - const parts: rs.Vec = rs.iterToVec(rs.strSplit(s, "/"), "next", 8); + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s.v, "/"), "next", 8); const _186: rs.Slice = rs.sliceFrom(parts.items); - const _188: string = p; - put(out, rs.strsJoin(rs.sliceItems(_186), _188)); - const _199: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (part3: string): string => { - return part3; + const _188: string = p.v; + put(out, rs.strsJoin(rs.sliceItems(_186), _188).v); + const _199: rs.Slice = rs.sliceFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (part3: string): rs.String => { + return rs.stringFrom(part3); }), undefined, 12, true).items); - const _201: string = p; - put(out, rs.strsJoin(rs.sliceItems(_199), _201)); - put(out, rs.strsJoin(["a", "", s], "/")); + const _201: string = p.v; + put(out, rs.strsJoin(rs.sliceItems(_199), _201).v); + put(out, rs.strsJoin(["a", "", s.v], "/").v); } else { const at2: (a0: rs.u8) => rs.usize = (b2: rs.u8): rs.usize => { if ((kind & 32) === 0) { - return rs.usizeRem(b2 as rs.usize, rs.usizeAdd(rs.stringLen(s), 2)); + return rs.usizeRem(b2 as rs.usize, rs.usizeAdd(s.len, 2)); } - return rs.usizeSaturatingSub(rs.usizeAdd(rs.stringLen(s), 1), rs.usizeRem(b2 as rs.usize, 4)); + return rs.usizeSaturatingSub(rs.usizeAdd(s.len, 1), rs.usizeRem(b2 as rs.usize, 4)); }; if (!(data.length >= 2)) { _219 = [0, 0] as [rs.usize, rs.usize]; @@ -394,13 +393,13 @@ export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.usize = _219[1]; const _233: rs.u8 = rs.u8Rem(rs.u8Div(kind, 8), 4); if (_233 === 0) { - sliced = rs.strSlice(s, a, b); + sliced = rs.strSlice(s.v, a, b); } else if (_233 === 1) { - sliced = rs.strSlice(s, a); + sliced = rs.strSlice(s.v, a); } else if (_233 === 2) { - sliced = rs.strSlice(s, 0, b); + sliced = rs.strSlice(s.v, 0, b); } else { - sliced = rs.strSlice(s, 0); + sliced = rs.strSlice(s.v, 0); } put(out, sliced); } @@ -415,10 +414,10 @@ export function digit(c: rs.char): boolean { } /** `/` separates parts, and `\` escapes a `/` or `\` within one. */ -export function unescape(path: string): rs.Vec { +export function unescape(path: string): rs.Vec { if (!(path.length === 0)) { - const parts: rs.Vec = new rs.Vec(); - let part: string = ""; + const parts: rs.Vec = new rs.Vec(); + let part: rs.String = rs.stringNew(); const chars: rs.Iter = rs.strChars(path); while (true) { const _7: rs.char | rs.Done = chars.next(); @@ -426,21 +425,21 @@ export function unescape(path: string): rs.Vec { const ch: rs.char = _7; if (ch === 47) { const taken = part; - part = ""; + part = rs.stringNew(); parts.items.push(taken); } else if (ch === 92) { const _14: rs.char | rs.Done = chars.next(); if (_14 === rs.DONE) { - part = part + "\\"; + rs.stringPush(part, 92); } else if (_14 === 47 || _14 === 92) { - part = part + String.fromCodePoint(_14); + rs.stringPush(part, _14); } else { const next2: rs.char = _14; - part = part + "\\"; - part = part + String.fromCodePoint(next2); + rs.stringPush(part, 92); + rs.stringPush(part, next2); } } else { - part = part + String.fromCodePoint(ch); + rs.stringPush(part, ch); } } else { break; @@ -452,19 +451,19 @@ export function unescape(path: string): rs.Vec { return new rs.Vec(); } -export function escape(parts: rs.Slice): string { +export function escape(parts: rs.Slice): rs.String { let _23!: boolean; - let path: string = ""; - const iter: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(parts))); + const path: rs.String = rs.stringNew(); + const iter: rs.Iter<[rs.usize, rs.String]> = rs.iterEnumerate(rs.iterSlice(rs.sliceItems(parts))); l1: while (true) { - const _7: [rs.usize, string] | rs.Done = iter.next(); + const _7: [rs.usize, rs.String] | rs.Done = iter.next(); if (_7 === rs.DONE) { return path; } if (_7[0] > 0) { - path = path + "/"; + rs.stringPush(path, 47); } - const iter2: rs.Iter = rs.strChars(_7[1]); + const iter2: rs.Iter = rs.strChars(_7[1].v); while (true) { const _19: rs.char | rs.Done = iter2.next(); if (_19 === rs.DONE) { @@ -477,9 +476,9 @@ export function escape(parts: rs.Slice): string { _23 = false; } if (_23) { - path = path + "\\"; + rs.stringPush(path, 92); } - path = path + String.fromCodePoint(ch); + rs.stringPush(path, ch); } } } @@ -511,15 +510,15 @@ export function offset(s: string, b: rs.u8): rs.usize { } /** `String::retain` by a function behind a `&mut`, behind two, and boxed behind one. */ -export function retainBy(s: rs.Place, f: rs.Place<(a0: rs.char) => boolean>, how: rs.u8): void { +export function retainBy(s: rs.String, f: rs.Place<(a0: rs.char) => boolean>, how: rs.u8): void { const _4: rs.u8 = rs.u8Rem(how, 3); if (_4 === 0) { - s.v = rs.stringRetain(s.v, f.v); + rs.stringRetain(s, f.v); } else if (_4 === 1) { let _7: rs.Place<(a0: rs.char) => boolean> = f; - s.v = rs.stringRetain(s.v, rs.place(() => _7, (value) => _7 = value).v.v); + rs.stringRetain(s, rs.place(() => _7, (value) => _7 = value).v.v); } else { - s.v = rs.stringRetain(s.v, f.v); + rs.stringRetain(s, f.v); } } @@ -528,29 +527,25 @@ export function odd(c: rs.char): boolean { } /** One edit of `s` by `op`, taking offsets and text from `a` and `b`, through a `&mut`. */ -export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs.ByteVec): void { +export function edit(s: rs.String, op: rs.u8, a: rs.u8, b: rs.u8, out: rs.ByteVec): void { let capacity!: rs.usize; - const piece: string = text(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, rs.u8Rem(a, 4) as rs.usize)); + const piece: rs.String = text(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, rs.u8Rem(a, 4) as rs.usize)); const _17: [rs.usize, rs.usize] = [offset(s.v, a), offset(s.v, b)]; const i: rs.usize = _17[0]; const j: rs.usize = _17[1]; const _24: rs.u8 = rs.u8Rem(op, 14); if (_24 === 0) { - s.v = s.v + piece; + rs.stringPushStr(s, piece.v); } else if (_24 === 1) { const _28: rs.u8 = rs.u8Rem(b, 4); if (_28 === 0) { - s.v = s.v + piece; + rs.stringPushStr(s, piece.v); } else if (_28 === 1) { - const taken2 = s.v; - s.v = ""; - s.v = taken2 + piece; + Object.assign(s, rs.stringAdd(rs.replaceIn(s, rs.stringNew()), piece.v)); } else if (_28 === 2) { - const taken = s.v; - s.v = ""; - s.v = taken + "" + piece + piece; + Object.assign(s, rs.stringAdd(rs.stringAdd(rs.stringAdd(rs.replaceIn(s, rs.stringNew()), ""), piece.v), piece.v)); } else { - s.v = rs.stringWithCapacity(a as rs.usize) + s.v + ""; + Object.assign(s, rs.stringAdd(rs.stringAdd(rs.stringWithCapacity(a as rs.usize), s.v), "")); } } else if (_24 === 2) { if (!(rs.u8Rem(a, 4) === 0)) { @@ -558,32 +553,28 @@ export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs if (!(_59 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _59); } - s.v = s.v + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_59]); + rs.stringPush(s, [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_59]); } else { - s.v = ""; + rs.stringClear(s); } } else if (_24 === 3) { - s.v = rs.stringTruncate(s.v, i); + rs.stringTruncate(s, i); } else if (_24 === 4) { - const edit3 = rs.stringPop(s.v); - s.v = edit3[0]; - putChar(out, edit3[1]); + putChar(out, rs.stringPop(s)); } else if (_24 === 5) { - const edit2 = rs.stringRemove(s.v, i); - s.v = edit2[0]; - putChar(out, edit2[1]); + putChar(out, rs.stringRemove(s, i)); } else if (_24 === 6) { const _68: rs.usize = rs.u8Rem(b, 16) as rs.usize; if (!(_68 < 16)) { rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _68); } - s.v = rs.stringInsertStr(s.v, i, String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_68])); + rs.stringInsertStr(s, i, String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_68])); } else if (_24 === 7) { - s.v = rs.stringInsertStr(s.v, i, piece); + rs.stringInsertStr(s, i, piece.v); } else if (_24 === 8) { if (!(rs.u8Rem(b, 2) === 1)) { const seen: rs.Vec = new rs.Vec(); - s.v = rs.stringRetain(s.v, (c: rs.char): boolean => { + rs.stringRetain(s, (c: rs.char): boolean => { seen.items.push(c); return rs.u32Rem(c as rs.u32, 3) !== rs.u8Rem(a, 3) as rs.u32; }); @@ -593,55 +584,48 @@ export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs retainBy(s, rs.place(() => f, (value) => f = value), a); } } else if (_24 === 9) { - const edit = rs.stringSplitOff(s.v, i); - s.v = edit[0]; - put(out, edit[1]); + put(out, rs.stringSplitOff(s, i).v); } else if (_24 === 10) { const _91: rs.u8 = rs.u8Rem(b, 7); if (_91 === 0) { - const _93: rs.Range = new rs.Range(i, j); - s.v = rs.stringReplaceRange(s.v, _93, piece); + rs.stringReplaceRange(s, new rs.Range(i, j), piece.v); } else if (_91 === 1) { - const _96: rs.RangeFrom = new rs.RangeFrom(i, rs.usizeStep); - s.v = rs.stringReplaceRange(s.v, _96, piece); + rs.stringReplaceRange(s, new rs.RangeFrom(i, rs.usizeStep), piece.v); } else if (_91 === 2) { - const _99: { end: rs.usize } = { end: j }; - s.v = rs.stringReplaceRange(s.v, _99, piece); + rs.stringReplaceRange(s, { end: j }, piece.v); } else if (_91 === 3) { - s.v = rs.stringReplaceRange(s.v, undefined, piece); + rs.stringReplaceRange(s, undefined, piece.v); } else if (_91 === 4) { - const _104: rs.RangeInclusive = new rs.RangeInclusive(i, j, rs.usizeStep); - s.v = rs.stringReplaceRange(s.v, _104, piece); + rs.stringReplaceRange(s, new rs.RangeInclusive(i, j, rs.usizeStep), piece.v); } else if (_91 === 5) { - const _107: { end: rs.usize; inclusive: true } = { end: j, inclusive: true }; - s.v = rs.stringReplaceRange(s.v, _107, piece); + rs.stringReplaceRange(s, { end: j, inclusive: true }, piece.v); } else { - const _110: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: i } as rs.RangeBound, { tag: "Included", _0: j } as rs.RangeBound]; - s.v = rs.stringReplaceRange(s.v, _110, piece); + rs.stringReplaceRange(s, [{ tag: "Excluded", _0: i } as rs.RangeBound, { tag: "Included", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], piece.v); } } else if (_24 === 11) { const _115: rs.u8 = rs.u8Rem(b, 5); if (_115 === 0) { - s.v = rs.stringExtendFromWithin(s.v, new rs.Range(i, j)); + rs.stringExtendFromWithin(s, new rs.Range(i, j)); } else if (_115 === 1) { - s.v = rs.stringExtendFromWithin(s.v, new rs.RangeFrom(i, rs.usizeStep)); + rs.stringExtendFromWithin(s, new rs.RangeFrom(i, rs.usizeStep)); } else if (_115 === 2) { - s.v = rs.stringExtendFromWithin(s.v, { end: j, inclusive: true }); + rs.stringExtendFromWithin(s, { end: j, inclusive: true }); } else if (_115 === 3) { - s.v = rs.stringExtendFromWithin(s.v, [{ tag: "Included", _0: i } as rs.RangeBound, { tag: "Excluded", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); + rs.stringExtendFromWithin(s, [{ tag: "Included", _0: i } as rs.RangeBound, { tag: "Excluded", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); } else { - s.v = rs.stringExtendFromWithin(s.v, undefined); + rs.stringExtendFromWithin(s, undefined); } } else if (_24 === 12) { const _123: rs.u8 = rs.u8Rem(a, 4); if (_123 === 0) { - rs.stringReserve(s.v, rs.usizeSub(4294967295, b as rs.usize)); + rs.stringReserve(s, rs.usizeSub(4294967295, b as rs.usize)); } else if (_123 === 1) { - const _128: rs.usize = rs.usizeAdd(rs.usizeAdd(rs.usizeSub(2147483647, rs.stringLen(s.v)), 1), rs.u8Rem(b, 2) as rs.usize); - rs.stringReserve(s.v, _128); + rs.stringReserveExact(s, rs.usizeAdd(rs.usizeAdd(rs.usizeSub(2147483647, s.len), 1), rs.u8Rem(b, 2) as rs.usize)); } else { - rs.stringReserve(s.v, a as rs.usize); - rs.stringReserve(s.v, b as rs.usize); + rs.stringReserve(s, a as rs.usize); + rs.stringReserveExact(s, b as rs.usize); + rs.stringShrinkTo(s, a as rs.usize); + rs.stringShrinkTo(s, 0); } } else { if (rs.u8Rem(a, 4) === 0) { @@ -649,9 +633,9 @@ export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs } else { capacity = a as rs.usize; } - let fresh: string = rs.stringWithCapacity(capacity); - fresh = fresh + s.v; - s.v = fresh; + const fresh: rs.String = rs.stringWithCapacity(capacity); + rs.stringPushStr(fresh, s.v); + Object.assign(s, fresh); } } @@ -666,7 +650,7 @@ export function edits(kind: rs.u8, dataData: Uint8Array, dataStart: number, data rs.panic("mid > len"); } const head: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart, mid); - let s: string = text(head); + let s: rs.String = text(head); const named: Named.Named = { name: text(head) }; const iter: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + mid, dataLen - mid), 3); while (true) { @@ -681,52 +665,34 @@ export function edits(kind: rs.u8, dataData: Uint8Array, dataStart: number, data const b: rs.u8 = _25[2]; const _39: rs.u8 = rs.u8Div(op, 64); if (_39 === 0) { - edit(rs.place(() => named.name, (value10) => named.name = value10), op, a, b, out); + edit(named.name, op, a, b, out); } else if (_39 === 1) { const _42: rs.u8 = rs.u8Rem(op, 8); if (_42 === 0) { - const _44: rs.Place = rs.place(() => s, (value9) => s = value9); - _44.v = _44.v + "é/"; + rs.stringPushStr(s, "é/"); } else if (_42 === 1) { - const _46: rs.Place = rs.place(() => s, (value8) => s = value8); - const _47: rs.usize = offset(s, a); - _46.v = rs.stringTruncate(_46.v, _47); + rs.stringTruncate(s, offset(s.v, a)); } else if (_42 === 2) { - const _51: rs.Place = rs.place(() => s, (value7) => s = value7); - const edit4 = rs.stringPop(_51.v); - _51.v = edit4[0]; - putChar(out, edit4[1]); + putChar(out, rs.stringPop(s)); } else if (_42 === 3) { - const _52: rs.Place = rs.place(() => s, (value6) => s = value6); - const _53: rs.usize = offset(s, a); - _52.v = rs.stringInsertStr(_52.v, _53, "😀"); + rs.stringInsertStr(s, offset(s.v, a), "😀"); } else if (_42 === 4) { - const _60: rs.Place = rs.place(() => s, (value5) => s = value5); - const _61: rs.usize = offset(s, a); - const edit3 = rs.stringSplitOff(_60.v, _61); - _60.v = edit3[0]; - put(out, edit3[1]); + put(out, rs.stringSplitOff(s, offset(s.v, a)).v); } else if (_42 === 5) { - const _66: rs.Place = rs.place(() => s, (value4) => s = value4); - const edit2 = rs.stringRemove(_66.v, 0); - _66.v = edit2[0]; - putChar(out, edit2[1]); + putChar(out, rs.stringRemove(s, 0)); } else if (_42 === 6) { - const _70: rs.Place = rs.place(() => s, (value3) => s = value3); - const edit_ = rs.stringSplitOff(_70.v, 1); - _70.v = edit_[0]; - put(out, edit_[1]); + put(out, rs.stringSplitOff(s, 1).v); } else { - s = ""; + rs.stringClear(s); } } else { - edit(rs.place(() => s, (value) => s = value), op, a, b, out); + edit(s, op, a, b, out); } - put(out, s); - put(out, named.name); + put(out, s.v); + put(out, named.name.v); } - s = s + "😀" + named.name; - put(out, s); + s = rs.stringAdd(rs.stringAdd(s, "😀"), named.name.v); + put(out, s.v); } /** @@ -735,7 +701,7 @@ export function edits(kind: rs.u8, dataData: Uint8Array, dataStart: number, data * alphabet of signs, digits, and the letters of `true` and `false`. */ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - let one!: string | undefined; + let one!: rs.String | undefined; let all!: rs.Vec; const radix: rs.u32 = rs.u32Add(2, rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.u32, 35)); const _13: rs.u8 = rs.u8Rem(rs.u8Div(kind, 14), 3); @@ -744,20 +710,20 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } else if (_13 === 1) { one = text(data); } else { - let s: string = ""; + const s: rs.String = rs.stringNew(); for (const b of rs.byteSliceView(data)) { const _29: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)); const _30: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)).length); rs.idx(_29, _30); - s = s + String.fromCodePoint(_29.data[_29.start + _30] as rs.char); + rs.stringPush(s, _29.data[_29.start + _30] as rs.char); } one = s; } - const _39: string | undefined = one; + const _39: rs.String | undefined = one; if (_39 === undefined) { all = rs.vecFrom(["true", "false", "True", "FALSE", "", " true", "true ", "t", "truefalse", "a", "é", "ࠀ", "😀", "􏿿", "ab", "a😀", "😀a", "éé", "0", "+0", "-0", "000", "1", "+1", "-1", "+", "-", "--1", "+-1", "1_0", "0x1", "127", "128", "-128", "-129", "255", "256", "32767", "32768", "-32768", "-32769", "65535", "65536", "2147483647", "2147483648", "-2147483648", "-2147483649", "4294967295", "4294967296", "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809", "18446744073709551615", "18446744073709551616", "170141183460469231731687303715884105727", "170141183460469231731687303715884105728", "-170141183460469231731687303715884105728", "-170141183460469231731687303715884105729", "340282366920938463463374607431768211455", "340282366920938463463374607431768211456"].slice()); } else { - all = rs.vecFrom([_39]); + all = rs.vecFrom([_39.v]); } for (const _49 of all.items) { const _53: rs.u8 = rs.u8Rem(kind, 14); @@ -771,11 +737,11 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed: rs.Result = _65; if (parsed.ok) { const arg26 = parsed.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(arg26, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtBool(arg26, f)]).v); } else { const part13 = new rs.ParseBoolError(); const args191 = [(f: rs.Formatter) => rs.fmtParseBoolErrorDisplay(part13, f), (f: rs.Formatter) => rs.fmtParseBoolErrorDebug(part13, f)]; - put(out, rs.fmtFormat([args191[0], "|", args191[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args191[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args191[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args191[1]), "|", rs.fmtSpec({ alternate: true }, args191[1])])); + put(out, rs.fmtFormat([args191[0], "|", args191[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args191[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args191[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args191[1]), "|", rs.fmtSpec({ alternate: true }, args191[1])]).v); } } parse$1yfzdza(_49); @@ -789,11 +755,11 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed2: rs.Result = _105; if (parsed2.ok) { const arg25 = parsed2.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCharDebug(arg25, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtCharDebug(arg25, f)]).v); } else { const e: rs.ParseCharError = parsed2.error; const args189 = [(f: rs.Formatter) => rs.fmtParseCharErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseCharErrorDebug(e, f)]; - put(out, rs.fmtFormat([args189[0], "|", args189[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args189[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args189[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args189[1]), "|", rs.fmtSpec({ alternate: true }, args189[1])])); + put(out, rs.fmtFormat([args189[0], "|", args189[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args189[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args189[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args189[1]), "|", rs.fmtSpec({ alternate: true }, args189[1])]).v); } } rs.charFromStr(_49); @@ -808,26 +774,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed3: rs.Result = _149; if (parsed3.ok) { const arg23 = parsed3.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(arg23, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Debug(arg23, f)]).v); } else { const e2: rs.ParseIntError = parsed3.error; const args184 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f)]; - put(out, rs.fmtFormat([args184[0], "|", args184[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args184[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args184[1]), "|", rs.fmtSpec({ alternate: true }, args184[1])])); + put(out, rs.fmtFormat([args184[0], "|", args184[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args184[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args184[1]), "|", rs.fmtSpec({ alternate: true }, args184[1])]).v); } } const _139: rs.Result = parse$1y4njjc(_49); if (!_139.ok) { const part12 = _139.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part12)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part12)]).v); } const _195: rs.Result = nonzero_fromStrRadix$1i96daa(_49, radix2); if (_195.ok) { const arg24 = _195.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg24, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u8Display(arg24, f)]).v); } else { const e4: rs.ParseIntError = _195.error; const args187 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f)]; - put(out, rs.fmtFormat([args187[0], "|", args187[1]])); + put(out, rs.fmtFormat([args187[0], "|", args187[1]]).v); } } else if (_53 === 3) { const radix3: rs.u32 = radix; @@ -840,26 +806,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed4: rs.Result = _236; if (parsed4.ok) { const arg21 = parsed4.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Debug(arg21, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Debug(arg21, f)]).v); } else { const e5: rs.ParseIntError = parsed4.error; const args179 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f)]; - put(out, rs.fmtFormat([args179[0], "|", args179[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args179[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args179[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args179[1]), "|", rs.fmtSpec({ alternate: true }, args179[1])])); + put(out, rs.fmtFormat([args179[0], "|", args179[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args179[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args179[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args179[1]), "|", rs.fmtSpec({ alternate: true }, args179[1])]).v); } } const _226: rs.Result = parse$13tnb7e(_49); if (!_226.ok) { const part11 = _226.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part11)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part11)]).v); } const _282: rs.Result = nonzero_fromStrRadix$0yk2yqd(_49, radix3); if (_282.ok) { const arg22 = _282.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg22, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(arg22, f)]).v); } else { const e7: rs.ParseIntError = _282.error; const args182 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f)]; - put(out, rs.fmtFormat([args182[0], "|", args182[1]])); + put(out, rs.fmtFormat([args182[0], "|", args182[1]]).v); } } else if (_53 === 4) { const radix4: rs.u32 = radix; @@ -872,26 +838,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed5: rs.Result = _323; if (parsed5.ok) { const arg19 = parsed5.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(arg19, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Debug(arg19, f)]).v); } else { const e8: rs.ParseIntError = parsed5.error; const args174 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f)]; - put(out, rs.fmtFormat([args174[0], "|", args174[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args174[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args174[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args174[1]), "|", rs.fmtSpec({ alternate: true }, args174[1])])); + put(out, rs.fmtFormat([args174[0], "|", args174[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args174[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args174[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args174[1]), "|", rs.fmtSpec({ alternate: true }, args174[1])]).v); } } const _313: rs.Result = parse$04z9euf(_49); if (!_313.ok) { const part10 = _313.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part10)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part10)]).v); } const _369: rs.Result = nonzero_fromStrRadix$1y934te(_49, radix4); if (_369.ok) { const arg20 = _369.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg20, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(arg20, f)]).v); } else { const e10: rs.ParseIntError = _369.error; const args177 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f)]; - put(out, rs.fmtFormat([args177[0], "|", args177[1]])); + put(out, rs.fmtFormat([args177[0], "|", args177[1]]).v); } } else if (_53 === 5) { const radix5: rs.u32 = radix; @@ -904,26 +870,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed6: rs.Result = _410; if (parsed6.ok) { const arg17 = parsed6.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Debug(arg17, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Debug(arg17, f)]).v); } else { const e11: rs.ParseIntError = parsed6.error; const args169 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f)]; - put(out, rs.fmtFormat([args169[0], "|", args169[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args169[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args169[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args169[1]), "|", rs.fmtSpec({ alternate: true }, args169[1])])); + put(out, rs.fmtFormat([args169[0], "|", args169[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args169[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args169[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args169[1]), "|", rs.fmtSpec({ alternate: true }, args169[1])]).v); } } const _400: rs.Result = parse$1fob3ck(_49); if (!_400.ok) { const part9 = _400.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part9)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part9)]).v); } const _456: rs.Result = nonzero_fromStrRadix$11u1rq7(_49, radix5); if (_456.ok) { const arg18 = _456.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg18, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u64Display(arg18, f)]).v); } else { const e13: rs.ParseIntError = _456.error; const args172 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f)]; - put(out, rs.fmtFormat([args172[0], "|", args172[1]])); + put(out, rs.fmtFormat([args172[0], "|", args172[1]]).v); } } else if (_53 === 6) { const radix6: rs.u32 = radix; @@ -936,26 +902,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed7: rs.Result = _497; if (parsed7.ok) { const arg15 = parsed7.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Debug(arg15, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Debug(arg15, f)]).v); } else { const e14: rs.ParseIntError = parsed7.error; const args164 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f)]; - put(out, rs.fmtFormat([args164[0], "|", args164[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args164[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args164[1]), "|", rs.fmtSpec({ alternate: true }, args164[1])])); + put(out, rs.fmtFormat([args164[0], "|", args164[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args164[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args164[1]), "|", rs.fmtSpec({ alternate: true }, args164[1])]).v); } } const _487: rs.Result = parse$0j8ztlu(_49); if (!_487.ok) { const part8 = _487.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part8)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part8)]).v); } const _543: rs.Result = nonzero_fromStrRadix$1ejhcoz(_49, radix6); if (_543.ok) { const arg16 = _543.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg16, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.u128Display(arg16, f)]).v); } else { const e16: rs.ParseIntError = _543.error; const args167 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f)]; - put(out, rs.fmtFormat([args167[0], "|", args167[1]])); + put(out, rs.fmtFormat([args167[0], "|", args167[1]]).v); } } else if (_53 === 7) { const radix7: rs.u32 = radix; @@ -968,26 +934,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed8: rs.Result = _584; if (parsed8.ok) { const arg13 = parsed8.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDebug(arg13, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDebug(arg13, f)]).v); } else { const e17: rs.ParseIntError = parsed8.error; const args159 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f)]; - put(out, rs.fmtFormat([args159[0], "|", args159[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args159[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args159[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args159[1]), "|", rs.fmtSpec({ alternate: true }, args159[1])])); + put(out, rs.fmtFormat([args159[0], "|", args159[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args159[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args159[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args159[1]), "|", rs.fmtSpec({ alternate: true }, args159[1])]).v); } } const _574: rs.Result = parse$1acldxi(_49); if (!_574.ok) { const part7 = _574.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part7)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part7)]).v); } const _630: rs.Result = nonzero_fromStrRadix$1dc88z1(_49, radix7); if (_630.ok) { const arg14 = _630.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg14, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.usizeDisplay(arg14, f)]).v); } else { const e19: rs.ParseIntError = _630.error; const args162 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f)]; - put(out, rs.fmtFormat([args162[0], "|", args162[1]])); + put(out, rs.fmtFormat([args162[0], "|", args162[1]]).v); } } else if (_53 === 8) { const radix8: rs.u32 = radix; @@ -1000,26 +966,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed9: rs.Result = _671; if (parsed9.ok) { const arg11 = parsed9.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Debug(arg11, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Debug(arg11, f)]).v); } else { const e20: rs.ParseIntError = parsed9.error; const args154 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f)]; - put(out, rs.fmtFormat([args154[0], "|", args154[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args154[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args154[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args154[1]), "|", rs.fmtSpec({ alternate: true }, args154[1])])); + put(out, rs.fmtFormat([args154[0], "|", args154[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args154[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args154[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args154[1]), "|", rs.fmtSpec({ alternate: true }, args154[1])]).v); } } const _661: rs.Result = parse$0jsh5gh(_49); if (!_661.ok) { const part6 = _661.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part6)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part6)]).v); } const _717: rs.Result = nonzero_fromStrRadix$011a32r(_49, radix8); if (_717.ok) { const arg12 = _717.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg12, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i8Display(arg12, f)]).v); } else { const e22: rs.ParseIntError = _717.error; const args157 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f)]; - put(out, rs.fmtFormat([args157[0], "|", args157[1]])); + put(out, rs.fmtFormat([args157[0], "|", args157[1]]).v); } } else if (_53 === 9) { const radix9: rs.u32 = radix; @@ -1032,26 +998,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed10: rs.Result = _758; if (parsed10.ok) { const arg9 = parsed10.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Debug(arg9, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Debug(arg9, f)]).v); } else { const e23: rs.ParseIntError = parsed10.error; const args149 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f)]; - put(out, rs.fmtFormat([args149[0], "|", args149[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args149[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args149[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args149[1]), "|", rs.fmtSpec({ alternate: true }, args149[1])])); + put(out, rs.fmtFormat([args149[0], "|", args149[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args149[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args149[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args149[1]), "|", rs.fmtSpec({ alternate: true }, args149[1])]).v); } } const _748: rs.Result = parse$0wntisu(_49); if (!_748.ok) { const part5 = _748.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part5)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part5)]).v); } const _804: rs.Result = nonzero_fromStrRadix$1u0zwz8(_49, radix9); if (_804.ok) { const arg10 = _804.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg10, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i16Display(arg10, f)]).v); } else { const e25: rs.ParseIntError = _804.error; const args152 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f)]; - put(out, rs.fmtFormat([args152[0], "|", args152[1]])); + put(out, rs.fmtFormat([args152[0], "|", args152[1]]).v); } } else if (_53 === 10) { const radix10: rs.u32 = radix; @@ -1064,26 +1030,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed11: rs.Result = _845; if (parsed11.ok) { const arg7 = parsed11.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Debug(arg7, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Debug(arg7, f)]).v); } else { const e26: rs.ParseIntError = parsed11.error; const args144 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f)]; - put(out, rs.fmtFormat([args144[0], "|", args144[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args144[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args144[1]), "|", rs.fmtSpec({ alternate: true }, args144[1])])); + put(out, rs.fmtFormat([args144[0], "|", args144[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args144[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args144[1]), "|", rs.fmtSpec({ alternate: true }, args144[1])]).v); } } const _835: rs.Result = parse$18h4mna(_49); if (!_835.ok) { const part4 = _835.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part4)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part4)]).v); } const _891: rs.Result = nonzero_fromStrRadix$1m6epfo(_49, radix10); if (_891.ok) { const arg8 = _891.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg8, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i32Display(arg8, f)]).v); } else { const e28: rs.ParseIntError = _891.error; const args147 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f)]; - put(out, rs.fmtFormat([args147[0], "|", args147[1]])); + put(out, rs.fmtFormat([args147[0], "|", args147[1]]).v); } } else if (_53 === 11) { const radix11: rs.u32 = radix; @@ -1096,26 +1062,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed12: rs.Result = _932; if (parsed12.ok) { const arg5 = parsed12.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Debug(arg5, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Debug(arg5, f)]).v); } else { const e29: rs.ParseIntError = parsed12.error; const args139 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f)]; - put(out, rs.fmtFormat([args139[0], "|", args139[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args139[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args139[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args139[1]), "|", rs.fmtSpec({ alternate: true }, args139[1])])); + put(out, rs.fmtFormat([args139[0], "|", args139[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args139[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args139[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args139[1]), "|", rs.fmtSpec({ alternate: true }, args139[1])]).v); } } const _922: rs.Result = parse$1gh8p0t(_49); if (!_922.ok) { const part3 = _922.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part3)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part3)]).v); } const _978: rs.Result = nonzero_fromStrRadix$15i0o2z(_49, radix11); if (_978.ok) { const arg6 = _978.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg6, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i64Display(arg6, f)]).v); } else { const e31: rs.ParseIntError = _978.error; const args142 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f)]; - put(out, rs.fmtFormat([args142[0], "|", args142[1]])); + put(out, rs.fmtFormat([args142[0], "|", args142[1]]).v); } } else if (_53 === 12) { const radix12: rs.u32 = radix; @@ -1128,26 +1094,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed13: rs.Result = _1019; if (parsed13.ok) { const arg3 = parsed13.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Debug(arg3, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Debug(arg3, f)]).v); } else { const e32: rs.ParseIntError = parsed13.error; const args134 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f)]; - put(out, rs.fmtFormat([args134[0], "|", args134[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args134[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args134[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args134[1]), "|", rs.fmtSpec({ alternate: true }, args134[1])])); + put(out, rs.fmtFormat([args134[0], "|", args134[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args134[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args134[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args134[1]), "|", rs.fmtSpec({ alternate: true }, args134[1])]).v); } } const _1009: rs.Result = parse$1d17hvd(_49); if (!_1009.ok) { const part2 = _1009.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part2)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part2)]).v); } const _1065: rs.Result = nonzero_fromStrRadix$09x3avk(_49, radix12); if (_1065.ok) { const arg4 = _1065.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg4, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.i128Display(arg4, f)]).v); } else { const e34: rs.ParseIntError = _1065.error; const args137 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f)]; - put(out, rs.fmtFormat([args137[0], "|", args137[1]])); + put(out, rs.fmtFormat([args137[0], "|", args137[1]]).v); } } else { const radix13: rs.u32 = radix; @@ -1160,26 +1126,26 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const parsed14: rs.Result = _1106; if (parsed14.ok) { const arg = parsed14.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDebug(arg, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDebug(arg, f)]).v); } else { const e35: rs.ParseIntError = parsed14.error; const args129 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f)]; - put(out, rs.fmtFormat([args129[0], "|", args129[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args129[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args129[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args129[1]), "|", rs.fmtSpec({ alternate: true }, args129[1])])); + put(out, rs.fmtFormat([args129[0], "|", args129[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args129[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args129[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args129[1]), "|", rs.fmtSpec({ alternate: true }, args129[1])]).v); } } const _1096: rs.Result = parse$09069e1(_49); if (!_1096.ok) { const part = _1096.error.kind; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtWriteStr(f, part)]).v); } const _1152: rs.Result = nonzero_fromStrRadix$1jg523s(_49, radix13); if (_1152.ok) { const arg2 = _1152.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]).v); } else { const e37: rs.ParseIntError = _1152.error; const args132 = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f)]; - put(out, rs.fmtFormat([args132[0], "|", args132[1]])); + put(out, rs.fmtFormat([args132[0], "|", args132[1]]).v); } } } @@ -1190,94 +1156,102 @@ export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { * picks, from text of chars of every UTF-8 width and its parts between `/`s. */ export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = text(data); - const chars: rs.Vec = rs.iterToVec(rs.strChars(s), "next", 4); - const parts: rs.Vec = rs.iterToVec(rs.strSplit(s, "/"), "next", 8); + const s: rs.String = text(data); + const chars: rs.Vec = rs.iterToVec(rs.strChars(s.v), "next", 4); + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s.v, "/"), "next", 8); const nexts: rs.Cell = new rs.Cell(0); const named: Named.Named = { name: text(rs.byteSliceRange(data, 0, rs.usizeDiv(data.length, 2))) }; const _21: rs.u8 = rs.u8Rem(kind, 4); if (_21 === 0) { - put(out, rs.stringExtendChars("", rs.strChars(s))); - put(out, rs.stringExtendChars("", rs.iterFilter(rs.iterRev(rs.strChars(s)), (c: rs.char): boolean => { + const _27: rs.Iter = rs.strChars(s.v); + put(out, rs.stringExtendChars(rs.stringNew(), _27).v); + const _34: rs.Iter = rs.iterFilter(rs.iterRev(rs.strChars(s.v)), (c: rs.char): boolean => { return !rs.isAsciiDigit(c); - }))); - put(out, rs.stringExtendChars("", rs.iterSlice(chars.items))); - put(out, rs.stringExtendChars("", rs.iterSkip(rs.iterSlice(chars.items), 1))); + }); + put(out, rs.stringExtendChars(rs.stringNew(), _34).v); + const _43: rs.Iter = rs.iterSlice(chars.items); + put(out, rs.stringExtendChars(rs.stringNew(), _43).v); + const _50: rs.Iter = rs.iterSkip(rs.iterSlice(chars.items), 1); + put(out, rs.stringExtendChars(rs.stringNew(), _50).v); rs.iterEmpty(); - put(out, rs.stringExtendChars("", rs.iterEmpty() as rs.Iter)); - put(out, rs.stringExtendChars("", rs.iterOption(rs.charFromU32(kind as rs.u32)))); - put(out, rs.stringExtendChars("", rs.iterFrom({ items: rs.sliceFrom(chars.items), nexts }, Counted.next$iter_Iterator_char))); + put(out, rs.stringExtendChars(rs.stringNew(), rs.iterEmpty() as rs.Iter).v); + const _64: rs.Iter = rs.iterOption(rs.charFromU32(kind as rs.u32)); + put(out, rs.stringExtendChars(rs.stringNew(), _64).v); + const counted: Counted.Counted = { items: rs.sliceFrom(chars.items), nexts }; + put(out, rs.stringExtendChars(rs.stringNew(), rs.iterFrom(counted, Counted.next$iter_Iterator_char)).v); } else if (_21 === 1) { - put(out, rs.stringExtend("", rs.iterSlice(parts.items))); - put(out, rs.stringExtend("", rs.iterRev(rs.strSplit(s, "/")))); - put(out, rs.stringFromStrings(rs.iterMap(rs.iterSlice(parts.items), (p3: string): string => { - return p3; - }))); - put(out, rs.stringFromStrings(rs.iterFilter(rs.iterMap(rs.strSplit(s, "/"), (p4: string): string => { + const _79: rs.Iter = rs.iterSlice(parts.items); + put(out, rs.stringExtend(rs.stringNew(), _79).v); + const _87: rs.Iter = rs.iterRev(rs.strSplit(s.v, "/")); + put(out, rs.stringExtend(rs.stringNew(), _87).v); + put(out, rs.stringFromStrings(rs.iterMap(rs.iterSlice(parts.items), (p3: string): rs.String => { + return rs.stringFrom(p3); + })).v); + put(out, rs.stringFromStrings(rs.iterFilter(rs.iterMap(rs.strSplit(s.v, "/"), (p4: string): rs.String => { const args6 = [(f: rs.Formatter) => rs.fmtPad(f, p4)]; return rs.fmtFormat([args6[0], args6[0]]); - }), (p5: string): boolean => { - return !(p5.length === 0); - }))); + }), (p5: rs.String): boolean => { + return !(p5.len === 0); + })).v); rs.iterEmpty(); - put(out, rs.stringFromStrings(rs.iterEmpty() as rs.Iter)); - put(out, rs.strCowStr(rs.stringExtendChars("", rs.iterRev(rs.strChars(s))))); - put(out, rs.stringExtend("", rs.iterSlice(parts.items))); - const owned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (p6: string): string => { - return p6; + put(out, rs.stringFromStrings(rs.iterEmpty() as rs.Iter).v); + const _114: rs.Iter = rs.iterRev(rs.strChars(s.v)); + put(out, rs.strCowStr(rs.stringExtendChars(rs.stringNew(), _114))); + const _122: rs.Iter = rs.iterSlice(parts.items); + put(out, rs.stringExtend(rs.stringNew(), _122).v); + const owned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (p6: string): rs.String => { + return rs.stringFrom(p6); }), undefined, 12, true); - put(out, rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.iterSlice(owned.items), (p7: string): rs.StrCow => { - return new rs.Borrowed(p7); - }), rs.strCowStr))); - put(out, rs.stringFromStrings(rs.iterFrom({ items: rs.sliceFrom(owned.items), nexts }, Counted.next$iter_Iterator_String))); + put(out, rs.stringFromStrings(rs.iterMap(rs.iterSlice(owned.items), (p7: rs.String): rs.StrCow => { + return new rs.Borrowed(p7.v); + })).v); + put(out, rs.stringFromStrings(rs.iterFrom({ items: rs.sliceFrom(owned.items), nexts }, Counted.next$iter_Iterator_String)).v); } else if (_21 === 2) { - let t: string = "é"; + const t: rs.String = rs.stringFrom("é"); const _153: rs.Slice = rs.sliceFrom(chars.items); - extendChars(rs.place(() => t, (value) => t = value), _153, kind); - const _157: rs.Iter = rs.iterRev(rs.strChars(s)); - t = rs.stringExtendChars(t, _157); - named.name = rs.stringExtendChars(named.name, rs.iterSlice(chars.items)); + extendChars(t, _153, kind); + const _157: rs.Iter = rs.iterRev(rs.strChars(s.v)); + rs.stringExtendChars(t, _157); + rs.stringExtendChars(named.name, rs.iterSlice(chars.items)); rs.iterEmpty(); - named.name = rs.stringExtendChars(named.name, rs.iterEmpty() as rs.Iter); + rs.stringExtendChars(named.name, rs.iterEmpty() as rs.Iter); const counted3: Counted.Counted = { items: rs.sliceFrom(chars.items), nexts }; - t = rs.stringExtendChars(t, rs.iterFrom(counted3, Counted.next$iter_Iterator_char)); - put(out, t); + rs.stringExtendChars(t, rs.iterFrom(counted3, Counted.next$iter_Iterator_char)); + put(out, t.v); } else { - let t2: string = ""; - const _179: rs.Iter = rs.strSplit(s, "/"); - t2 = rs.stringExtend(t2, _179); - const _184: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p: string): string => { + const t2: rs.String = rs.stringNew(); + const _179: rs.Iter = rs.strSplit(s.v, "/"); + rs.stringExtend(t2, _179); + const _184: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p: string): rs.String => { return rs.fmtFormat([(f: rs.Formatter) => rs.fmtPad(f, p), "é"]); }); - t2 = rs.stringExtend(t2, _184); + rs.stringExtend(t2, _184); const _190: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); - named.name = rs.stringExtend(named.name, _190); + rs.stringExtend(named.name, _190); const _197: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p2: string): rs.StrCow => { - return p2; + return rs.stringFrom(p2); }); - named.name = rs.stringExtend(named.name, rs.iterMap(_197, rs.strCowStr)); + rs.stringExtend(named.name, _197); rs.iterEmpty(); - named.name = rs.stringExtend(named.name, rs.iterEmpty() as rs.Iter); + rs.stringExtend(named.name, rs.iterEmpty() as rs.Iter); const counted4: Counted.Counted = { items: rs.sliceFrom(parts.items), nexts }; - t2 = rs.stringExtend(t2, rs.iterFrom(counted4, Counted.next$iter_Iterator_ref_str)); - put(out, t2); + rs.stringExtend(t2, rs.iterFrom(counted4, Counted.next$iter_Iterator_ref_str)); + put(out, t2.v); } - put(out, named.name); + put(out, named.name.v); rs.byteVecPush(out, nexts.v); } -export function extendChars(t: rs.Place, chars: rs.Slice, kind: rs.u8): void { +export function extendChars(t: rs.String, chars: rs.Slice, kind: rs.u8): void { const _4: rs.u8 = rs.u8Rem(rs.u8Div(kind, 4), 3); if (_4 === 0) { - const _8: rs.Iter = rs.iterSlice(rs.sliceItems(chars)); - t.v = rs.stringExtendChars(t.v, _8); + rs.stringExtendChars(t, rs.iterSlice(rs.sliceItems(chars))); } else if (_4 === 1) { - const _9: rs.Iter = rs.iterFilter(rs.iterSlice(rs.sliceItems(chars)), (c: rs.char): boolean => { + rs.stringExtendChars(t, rs.iterFilter(rs.iterSlice(rs.sliceItems(chars)), (c: rs.char): boolean => { return rs.isAsciiDigit(c); - }); - t.v = rs.stringExtendChars(t.v, _9); + })); } else { - t.v = rs.stringExtendChars(t.v, rs.iterOption(128512)); + rs.stringExtendChars(t, rs.iterOption(128512)); } } @@ -1285,7 +1259,7 @@ export function extendChars(t: rs.Place, chars: rs.Slice, kind: * `String::drain` of `s` by the range `form` picks, between offsets from `a` and `b`, * read from either end by `steps`' bits, then dropped, forgotten, or read to its end. */ -export function drainBy(s: rs.Place, form: rs.u8, a: rs.u8, b: rs.u8, steps: rs.u8, out: rs.ByteVec): void { +export function drainBy(s: rs.String, form: rs.u8, a: rs.u8, b: rs.u8, steps: rs.u8, out: rs.ByteVec): void { let drain!: rs.Iter; let _35!: rs.u8; let c!: rs.char | undefined; @@ -1336,7 +1310,8 @@ export function drainBy(s: rs.Place, form: rs.u8, a: rs.u8, b: rs.u8, st _71 = false; } else if (_49 === 2) { _71 = false; - put(out, rs.stringExtendChars("", drain, true)); + const _57: rs.Iter = drain; + put(out, rs.stringExtendChars(rs.stringNew(), _57, true).v); } else { put(out, rs.stringDrainAsStr(drain)); _71 = false; @@ -1368,7 +1343,7 @@ export function drains(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat rs.panic("mid > len"); } const head: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart, mid); - let s: string = text(head); + const s: rs.String = text(head); const named: Named.Named = { name: text(head) }; const iter: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + mid, dataLen - mid), 4); while (true) { @@ -1384,26 +1359,27 @@ export function drains(kind: rs.u8, dataData: Uint8Array, dataStart: number, dat const steps: rs.u8 = _26[3]; const _44: rs.u8 = rs.u8Rem(rs.u8Div(form, 32), 4); if (_44 === 0) { - drainBy(rs.place(() => named.name, (value6) => named.name = value6), form, a, b, steps, out); + drainBy(named.name, form, a, b, steps, out); } else if (_44 === 1) { const _49: rs.u8 = rs.u8Rem(form, 4); if (_49 === 0) { - const _56: { end: rs.usize } = { end: offset(s, a) }; - put(out, rs.stringExtendChars("", rs.stringDrain(rs.place(() => s, (value5) => s = value5), _56), true)); + const _56: { end: rs.usize } = { end: offset(s.v, a) }; + const _54: rs.Iter = rs.stringDrain(s, _56); + put(out, rs.stringExtendChars(rs.stringNew(), _54, true).v); } else if (_49 === 1) { - const _64: rs.RangeFrom = new rs.RangeFrom(offset(s, a), rs.usizeStep); - rs.byteVecPush(out, rs.ownedCount(rs.stringDrain(rs.place(() => s, (value4) => s = value4), _64)) & 0xff); + const _64: rs.RangeFrom = new rs.RangeFrom(offset(s.v, a), rs.usizeStep); + rs.byteVecPush(out, rs.ownedCount(rs.stringDrain(s, _64)) & 0xff); } else if (_49 === 2) { - putChar(out, rs.ownedLast(rs.stringDrain(rs.place(() => s, (value3) => s = value3), undefined))); + putChar(out, rs.ownedLast(rs.stringDrain(s, undefined))); } else { - const _73: rs.Range = new rs.Range(offset(s, a), offset(s, b)); - rs.drop(rs.stringDrain(rs.place(() => s, (value2) => s = value2), _73)); + const _73: rs.Range = new rs.Range(offset(s.v, a), offset(s.v, b)); + rs.drop(rs.stringDrain(s, _73)); } } else { - drainBy(rs.place(() => s, (value) => s = value), form, a, b, steps, out); + drainBy(s, form, a, b, steps, out); } - put(out, s); - put(out, named.name); + put(out, s.v); + put(out, named.name.v); } } @@ -1426,10 +1402,8 @@ export function hinted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const n: rs.u32 = _7[0]; const m: rs.u32 = _7[1]; const sub: rs.usize = rs.usizeDiv(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0) as rs.usize, rs.sliceFrom([0, 5, 8, 9, 2147483645, 2147483648, 4294967295]).length); - let t: string = "aé"; - const _25: rs.Place = rs.place(() => t, (value) => t = value); - const _26: string = text(option_unwrapOr$0yvilko(rs.byteSliceGetRange(data, 2), rs.byteSliceFrom(Uint8Array.of()))); - _25.v = _25.v + _26; + let t: rs.String = rs.stringFrom("aé"); + rs.stringPushStr(t, text(option_unwrapOr$0yvilko(rs.byteSliceGetRange(data, 2), rs.byteSliceFrom(Uint8Array.of()))).v); const calls: rs.Cell = new rs.Cell(0); const f: (a0: rs.u32) => rs.char = (_2: rs.u32): rs.char => { rs.cellSet(calls, rs.usizeAdd(calls.v, 1)); @@ -1445,83 +1419,62 @@ export function hinted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }; const _38: rs.u8 = rs.u8Rem(kind, 10); if (_38 === 0) { - const _40: rs.Place = rs.place(() => t, (value13) => t = value13); - const _41: rs.Iter = rs.iterMap(new rs.Range(0, n), f); - _40.v = rs.stringExtendChars(_40.v, _41); + rs.stringExtendChars(t, rs.iterMap(new rs.Range(0, n), f)); } else if (_38 === 1) { - t = rs.stringExtendChars("", rs.iterMap(rs.iterChain(new rs.RangeInclusive(0, n, rs.u32Step), new rs.Range(0, n)), f)); + const _44: rs.Iter = rs.iterMap(rs.iterChain(new rs.RangeInclusive(0, n, rs.u32Step), new rs.Range(0, n)), f); + t = rs.stringExtendChars(rs.stringNew(), _44); } else if (_38 === 2) { - const _48: rs.Place = rs.place(() => t, (value12) => t = value12); - const _49: rs.Iter = rs.iterSkip(rs.iterMap(new rs.Range(0, rs.u64Or(rs.u64Shl(n as rs.u64, 8), m as rs.u64), rs.u64Step), (i4: rs.u64): rs.char => { + rs.stringExtendChars(t, rs.iterSkip(rs.iterMap(new rs.Range(0, rs.u64Or(rs.u64Shl(n as rs.u64, 8), m as rs.u64), rs.u64Step), (i4: rs.u64): rs.char => { return f(rs.u64Low(i4)); - }), m as rs.usize); - _48.v = rs.stringExtendChars(_48.v, _49); + }), m as rs.usize)); } else if (_38 === 3) { - const _61: rs.Place = rs.place(() => t, (value11) => t = value11); - const _62: rs.Iter = rs.iterTake(rs.iterMap(new rs.Range(0, n), f), m as rs.usize, undefined, true); - _61.v = rs.stringExtendChars(_61.v, _62); + rs.stringExtendChars(t, rs.iterTake(rs.iterMap(new rs.Range(0, n), f), m as rs.usize, undefined, true)); } else if (_38 === 4) { - const _66: rs.Place = rs.place(() => t, (value10) => t = value10); + const _66: rs.String = t; const _69: rs.Range = new rs.Range(0, n); if (!(n === 4294967295)) { _70 = 1; } else { _70 = rs.usizeAdd(1, rs.usizeRem(m as rs.usize, 2)); } - const _67: rs.Iter = rs.iterMap(rs.iterStepBy(_69, _70, undefined, 4294967295), f); - _66.v = rs.stringExtendChars(_66.v, _67); + rs.stringExtendChars(_66, rs.iterMap(rs.iterStepBy(_69, _70, undefined, 4294967295), f)); } else if (_38 === 5) { if (rs.u32Rem(m, 2) === 0) { - const _78: rs.Place = rs.place(() => t, (value9) => t = value9); - const _79: rs.Iter = rs.iterChain(rs.iterMap(new rs.Range(0, n), f), rs.iterMap(new rs.Range(0, m), f)); - _78.v = rs.stringExtendChars(_78.v, _79); + rs.stringExtendChars(t, rs.iterChain(rs.iterMap(new rs.Range(0, n), f), rs.iterMap(new rs.Range(0, m), f))); } else { - const _84: rs.Place = rs.place(() => t, (value8) => t = value8); - const _85: rs.Iter = rs.iterMap(rs.iterZip(new rs.Range(0, n), new rs.Range(0, m), [false, false]), (_211: [rs.u32, rs.u32]): rs.char => { + rs.stringExtendChars(t, rs.iterMap(rs.iterZip(new rs.Range(0, n), new rs.Range(0, m), [false, false]), (_211: [rs.u32, rs.u32]): rs.char => { return f(_211[0]); - }); - _84.v = rs.stringExtendChars(_84.v, _85); + })); } } else if (_38 === 6) { - const _91: rs.Place = rs.place(() => t, (value7) => t = value7); - const _92: rs.Iter = rs.iterFlatMap(new rs.Range(0, n), (i2: rs.u32): rs.char[] => { + rs.stringExtendChars(t, rs.iterFlatMap(new rs.Range(0, n), (i2: rs.u32): rs.char[] => { return [f(i2), f(i2)]; - }, (value: rs.char[]) => rs.iterSlice(value), true, 2); - _91.v = rs.stringExtendChars(_91.v, _92); + }, (value: rs.char[]) => rs.iterSlice(value), true, 2)); } else if (_38 === 7) { - const _96: rs.Place = rs.place(() => t, (value6) => t = value6); - const _97: rs.Iter = rs.iterChain(rs.iterChain(rs.iterChain(rs.iterChain(rs.iterMap(new rs.Range(0, rs.u32SaturatingSub(n, 5)), f), rs.iterOnce(120)), rs.iterOption(121)), rs.strChars("é😀")), rs.iterSlice([122])); - _96.v = rs.stringExtendChars(_96.v, _97); + rs.stringExtendChars(t, rs.iterChain(rs.iterChain(rs.iterChain(rs.iterChain(rs.iterMap(new rs.Range(0, rs.u32SaturatingSub(n, 5)), f), rs.iterOnce(120)), rs.iterOption(121)), rs.strChars("é😀")), rs.iterSlice([122]))); } else if (_38 === 8) { const _112: rs.usize = rs.usizeRem(sub, 3); if (_112 === 0) { - const _114: rs.Place = rs.place(() => t, (value5) => t = value5); - const _115: rs.Iter = rs.iterMap(new rs.Range({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_210: rs.u64): rs.char => { + rs.stringExtendChars(t, rs.iterMap(new rs.Range({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_210: rs.u64): rs.char => { return f(0); - }); - _114.v = rs.stringExtendChars(_114.v, _115); + })); } else if (_112 === 1) { - const _128: rs.Place = rs.place(() => t, (value4) => t = value4); - const _129: rs.Iter = rs.iterMap(new rs.Range(rs.i128Neg(rs.i128Shl(1, 100)), rs.i128Add(rs.i128Neg(rs.i128Shl(1, 100)), n as rs.i128), rs.i128Step), (_27: rs.i128): rs.char => { + rs.stringExtendChars(t, rs.iterMap(new rs.Range(rs.i128Neg(rs.i128Shl(1, 100)), rs.i128Add(rs.i128Neg(rs.i128Shl(1, 100)), n as rs.i128), rs.i128Step), (_27: rs.i128): rs.char => { return f(0); - }); - _128.v = rs.stringExtendChars(_128.v, _129); + })); } else { - const _146: rs.Place = rs.place(() => t, (value3) => t = value3); - const _147: rs.Iter = rs.iterMap(new rs.RangeInclusive({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_24: rs.u64): rs.char => { + rs.stringExtendChars(t, rs.iterMap(new rs.RangeInclusive({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_24: rs.u64): rs.char => { return f(0); - }); - _146.v = rs.stringExtendChars(_146.v, _147); + })); } } else { const chars: rs.Peekable = rs.iterPeekable(rs.iterFuse(rs.iterRev(rs.iterMap(rs.iterEnumerate(rs.iterMap(new rs.Range(0, n), f)), (_23: [rs.usize, rs.char]): rs.char => { return _23[1]; })), true)); putChar(out, rs.peekablePeek(chars)); - const _172: rs.Place = rs.place(() => t, (value2) => t = value2); - _172.v = rs.stringExtendChars(_172.v, chars); + rs.stringExtendChars(t, chars); } - put(out, t); + put(out, t.v); } /** A part a checked read gives, or 0xfe if it gave none. */ @@ -1586,7 +1539,7 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const a: rs.usize = _10[0]; const b: rs.usize = _10[1]; const s: string = text; - let string: string = text; + const string: rs.String = rs.stringFrom(text); const _20: rs.u8 = rs.u8Rem(kind, 16); if (_20 === 0) { putPart(out, rs.strGet(s, a, b)); @@ -1598,7 +1551,7 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { putPart(out, rs.strGet(s, bounds22[0], bounds22[1])); const bounds23 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(s)); putPart(out, rs.strGet(s, bounds23[0], bounds23[1])); - const _41: string = string; + const _41: string = string.v; const bounds24 = rs.sliceGetBounds(exhausted(a, b), rs.stringLen(_41)); putPart(out, rs.strGet(_41, bounds24[0], bounds24[1])); } else if (_20 === 2) { @@ -1618,11 +1571,11 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { put(out, rs.strSlice(s, bounds16[0], bounds16[1])); } else if (_20 === 5) { const _70: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const bounds15 = rs.strInclusive(string, _70); - put(out, rs.strSlice(string, bounds15[0], bounds15[1])); + const bounds15 = rs.strInclusive(string.v, _70); + put(out, rs.strSlice(string.v, bounds15[0], bounds15[1])); } else if (_20 === 6) { - const bounds14 = rs.strInclusive(string, { end: b, inclusive: true }); - put(out, rs.strSlice(string, bounds14[0], bounds14[1])); + const bounds14 = rs.strInclusive(string.v, { end: b, inclusive: true }); + put(out, rs.strSlice(string.v, bounds14[0], bounds14[1])); } else if (_20 === 7) { const bounds13 = rs.strInclusive(s, exhausted(a, b)); put(out, rs.strSlice(s, bounds13[0], bounds13[1])); @@ -1630,60 +1583,55 @@ export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const bounds12 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s)); put(out, rs.strSlice(s, bounds12[0], bounds12[1])); } else if (_20 === 9) { - const bounds11 = rs.boundsRange([{ tag: "Included", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(string)); - put(out, rs.strSlice(string, bounds11[0], bounds11[1])); + const bounds11 = rs.boundsRange([{ tag: "Included", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(string.v)); + put(out, rs.strSlice(string.v, bounds11[0], bounds11[1])); } else if (_20 === 10) { - const _89: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const s7 = rs.place(() => string, (value6) => string = value6); - const bounds7 = rs.sliceGetBounds(_89, rs.stringLen(s7.v)); - putUpper(out, rs.strGetMut(s7, bounds7[0], bounds7[1])); - const s8 = rs.place(() => string, (value7) => string = value7); - const bounds8 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(s8.v)); - putUpper(out, rs.strGetMut(s8, bounds8[0], bounds8[1])); - const _99: rs.RangeInclusive = exhausted(a, b); - const s9 = rs.place(() => string, (value8) => string = value8); - const bounds9 = rs.sliceGetBounds(_99, rs.stringLen(s9.v)); - putUpper(out, rs.strGetMut(s9, bounds9[0], bounds9[1])); - const s10 = rs.place(() => string, (value9) => string = value9); - const bounds10 = rs.sliceGetBounds([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s10.v)); - putUpper(out, rs.strGetMut(s10, bounds10[0], bounds10[1])); - put(out, string); + const _87: rs.Place = string; + const bounds7 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), rs.stringLen(_87.v)); + putUpper(out, rs.strGetMut(_87, bounds7[0], bounds7[1])); + const _92: rs.Place = string; + const bounds8 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(_92.v)); + putUpper(out, rs.strGetMut(_92, bounds8[0], bounds8[1])); + const _97: rs.Place = string; + const bounds9 = rs.sliceGetBounds(exhausted(a, b), rs.stringLen(_97.v)); + putUpper(out, rs.strGetMut(_97, bounds9[0], bounds9[1])); + const _102: rs.Place = string; + const bounds10 = rs.sliceGetBounds([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(_102.v)); + putUpper(out, rs.strGetMut(_102, bounds10[0], bounds10[1])); + put(out, string.v); } else if (_20 === 11) { const _113: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); - const s6 = rs.place(() => string, (value5) => string = value5); - const bounds6 = rs.strInclusive(s6.v, _113); - const _111: rs.Place = rs.strPart(s6, bounds6[0], bounds6[1]); + const bounds6 = rs.strInclusive(string.v, _113); + const _111: rs.Place = rs.strPart(string, bounds6[0], bounds6[1]); _111.v = rs.strToAsciiUppercase(_111.v); - put(out, string); + put(out, string.v); } else if (_20 === 12) { - const s5 = rs.place(() => string, (value4) => string = value4); - const bounds5 = rs.strInclusive(s5.v, { end: b, inclusive: true }); - const _118: rs.Place = rs.strPart(s5, bounds5[0], bounds5[1]); + const _119: rs.Place = string; + const bounds5 = rs.strInclusive(_119.v, { end: b, inclusive: true }); + const _118: rs.Place = rs.strPart(_119, bounds5[0], bounds5[1]); _118.v = rs.strToAsciiUppercase(_118.v); - put(out, string); + put(out, string.v); } else if (_20 === 13) { const _128: rs.RangeInclusive = exhausted(a, b); - const s4 = rs.place(() => string, (value3) => string = value3); - const bounds4 = rs.strInclusive(s4.v, _128); - const _126: rs.Place = rs.strPart(s4, bounds4[0], bounds4[1]); + const bounds4 = rs.strInclusive(string.v, _128); + const _126: rs.Place = rs.strPart(string, bounds4[0], bounds4[1]); _126.v = rs.strToAsciiUppercase(_126.v); - put(out, string); + put(out, string.v); } else if (_20 === 14) { - const s3 = rs.place(() => string, (value2) => string = value2); - const bounds3 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s3.v)); - const _133: rs.Place = rs.strPart(s3, bounds3[0], bounds3[1]); + const _134: rs.Place = string; + const bounds3 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(_134.v)); + const _133: rs.Place = rs.strPart(_134, bounds3[0], bounds3[1]); _133.v = rs.strToAsciiUppercase(_133.v); - put(out, string); + put(out, string.v); } else { - const s2 = rs.place(() => string, (value) => string = value); - const bounds = rs.strInclusive(s2.v, { end: b, inclusive: true }); - const part: rs.Place = rs.strPart(s2, bounds[0], bounds[1]); + const bounds = rs.strInclusive(string.v, { end: b, inclusive: true }); + const part: rs.Place = rs.strPart(string, bounds[0], bounds[1]); const last: rs.usize = rs.usizeSaturatingSub(rs.stringLen(part.v), 1); const _150: rs.RangeInclusive = new rs.RangeInclusive(rs.min(a, last), last, rs.usizeStep); const bounds2 = rs.strInclusive(part.v, _150); const _149: rs.Place = rs.strPart(part, bounds2[0], bounds2[1]); _149.v = rs.strToAsciiUppercase(_149.v); - put(out, string); + put(out, string.v); } } @@ -1809,12 +1757,12 @@ export function walk$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter, pu */ export function escaped$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { const args3 = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])])); + put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])]).v); walk$str_EscapeDebug(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); while (rs.iterToOption(it.next()) !== undefined) { - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)).v); } } @@ -1824,12 +1772,12 @@ export function escaped$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter): */ export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { const args3 = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])])); + put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])]).v); walk$str_EscapeDefault(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); while (rs.iterToOption(it.next()) !== undefined) { - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)).v); } } @@ -1839,12 +1787,12 @@ export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter) */ export function escaped$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { const args3 = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; - put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])])); + put(out, rs.fmtFormat([args3[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args3[0])]).v); walk$str_EscapeUnicode(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); while (rs.iterToOption(it.next()) !== undefined) { - put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)).v); } } @@ -1854,55 +1802,56 @@ export function escaped$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter) * and each iterator's size hints as it goes. */ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _5: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { const _54: rs.usize = rs.u8Rem(_2, 32) as rs.usize; if (!(_54 < 32)) { rs.panic("index out of bounds: the len is " + 32 + " but the index is " + _54); } return [931, 931, 962, 65, 97, 453, 66560, 223, 304, 912, 64259, 46, 39, 58, 769, 837, 173, 119143, 32, 49, 20013, 128512, 233, 34, 92, 10, 9, 0, 127, 57344, 65279, 1114111][_54]; - })); - const words: rs.Vec = rs.iterToVec(rs.strSplit(s, " "), "next", 8); + }); + const s: rs.String = rs.stringExtendChars(rs.stringNew(), _5); + const words: rs.Vec = rs.iterToVec(rs.strSplit(s.v, " "), "next", 8); const _11: rs.u8 = rs.u8Rem(kind, 5); if (_11 === 0) { - put(out, rs.strToLowercase(s)); - put(out, rs.strToUppercase(s)); - const lower: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a08: string): string => { + put(out, rs.strToLowercase(s.v).v); + put(out, rs.strToUppercase(s.v).v); + const lower: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a08: string): rs.String => { return rs.strToLowercase(a08); }), undefined, 12, true); - const upper: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a09: string): string => { + const upper: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a09: string): rs.String => { return rs.strToUppercase(a09); }), undefined, 12, true); - const args18 = [(f: rs.Formatter) => rs.fmtList(lower.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(upper.items, f, rs.fmtStr)]; - put(out, rs.fmtFormat([args18[0], "|", args18[1]])); + const args18 = [(f: rs.Formatter) => rs.fmtList(lower.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(upper.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]; + put(out, rs.fmtFormat([args18[0], "|", args18[1]]).v); } else if (_11 === 1) { - escaped$str_EscapeDebug(out, rs.strEscapeDebug(s)); - const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a07: string): rs.Iter => { + escaped$str_EscapeDebug(out, rs.strEscapeDebug(s.v)); + const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a07: string): rs.Iter => { return rs.strEscapeDebug(a07); - }), (e2: rs.Iter): string => { + }), (e2: rs.Iter): rs.String => { return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e2, f)); }), undefined, 12, true); - const args17 = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(s, f)]; - put(out, rs.fmtFormat([args17[0], "|", args17[1]])); + const args17 = [(f: rs.Formatter) => rs.fmtList(each.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtStr(s.v, f)]; + put(out, rs.fmtFormat([args17[0], "|", args17[1]]).v); } else if (_11 === 2) { - escaped$str_EscapeDefault(out, rs.strEscapeDefault(s)); + escaped$str_EscapeDefault(out, rs.strEscapeDefault(s.v)); const part2 = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a06: string): rs.Iter => { return rs.strEscapeDefault(a06); - }), (e: rs.Iter): string => { + }), (e: rs.Iter): rs.String => { return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e, f)); }), undefined, 12, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.fmtStr)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part2.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f))]).v); } else if (_11 === 3) { - escaped$str_EscapeUnicode(out, rs.strEscapeUnicode(s)); + escaped$str_EscapeUnicode(out, rs.strEscapeUnicode(s.v)); const part = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a04: string): rs.Iter => { return rs.strEscapeUnicode(a04); }), (a05: rs.Iter): rs.usize => { return rs.iterCount(a05); }), undefined, 4, true); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part.items, f, rs.usizeDebug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtList(part.items, f, rs.usizeDebug)]).v); } else { - const it: rs.Iter = rs.strEncodeUtf16(s); + const it: rs.Iter = rs.strEncodeUtf16(s.v); const args13 = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16"))]; - put(out, rs.fmtFormat([args13[0], "|", rs.fmtSpec({ alternate: true }, args13[0]), "|", rs.fmtSpec({ align: ">", width: 30 }, args13[0])])); + put(out, rs.fmtFormat([args13[0], "|", rs.fmtSpec({ alternate: true }, args13[0]), "|", rs.fmtSpec({ align: ">", width: 30 }, args13[0])]).v); walk$str_EncodeUtf16(out, it.clone(), (out2: rs.ByteVec, u: rs.u16): undefined => { rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(u))); }); @@ -1912,24 +1861,25 @@ export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void }), (a02: rs.Iter): rs.usize => { return rs.iterCount(a02); }), undefined, 4, true); - const _164: boolean = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { + const _150: rs.Iter = rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { return rs.resultUnwrap(a03, rs.fmtDecodeUtf16ErrorDebug); - })) === s; + }); + const _164: boolean = rs.eqStr(rs.stringExtendChars(rs.stringNew(), _150), s); const args14 = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(each4.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(_164, f)]; - put(out, rs.fmtFormat([args14[0], "|", args14[1], "|", args14[2]])); + put(out, rs.fmtFormat([args14[0], "|", args14[1], "|", args14[2]]).v); } } /** What a `String` from UTF-16 is, or its error's `Display`, padded or not, and `Debug`. */ -export function putUtf16(out: rs.ByteVec, r: rs.Result): void { +export function putUtf16(out: rs.ByteVec, r: rs.Result): void { if (r.ok) { const part = r.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(part, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(part.v, f)]).v); } else { const e: rs.FromUtf16Error = r.error; - const _24: rs.usize = rs.stringLen(rs.fmtToString((f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f))); + const _24: rs.usize = rs.fmtToString((f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f)).len; const args5 = [(f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; - put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args5[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 12 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", args5[2]])); + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args5[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 12 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1]), "|", args5[2]]).v); } } @@ -1957,9 +1907,9 @@ export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } putUtf16(out, rs.stringFromUtf16(rs.sliceFrom(units.items))); const part3 = rs.stringFromUtf16Lossy(rs.sliceFrom(units.items)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(part3, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(part3.v, f)]).v); const part4 = rs.stringFromUtf16(rs.sliceFrom(units.items)); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part4, f, rs.fmtStr, rs.fmtFromUtf16ErrorDebug)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtResult(part4, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f), rs.fmtFromUtf16ErrorDebug)]).v); const le: rs.ByteVec = rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(units.items), (u: rs.u16): Uint8Array => { return rs.u16ToBeBytes(u).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -1975,44 +1925,44 @@ export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } putUtf16(out, rs.stringFromUtf16le(_79[0])); putUtf16(out, rs.stringFromUtf16be(_79[1])); - const _96: string = rs.stringFromUtf16leLossy(_79[0]); - const _98: string = rs.stringFromUtf16beLossy(_79[1]); - const args11 = [(f: rs.Formatter) => rs.fmtStr(_96, f), (f: rs.Formatter) => rs.fmtStr(_98, f)]; - put(out, rs.fmtFormat([args11[0], "|", args11[1]])); + const _96: rs.String = rs.stringFromUtf16leLossy(_79[0]); + const _98: rs.String = rs.stringFromUtf16beLossy(_79[1]); + const args11 = [(f: rs.Formatter) => rs.fmtStr(_96.v, f), (f: rs.Formatter) => rs.fmtStr(_98.v, f)]; + put(out, rs.fmtFormat([args11[0], "|", args11[1]]).v); } - const lossy: Array<(a0: rs.ByteSlice) => string> = [(a03: rs.ByteSlice): string => { + const lossy: Array<(a0: rs.ByteSlice) => rs.String> = [(a03: rs.ByteSlice): rs.String => { return rs.stringFromUtf16leLossy(a03); - }, (a04: rs.ByteSlice): string => { + }, (a04: rs.ByteSlice): rs.String => { return rs.stringFromUtf16beLossy(a04); }]; - const iter2: rs.Iter<[(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => string]> = rs.iterZip(rs.iterSlice([(a0: rs.ByteSlice): rs.Result => { + const iter2: rs.Iter<[(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => rs.String]> = rs.iterZip(rs.iterSlice([(a0: rs.ByteSlice): rs.Result => { return rs.stringFromUtf16le(a0); - }, (a02: rs.ByteSlice): rs.Result => { + }, (a02: rs.ByteSlice): rs.Result => { return rs.stringFromUtf16be(a02); }]), rs.iterSlice(lossy), "index"); while (true) { - const _114: [(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => string] | rs.Done = iter2.next(); + const _114: [(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => rs.String] | rs.Done = iter2.next(); if (_114 === rs.DONE) { break; } - const decode2: (a0: rs.ByteSlice) => rs.Result = _114[0]; - const lossy2: (a0: rs.ByteSlice) => string = _114[1]; + const decode2: (a0: rs.ByteSlice) => rs.Result = _114[0]; + const lossy2: (a0: rs.ByteSlice) => rs.String = _114[1]; putUtf16(out, decode2(data)); - put(out, lossy2(data)); + put(out, lossy2(data).v); } const parts: rs.Vec> = rs.iterToVec(rs.sliceSplit(rs.sliceFrom(units.items), (_22: rs.u16): boolean => { return _22 === 0; }), "next", 8); - const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (a05: rs.Slice): string => { + const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (a05: rs.Slice): rs.String => { return rs.stringFromUtf16Lossy(a05); }), undefined, 12, true); - const ok: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(parts.items), (a06: rs.Slice): rs.Result => { + const ok: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(parts.items), (a06: rs.Slice): rs.Result => { return rs.stringFromUtf16(a06); - }), (r: rs.Result): boolean => { + }), (r: rs.Result): boolean => { return r.ok; }), undefined, 1, true); - const args12 = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(ok.items, f, rs.fmtBool)]; - put(out, rs.fmtFormat([args12[0], "|", args12[1]])); + const args12 = [(f: rs.Formatter) => rs.fmtList(each.items, f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(ok.items, f, rs.fmtBool)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1]]).v); } //# sourceMappingURL=strs.ts.map diff --git a/ts/fixtures/lang/tuples/expected/tuples.ts b/ts/fixtures/lang/tuples/expected/tuples.ts index 1d4812798..c5902ba1f 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.ts @@ -77,9 +77,10 @@ export function ones(data: rs.ByteSlice, out: rs.ByteVec): void { rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(rs.tupleExtendOne([new rs.Vec()] as [rs.Vec], _5, (c, items) => rs.iterExtend(c, items, undefined, 2, true))[0].items), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(rs.tupleExtendOne([""] as [string], rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.char] => { + const _14: rs.Iter<[rs.char]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.char] => { return [_24 as rs.char] as [rs.char]; - }), (c2, items2) => rs.stringExtendChars(c2, items2))[0]), undefined, true); + }); + rs.iterExtendBytes(out, rs.strBytes(rs.tupleExtendOne([rs.stringNew()] as [rs.String], _14, (c2, items2) => rs.stringExtendChars(c2, items2))[0].v), undefined, true); const _22: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): [rs.u8] => { return [_26] as [rs.u8]; }); @@ -105,7 +106,7 @@ export function ones(data: rs.ByteSlice, out: rs.ByteVec): void { }); rs.tupleExtendOne(t, _48, (c8, items7) => rs.iterExtendBytes(c8, items7, undefined, true)); rs.iterExtendBytes(out, rs.byteVecIntoIter(t[0]), undefined, true); - const t2: [string] = ["ab"]; + const t2: [rs.String] = [rs.stringFrom("ab")]; const _56: rs.Iter<[string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): [string] => { const _84: rs.usize = rs.u8Rem(_214, 3) as rs.usize; if (!(_84 < 3)) { @@ -114,7 +115,7 @@ export function ones(data: rs.ByteSlice, out: rs.ByteVec): void { return [["x", "", "yz"][_84]] as [string]; }); rs.tupleExtendOne(t2, _56, (c9, items8) => rs.stringExtend(c9, items8)); - rs.iterExtendBytes(out, rs.strBytes(t2[0]), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(t2[0].v), undefined, true); const _65: rs.Iter<[[rs.u8, rs.u8]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): [[rs.u8, rs.u8]] => { const b9: rs.u8 = _215; return [[b9, b9] as [rs.u8, rs.u8]] as [[rs.u8, rs.u8]]; @@ -140,11 +141,11 @@ export function pairs(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = _2; return [b ^ 90, b as rs.char] as [rs.u8, rs.char]; }); - const _5: [rs.ByteVec, string] = rs.tupleExtend([new rs.ByteVec(), ""] as [rs.ByteVec, string], _6, [rs.byteVecPart(), rs.STRING_CHARS_PART]); + const _5: [rs.ByteVec, rs.String] = rs.tupleExtend([new rs.ByteVec(), rs.stringNew()] as [rs.ByteVec, rs.String], _6, [rs.byteVecPart(), rs.STRING_CHARS_PART]); const v: rs.ByteVec = _5[0]; - const s: string = _5[1]; + const s: rs.String = _5[1]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); const _16: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): [rs.u8, rs.u8] => { const b2: rs.u8 = _25; return [b2, rs.u8Rem(b2, 8)] as [rs.u8, rs.u8]; @@ -190,15 +191,15 @@ export function triples(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = _2; return [b, ((b as rs.u16) << 8) & 0xffff, rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char] as [rs.u8, rs.u16, rs.char]; }); - const _6: [rs.ByteVec, rs.VecDeque, string] = rs.tupleExtend([new rs.ByteVec(), rs.dequeNew(2) as rs.VecDeque, ""] as [rs.ByteVec, rs.VecDeque, string], _7, [rs.byteVecPart(), rs.dequePart(), rs.STRING_CHARS_PART]); + const _6: [rs.ByteVec, rs.VecDeque, rs.String] = rs.tupleExtend([new rs.ByteVec(), rs.dequeNew(2) as rs.VecDeque, rs.stringNew()] as [rs.ByteVec, rs.VecDeque, rs.String], _7, [rs.byteVecPart(), rs.dequePart(), rs.STRING_CHARS_PART]); const v: rs.ByteVec = _6[0]; const q: rs.VecDeque = _6[1]; - const s: string = _6[2]; + const s: rs.String = _6[2]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.dequeIter(q), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); const _22: rs.Iter<[[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8] => { const b2: rs.u8 = _24; return [[rs.u8Rem(b2, 8), b2] as [rs.u8, rs.u8], [rs.u8Rem(b2, 5), b2 as rs.u16] as [rs.u8, rs.u16], b2] as [[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8]; @@ -216,12 +217,12 @@ export function triples(data: rs.ByteSlice, out: rs.ByteVec): void { const b3: rs.u8 = _26; return [b3, [b3 as rs.char, rs.u16Add(b3 as rs.u16, 1)] as [rs.char, rs.u16]] as [rs.u8, [rs.char, rs.u16]]; }); - const _34: [rs.ByteVec, [string, rs.Vec]] = rs.tupleExtend([new rs.ByteVec(), ["", new rs.Vec()]] as [rs.ByteVec, [string, rs.Vec]], _35, [rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART, rs.vecPart(2)])]); + const _34: [rs.ByteVec, [rs.String, rs.Vec]] = rs.tupleExtend([new rs.ByteVec(), [rs.stringNew(), new rs.Vec()]] as [rs.ByteVec, [rs.String, rs.Vec]], _35, [rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART, rs.vecPart(2)])]); const v2: rs.ByteVec = _34[0]; - const s2: string = _34[1][0]; + const s2: rs.String = _34[1][0]; const w: rs.Vec = _34[1][1]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s2.v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(w.items), (n2: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n2).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -255,11 +256,11 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { const _28: [rs.u8, [rs.char]] = [b ^ 51, [rs.u8Add(65, rs.u8Rem(b, 26)) as rs.char] as [rs.char]]; return [b, _12, _152, _5[_8], _162, b, _172, _202, _222, _262, undefined, _28] as [rs.u8, rs.u16, rs.char, string, rs.u8, rs.u8, [rs.u8, rs.u8], rs.u8, [rs.u8, rs.u16], rs.u8, undefined, [rs.u8, [rs.char]]]; }); - const _15: [rs.ByteVec, rs.Vec, string, string, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [string]]] = rs.tupleExtend([new rs.ByteVec(), new rs.Vec(), "", "", rs.dequeNew(1, true) as rs.VecDeque, rs.heapNew() as rs.BinaryHeap, rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet, rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.btreeNew(rs.cmp) as rs.BTreeSet, undefined, [new rs.ByteVec(), [""]]] as [rs.ByteVec, rs.Vec, string, string, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [string]]], _16, [rs.byteVecPart(), rs.vecPart(2), rs.STRING_CHARS_PART, rs.STRING_PART, rs.dequePart(), rs.heapPart(rs.le, 1), rs.hashPart(undefined, undefined, 469762048), rs.hashKeysPart(undefined, 469762048), rs.btreePart(), rs.btreeKeysPart(), rs.UNIT_PART, rs.tuplePart([rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART])])]); + const _15: [rs.ByteVec, rs.Vec, rs.String, rs.String, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [rs.String]]] = rs.tupleExtend([new rs.ByteVec(), new rs.Vec(), rs.stringNew(), rs.stringNew(), rs.dequeNew(1, true) as rs.VecDeque, rs.heapNew() as rs.BinaryHeap, rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet, rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.btreeNew(rs.cmp) as rs.BTreeSet, undefined, [new rs.ByteVec(), [rs.stringNew()]]] as [rs.ByteVec, rs.Vec, rs.String, rs.String, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [rs.String]]], _16, [rs.byteVecPart(), rs.vecPart(2), rs.STRING_CHARS_PART, rs.STRING_PART, rs.dequePart(), rs.heapPart(rs.le, 1), rs.hashPart(undefined, undefined, 469762048), rs.hashKeysPart(undefined, 469762048), rs.btreePart(), rs.btreeKeysPart(), rs.UNIT_PART, rs.tuplePart([rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART])])]); const bytes: rs.ByteVec = _15[0]; const wide: rs.Vec = _15[1]; - const chars: string = _15[2]; - const texts: string = _15[3]; + const chars: rs.String = _15[2]; + const texts: rs.String = _15[3]; const q: rs.VecDeque = _15[4]; const heap: rs.BinaryHeap = _15[5]; const map: rs.HashMap = _15[6]; @@ -267,13 +268,13 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { const tree: rs.BTreeMap = _15[8]; const keys: rs.BTreeSet = _15[9]; const v: rs.ByteVec = _15[11][0]; - const s: string = _15[11][1][0]; + const s: rs.String = _15[11][1][0]; rs.iterExtendBytes(out, rs.byteVecIntoIter(bytes), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(wide.items), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(chars), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(texts), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(chars.v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(texts.v), undefined, true); rs.iterExtendBytes(out, rs.dequeIntoIter(q), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(heap)), undefined, true); entries(map, out); @@ -286,7 +287,7 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); rs.iterExtendBytes(out, rs.btreeKeys(keys), undefined, true); rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); } /** @@ -294,19 +295,19 @@ export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { * and a map or set keeps an equal key already there. */ export function extended(data: rs.ByteSlice, out: rs.ByteVec): void { - const t: [rs.ByteVec, string, rs.BTreeMap, rs.VecDeque, rs.HashSet] = [rs.byteVecFrom(Uint8Array.of(9, 8)), "pre", rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterSlice([[3, 30] as [rs.u8, rs.u16]]), true, undefined, undefined, undefined, 4, true), rs.dequeFromArray([1], 2) as rs.VecDeque, rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; + const t: [rs.ByteVec, rs.String, rs.BTreeMap, rs.VecDeque, rs.HashSet] = [rs.byteVecFrom(Uint8Array.of(9, 8)), rs.stringFrom("pre"), rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterSlice([[3, 30] as [rs.u8, rs.u16]]), true, undefined, undefined, undefined, 4, true), rs.dequeFromArray([1], 2) as rs.VecDeque, rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; const _16: rs.Iter<[rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8] => { const b: rs.u8 = _2; return [b, b as rs.char, [rs.u8Rem(b, 8), b as rs.u16] as [rs.u8, rs.u16], b as rs.u16, rs.u8Rem(b, 16)] as [rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8]; }); rs.tupleExtend(t, _16, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.btreePart(), rs.dequePart(), rs.hashKeysPart(undefined, 469762048)]); const v: rs.ByteVec = t[0]; - const s: string = t[1]; + const s: rs.String = t[1]; const tree: rs.BTreeMap = t[2]; const q: rs.VecDeque = t[3]; const set: rs.HashSet = t[4]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(tree), (_22: [rs.u8, rs.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -330,7 +331,7 @@ export function borrowed(data: rs.ByteSlice, out: rs.ByteVec): void { const b: rs.u8 = _2; return { x: b, y: ((b as rs.u16) << 2) & 0xffff }; }), undefined, 4, true); - const t: [rs.ByteVec, rs.Vec, rs.HashMap, string] = [new rs.ByteVec(), new rs.Vec(), rs.hashNew() as rs.HashMap, ""]; + const t: [rs.ByteVec, rs.Vec, rs.HashMap, rs.String] = [new rs.ByteVec(), new rs.Vec(), rs.hashNew() as rs.HashMap, rs.stringNew()]; const marks: rs.char[] = [122, 233]; const _11: rs.Iter<[rs.u8, Spot.Spot]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterSlice(points.items), [false, false]); const _15: rs.Slice = rs.sliceFrom(marks); @@ -354,13 +355,13 @@ export function borrowed(data: rs.ByteSlice, out: rs.ByteVec): void { const v: rs.ByteVec = t[0]; const copied: rs.Vec = t[1]; const map: rs.HashMap = t[2]; - const s: string = t[3]; + const s: rs.String = t[3]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterChain(rs.iterSlice(copied.items), rs.iterSlice(ones[0].items)), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); entries(map, out); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(points.items), (p3: Spot.Spot): rs.u8 => { return p3.x; }), undefined, true); @@ -457,12 +458,12 @@ export function panicked(data: rs.ByteSlice, out: rs.ByteVec): void { return [b, b as rs.char, b as rs.u16] as [rs.u8, rs.char, rs.u16]; } }); - const _12: [rs.ByteVec, string, rs.Vec] = rs.tupleExtend([new rs.ByteVec(), "", new rs.Vec()] as [rs.ByteVec, string, rs.Vec], _13, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.vecPart(2)]); + const _12: [rs.ByteVec, rs.String, rs.Vec] = rs.tupleExtend([new rs.ByteVec(), rs.stringNew(), new rs.Vec()] as [rs.ByteVec, rs.String, rs.Vec], _13, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.vecPart(2)]); const v: rs.ByteVec = _12[0]; - const s: string = _12[1]; + const s: rs.String = _12[1]; const w: rs.Vec = _12[2]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(w.items), (n: rs.u16): Uint8Array => { return rs.u16ToBeBytes(n).reverse(); }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); @@ -499,8 +500,8 @@ export function reserved(data: rs.ByteSlice, out: rs.ByteVec): void { const _43: rs.Iter<[undefined, rs.char]> = rs.iterMap(items, (_2: rs.u32): [undefined, rs.char] => { return [undefined, 97] as [undefined, rs.char]; }); - const _42: [rs.Vec, string] = rs.tupleExtend([new rs.Vec(), ""] as [rs.Vec, string], _43, [rs.vecPart(0), rs.STRING_CHARS_PART]); - rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_42[0].items.length & 0xff, rs.stringLen(_42[1]) & 0xff)), undefined, true); + const _42: [rs.Vec, rs.String] = rs.tupleExtend([new rs.Vec(), rs.stringNew()] as [rs.Vec, rs.String], _43, [rs.vecPart(0), rs.STRING_CHARS_PART]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_42[0].items.length & 0xff, _42[1].len & 0xff)), undefined, true); } else if (_4 === 4) { const _55: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(items, (i2: rs.u32): [rs.u8, rs.u16] => { return [i2 & 0xff, i2 & 0xffff] as [rs.u8, rs.u16]; @@ -519,18 +520,18 @@ export function reserved(data: rs.ByteSlice, out: rs.ByteVec): void { /** `collect` of `Result`s and `Option`s of pairs, into one of a tuple, which std's docs show. */ export function shunted(data: rs.ByteSlice, out: rs.ByteVec): void { - const parsed: rs.Result<[rs.ByteVec, string], rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result<[rs.u8, rs.char], rs.u8> => { + const parsed: rs.Result<[rs.ByteVec, rs.String], rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result<[rs.u8, rs.char], rs.u8> => { const b: rs.u8 = _2; if (!(b === 0)) { return rs.Ok([b, b as rs.char] as [rs.u8, rs.char]); } return rs.Err(b); - }), (values: rs.Iter<[rs.u8, rs.char]>) => rs.tupleExtend([new rs.ByteVec(), ""] as [rs.ByteVec, string], values, [rs.byteVecPart(), rs.STRING_CHARS_PART])); + }), (values: rs.Iter<[rs.u8, rs.char]>) => rs.tupleExtend([new rs.ByteVec(), rs.stringNew()] as [rs.ByteVec, rs.String], values, [rs.byteVecPart(), rs.STRING_CHARS_PART])); if (parsed.ok) { const v: rs.ByteVec = parsed.value[0]; - const s: string = parsed.value[1]; + const s: rs.String = parsed.value[1]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); } else { rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } @@ -646,21 +647,21 @@ export function own(data: rs.ByteSlice, out: rs.ByteVec): void { const b11: rs.u8 = _211; return [b11, b11 as rs.char, ~b11 & 0xff] as [rs.u8, rs.char, rs.u8]; }); - const _62: [Tally.Tally, string, Tally.Tally] = rs.tupleExtend([Tally.default$Default(), "", Tally.default$Default()] as [Tally.Tally, string, Tally.Tally], _63, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART, rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); + const _62: [Tally.Tally, rs.String, Tally.Tally] = rs.tupleExtend([Tally.default$Default(), rs.stringNew(), Tally.default$Default()] as [Tally.Tally, rs.String, Tally.Tally], _63, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART, rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); const a: Tally.Tally = _62[0]; - const s: string = _62[1]; + const s: rs.String = _62[1]; rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a.sum, _62[2].sum)), undefined, true); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); calls(out); const _81: rs.Iter<[rs.char, rs.char, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_212: rs.u8): [rs.char, rs.char, rs.u8] => { const b12: rs.u8 = _212; return [b12 as rs.char, rs.u8Add(97, rs.u8Rem(b12, 26)) as rs.char, b12] as [rs.char, rs.char, rs.u8]; }); - const _80: [string, Last.Last, Tally.Tally] = rs.tupleExtend(["", Last.default$Default(), Tally.default$Default()] as [string, Last.Last, Tally.Tally], _81, [rs.STRING_CHARS_PART, rs.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rs.Place, a1: rs.char | undefined) => undefined, true), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); - const s2: string = _80[0]; + const _80: [rs.String, Last.Last, Tally.Tally] = rs.tupleExtend([rs.stringNew(), Last.default$Default(), Tally.default$Default()] as [rs.String, Last.Last, Tally.Tally], _81, [rs.STRING_CHARS_PART, rs.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rs.Place, a1: rs.char | undefined) => undefined, true), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); + const s2: rs.String = _80[0]; const last: Last.Last = _80[1]; const t4: Tally.Tally = _80[2]; - rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s2.v), undefined, true); Last.put(last, out); rs.byteVecPush(out, t4.sum); calls(out); @@ -798,13 +799,13 @@ export function ownPanicked(data: rs.ByteSlice, out: rs.ByteVec): void { const _25: rs.Iter<[rs.u8, rs.u8, rs.char]> = rs.iterMap(items, (b3: rs.u8): [rs.u8, rs.u8, rs.char] => { return [b3, b3, b3 as rs.char] as [rs.u8, rs.u8, rs.char]; }); - const _24: [rs.ByteVec, Tally.Tally, string] = rs.tupleExtend([new rs.ByteVec(), Tally.default$Default(), ""] as [rs.ByteVec, Tally.Tally, string], _25, [rs.byteVecPart(), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART]); + const _24: [rs.ByteVec, Tally.Tally, rs.String] = rs.tupleExtend([new rs.ByteVec(), Tally.default$Default(), rs.stringNew()] as [rs.ByteVec, Tally.Tally, rs.String], _25, [rs.byteVecPart(), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART]); const v: rs.ByteVec = _24[0]; const t: Tally.Tally = _24[1]; - const s: string = _24[2]; + const s: rs.String = _24[2]; rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); rs.byteVecPush(out, t.sum); - rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s.v), undefined, true); } else { const _35: rs.Iter<[rs.u8]> = rs.iterMap(items, (b2: rs.u8): [rs.u8] => { return [b2] as [rs.u8]; diff --git a/ts/fixtures/lang/utf8/expected/utf8.ts b/ts/fixtures/lang/utf8/expected/utf8.ts index 546ec03fa..95ddb7d4e 100644 --- a/ts/fixtures/lang/utf8/expected/utf8.ts +++ b/ts/fixtures/lang/utf8/expected/utf8.ts @@ -31,7 +31,7 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _14: rs.Result = rs.strFromUtf8(rs.byteSliceRange(rs.byteVecSlice(bytes), _10)); if (_14.ok) { const s: string = _14.value; - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(s, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtStr(s, f)]).v); rs.byteVecPush(out, rs.stringLen(s) & 0xff); } else { const e: rs.Utf8Error = _14.error; @@ -40,7 +40,7 @@ export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void return n & 0xff; })); const args5 = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f)]; - put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 64 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1])])); + put(out, rs.fmtFormat([args5[0], "|", rs.fmtSpec({ align: ">", width: 64 }, args5[0]), "|", args5[1], "|", rs.fmtSpec({ alternate: true }, args5[1])]).v); } } const _57: rs.Result = rs.strFromUtf8(rs.byteVecSlice(bytes)); @@ -69,17 +69,17 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { } rs.byteVecPush(out, _20 ? 1 : 0); const args13 = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(text)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(text), f)]; - put(out, rs.fmtFormat([args13[0], "|", args13[1]])); + put(out, rs.fmtFormat([args13[0], "|", args13[1]]).v); rs.byteVecPush(out, rs.stringLen(rs.strCowStr(text)) & 0xff); - const owned: string = rs.strCowStr(text); - put(out, owned); - put(out, rs.strFromUtf8Unchecked(rs.stringAsBytes(owned))); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(owned))); - rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(owned))); - put(out, rs.strFromUtf8Unchecked(rs.byteVecSlice(rs.stringIntoBytes(owned)))); + const owned: rs.String = rs.strCowIntoOwned(text); + put(out, owned.v); + put(out, rs.strFromUtf8Unchecked(rs.stringAsBytes(owned.v))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(rs.stringClone(owned)))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.strToBytes(owned.v))); + put(out, rs.stringFromUtf8Unchecked(rs.stringIntoBytes(owned)).v); const chunks: rs.Iter = rs.byteSliceUtf8Chunks(rest); const args14 = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; - put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0])])); + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0])]).v); let last: rs.Utf8Chunk | undefined = undefined; while (true) { const _79: rs.Utf8Chunk | rs.Done = chunks.next(); @@ -89,8 +89,8 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, chunk.invalid); rs.byteVecPush(out, chunk.invalid.length & 0xff); const args15 = [(f: rs.Formatter) => rs.fmtUtf8ChunkDebug(chunk, f)]; - put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0])])); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)])); + put(out, rs.fmtFormat([args15[0], "|", rs.fmtSpec({ alternate: true }, args15[0])]).v); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]).v); rs.byteVecPush(out, rs.iterCount(chunks.clone()) & 0xff); rs.byteVecPush(out, lossy_eq$1kzzmg3(chunk, chunk) ? 1 : 0); const _134: rs.Utf8Chunk | undefined = last; @@ -101,11 +101,11 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { break; } } - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]).v); } - const _152: rs.Result = rs.stringFromUtf8(bytes); + const _152: rs.Result = rs.stringFromUtf8(bytes); if (_152.ok) { - put(out, _152.value); + put(out, _152.value.v); } else { const e: rs.FromUtf8Error = _152.error; rs.byteVecExtendFromSlice(out, rs.byteVecSlice(e.bytes)); @@ -114,7 +114,7 @@ export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, option_mapOr$188iunt(u.errorLen, 255, (n: rs.usize): rs.u8 => { return n & 0xff; })); - put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(u, f)])); + put(out, rs.fmtFormat([(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(u, f)]).v); put(out, rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteVecSlice(e.bytes)))); rs.byteVecPush(out, string_eq$1enuhj8(rs.fromUtf8ErrorClone(e), e) ? 1 : 0); rs.byteVecExtendFromSlice(out, rs.byteVecSlice(e.bytes)); diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.ts b/ts/fixtures/lang/wrappers/expected/wrappers.ts index 2a5b1f2a5..1d1ce5201 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.ts @@ -461,7 +461,7 @@ export function wrappers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.byteVecPush(out, d); rs.byteVecPush(out, i2 & 0xff); } - put(out, "held"); + put(out, rs.stringFrom("held").v); } else if (_21 === 3) { const n: rs.u64 | undefined = rs.nonZero(a); if (n === undefined) { @@ -473,7 +473,7 @@ export function wrappers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void const _519: rs.u64 = option_unwrapOr$15hbiwd(rs.nonZero(b), n2); const _516: boolean = rs.u64Eq(n2, _519); const args3 = [(f: rs.Formatter) => rs.u64Display(n2, f), (f: rs.Formatter) => rs.u64Debug(n2, f), (f: rs.Formatter) => rs.fmtBool(_516, f)]; - put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2]])); + put(out, rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2]]).v); rs.byteVecPush(out, rs.u64Gt(n2, { _0: 1 }._0) ? 1 : 0); rs.byteVecPush(out, rs.cmp(n2, { _0: 1000 }._0) & 0xff); } diff --git a/ts/fixtures/lang/wraps/expected/wraps.ts b/ts/fixtures/lang/wraps/expected/wraps.ts index 383daf58e..5a0786bc3 100644 --- a/ts/fixtures/lang/wraps/expected/wraps.ts +++ b/ts/fixtures/lang/wraps/expected/wraps.ts @@ -369,7 +369,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.u8[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u8WrappingAdd, 0); @@ -394,7 +394,7 @@ export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u8(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u8(x7), hashed$num_Wrapping_u8(a)) ? 1 : 0); @@ -552,7 +552,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.u16[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u16WrappingAdd, 0); @@ -577,7 +577,7 @@ export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u16(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u16(x7), hashed$num_Wrapping_u16(a)) ? 1 : 0); @@ -735,7 +735,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.u32[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u32WrappingAdd, 0); @@ -760,7 +760,7 @@ export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u32(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u32(x7), hashed$num_Wrapping_u32(a)) ? 1 : 0); @@ -918,7 +918,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.u64[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u64WrappingAdd, 0); @@ -943,7 +943,7 @@ export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u64(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u64(x7), hashed$num_Wrapping_u64(a)) ? 1 : 0); @@ -1101,7 +1101,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.u128[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.u128WrappingAdd, 0); @@ -1126,7 +1126,7 @@ export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_u128(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_u128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u128(x7), hashed$num_Wrapping_u128(a)) ? 1 : 0); @@ -1284,7 +1284,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.usize[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.usizeWrappingAdd, 0); @@ -1309,7 +1309,7 @@ export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_usize(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_usize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_usize(x7), hashed$num_Wrapping_usize(a)) ? 1 : 0); @@ -1469,7 +1469,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.i8[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i8WrappingAdd, 0); @@ -1494,7 +1494,7 @@ export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i8(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i8(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i8(x7), hashed$num_Wrapping_i8(a)) ? 1 : 0); @@ -1654,7 +1654,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.i16[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i16WrappingAdd, 0); @@ -1679,7 +1679,7 @@ export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i16(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i16(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i16(x7), hashed$num_Wrapping_i16(a)) ? 1 : 0); @@ -1839,7 +1839,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.i32[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i32WrappingAdd, 0); @@ -1864,7 +1864,7 @@ export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i32(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i32(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i32(x7), hashed$num_Wrapping_i32(a)) ? 1 : 0); @@ -2024,7 +2024,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.i64[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i64WrappingAdd, 0); @@ -2049,7 +2049,7 @@ export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i64(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i64(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i64(x7), hashed$num_Wrapping_i64(a)) ? 1 : 0); @@ -2209,7 +2209,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.i128[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.i128WrappingAdd, 0); @@ -2234,7 +2234,7 @@ export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_i128(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_i128(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i128(x7), hashed$num_Wrapping_i128(a)) ? 1 : 0); @@ -2394,7 +2394,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { const args6 = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", args6[3], " ", args6[4], " ", args6[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args6[6]), " ", rs.fmtSpec({ alternate: true }, args6[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args6[8]), " ", rs.fmtSpec({ plus: true }, args6[6])]).v)); } else if (_31 === 21) { const all: rs.isize[] = [a, b, c]; const part6 = rs.iterSum(rs.iterSlice(all), rs.isizeWrappingAdd, 0); @@ -2419,7 +2419,7 @@ export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const y: Tick.Tick = _357[1]; const _365: Tick.Tick = Tick.default$Default_isize(); const args5 = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(_365, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args5[0], " ", args5[1]]).v)); rs.byteVecPush(out, Tick.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); rs.byteVecPush(out, Tick.cmp$cmp_Ord_isize(x7, y) & 0xff); rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_isize(x7), hashed$num_Wrapping_isize(a)) ? 1 : 0); diff --git a/ts/fixtures/lang/zeros/expected/core/option.ts b/ts/fixtures/lang/zeros/expected/core/option.ts index 9210f934d..a3b1eba38 100644 --- a/ts/fixtures/lang/zeros/expected/core/option.ts +++ b/ts/fixtures/lang/zeros/expected/core/option.ts @@ -18,7 +18,7 @@ export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u return self; } -export function unwrapOrDefault$1b97y1a(self: Tagged.Tagged | undefined): Tagged.Tagged { +export function unwrapOrDefault$0348bav(self: Tagged.Tagged | undefined): Tagged.Tagged { if (self === undefined) { return Tagged.default$Default_String(); } diff --git a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts index 9c715e053..5e14b17d7 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts @@ -2,14 +2,14 @@ import * as rs from "./rs.ts"; -export function clone$Clone_String(self: Tagged): Tagged { +export function clone$Clone_String(self: Tagged): Tagged { const _2: rs.u8 = self.n; self.of; self.pin; return { n: _2, of: undefined, pin: undefined, unit: undefined }; } -export function fmt$fmt_Debug_String(self: Tagged, f: rs.Formatter): rs.Result { +export function fmt$fmt_Debug_String(self: Tagged, f: rs.Formatter): rs.Result { const _3: string = "Tagged"; const _4: string = "n"; const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.n, f); @@ -35,7 +35,7 @@ export function fmt$fmt_Debug_u8(self: Tagged, f: rs.Formatter): rs.Resul return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); } -export function default$Default_String(): Tagged { +export function default$Default_String(): Tagged { const _1: rs.u8 = 0; undefined; undefined; @@ -51,7 +51,7 @@ export function default$Default_u8(): Tagged { return { n: _1, of: undefined, pin: undefined, unit: undefined }; } -export function eq$cmp_PartialEq_String(self: Tagged, other: Tagged): boolean { +export function eq$cmp_PartialEq_String(self: Tagged, other: Tagged): boolean { if (self.n === other.n) { if (true) { if (true) { @@ -62,7 +62,7 @@ export function eq$cmp_PartialEq_String(self: Tagged, other: Tagged, other: Tagged): rs.Ordering | undefined { +export function partialCmp$cmp_PartialOrd_String(self: Tagged, other: Tagged): rs.Ordering | undefined { const cmp: rs.Ordering | undefined = rs.cmp(self.n, other.n); if (cmp !== undefined) { if (cmp === 0) { @@ -84,7 +84,7 @@ export function partialCmp$cmp_PartialOrd_String(self: Tagged, other: Ta return cmp; } -export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): rs.Ordering { +export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): rs.Ordering { const cmp: rs.Ordering = rs.cmp(self.n, other.n); if (cmp === 0) { const cmp2: rs.Ordering = rs.cmpNothing(self.of, other.of); @@ -100,7 +100,7 @@ export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): return cmp; } -export function hash$Hash_String_hash_DefaultHasher(self: Tagged, state: rs.Hasher): void { +export function hash$Hash_String_hash_DefaultHasher(self: Tagged, state: rs.Hasher): void { rs.hash8(self.n, state); rs.hashNothing(self.of, state); rs.hashNothing(self.pin, state); diff --git a/ts/fixtures/lang/zeros/expected/zeros.ts b/ts/fixtures/lang/zeros/expected/zeros.ts index 6585fa323..241ffb053 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { drop$zeros_Lock_u32, drop$zeros_Lock_zeros_Loud } from "./lib.ts"; import { thenSome$1n1oy1h } from "./core/bool.ts"; -import { unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1b97y1a as option_unwrapOrDefault$1b97y1a, map$1b6tbot as option_map$1b6tbot, map$12cu62z as option_map$12cu62z, map$0ul65ro as option_map$0ul65ro, map$0w716ia as option_map$0w716ia } from "./core/option.ts"; +import { unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$0348bav as option_unwrapOrDefault$0348bav, map$1b6tbot as option_map$1b6tbot, map$12cu62z as option_map$12cu62z, map$0ul65ro as option_map$0ul65ro, map$0w716ia as option_map$0w716ia } from "./core/option.ts"; import * as Both from "./zeros.Both.ts"; import * as Defaulted from "./zeros.Defaulted.ts"; import * as Holds from "./zeros.Holds.ts"; @@ -31,7 +31,7 @@ export function pair(): Pair.Pair { return { _0: {}, _1: undefined }; } -export function none$String(): string[] { +export function none$String(): rs.String[] { return []; } @@ -81,7 +81,7 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(_11, {}) ? 1 : 0) | (((Unit.eq$cmp_PartialEq(_13._0, _16) ? 1 : 0) << 1) & 0xff)); const _40: One.One = One.clone$Clone("Only" as One.One); const args6 = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_11, f), (f: rs.Formatter) => One.fmt$fmt_Debug(_40, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]]).v), undefined, true); } else if (_8 === 1) { rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): Uint8Array => { return Uint8Array.of(); @@ -100,12 +100,12 @@ export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, One.eq$cmp_PartialEq(_72(1), one()) ? 1 : 0); } else if (_8 === 2) { const _87: Unit.Unit = unit(); - const _88: rs.Slice = rs.sliceFrom(none$String()); + const _88: rs.Slice = rs.sliceFrom(none$String()); const _90: rs.Slice = rs.sliceFrom(units()); const _93: One.One = one(); const _95: [undefined, Unit.Unit, Uint8Array] = tuple(); - const args5 = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_88), f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_90), f, (value: Unit.Unit, f: rs.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(_95[0], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rs.Formatter) => rs.fmtList(_95[2], f, rs.u8Debug)], f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4]])), undefined, true); + const args5 = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_88), f, (value: rs.String, f: rs.Formatter) => rs.fmtStr(value.v, f)), (f: rs.Formatter) => rs.fmtList(rs.sliceItems(_90), f, (value: Unit.Unit, f: rs.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(_95[0], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rs.Formatter) => rs.fmtList(_95[2], f, rs.u8Debug)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", args5[2], " ", args5[3], " ", args5[4]]).v), undefined, true); } else if (_8 === 3) { const _108: (a0: rs.u8) => rs.u8 = adder(); adder(); @@ -229,7 +229,7 @@ export function hash$zeros_Names(value: Names.Names): rs.u64 { } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$zeros_Tagged_String(value: Tagged.Tagged): rs.u64 { +export function hash$zeros_Tagged_String(value: Tagged.Tagged): rs.u64 { const h: rs.Hasher = rs.hasher(); Tagged.hash$Hash_String_hash_DefaultHasher(value, h); return rs.hashFinish(h); @@ -266,41 +266,41 @@ export function digest$zeros_Names(value: Names.Names, out: rs.ByteVec): void { } /** [`hash`] of `value`, little-endian. */ -export function digest$zeros_Tagged_String(value: Tagged.Tagged, out: rs.ByteVec): void { +export function digest$zeros_Tagged_String(value: Tagged.Tagged, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$zeros_Tagged_String(value)).reverse())); } /** The impls `#[derive]` calls on `PhantomData`, `PhantomPinned`, and `()` fields. */ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { - const tags: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tagged.Tagged => { + const tags: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tagged.Tagged => { const n: rs.u8 = _2; Tagged.default$Default_String(); return { n, of: undefined, pin: undefined, unit: undefined }; }), undefined, 1, true); const _7: rs.u8 = rs.u8Rem(kind, 4); if (_7 === 0) { - const _11: Tagged.Tagged | undefined = rs.sliceFirst(rs.sliceFrom(tags.items)); - const t: Tagged.Tagged = option_unwrapOrDefault$1b97y1a(_11 === undefined ? undefined : Tagged.clone$Clone_String(_11)); + const _11: Tagged.Tagged | undefined = rs.sliceFirst(rs.sliceFrom(tags.items)); + const t: Tagged.Tagged = option_unwrapOrDefault$0348bav(_11 === undefined ? undefined : Tagged.clone$Clone_String(_11)); const _15: rs.u8 = t.n; Tagged.default$Default_u8(); const copied: Tagged.Tagged = { n: _15, of: undefined, pin: undefined, unit: undefined }; const again: Tagged.Tagged = copied; const _27: Names.Names = Names.default$Default(); const args5 = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_String(t, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(copied, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(again, f), (f: rs.Formatter) => Names.fmt$fmt_Debug(_27, f)]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", rs.fmtSpec({ alternate: true }, args5[2]), " ", rs.fmtSpec({ alternate: true }, args5[3])])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args5[0], " ", args5[1], " ", rs.fmtSpec({ alternate: true }, args5[2]), " ", rs.fmtSpec({ alternate: true }, args5[3])]).v), undefined, true); const _38: Rest.Rest = Rest.clone$Clone(Rest.default$Default()); const args6 = [(f: rs.Formatter) => Rest.fmt$fmt_Debug(_38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"])]; - rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[0]), " ", rs.fmtSpec({ align: ">", width: 9 }, args6[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args6[2]), "|"])), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[0]), " ", rs.fmtSpec({ align: ">", width: 9 }, args6[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args6[2]), "|"]).v), undefined, true); rs.byteVecPush(out, rs.iterCount(rs.iterEmpty() as rs.Iter) & 0xff); } else if (_7 === 1) { - const sorted: rs.Vec> = rs.vecFrom(tags.items.map(Tagged.clone$Clone_String)); + const sorted: rs.Vec> = rs.vecFrom(tags.items.map(Tagged.clone$Clone_String)); rs.sliceSort(rs.sliceFrom(sorted.items), rs.cmpLt(Tagged.partialCmp$cmp_PartialOrd_String), 1, true); - rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted.items), (t3: Tagged.Tagged): rs.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted.items), (t3: Tagged.Tagged): rs.u8 => { return t3.n; }), undefined, true); - const iter: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(tags.items), 2); + const iter: rs.Iter>> = rs.sliceWindows(rs.sliceFrom(tags.items), 2); while (true) { - const _76: rs.Slice> | rs.Done = iter.next(); + const _76: rs.Slice> | rs.Done = iter.next(); if (_76 === rs.DONE) { break; } @@ -308,8 +308,8 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.idx(_76, 1); const part = _76.data[_76.start]; const part2 = _76.data[_76.start + 1]; - const a: Tagged.Tagged = part; - const b: Tagged.Tagged = part2; + const a: Tagged.Tagged = part; + const b: Tagged.Tagged = part2; rs.byteVecPush(out, (Tagged.cmp$cmp_Ord_String(a, b) & 0xff) | (((Tagged.eq$cmp_PartialEq_String(a, b) ? 1 : 0) << 2) & 0xff) | (((Tagged.partialCmp$cmp_PartialOrd_String(a, b) === Tagged.cmp$cmp_Ord_String(a, b) as rs.Ordering | undefined ? 1 : 0) << 3) & 0xff)); rs.byteVecPush(out, Tagged.cmp$cmp_Ord_String(a, b) === 0 === rs.u64Eq(hash$zeros_Tagged_String(a), hash$zeros_Tagged_String(b)) ? 1 : 0); } @@ -332,7 +332,7 @@ export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecPush(out, Names.eq$cmp_PartialEq(_168, _176) ? 1 : 0); const _183: Names.Names = Names.default$Default(); rs.byteVecPush(out, Names.cmp$cmp_Ord(_168, _183) === 0 ? 1 : 0); - rs.byteVecPush(out, rs.iterAll(rs.iterSlice(tags.items), (t2: Tagged.Tagged): boolean => { + rs.byteVecPush(out, rs.iterAll(rs.iterSlice(tags.items), (t2: Tagged.Tagged): boolean => { return Tagged.eq$cmp_PartialEq_String(Tagged.clone$Clone_String(t2), t2); }) ? 1 : 0); Rest.default$Default(); diff --git a/ts/fixtures/model/expected/harness.ts b/ts/fixtures/model/expected/harness.ts index 69c6d5f2d..130938510 100644 --- a/ts/fixtures/model/expected/harness.ts +++ b/ts/fixtures/model/expected/harness.ts @@ -88,8 +88,8 @@ export function putU128(out: rs.ByteVec, value: rs.u128): void { } /** Text callers see, such as a `Debug` or `Display`, ended by a zero byte. */ -export function putText(out: rs.ByteVec, text: string): void { - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); +export function putText(out: rs.ByteVec, text: rs.String): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text.v)); rs.byteVecPush(out, 0); } diff --git a/ts/fixtures/names/expected/lib.ts b/ts/fixtures/names/expected/lib.ts index a0f3e4295..9eb85a557 100644 --- a/ts/fixtures/names/expected/lib.ts +++ b/ts/fixtures/names/expected/lib.ts @@ -24,7 +24,7 @@ export function run(data: rs.ByteSlice): rs.ByteVec { }); rs.byteVecPush(out, _15); const part = Wrap.new$wrap_Pair(pair); - const _22: rs.ByteSlice = rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Wrap.fmt$fmt_Display_wrap_Pair(part, f)])); + const _22: rs.ByteSlice = rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => Wrap.fmt$fmt_Display_wrap_Pair(part, f)]).v); rs.byteVecExtendFromSlice(out, _22); if (!(first === 0)) { shape = "Line" as shapes_Shape.Shape; diff --git a/ts/fixtures/reject/census.txt b/ts/fixtures/reject/census.txt index 8c74743d0..3c55f71fa 100644 --- a/ts/fixtures/reject/census.txt +++ b/ts/fixtures/reject/census.txt @@ -15,14 +15,6 @@ fixtures/reject/src/alloc.rs:vec_pointer+1:10: a raw pointer to `std::vec::Vec`, which would drop with the last clone of what it makes, which is not supported fixtures/reject/src/buffers.rs:spare+1:4: `Vec::spare_capacity_mut` of other than bytes, whose room past its length no JS array holds, which is not supported yet fixtures/reject/src/clones.rs:given_slots+6:2: a raw pointer to `(u8, u8)` in `([clones::Touched; 2], (u8, u8))`, which the crate may put another object in place of diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index b3b900074..b4a1ed0a8 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -19,14 +19,6 @@ fixtures/reject/src/alloc.rs:vec_pointer+1:10: a raw pointer to `std::vec::Vec`, which would drop with the last clone of what it makes, which is not supported fixtures/reject/src/buffers.rs:spare+1:4: `Vec::spare_capacity_mut` of other than bytes, whose room past its length no JS array holds, which is not supported yet fixtures/reject/src/clones.rs:greatest_slot+6:13: a raw pointer to `(u8, u8)` in `([clones::Greatest; 2], (u8, u8))`, which the crate may put another object in place of diff --git a/ts/fixtures/stock/caller.ts b/ts/fixtures/stock/caller.ts index 98ee5b707..cb2f3ceb4 100644 --- a/ts/fixtures/stock/caller.ts +++ b/ts/fixtures/stock/caller.ts @@ -2,7 +2,8 @@ // `buf::far`'s reads past where a vector shares its storage, which only these reach, as // each allocates 128 MiB, `buf::reclaims` after each pick of the handles to drop, each of `hashlink`'s iterators read through every pick of steps from // either end, each `buf::chains` chain copied by each pick of a length, split at either -// end and between, and every pair of steps over `hashlink`'s maps of what drops. +// end and between, every pair of steps over `hashlink`'s maps of what drops, and each +// `Bytes` of a `String` by each room and way taken back. import { cases as named, op, run } from "./harness.ts"; @@ -38,4 +39,9 @@ const reclaims = [0, 3, 200].flatMap((cap) => Array.from({ length: 8 * 4 * 2 }, (_, i) => Uint8Array.of(op("buf::reclaims"), cap, i % 8, [0, 3, 40, 255][Math.floor(i / 8) % 4], i < 32 ? 0 : 5)), ); -export const cases: Uint8Array[] = [...far, ...reclaims, ...linked, ...chains, ...nested]; +/** `buf::strings` of no room, of exactly its text, and of more, each way taken back, with a clone held or not. */ +const strings = [0, 4, 23].flatMap((cap) => + Array.from({ length: 2 * 2 * 3 }, (_, i) => Uint8Array.of(op("buf::strings"), cap, 4, 0x61, 0xc3, 0xa9, 0x62, i % 2 === 0 ? 0 : 6, Math.floor(i / 2) % 2, Math.floor(i / 4))), +); + +export const cases: Uint8Array[] = [...far, ...reclaims, ...linked, ...chains, ...nested, ...strings]; diff --git a/ts/fixtures/stock/expected/buf.Ops.ts b/ts/fixtures/stock/expected/buf.Ops.ts index 6914f8578..48635a8e6 100644 --- a/ts/fixtures/stock/expected/buf.Ops.ts +++ b/ts/fixtures/stock/expected/buf.Ops.ts @@ -3,7 +3,6 @@ import * as rs from "./rs.ts"; import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; -/** The bytes of a case's input, taken from the front. */ export interface Ops { _0Data: Uint8Array; _0Start: number; diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index ff71ac152..933a850af 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { drop$Option_bytes_Bytes as lib_drop$Option_bytes_Bytes, drop$bytes_buf_Chain_buf_Provided_bytes_Bytes as lib_drop$bytes_buf_Chain_buf_Provided_bytes_Bytes, drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8, drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces, drop$bytes_buf_Take_bytes_Bytes as lib_drop$bytes_buf_Take_bytes_Bytes, of$buf_Counted, of$buf_Pieces, of$buf_Provided, of$bytes_Bytes, of$bytes_BytesMut, of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8, of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, of$bytes_buf_Take_bytes_Bytes, of$bytes_buf_Take_ref_slice_u8, of$ref_slice_u8, ofPlace$bytes_Bytes, ofPlace$ref_slice_u8, out$i64, out$u128, out$u16, out$u8 } from "./lib.ts"; +import { drop$Option_bytes_Bytes as lib_drop$Option_bytes_Bytes, drop$Result_bytes_BytesMut_bytes_Bytes as lib_drop$Result_bytes_BytesMut_bytes_Bytes, drop$bytes_buf_Chain_buf_Provided_bytes_Bytes as lib_drop$bytes_buf_Chain_buf_Provided_bytes_Bytes, drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8, drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces, drop$bytes_buf_Take_bytes_Bytes as lib_drop$bytes_buf_Take_bytes_Bytes, of$buf_Counted, of$buf_Pieces, of$buf_Provided, of$bytes_Bytes, of$bytes_BytesMut, of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8, of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, of$bytes_buf_Take_bytes_Bytes, of$bytes_buf_Take_ref_slice_u8, of$ref_slice_u8, ofPlace$bytes_Bytes, ofPlace$ref_slice_u8, out$i64, out$u128, out$u16, out$u8 } from "./lib.ts"; import * as buf_Counted from "./buf.Counted.ts"; import * as Fixed from "./buf.Fixed.ts"; import type * as Leased from "./buf.Leased.ts"; @@ -16,6 +16,7 @@ import * as Chain from "./bytes/buf/chain.Chain.ts"; import * as Take from "./bytes/buf/take.Take.ts"; import * as UninitSlice from "./bytes/buf/uninit_slice.UninitSlice.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; +import { then$0abhnvu } from "./core/bool.ts"; import { clone$1i3gmk3 as option_clone$1i3gmk3 } from "./core/option.ts"; import { map$1rpus2m as result_map$1rpus2m, map$1cosroz as result_map$1cosroz, map$1k6isgs as result_map$1k6isgs } from "./core/result.ts"; @@ -322,16 +323,16 @@ export function bytesMut(data: rs.ByteSlice, out: rs.ByteVec): void { const _403: rs.usize = buf.length; const _406: rs.usize = buf.cap; const args7 = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(buf), f), (f: rs.Formatter) => rs.usizeDisplay(_403, f), (f: rs.Formatter) => rs.usizeDisplay(_406, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args7[0], " ", args7[1], " ", args7[2], "\n"]).v)); for (const piece6 of pieces.items) { const _430: rs.usize = piece6.cap; const args8 = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(piece6), f), (f: rs.Formatter) => rs.usizeDisplay(_430, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], " ", args8[1], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], " ", args8[1], "\n"]).v)); } for (const bytes3 of frozen.items) { const _452: boolean = rs.bytesIsUnique(bytes3); const args9 = [(f: rs.Formatter) => rs.bytesDebug(bytes3, f), (f: rs.Formatter) => rs.fmtBool(_452, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args9[0], " ", args9[1], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args9[0], " ", args9[1], "\n"]).v)); } const vec2: rs.ByteVec = rs.bytesMutToByteVec(buf); rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(vec2.data.length as rs.u32).reverse())); @@ -3216,7 +3217,7 @@ export function chunkWrite(chunk: rs.ByteSlice, op: rs.u8, n: rs.u8, out: rs.Byt break b1; } } - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => UninitSlice.fmt$fmt_Debug(chunk, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => UninitSlice.fmt$fmt_Debug(chunk, f)]).v)); return 0; } return k; @@ -3946,7 +3947,7 @@ export function edits(dataData: Uint8Array, dataStart: number, dataLen: number, const _68: boolean = rs.bytesIsUnique(bytes); const _70: rs.ByteSlice = part; const args3 = [(f: rs.Formatter) => rs.bytesDebug(_70, f), (f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.fmtBool(_65, f), (f: rs.Formatter) => rs.fmtBool(_68, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3]]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args3[0], " ", args3[1], " ", args3[2], " ", args3[3]]).v)); rs.bytesDrop(part); rs.bytesDrop(bytes); } @@ -4262,4 +4263,52 @@ export function chained$dyn_bytes_Buf(at: rs.usize[], buf: Buf.Buf, pick: rs.u8, return readAll$dyn_bytes_Buf(buf, ops, out); } +/** + * The bytes of a case's input, taken from the front. + * A `Bytes` of a `String`, which takes its storage, of the room its first bytes pick past + * its text: whether it is the one handle of it, and the room a `BytesMut` or a `Vec` taken + * back of it holds, with a clone of it held or not. + */ +export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: [rs.usize, rs.usize]; + const ops: Ops.Ops = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; + const s: rs.String = rs.stringWithCapacity(rs.usizeRem(Ops.byte(ops) as rs.usize, 24)); + const n: rs.usize = rs.usizeRem(Ops.byte(ops) as rs.usize, 12); + const _17: string = rs.strCowStr(rs.stringFromUtf8Lossy(Ops.take(ops, n))); + rs.stringPushStr(s, _17); + const _24: rs.usize = rs.usizeRem(Ops.byte(ops) as rs.usize, 7); + rs.stringReserve(s, _24); + const bytes: rs.ByteSlice = rs.bytesFromVec(rs.stringIntoBytes(s)); + rs.byteVecPush(out, rs.bytesIsUnique(bytes) ? 1 : 0); + const held: rs.ByteSlice | undefined = then$0abhnvu(rs.u8Rem(Ops.byte(ops), 2) === 1, (): rs.ByteSlice => { + return rs.bytesClone(bytes); + }); + const _46: rs.u8 = rs.u8Rem(Ops.byte(ops), 3); + if (_46 === 0) { + const m: rs.BytesMut = rs.bytesMutFromBytes(bytes); + _45 = [m.length, m.cap] as [rs.usize, rs.usize]; + m[Symbol.dispose](); + } else if (_46 === 1) { + const _56: rs.Result = rs.bytesTryIntoMut(bytes); + if (_56.ok) { + const m2: rs.BytesMut = _56.value; + _45 = [m2.length, m2.cap] as [rs.usize, rs.usize]; + m2[Symbol.dispose](); + } else { + _45 = [4294967295, 0] as [rs.usize, rs.usize]; + } + if (!_56.ok) { + lib_drop$Result_bytes_BytesMut_bytes_Bytes(_56); + } + } else { + const v: rs.ByteVec = rs.bytesToByteVec(bytes); + _45 = [v.length, v.data.length] as [rs.usize, rs.usize]; + } + const len: rs.usize = _45[0]; + const cap: rs.usize = _45[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(cap as rs.u32).reverse())); + lib_drop$Option_bytes_Bytes(held); +} + //# sourceMappingURL=buf.ts.map diff --git a/ts/fixtures/stock/expected/core/bool.ts b/ts/fixtures/stock/expected/core/bool.ts new file mode 100644 index 000000000..d4fdee6c9 --- /dev/null +++ b/ts/fixtures/stock/expected/core/bool.ts @@ -0,0 +1,12 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; + +export function then$0abhnvu(self: boolean, f: () => rs.ByteSlice): rs.ByteSlice | undefined { + if (!self) { + return undefined; + } + return f(); +} + +//# sourceMappingURL=bool.ts.map diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index 373a4245f..517fb084d 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { bytesMut, far, reclaims, reads, dyns, late, vecSpares, chunks, writes, edits, chains } from "./buf.ts"; +import { bytesMut, far, reclaims, reads, dyns, late, vecSpares, chunks, writes, edits, chains, strings } from "./buf.ts"; import * as Owner from "./harness.Owner.ts"; import { map as maps_map, table, capacity, linked, linkedIters, nested, ownHasher, ownFromIter, equal, defaultHasher } from "./maps.ts"; import { ranges } from "./ranges.ts"; @@ -39,7 +39,7 @@ export function cases(): rs.Vec<[string, (a0: rs.ByteSlice, a1: rs.ByteVec) => u reclaims(a013.data, a013.start, a013.length, a113); }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::vec_spares", vecSpares as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::chunks", (a014: rs.ByteSlice, a114: rs.ByteVec): undefined => { chunks(a014.data, a014.start, a014.length, a114); - }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["ranges", ranges as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::strings", strings as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["ranges", ranges as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); } /** Run one case. */ @@ -145,7 +145,7 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o const copied: rs.ByteSlice = rs.bytesCopyFromSlice(rs.byteVecSlice(source)); rs.byteVecClear(source); rs.byteVecPush(source, 0); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.bytesDebug(copied, f)]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([(f: rs.Formatter) => rs.bytesDebug(copied, f)]).v)); const iter: rs.Iter = rs.iterSlice(made, rs.bytesDrop); while (true) { const _44: rs.ByteSlice | rs.Done = iter.next(); @@ -155,7 +155,7 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o const bytes: rs.ByteSlice = _44; const _56: rs.usize = bytes.length; const args6 = [(f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.usizeDisplay(_56, f)]; - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], "\n"]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], "\n"]).v)); rs.bytesDrop(bytes); } rs.drop(iter); diff --git a/ts/fixtures/stock/expected/lib.ts b/ts/fixtures/stock/expected/lib.ts index b6c1611a6..24485f1c2 100644 --- a/ts/fixtures/stock/expected/lib.ts +++ b/ts/fixtures/stock/expected/lib.ts @@ -81,6 +81,14 @@ export function drop$Option_tuple2_u16_maps_Logged(_1: [rs.u16, Logged.Logged] | } } +export function drop$Result_bytes_BytesMut_bytes_Bytes(_1: rs.Result): void { + if (_1.ok) { + _1.value[Symbol.dispose](); + } else { + rs.bytesDrop(_1.error); + } +} + export function drop$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes(_1: Chain.Chain): void { rs.drop(_1.a); rs.bytesDrop(_1.b); diff --git a/ts/fixtures/stock/expected/maps.ts b/ts/fixtures/stock/expected/maps.ts index cd149ec12..5d9fbff43 100644 --- a/ts/fixtures/stock/expected/maps.ts +++ b/ts/fixtures/stock/expected/maps.ts @@ -33,7 +33,7 @@ export function put(out: rs.ByteVec, n: rs.usize): void { export function map(data: rs.ByteSlice, out: rs.ByteVec): void { const own: rs.HashMap = rs.hashNew() as rs.HashMap; const pairs: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8], rs.u32>; - const set: rs.HashSet = rs.hashWithCapacity(rs.usizeDiv(data.length, 4), 117440512) as rs.HashSet; + const set: rs.HashSet = rs.hashWithCapacity(rs.usizeDiv(data.length, 4), 117440512, rs.HASH_TEXT) as rs.HashSet; const iter: rs.Iter = rs.byteSliceChunks(data, 2); while (true) { const _12: rs.ByteSlice | rs.Done = iter.next(); @@ -82,13 +82,13 @@ export function map(data: rs.ByteSlice, out: rs.ByteVec): void { return k5[0] !== rs.u8Rem(arg, 4); }); } else if (_35 === 6) { - const _88: string = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(key, f)]); + const _88: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(key, f)]); rs.byteVecPush(out, rs.hashAdd(set, _88) ? 1 : 0); const part = rs.u16Add(key, 1); - const _102: string = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(part, f)]); + const _102: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(part, f)]); rs.byteVecPush(out, rs.hashContains(set, _102) ? 1 : 0); } else if (_35 === 7) { - const _117: string = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(key, f)]); + const _117: rs.String = rs.fmtFormat([(f: rs.Formatter) => rs.u16Display(key, f)]); rs.byteVecPush(out, rs.hashDelete(set, _117) ? 1 : 0); } else if (_35 === 8) { put(out, option_mapOr$0o00yzv(rs.hashRemoveEntry(own, key), 256, (_26: [rs.u16, rs.u32]): rs.usize => { @@ -122,9 +122,9 @@ export function map(data: rs.ByteSlice, out: rs.ByteVec): void { rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, b))); put(out, v2 as rs.usize); } - const set2: rs.Vec = rs.iterToVec(rs.hashKeys(set), "next", 12); + const set2: rs.Vec = rs.iterToVec(rs.hashKeys(set), "next", 12); rs.sliceSort(rs.sliceFrom(set2.items), rs.cmpLt(rs.cmpStr), 12, true); - rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strsJoin(set2.items, ","))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strsJoin(set2.items, ",").v)); } /** diff --git a/ts/fixtures/stock/src/buf.rs b/ts/fixtures/stock/src/buf.rs index aad61cffb..bc205474b 100644 --- a/ts/fixtures/stock/src/buf.rs +++ b/ts/fixtures/stock/src/buf.rs @@ -981,6 +981,37 @@ fn chained(at: [usize; 2], buf: &mut B, pick: &u8, ops: &[u8], } /// The bytes of a case's input, taken from the front. +/// A `Bytes` of a `String`, which takes its storage, of the room its first bytes pick past +/// its text: whether it is the one handle of it, and the room a `BytesMut` or a `Vec` taken +/// back of it holds, with a clone of it held or not. +pub fn strings(data: &[u8], out: &mut Vec) { + let mut ops = Ops(data); + let mut s = String::with_capacity(ops.byte() as usize % 24); + let n = ops.byte() as usize % 12; + s.push_str(&String::from_utf8_lossy(ops.take(n))); + s.reserve(ops.byte() as usize % 7); + let bytes = Bytes::from(s); + out.push(bytes.is_unique() as u8); + let held = (ops.byte() % 2 == 1).then(|| bytes.clone()); + let (len, cap) = match ops.byte() % 3 { + 0 => { + let m = BytesMut::from(bytes); + (m.len(), m.capacity()) + } + 1 => match bytes.try_into_mut() { + Ok(m) => (m.len(), m.capacity()), + Err(_) => (usize::MAX, 0), + }, + _ => { + let v: Vec = bytes.into(); + (v.len(), v.capacity()) + } + }; + out.extend_from_slice(&(len as u32).to_le_bytes()); + out.extend_from_slice(&(cap as u32).to_le_bytes()); + drop(held); +} + struct Ops<'a>(&'a [u8]); impl<'a> Ops<'a> { diff --git a/ts/fixtures/stock/src/harness.rs b/ts/fixtures/stock/src/harness.rs index ec6baae8c..711644cc4 100644 --- a/ts/fixtures/stock/src/harness.rs +++ b/ts/fixtures/stock/src/harness.rs @@ -36,6 +36,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("buf::reclaims", crate::buf::reclaims), ("buf::vec_spares", crate::buf::vec_spares), ("buf::chunks", crate::buf::chunks), + ("buf::strings", crate::buf::strings), ("ranges", crate::ranges::ranges), ] } diff --git a/ts/fixtures/task/expected/closures.ts b/ts/fixtures/task/expected/closures.ts index 965073da1..731891005 100644 --- a/ts/fixtures/task/expected/closures.ts +++ b/ts/fixtures/task/expected/closures.ts @@ -280,7 +280,7 @@ export class closuresFuture { const _91: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(arg5[0], f), (f: rs.Formatter) => rs.u32Debug(arg5[1], f), (f: rs.Formatter) => rs.u32Debug(arg5[2], f)], f); const arg6 = this.#count; const args9 = [_87, _88, _89, _90, _91, (f: rs.Formatter) => rs.u32Display(arg6, f)]; - const _74: string = rs.fmtFormat(["seen ", args9[0], " first ", args9[1], " second ", args9[2], " reads ", args9[3], " tallied ", args9[4], " count ", args9[5]]); + const _74: string = rs.fmtFormat(["seen ", args9[0], " first ", args9[1], " second ", args9[2], " reads ", args9[3], " tallied ", args9[4], " count ", args9[5]]).v; Guard.note(this.#guard, _74); const captured2 = Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)); this.#awaitee$3 = new callOnceFuture$closures_closures_closure0_closure2(rs.closure(rs.byMove((rx: Consumer.Consumer): rs.Future => { @@ -300,7 +300,7 @@ export class closuresFuture { this.#third = _105; rs.drop(this.#awaitee$3); const arg7 = this.#third; - const _115: string = rs.fmtFormat(["third ", (f: rs.Formatter) => rs.u64Display(arg7, f)]); + const _115: string = rs.fmtFormat(["third ", (f: rs.Formatter) => rs.u64Display(arg7, f)]).v; Guard.note(this.#guard, _115); this.#lent = Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)); this.#peek = (value3: rs.u64): rs.Future => { @@ -415,7 +415,7 @@ export class closuresFuture { const _249: rs.Fmt = (f: rs.Formatter) => rs.u64Display(arg8, f); const arg9 = this.#fifth; const args11 = [_249, (f: rs.Formatter) => rs.u64Display(arg9, f)]; - const _240: string = rs.fmtFormat(["fourth ", args11[0], " fifth ", args11[1]]); + const _240: string = rs.fmtFormat(["fourth ", args11[0], " fifth ", args11[1]]).v; Guard.note(this.#guard, _240); const captured5 = Guard.new(rs.u32Add(this.#id, 900), Log.clone$Clone(this.#log)); this.#awaitee$3 = new callOnceFuture$boxed_Box_closures_closures_closure0_closure7(rs.closure(rs.byMove((rx2: Consumer.Consumer): rs.Future => { @@ -480,7 +480,7 @@ export class closuresFuture { }))()); const arg10 = this.#sixth; const args12 = [(f: rs.Formatter) => rs.u64Display(arg10, f), (f: rs.Formatter) => rs.u32Display(seventh, f)]; - const _319: string = rs.fmtFormat(["sixth ", args12[0], " seventh ", args12[1]]); + const _319: string = rs.fmtFormat(["sixth ", args12[0], " seventh ", args12[1]]).v; Guard.note(this.#guard, _319); const _360: rs.u64 = rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(option_unwrapOr$15hbiwd(this.#first, 0), option_unwrapOr$15hbiwd(this.#second, 0)), this.#third), this.#fourth), this.#fifth), this.#sixth); this.#saved$4 = false; @@ -591,7 +591,7 @@ export class closuresFuture$closure2_closure0 { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - Guard.note(this.#owned, rs.fmtFormat(["once ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)])); + Guard.note(this.#owned, rs.fmtFormat(["once ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]).v); const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; @@ -631,7 +631,7 @@ export class closuresFuture$closure2_closure0_once { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - const _17: string = rs.fmtFormat(["once ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]); + const _17: string = rs.fmtFormat(["once ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]).v; Guard.note(this.#owned, _17); const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#owned[Symbol.dispose](); @@ -659,7 +659,7 @@ export class closuresFuture$closure3_closure0 { poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const value: rs.u64 = this.#value; - Guard.note(this.#lent, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.u64Display(value, f)])); + Guard.note(this.#lent, rs.fmtFormat(["peek ", (f: rs.Formatter) => rs.u64Display(value, f)]).v); const _0: rs.Poll = rs.u64Add(value, 1); this.#state = 1; return _0; @@ -730,7 +730,7 @@ export class closuresFuture$closure6_closure0 { poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const value: rs.u64 = this.#value; - Guard.note(this.#last, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.u64Display(value, f)])); + Guard.note(this.#last, rs.fmtFormat(["last ", (f: rs.Formatter) => rs.u64Display(value, f)]).v); this.#state = 1; return value; } @@ -757,7 +757,7 @@ export class closuresFuture$closure6_closure0_once { poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const value: rs.u64 = this.#value; - const _6: string = rs.fmtFormat(["last ", (f: rs.Formatter) => rs.u64Display(value, f)]); + const _6: string = rs.fmtFormat(["last ", (f: rs.Formatter) => rs.u64Display(value, f)]).v; Guard.note(this.#last, _6); this.#last[Symbol.dispose](); this.#state = 1; @@ -794,7 +794,7 @@ export class closuresFuture$closure7_closure0 { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - Guard.note(this.#boxed, rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)])); + Guard.note(this.#boxed, rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]).v); const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; @@ -834,7 +834,7 @@ export class closuresFuture$closure7_closure0_once { if (_7 !== rs.Pending) { const value: rs.u64 | undefined = _7; rs.drop(this.#awaitee); - const _17: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]); + const _17: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]).v; Guard.note(this.#boxed, _17); const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#boxed[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops.Key.ts b/ts/fixtures/task/expected/drops.Key.ts index 2815d6461..049fe23e8 100644 --- a/ts/fixtures/task/expected/drops.Key.ts +++ b/ts/fixtures/task/expected/drops.Key.ts @@ -28,7 +28,7 @@ function new_(id: rs.u32, log: Log.Log): Key { export function drop$ops_Drop(self: Key): void { const arg = self.id; - const _4: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); self.id = 4294967295; } @@ -48,7 +48,7 @@ export function cmp$cmp_Ord(self: Key, other: Key): rs.Ordering { export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void { if (self.counted) { const arg = self.id; - const _6: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " hashed"]); + const _6: rs.String = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " hashed"]); Log.note(self.log, _6); } rs.hash32(self.id, state); @@ -56,7 +56,7 @@ export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void export function clone$Clone(self: Key): Key { const arg = self.id; - const _4: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " cloned"]); + const _4: rs.String = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " cloned"]); Log.note(self.log, _4); return new Key(self.id, Log.clone$Clone(self.log), self.counted); } diff --git a/ts/fixtures/task/expected/drops.Wrap.ts b/ts/fixtures/task/expected/drops.Wrap.ts index 3ff9e5afd..2b8bc946e 100644 --- a/ts/fixtures/task/expected/drops.Wrap.ts +++ b/ts/fixtures/task/expected/drops.Wrap.ts @@ -22,37 +22,37 @@ export class Wrap { export function drop$ops_Drop_Vec_drops_Wrap_drops_Held(self: Wrap>>): void { const arg = self.id; - const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Held(self: Wrap): void { const arg = self.id; - const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Pair_drops_Held(self: Wrap>): void { const arg = self.id; - const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_model_Guard(self: Wrap): void { const arg = self.id; - const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_sync_Arc_drops_Held(self: Wrap>): void { const arg = self.id; - const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_u32(self: Wrap): void { const arg = self.id; - const _4: string = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["w", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 504a5274e..19bc6053f 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -289,7 +289,7 @@ export class heldFuture { const _54: boolean = Held.isSome(this.#wrap.inner.value); const arg = this.#id; const args3 = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_51, f), (f: rs.Formatter) => rs.fmtBool(_54, f)]; - const _46: string = rs.fmtFormat(["g", args3[0], " held ", args3[1], " ", args3[2]]); + const _46: rs.String = rs.fmtFormat(["g", args3[0], " held ", args3[1], " ", args3[2]]); Log.note(this.#log, _46); lib_drop$drops_Wrap_sync_Arc_drops_Held(this.#wrap); rs.dropVec(this.#held, lib_drop$drops_Held); @@ -346,7 +346,7 @@ export function ordered(log: Log.Log, id: rs.u32): void { } else { const _86: Guard.Guard = rs.entryRemove(_72, rs.drop); const part3 = Guard.id(_86); - const _80: string = rs.fmtFormat(["occupied ", (f: rs.Formatter) => rs.u32Display(part3, f)]); + const _80: rs.String = rs.fmtFormat(["occupied ", (f: rs.Formatter) => rs.u32Display(part3, f)]); _86[Symbol.dispose](); Log.note(log, _80); } @@ -383,7 +383,7 @@ export function ordered(log: Log.Log, id: rs.u32): void { Log.note(log, rs.fmtFormat(["again ", (f: rs.Formatter) => rs.fmtBool(part5, f)])); const _192: Key.Key = key(11); const part6 = rs.btreeDelete(set, _192, rs.drop); - const _185: string = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part6, f)]); + const _185: rs.String = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part6, f)]); _192[Symbol.dispose](); Log.note(log, _185); const _201: Key.Key = key(12); @@ -559,7 +559,7 @@ export function hashed(log: Log.Log, id: rs.u32): void { Log.note(log, rs.fmtFormat(["again ", (f: rs.Formatter) => rs.fmtBool(part2, f)])); const _183: Key.Key = key(11); const part3 = rs.hashDelete(set, _183, rs.drop); - const _176: string = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); + const _176: rs.String = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); _183[Symbol.dispose](); Log.note(log, _176); const _192: Key.Key = key(12); @@ -893,7 +893,7 @@ export function elements(log: Log.Log, id: rs.u32): void { captured[Symbol.dispose](); }), rs.drop, rs.None); const part5 = _151 !== rs.None; - const _145: string = rs.fmtFormat(["uncalled ", (f: rs.Formatter) => rs.fmtBool(part5, f)]); + const _145: rs.String = rs.fmtFormat(["uncalled ", (f: rs.Formatter) => rs.fmtBool(part5, f)]); rs.drop(_151); Log.note(log, _145); v.items.push(undefined as Guard.Guard | undefined); @@ -1056,7 +1056,7 @@ export function elements(log: Log.Log, id: rs.u32): void { return k7.id; }); }); - const _458: string = rs.fmtFormat(["get ", (f: rs.Formatter) => rs.fmtOption(part20, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]); + const _458: rs.String = rs.fmtFormat(["get ", (f: rs.Formatter) => rs.fmtOption(part20, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]); rs.drop(_466); Log.note(log, _458); const _477: Key.Key | undefined = key(10); @@ -1071,7 +1071,7 @@ export function elements(log: Log.Log, id: rs.u32): void { const _493: Key.Key | undefined | rs.None = rs.btreeKey(sorted, _496, true, rs.None); const _491: boolean = _493 !== rs.None; const args72 = [(f: rs.Formatter) => rs.fmtOption(_487, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtBool(_491, f)]; - const _483: string = rs.fmtFormat(["take ", args72[0], " ", args72[1]]); + const _483: rs.String = rs.fmtFormat(["take ", args72[0], " ", args72[1]]); rs.drop(_493); rs.drop(_496); Log.note(log, _483); @@ -1205,7 +1205,7 @@ export function arcs(log: Log.Log, id: rs.u32): void { const clone: rs.Arc = rs.arcClone(shared); const _176: Guard.Guard | undefined = rs.arcIntoInner(shared); const part10 = _176 !== undefined; - const _170: string = rs.fmtFormat(["into_inner ", (f: rs.Formatter) => rs.fmtBool(part10, f)]); + const _170: rs.String = rs.fmtFormat(["into_inner ", (f: rs.Formatter) => rs.fmtBool(part10, f)]); rs.drop(_176); Log.note(log, _170); const inner: Guard.Guard | undefined = rs.arcIntoInner(clone); @@ -1213,7 +1213,7 @@ export function arcs(log: Log.Log, id: rs.u32): void { const _194: rs.Arc | undefined = rs.weakUpgrade(weak); const _192: boolean = _194 !== undefined; const args20 = [(f: rs.Formatter) => rs.fmtOption(_188, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_192, f)]; - const _184: string = rs.fmtFormat(["into_inner ", args20[0], " ", args20[1]]); + const _184: rs.String = rs.fmtFormat(["into_inner ", args20[0], " ", args20[1]]); rs.drop(_194); Log.note(log, _184); rs.drop(inner); @@ -1323,10 +1323,10 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const key: (a0: rs.u32) => Key.Key = (n: rs.u32): Key.Key => { return Key.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const ids: (a0: rs.Slice) => string = (v13: rs.Slice): string => { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(v13)), (k: Key.Key): string => { + const ids: (a0: rs.Slice) => rs.String = (v13: rs.Slice): rs.String => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.sliceItems(v13)), (k: Key.Key): rs.String => { const _43: rs.u32 = rs.u32Sub(k.id, id); - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_43, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_43, f), 0); }), undefined, 12, true).items, ","); }; const _8: rs.u8 = rs.u8Rem(arg, 9); @@ -1346,13 +1346,13 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, rs.drop); const part24 = rs.sliceFrom(v.items); const part25 = ids(part24); - Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, part25)])); + Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, part25.v)])); rs.vecRetain(v, (k7: Key.Key): boolean => { return k7.id !== rs.u32Add(id, 3); }, rs.drop); const part26 = rs.sliceFrom(v.items); const part27 = ids(part26); - Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, part27)])); + Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, part27.v)])); rs.dropVec(v); } else if (_8 === 1) { const v4: rs.Vec = new rs.Vec(); @@ -1370,19 +1370,19 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecDedupBy(v3, Key.eq$cmp_PartialEq, rs.drop); const part18 = rs.sliceFrom(v3.items); const part19 = ids(part18); - Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part19)])); + Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part19.v)])); rs.vecDedupByKey(v3, (k5: Key.Key): rs.u32 => { return rs.u32Div(k5.id, 2); }, rs.same, rs.drop); const part20 = rs.sliceFrom(v3.items); const part21 = ids(part20); - Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part21)])); + Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part21.v)])); rs.vecDedupBy(v3, (a: Key.Key, b: Key.Key): boolean => { return a.id > b.id; }, rs.drop); const part22 = rs.sliceFrom(v3.items); const part23 = ids(part22); - Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part23)])); + Log.note(log, rs.fmtFormat(["deduped ", (f: rs.Formatter) => rs.fmtPad(f, part23.v)])); rs.dropVec(v3); } else if (_8 === 2) { const v6: rs.Vec = new rs.Vec(); @@ -1396,7 +1396,7 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecSwapRemove(v5, 0)[Symbol.dispose](); const part16 = rs.sliceFrom(v5.items); const part17 = ids(part16); - Log.note(log, rs.fmtFormat(["swapped ", (f: rs.Formatter) => rs.fmtPad(f, part17)])); + Log.note(log, rs.fmtFormat(["swapped ", (f: rs.Formatter) => rs.fmtPad(f, part17.v)])); rs.vecSwapRemove(v5, 3)[Symbol.dispose](); rs.dropVec(v5); } else if (_8 === 3) { @@ -1409,7 +1409,7 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _209: rs.Vec = rs.vecFrom(v7.items.map(Key.clone$Clone)); const part14 = rs.sliceFrom(_209.items); const part15 = ids(part14); - const _200: string = rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part15)]); + const _200: rs.String = rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part15.v)]); rs.dropVec(_209); Log.note(log, _200); rs.dropVec(v7); @@ -1430,15 +1430,15 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.vecInsert(v9, 1, _244); const part8 = rs.sliceFrom(v9.items); const part9 = ids(part8); - Log.note(log, rs.fmtFormat(["inserted ", (f: rs.Formatter) => rs.fmtPad(f, part9)])); + Log.note(log, rs.fmtFormat(["inserted ", (f: rs.Formatter) => rs.fmtPad(f, part9.v)])); rs.vecRemove(v9, 0)[Symbol.dispose](); const part10 = rs.sliceFrom(v9.items); const part11 = ids(part10); - Log.note(log, rs.fmtFormat(["removed ", (f: rs.Formatter) => rs.fmtPad(f, part11)])); + Log.note(log, rs.fmtFormat(["removed ", (f: rs.Formatter) => rs.fmtPad(f, part11.v)])); rs.vecTruncate(v9, 1, rs.drop); const part12 = rs.sliceFrom(v9.items); const part13 = ids(part12); - Log.note(log, rs.fmtFormat(["truncated ", (f: rs.Formatter) => rs.fmtPad(f, part13)])); + Log.note(log, rs.fmtFormat(["truncated ", (f: rs.Formatter) => rs.fmtPad(f, part13.v)])); rs.vecTruncate(v9, 0, rs.drop); rs.dropVec(v9); } else if (_8 === 6) { @@ -1474,29 +1474,29 @@ export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { const boxed: Key.Key = key(1); const _377: Key.Key = Key.clone$Clone(boxed); const part5 = rs.u32Sub(_377.id, id); - const _371: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.u32Display(part5, f)]); + const _371: rs.String = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.u32Display(part5, f)]); _377[Symbol.dispose](); Log.note(log, _371); boxed[Symbol.dispose](); } else { const _392: Key.Key = rs.ordMax(key(1), key(2), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part = rs.u32Sub(_392.id, id); - const _386: string = rs.fmtFormat(["max ", (f: rs.Formatter) => rs.u32Display(part, f)]); + const _386: rs.String = rs.fmtFormat(["max ", (f: rs.Formatter) => rs.u32Display(part, f)]); _392[Symbol.dispose](); Log.note(log, _386); const _412: Key.Key = rs.ordMin(key(5), key(4), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part2 = rs.u32Sub(_412.id, id); - const _406: string = rs.fmtFormat(["min ", (f: rs.Formatter) => rs.u32Display(part2, f)]); + const _406: rs.String = rs.fmtFormat(["min ", (f: rs.Formatter) => rs.u32Display(part2, f)]); _412[Symbol.dispose](); Log.note(log, _406); const _432: Key.Key = rs.ordClamp(key(2), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part3 = rs.u32Sub(_432.id, id); - const _426: string = rs.fmtFormat(["clamped ", (f: rs.Formatter) => rs.u32Display(part3, f)]); + const _426: rs.String = rs.fmtFormat(["clamped ", (f: rs.Formatter) => rs.u32Display(part3, f)]); _432[Symbol.dispose](); Log.note(log, _426); const _455: Key.Key = rs.ordClamp(key(0), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); const part4 = rs.u32Sub(_455.id, id); - const _449: string = rs.fmtFormat(["clamped ", (f: rs.Formatter) => rs.u32Display(part4, f)]); + const _449: rs.String = rs.fmtFormat(["clamped ", (f: rs.Formatter) => rs.u32Display(part4, f)]); _455[Symbol.dispose](); Log.note(log, _449); } diff --git a/ts/fixtures/task/expected/drops/called.ts b/ts/fixtures/task/expected/drops/called.ts index e0d57542a..868d8b4f9 100644 --- a/ts/fixtures/task/expected/drops/called.ts +++ b/ts/fixtures/task/expected/drops/called.ts @@ -270,7 +270,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args102 = [(f: rs.Formatter) => rs.fmtOption(_280, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_283[0], f), (f: rs.Formatter) => rs.fmtOption(_283[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_286[0], f), (f: rs.Formatter) => rs.fmtOption(_286[1], f, rs.usizeDebug)], f)]; Log.note(log, rs.fmtFormat(["first ", args102[0], " ", args102[1], " ", args102[2]])); rs.drop(it5); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); rs.dropVec(made); } else if (_17 === 6) { const _303: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); @@ -362,7 +362,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured9[Symbol.dispose](); })); - Log.note(log, "made"); + Log.note(log, rs.stringFrom("made")); const _425: rs.u32 = lazy.force(); const _427: rs.u32 = lazy.force(); const args82 = [(f: rs.Formatter) => rs.u32Display(_425, f), (f: rs.Formatter) => rs.u32Display(_427, f)]; @@ -376,7 +376,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured10[Symbol.dispose](); })), undefined, rs.drop); - Log.note(log, "unused"); + Log.note(log, rs.stringFrom("unused")); const captured11 = guard(22); const lazy2: rs.LazyCell = new rs.LazyCell(rs.once(rs.closure((): rs.u32 => { return Guard.id(captured11); @@ -409,7 +409,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _137: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell2); const _1110: boolean = !_137.ok; const args72 = [(f: rs.Formatter) => rs.u32Display(n8.v, f), (f: rs.Formatter) => rs.u32Display(_95, f), (f: rs.Formatter) => rs.fmtBool(_1110, f)]; - const _512: string = rs.fmtFormat(["replace ", args72[0], " ", args72[1], " ", args72[2]]); + const _512: rs.String = rs.fmtFormat(["replace ", args72[0], " ", args72[1], " ", args72[2]]); lib_drop$Result_cell_Ref_u32_cell_BorrowError(_137); Log.note(log, _512); n8.v = rs.u32Add(n8.v, 1); @@ -417,7 +417,7 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, true); const _484: rs.RefCell = rs.refCellBorrow(cell2); const args73 = [(f: rs.Formatter) => rs.u32Display(old, f), (f: rs.Formatter) => rs.u32Display(_484.value, f)]; - const _480: string = rs.fmtFormat(["replaced ", args73[0], " ", args73[1]]); + const _480: rs.String = rs.fmtFormat(["replaced ", args73[0], " ", args73[1]]); rs.refRelease(_484); Log.note(log, _480); const _494: [Guard.Guard, Guard.Guard] = [guard(22), guard(23)]; @@ -519,8 +519,8 @@ export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { const _143: rs.u32 = Guard.id(g2); const _174: rs.u32 = Guard.id(captured2); - const _205: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); - const args61 = [(f: rs.Formatter) => rs.u32Display(_143, f), (f: rs.Formatter) => rs.u32Display(_174, f), (f: rs.Formatter) => rs.fmtPad(f, _205)]; + const _205: rs.String = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); + const args61 = [(f: rs.Formatter) => rs.u32Display(_143, f), (f: rs.Formatter) => rs.u32Display(_174, f), (f: rs.Formatter) => rs.fmtPad(f, _205.v)]; rs.panicFmt(["try_fold of g", args61[0], " with g", args61[1], " after\n", args61[2]]); } else { const _04: rs.u32 | undefined = rs.u32Add(n4, Guard.id(g2)); diff --git a/ts/fixtures/task/expected/drops/flattened.ts b/ts/fixtures/task/expected/drops/flattened.ts index 49c18e8ff..4a55d879b 100644 --- a/ts/fixtures/task/expected/drops/flattened.ts +++ b/ts/fixtures/task/expected/drops/flattened.ts @@ -102,7 +102,7 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { g24[Symbol.dispose](); return _026; }); - const _147: string = rs.fmtFormat(["all ", (f: rs.Formatter) => rs.fmtBool(part56, f)]); + const _147: rs.String = rs.fmtFormat(["all ", (f: rs.Formatter) => rs.fmtBool(part56, f)]); rs.drop(_153); Log.note(log, _147); const _168: rs.Iter = firsts(log, id, 60); @@ -111,7 +111,7 @@ export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { g25[Symbol.dispose](); return _027; }); - const _162: string = rs.fmtFormat(["position ", (f: rs.Formatter) => rs.fmtOption(part57, f, rs.usizeDebug)]); + const _162: rs.String = rs.fmtFormat(["position ", (f: rs.Formatter) => rs.fmtOption(part57, f, rs.usizeDebug)]); rs.drop(_168); Log.note(log, _162); } else if (_6 === 3) { diff --git a/ts/fixtures/task/expected/drops/folds.Pile.ts b/ts/fixtures/task/expected/drops/folds.Pile.ts index 8eb37427e..bf5a09c81 100644 --- a/ts/fixtures/task/expected/drops/folds.Pile.ts +++ b/ts/fixtures/task/expected/drops/folds.Pile.ts @@ -34,7 +34,7 @@ export function sizeHint$iter_Iterator(self: Pile): [rs.usize, rs.usize | undefi } export function nth$iter_Iterator(self: Pile, n: rs.usize): Guard.Guard | undefined { - const _5: string = rs.fmtFormat(["pile nth ", (f: rs.Formatter) => rs.usizeDisplay(n, f)]); + const _5: rs.String = rs.fmtFormat(["pile nth ", (f: rs.Formatter) => rs.usizeDisplay(n, f)]); Log.note(self.log, _5); let iterStart: rs.usize = 0; const iterEnd: rs.usize = n; @@ -50,21 +50,23 @@ export function nth$iter_Iterator(self: Pile, n: rs.usize): Guard.Guard | undefi } export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: Guard.Guard) => rs.u32 | undefined): rs.u32 | undefined { - Log.note(self.log, "pile fold"); + const _6: rs.String = rs.stringFrom("pile fold"); + Log.note(self.log, _6); let acc: rs.u32 | undefined = init; while (self.held.items.length > 1) { const part = rs.optionUnwrap(rs.vecPop(self.held)); acc = f(acc, part); } rs.drop(f); - Log.note(self.log, "pile folded"); + const _23: rs.String = rs.stringFrom("pile folded"); + Log.note(self.log, _23); self[Symbol.dispose](); return acc; } export function count$iter_Iterator(self: Pile): rs.usize { const part = self.held.items.length; - const _4: string = rs.fmtFormat(["pile count ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); + const _4: rs.String = rs.fmtFormat(["pile count ", (f: rs.Formatter) => rs.usizeDisplay(part, f)]); Log.note(self.log, _4); const _0: rs.usize = self.held.items.length; self[Symbol.dispose](); @@ -72,7 +74,8 @@ export function count$iter_Iterator(self: Pile): rs.usize { } export function last$iter_Iterator(self: Pile): Guard.Guard | undefined { - Log.note(self.log, "pile last"); + const _4: rs.String = rs.stringFrom("pile last"); + Log.note(self.log, _4); const _0: Guard.Guard | undefined = then$1xpp3sz(!(self.held.items.length === 0), (): Guard.Guard => { return rs.vecRemove(self.held, 0); }); @@ -87,7 +90,7 @@ export function nextBack$iter_DoubleEndedIterator(self: Pile): Guard.Guard | und } export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rs.usize): Guard.Guard | undefined { - const _5: string = rs.fmtFormat(["pile nth_back ", (f: rs.Formatter) => rs.usizeDisplay(n, f)]); + const _5: rs.String = rs.fmtFormat(["pile nth_back ", (f: rs.Formatter) => rs.usizeDisplay(n, f)]); Log.note(self.log, _5); let iterStart: rs.usize = 0; const iterEnd: rs.usize = n; @@ -103,14 +106,16 @@ export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rs.usize): Guard } export function rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: Guard.Guard) => rs.u32 | undefined): rs.u32 | undefined { - Log.note(self.log, "pile rfold"); + const _6: rs.String = rs.stringFrom("pile rfold"); + Log.note(self.log, _6); let acc: rs.u32 | undefined = init; while (self.held.items.length > 1) { const part = rs.vecRemove(self.held, 0); acc = f(acc, part); } rs.drop(f); - Log.note(self.log, "pile rfolded"); + const _22: rs.String = rs.stringFrom("pile rfolded"); + Log.note(self.log, _22); self[Symbol.dispose](); return acc; } diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 571ebbcad..3c450ae3c 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -1644,8 +1644,8 @@ export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { const _146: rs.u32 = Guard.id(g2); const _172: rs.u32 = Guard.id(captured2); - const _202: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); - const args57 = [(f: rs.Formatter) => rs.u32Display(_146, f), (f: rs.Formatter) => rs.u32Display(_172, f), (f: rs.Formatter) => rs.fmtPad(f, _202)]; + const _202: rs.String = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); + const args57 = [(f: rs.Formatter) => rs.u32Display(_146, f), (f: rs.Formatter) => rs.u32Display(_172, f), (f: rs.Formatter) => rs.fmtPad(f, _202.v)]; rs.panicFmt(["try_rfold of g", args57[0], " with g", args57[1], " after\n", args57[2]]); } else { const _04: rs.u32 | undefined = rs.u32Add(n13, Guard.id(g2)); diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 9b3206797..78bb51c72 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -32,13 +32,13 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const n: rs.u8 = _13; const _24: Log.Log = Log.clone$Clone(log); const _23: Listed.Listed = new Listed.Listed(id, _24, n); - const _19: string = rs.fmtFormat(["listed ", (f: rs.Formatter) => Listed.fmt$fmt_Debug(_23, f)]); + const _19: rs.String = rs.fmtFormat(["listed ", (f: rs.Formatter) => Listed.fmt$fmt_Debug(_23, f)]); _23[Symbol.dispose](); Log.note(log, _19); } const _36: Log.Log = Log.clone$Clone(log); const _35: Listed.Listed = new Listed.Listed(id, _36, 2); - const _31: string = rs.fmtFormat(["pretty ", rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Listed.fmt$fmt_Debug(_35, f))]); + const _31: rs.String = rs.fmtFormat(["pretty ", rs.fmtSpec({ alternate: true }, (f: rs.Formatter) => Listed.fmt$fmt_Debug(_35, f))]); _35[Symbol.dispose](); Log.note(log, _31); } else if (_8 === 1) { @@ -75,21 +75,21 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { }); Log.note(log, rs.fmtFormat(["deque ", (f: rs.Formatter) => rs.fmtOption(part17, f, rs.u32Debug)])); rs.drop(it); - let s: string = "abcdef"; + const s: rs.String = rs.stringFrom("abcdef"); const _180: Spent.Spent = new Spent.Spent(guard(12), 1, 3); - const s4 = rs.place(() => s, (value2) => s = value2); - const part18 = rs.stringExtendChars("", rs.stringDrain(s4, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s4.v)), rs.drop)), true); - Log.note(log, rs.fmtFormat(["text ", (f: rs.Formatter) => rs.fmtPad(f, part18)])); + const _178: rs.Iter = rs.stringDrain(s, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop)); + const part18 = rs.stringExtendChars(rs.stringNew(), _178, true); + Log.note(log, rs.fmtFormat(["text ", (f: rs.Formatter) => rs.fmtPad(f, part18.v)])); const _190: Spent.Spent = new Spent.Spent(guard(13), 0, 1); - s = rs.stringReplaceRange(s, rs.dropAfter(_190, (range15) => rs.boundsChecked(rs.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s)), rs.drop), "xy"); + rs.stringReplaceRange(s, rs.dropAfter(_190, (range15) => rs.boundsChecked(rs.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop), "xy"); const _197: Spent.Spent = new Spent.Spent(guard(14), 2, 4); - s = rs.stringExtendFromWithin(s, rs.dropAfter(_197, (range16) => rs.boundsChecked(rs.boundsOf(range16, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s)), rs.drop)); + rs.stringExtendFromWithin(s, rs.dropAfter(_197, (range16) => rs.boundsChecked(rs.boundsOf(range16, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), s.len), rs.drop)); const bytes: Uint8Array = Uint8Array.of(1, 2, 3, 4); const _203: rs.ByteSlice = rs.byteSliceFrom(bytes); const bounds = rs.dropAfter(new Spent.Spent(guard(15), 0, 2), (range17) => rs.boundsRange(rs.boundsOf(range17, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), _203.length), rs.drop); rs.byteSliceCopyWithin(_203, bounds[0], bounds[1], 2); - [s, rs.byteSliceFrom(bytes)] as [string, rs.ByteSlice]; - const _217: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s); + [s, rs.byteSliceFrom(bytes)] as [rs.String, rs.ByteSlice]; + const _217: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s.v); const arg2 = rs.byteSliceFrom(bytes); const args82 = [_217, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; Log.note(log, rs.fmtFormat(["edited ", args82[0], " ", args82[1]])); @@ -159,7 +159,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["next ", (f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)])); const _421: Key.Key | undefined = rs.iterToOption(keys.next()); const part6 = _421 === undefined; - const _415: string = rs.fmtFormat(["done ", (f: rs.Formatter) => rs.fmtBool(part6, f)]); + const _415: rs.String = rs.fmtFormat(["done ", (f: rs.Formatter) => rs.fmtBool(part6, f)]); rs.drop(_421); Log.note(log, _415); rs.iterForEach(rs.hashValues(map3(2), rs.drop, rs.drop), (g8: Guard.Guard): undefined => { @@ -213,7 +213,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured3 = c; rs.iterForEach(_551, rs.closure((g2: Guard.Guard): undefined => { const part = Guard.id(captured3); - const _49: string = rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part, f)]); + const _49: string = rs.fmtFormat(["each ", (f: rs.Formatter) => rs.u32Display(part, f)]).v; Guard.note(g2, _49); g2[Symbol.dispose](); }, (): void => { @@ -233,7 +233,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const h: rs.u32 = _311[1]; const _155: rs.u32 = Guard.id(captured5); const args55 = [(f: rs.Formatter) => rs.u32Display(h, f), (f: rs.Formatter) => rs.u32Display(_155, f)]; - const _87: string = rs.fmtFormat(["fold ", args55[0], " ", args55[1]]); + const _87: string = rs.fmtFormat(["fold ", args55[0], " ", args55[1]]).v; Guard.note(g4, _87); const _04: rs.i32 = rs.i32Add(n7, 1); g4[Symbol.dispose](); @@ -255,7 +255,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured7 = f; rs.iterForEach(_581, rs.closure((g5: Guard.Guard): undefined => { const part3 = Guard.id(captured7); - const _417: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part3, f)]); + const _417: string = rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part3, f)]).v; Guard.note(g5, _417); g5[Symbol.dispose](); }, (): void => { @@ -297,7 +297,7 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured9[Symbol.dispose](); }); rs.iterForEach(rs.iterMap(new rs.Range(17, 19), guard), count); - Log.note(log, "lent"); + Log.note(log, rs.stringFrom("lent")); rs.drop(count); kept[Symbol.dispose](); } else if (_8 === 7) { @@ -322,16 +322,15 @@ export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(rs.dropAfter(new Spent.Spent(guard(10), 1, 4), (range4) => rs.vecDrain(v3, rs.boundsOf(range4, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop)); rs.dropVec(v3); } else { - let s2: string = "é"; + const s2: rs.String = rs.stringFrom("é"); const bomb: Bomb.Bomb = new Bomb.Bomb(1, 2); const _636: rs.u8 = rs.u8Rem(rs.u8Div(arg, 10), 3); if (_636 === 0) { - const s3 = rs.place(() => s2, (value) => s2 = value); - rs.drop(rs.stringDrain(s3, rs.dropAfter(bomb, (range3) => rs.boundsChecked(rs.boundsOf(range3, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s3.v)), rs.drop))); + rs.drop(rs.stringDrain(s2, rs.dropAfter(bomb, (range3) => rs.boundsChecked(rs.boundsOf(range3, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), s2.len), rs.drop))); } else if (_636 === 1) { - s2 = rs.stringReplaceRange(s2, rs.dropAfter(bomb, (range2) => rs.boundsChecked(rs.boundsOf(range2, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s2)), rs.drop), "x"); + rs.stringReplaceRange(s2, rs.dropAfter(bomb, (range2) => rs.boundsChecked(rs.boundsOf(range2, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), s2.len), rs.drop), "x"); } else { - s2 = rs.stringExtendFromWithin(s2, rs.dropAfter(bomb, (range) => rs.boundsChecked(rs.boundsOf(range, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s2)), rs.drop)); + rs.stringExtendFromWithin(s2, rs.dropAfter(bomb, (range) => rs.boundsChecked(rs.boundsOf(range, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), s2.len), rs.drop)); } } } diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index dfbccff97..94db7582a 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -475,7 +475,7 @@ export function drained(log: Log.Log, id: rs.u32): void { k[Symbol.dispose](); return _05; }); - const _63: string = rs.fmtFormat(["set ", (f: rs.Formatter) => rs.u32Display(part, f)]); + const _63: rs.String = rs.fmtFormat(["set ", (f: rs.Formatter) => rs.u32Display(part, f)]); rs.drop(_70); Log.note(log, _63); const queue: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; @@ -501,7 +501,7 @@ export function drained(log: Log.Log, id: rs.u32): void { return _07; }); const args22 = [(f: rs.Formatter) => rs.usizeDisplay(_113, f), (f: rs.Formatter) => rs.u32Display(_116, f)]; - const _109: string = rs.fmtFormat(["queue ", args22[0], " ", args22[1]]); + const _109: rs.String = rs.fmtFormat(["queue ", args22[0], " ", args22[1]]); rs.drop(_119); Log.note(log, _109); const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; @@ -511,7 +511,7 @@ export function drained(log: Log.Log, id: rs.u32): void { const entries: rs.Iter<[Key.Key, Guard.Guard]> = rs.hashIter(map, rs.drop, rs.drop); const _145: [Key.Key, Guard.Guard] | undefined = rs.iterToOption(entries.next()); const part3 = _145 !== undefined; - const _139: string = rs.fmtFormat(["entry ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); + const _139: rs.String = rs.fmtFormat(["entry ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); lib_drop$Option_tuple2_drops_Key_model_Guard(_145); Log.note(log, _139); const map2: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; diff --git a/ts/fixtures/task/expected/drops/lists.ts b/ts/fixtures/task/expected/drops/lists.ts index ab19c0eb2..4fbf979fb 100644 --- a/ts/fixtures/task/expected/drops/lists.ts +++ b/ts/fixtures/task/expected/drops/lists.ts @@ -6,10 +6,10 @@ import * as Key from "../drops.Key.ts"; import * as Log from "../log.Log.ts"; /** The ids of a list's keys, front to back, apart from `id`. */ -export function ids(id: rs.u32, l: rs.LinkedList): string { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.listIter(l), (k: Key.Key): string => { +export function ids(id: rs.u32, l: rs.LinkedList): rs.String { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.listIter(l), (k: Key.Key): rs.String => { const _4: rs.u32 = rs.u32Sub(k.id, id); - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_4, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_4, f), 0); }), undefined, 12, true).items, ","); } @@ -38,10 +38,10 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _33: Key.Key = key(0); rs.listPushFront(l, _33); rs.drop(rs.listPopBack(l)); - Log.note(log, "popped back"); + Log.note(log, rs.stringFrom("popped back")); rs.drop(rs.listPopFront(l)); const part11 = ids(id, l); - Log.note(log, rs.fmtFormat(["left ", (f: rs.Formatter) => rs.fmtPad(f, part11)])); + Log.note(log, rs.fmtFormat(["left ", (f: rs.Formatter) => rs.fmtPad(f, part11.v)])); rs.listDrop(l, rs.drop); } else if (_8 === 1) { let l2: rs.LinkedList = keys(rs.sliceFrom([1, 2, 3])); @@ -53,7 +53,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.listDrop(l2, rs.drop); l2 = _81; const part10 = ids(id, l2); - Log.note(log, rs.fmtFormat(["replaced ", (f: rs.Formatter) => rs.fmtPad(f, part10)])); + Log.note(log, rs.fmtFormat(["replaced ", (f: rs.Formatter) => rs.fmtPad(f, part10.v)])); rs.listDrop(l2, rs.drop); } else if (_8 === 2) { const it: rs.Iter = rs.listIter(keys(rs.sliceFrom([1, 2, 3, 4, 5, 6])), rs.drop); @@ -74,14 +74,14 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const back: rs.LinkedList = rs.listSplitOff(l3, 3); const none: rs.LinkedList = rs.listSplitOff(l3, 3); const all: rs.LinkedList = rs.listSplitOff(l3, 0); - const _157: string = ids(id, l3); - const _160: string = ids(id, back); - const _163: string = ids(id, none); - const _166: string = ids(id, all); - const args43 = [(f: rs.Formatter) => rs.fmtPad(f, _157), (f: rs.Formatter) => rs.fmtPad(f, _160), (f: rs.Formatter) => rs.fmtPad(f, _163), (f: rs.Formatter) => rs.fmtPad(f, _166)]; + const _157: rs.String = ids(id, l3); + const _160: rs.String = ids(id, back); + const _163: rs.String = ids(id, none); + const _166: rs.String = ids(id, all); + const args43 = [(f: rs.Formatter) => rs.fmtPad(f, _157.v), (f: rs.Formatter) => rs.fmtPad(f, _160.v), (f: rs.Formatter) => rs.fmtPad(f, _163.v), (f: rs.Formatter) => rs.fmtPad(f, _166.v)]; Log.note(log, rs.fmtFormat(["split ", args43[0], " ", args43[1], " ", args43[2], " ", args43[3]])); rs.listDrop(all, rs.drop); - Log.note(log, "front dropped"); + Log.note(log, rs.stringFrom("front dropped")); rs.listDrop(back, rs.drop); rs.listDrop(none, rs.drop); rs.listDrop(l3, rs.drop); @@ -89,9 +89,9 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const l4: rs.LinkedList = keys(rs.sliceFrom([1, 2])); const other: rs.LinkedList = keys(rs.sliceFrom([3, 4])); rs.listAppend(l4, other); - const _199: string = ids(id, l4); + const _199: rs.String = ids(id, l4); const _202: rs.usize = other.n; - const args41 = [(f: rs.Formatter) => rs.fmtPad(f, _199), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; + const args41 = [(f: rs.Formatter) => rs.fmtPad(f, _199.v), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; Log.note(log, rs.fmtFormat(["appended ", args41[0], " ", args41[1]])); const _211: Key.Key = key(5); rs.listPushBack(other, _211); @@ -100,9 +100,9 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.listExtend(l4, rs.iterSlice(_219, rs.drop), "fold"); const empty: rs.LinkedList = rs.listNew() as rs.LinkedList; rs.listAppend(empty, l4); - const _236: string = ids(id, empty); + const _236: rs.String = ids(id, empty); const _239: rs.usize = l4.n; - const args42 = [(f: rs.Formatter) => rs.fmtPad(f, _236), (f: rs.Formatter) => rs.usizeDisplay(_239, f)]; + const args42 = [(f: rs.Formatter) => rs.fmtPad(f, _236.v), (f: rs.Formatter) => rs.usizeDisplay(_239, f)]; Log.note(log, rs.fmtFormat(["moved ", args42[0], " ", args42[1]])); rs.listDrop(empty, rs.drop); rs.listDrop(l4, rs.drop); @@ -111,11 +111,11 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const source: rs.LinkedList = keys(rs.sliceFrom([5, 6])); rs.listCloneFrom(l5, source, Key.clone$Clone, rs.drop); const part5 = ids(id, l5); - Log.note(log, rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part5)])); + Log.note(log, rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part5.v)])); const longer: rs.LinkedList = keys(rs.sliceFrom([7, 8, 9])); rs.listCloneFrom(l5, longer, Key.clone$Clone, rs.drop); const part6 = ids(id, l5); - Log.note(log, rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part6)])); + Log.note(log, rs.fmtFormat(["cloned ", (f: rs.Formatter) => rs.fmtPad(f, part6.v)])); rs.listDrop(longer, rs.drop); rs.listDrop(source, rs.drop); rs.listDrop(l5, rs.drop); @@ -125,8 +125,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { return rs.u32Rem(rs.u32Sub(k2.id, id), 2) === 0; }), "next", 12); const _307: rs.usize = taken.items.length; - const _310: string = ids(id, l6); - const args35 = [(f: rs.Formatter) => rs.usizeDisplay(_307, f), (f: rs.Formatter) => rs.fmtPad(f, _310)]; + const _310: rs.String = ids(id, l6); + const args35 = [(f: rs.Formatter) => rs.usizeDisplay(_307, f), (f: rs.Formatter) => rs.fmtPad(f, _310.v)]; Log.note(log, rs.fmtFormat(["taken ", args35[0], " left ", args35[1]])); rs.dropVec(taken); const first: Key.Key | undefined = rs.iterToOption(rs.listExtractIf(l6, (k3: Key.Key): boolean => { @@ -135,8 +135,8 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _330: rs.u32 | undefined = option_map$0bmexgo(first, (k4: Key.Key): rs.u32 => { return rs.u32Sub(k4.id, id); }); - const _336: string = ids(id, l6); - const args36 = [(f: rs.Formatter) => rs.fmtOption(_330, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtPad(f, _336)]; + const _336: rs.String = ids(id, l6); + const args36 = [(f: rs.Formatter) => rs.fmtOption(_330, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtPad(f, _336.v)]; Log.note(log, rs.fmtFormat(["first ", args36[0], " left ", args36[1]])); const captured = key(9); const it2: rs.Iter = rs.listExtractIf(l6, rs.closure((k5: Key.Key): boolean => { @@ -146,12 +146,12 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { })); const _357: Key.Key | undefined = rs.iterToOption(it2.next()); const part3 = _357 === undefined; - const _351: string = rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); + const _351: rs.String = rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part3, f)]); rs.drop(_357); Log.note(log, _351); rs.drop(it2); const part4 = ids(id, l6); - Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.fmtPad(f, part4)])); + Log.note(log, rs.fmtFormat(["kept ", (f: rs.Formatter) => rs.fmtPad(f, part4.v)])); rs.drop(first); rs.listDrop(l6, rs.drop); } else { diff --git a/ts/fixtures/task/expected/drops/objects.ts b/ts/fixtures/task/expected/drops/objects.ts index 145528ae7..e8ca7fa39 100644 --- a/ts/fixtures/task/expected/drops/objects.ts +++ b/ts/fixtures/task/expected/drops/objects.ts @@ -122,7 +122,7 @@ export function shared(log: Log.Log, id: rs.u32): void { kept[Symbol.dispose](); const _122: rs.Arc | undefined = rs.weakUpgrade(weak); const part4 = _122 === undefined; - const _116: string = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part4, f)]); + const _116: rs.String = rs.fmtFormat(["gone ", (f: rs.Formatter) => rs.fmtBool(part4, f)]); rs.drop(_122); Log.note(log, _116); const _132: rs.Arc> = new rs.Arc(new sharedFuture$closure1(guard(6))); @@ -214,7 +214,7 @@ export function anys(log: Log.Log, id: rs.u32): void { }); Log.note(log, rs.fmtFormat(["typed ", (f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u32, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f))])); lib_drop$Option_sync_Arc_tuple2_model_Guard_model_Guard(typed); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); b[Symbol.dispose](); const _149: Any.Any = slot; const part5 = (_149 instanceof of$drops_Held ? _149.v : _149 instanceof ofPlace$drops_Held ? _149.v.v : undefined) !== undefined; @@ -352,7 +352,7 @@ export function fns(log: Log.Log, id: rs.u32): void { const part12 = again.strong; Log.note(log, rs.fmtFormat(["up ", (f: rs.Formatter) => rs.usizeDisplay(part12, f)])); again[Symbol.dispose](); - Log.note(log, "gone"); + Log.note(log, rs.stringFrom("gone")); const _257: [Guard.Guard, Guard.Guard] = [guard(13), guard(14)]; const n: Guard.Guard = _257[0]; const o: Guard.Guard = _257[1]; @@ -370,7 +370,7 @@ export function fns(log: Log.Log, id: rs.u32): void { captured14[Symbol.dispose](); })); Log.note(log, rs.fmtFormat(["run ", (f: rs.Formatter) => rs.u32Display(part14, f)])); - Log.note(log, "ran"); + Log.note(log, rs.stringFrom("ran")); const _296: [Guard.Guard, Guard.Guard] = [guard(15), guard(16)]; const p: Guard.Guard = _296[0]; const captured15 = _296[1]; diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts index c1c162b7a..6ad0a9453 100644 --- a/ts/fixtures/task/expected/drops/once.ts +++ b/ts/fixtures/task/expected/drops/once.ts @@ -19,7 +19,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _19: Guard.Guard = guard(1); const _17: rs.Result = rs.onceSet(cell, _19); const part13 = _17.ok; - const _11: string = rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtBool(part13, f)]); + const _11: rs.String = rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtBool(part13, f)]); lib_drop$Result_unit_model_Guard(_17); Log.note(log, _11); const _28: Guard.Guard = guard(2); @@ -105,7 +105,7 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { rs.drop(taken); const _198: Guard.Guard | undefined = rs.onceTake(cell3); const part9 = _198 === undefined; - const _192: string = rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtBool(part9, f)]); + const _192: rs.String = rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtBool(part9, f)]); rs.drop(_198); Log.note(log, _192); const _206: Guard.Guard = guard(22); @@ -158,13 +158,13 @@ export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { const cell5: rs.OnceCell = new rs.OnceCell(rs.None); const _315: rs.Result = rs.onceSet(cell5, undefined as Guard.Guard | undefined, rs.None); const part = _315.ok; - const _309: string = rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part, f)]); + const _309: rs.String = rs.fmtFormat(["none ", (f: rs.Formatter) => rs.fmtBool(part, f)]); lib_drop$Result_unit_Option_model_Guard(_315); Log.note(log, _309); const _332: Guard.Guard | undefined = guard(71); const _330: rs.Result = rs.onceSet(cell5, _332, rs.None); const part2 = !_330.ok; - const _324: string = rs.fmtFormat(["full ", (f: rs.Formatter) => rs.fmtBool(part2, f)]); + const _324: rs.String = rs.fmtFormat(["full ", (f: rs.Formatter) => rs.fmtBool(part2, f)]); lib_drop$Result_unit_Option_model_Guard(_330); Log.note(log, _324); const unit: rs.OnceLock = new rs.OnceLock(rs.None); diff --git a/ts/fixtures/task/expected/drops/orders.Ranked.ts b/ts/fixtures/task/expected/drops/orders.Ranked.ts index e317b7383..f0692b3b6 100644 --- a/ts/fixtures/task/expected/drops/orders.Ranked.ts +++ b/ts/fixtures/task/expected/drops/orders.Ranked.ts @@ -26,7 +26,7 @@ export class Ranked { export function drop$ops_Drop(self: Ranked): void { const arg = self.id; - const _4: string = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["k", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } @@ -35,7 +35,7 @@ export function eq$cmp_PartialEq(self: Ranked, other: Ranked): boolean { const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; const args3 = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["eq ", args3[0], " ", args3[1]]); + const _5: rs.String = rs.fmtFormat(["eq ", args3[0], " ", args3[1]]); Log.note(self.log, _5); return rs.u8Rem(self.rank, 3) === rs.u8Rem(other.rank, 3); } @@ -45,7 +45,7 @@ export function partialCmp$cmp_PartialOrd(self: Ranked, other: Ranked): rs.Order const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; const args3 = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["partial_cmp ", args3[0], " ", args3[1]]); + const _5: rs.String = rs.fmtFormat(["partial_cmp ", args3[0], " ", args3[1]]); Log.note(self.log, _5); return rs.cmp(rs.u8Div(self.rank, 2), rs.u8Div(other.rank, 2)); } @@ -55,7 +55,7 @@ export function cmp$cmp_Ord(self: Ranked, other: Ranked): rs.Ordering { const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; const args5 = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; - const _5: string = rs.fmtFormat(["cmp ", args5[0], " ", args5[1]]); + const _5: rs.String = rs.fmtFormat(["cmp ", args5[0], " ", args5[1]]); Log.note(self.log, _5); if (self.rank !== 99) { if (other.rank !== 99) { diff --git a/ts/fixtures/task/expected/drops/orders.ts b/ts/fixtures/task/expected/drops/orders.ts index 8541f6208..9d127599c 100644 --- a/ts/fixtures/task/expected/drops/orders.ts +++ b/ts/fixtures/task/expected/drops/orders.ts @@ -26,14 +26,14 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { return entry(_23[0], _23[1]); }), undefined, 20, true); }; - const setIds: (a0: rs.BTreeSet) => string = (s: rs.BTreeSet): string => { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeKeys(s), (k: Ranked.Ranked): string => { + const setIds: (a0: rs.BTreeSet) => rs.String = (s: rs.BTreeSet): rs.String => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeKeys(s), (k: Ranked.Ranked): rs.String => { const _410: rs.u32 = rs.u32Sub(k.id, id); - return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_410, f)); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_410, f), 0); }), undefined, 12, true).items, ","); }; - const mapIds: (a0: rs.BTreeMap) => string = (m: rs.BTreeMap): string => { - return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(m), (_26: [Ranked.Ranked, Guard.Guard]): string => { + const mapIds: (a0: rs.BTreeMap) => rs.String = (m: rs.BTreeMap): rs.String => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(m), (_26: [Ranked.Ranked, Guard.Guard]): rs.String => { const _98: rs.u32 = rs.u32Sub(_26[0].id, id); const _144: rs.u32 = rs.u32Sub(Guard.id(_26[1]), id); const args33 = [(f: rs.Formatter) => rs.u32Display(_98, f), (f: rs.Formatter) => rs.u32Display(_144, f)]; @@ -50,15 +50,15 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _24: rs.Iter = rs.vecIntoIter(keys(part29), rs.drop); const set: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_24, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part31 = setIds(set); - Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part31)])); + Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part31.v)])); rs.btreeDrop(set, rs.drop); const _46: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of())), rs.drop); const none: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_46, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const _53: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of(7))), rs.drop); const one: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_53, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const _65: rs.usize = rs.btreeLen(none); - const _68: string = setIds(one); - const args54 = [(f: rs.Formatter) => rs.usizeDisplay(_65, f), (f: rs.Formatter) => rs.fmtPad(f, _68)]; + const _68: rs.String = setIds(one); + const args54 = [(f: rs.Formatter) => rs.usizeDisplay(_65, f), (f: rs.Formatter) => rs.fmtPad(f, _68.v)]; Log.note(log, rs.fmtFormat(["small ", args54[0], " ", args54[1]])); rs.btreeDrop(one, rs.drop); rs.btreeDrop(none, rs.drop); @@ -67,17 +67,17 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _78: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part26), lib_drop$tuple2_drops_orders_Ranked_model_Guard); const map: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_78, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part28 = mapIds(map); - Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part28)])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part28.v)])); rs.btreeDrop(map, rs.drop, rs.drop); } else if (_21 === 2) { const _99: Ranked.Ranked[] = [key(1, 4), key(2, 2), key(3, 4), key(4, 1), key(5, 2)]; const set2: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(rs.iterSlice(_99, rs.drop), "fold", 12, true).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part23 = setIds(set2); - Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part23)])); + Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part23.v)])); const _130: [Ranked.Ranked, Guard.Guard][] = [entry(1, 4), entry(2, 2), entry(3, 4), entry(4, 1), entry(5, 2)]; const map2: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(rs.iterSlice(_130, lib_drop$tuple2_drops_orders_Ranked_model_Guard), "fold", 20, true).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part25 = mapIds(map2); - Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part25)])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part25.v)])); rs.btreeDrop(map2, rs.drop, rs.drop); rs.btreeDrop(set2, rs.drop); } else if (_21 === 3) { @@ -85,7 +85,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _161: rs.Iter = rs.vecIntoIter(keys(part16), rs.drop); const set3: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_161, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part18 = setIds(set3); - Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part18)])); + Log.note(log, rs.fmtFormat(["set ", (f: rs.Formatter) => rs.fmtPad(f, part18.v)])); rs.iterForEach(rs.btreeKeys(set3, rs.drop), (a0: Ranked.Ranked): undefined => { a0[Symbol.dispose](); }, true); @@ -93,7 +93,7 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _184: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part19), lib_drop$tuple2_drops_orders_Ranked_model_Guard); const map3: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_184, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part21 = mapIds(map3); - Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part21)])); + Log.note(log, rs.fmtFormat(["map ", (f: rs.Formatter) => rs.fmtPad(f, part21.v)])); rs.iterForEach(rs.btreeIter(map3, rs.drop, rs.drop), (a02: [Ranked.Ranked, Guard.Guard]): undefined => { lib_drop$tuple2_drops_orders_Ranked_model_Guard(a02); }, true); @@ -104,14 +104,14 @@ export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { return [new rs.Cell({ _0: r }), Guard.new(rs.u32Add(id, n9), Log.clone$Clone(log))] as [rs.Cell, Guard.Guard]; }); const map4: rs.BTreeMap, Guard.Guard> = rs.btreeCollect(rs.btreeNew(rs.cellBy(Rank.cmp$cmp_Ord)) as rs.BTreeMap, Guard.Guard>, rs.iterToVec(_207, undefined, 12, true).items, 12, false, rs.cellBy(Rank.eq$cmp_PartialEq), undefined, rs.drop); - const part15 = rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(map4), (_219: [rs.Cell, Guard.Guard]): string => { + const part15 = rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(map4), (_219: [rs.Cell, Guard.Guard]): rs.String => { const _913: Rank.Rank = _219[0].v; const _1111: rs.u32 = rs.u32Sub(Guard.id(_219[1]), id); const arg2 = _913._0; const args46 = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; return rs.fmtFormat([args46[0], ":", args46[1]]); }), undefined, 12, true).items, ","); - Log.note(log, rs.fmtFormat(["cells ", (f: rs.Formatter) => rs.fmtPad(f, part15)])); + Log.note(log, rs.fmtFormat(["cells ", (f: rs.Formatter) => rs.fmtPad(f, part15.v)])); rs.btreeDrop(map4, undefined, rs.drop); } else if (_21 === 5) { const by: (a0: Guard.Guard) => Ranked.Ranked = (g: Guard.Guard): Ranked.Ranked => { diff --git a/ts/fixtures/task/expected/drops/released.ts b/ts/fixtures/task/expected/drops/released.ts index 2f3b06034..bf47c901e 100644 --- a/ts/fixtures/task/expected/drops/released.ts +++ b/ts/fixtures/task/expected/drops/released.ts @@ -35,7 +35,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { _262 = true; _252 = true; const part27 = Guard.id(captured26); - const _627: string = rs.fmtFormat(["reduce ", (f: rs.Formatter) => rs.u32Display(part27, f)]); + const _627: string = rs.fmtFormat(["reduce ", (f: rs.Formatter) => rs.u32Display(part27, f)]).v; Guard.note(y4, _627); if (!(Guard.id(x4) < Guard.id(y4))) { _262 = false; @@ -215,7 +215,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured15 = a4; const part16 = rs.iterIsSortedBy(rs.iterMap(_235, rs.closure((g6: Guard.Guard): rs.u32 => { const part15 = Guard.id(captured15); - const _517: string = rs.fmtFormat(["key ", (f: rs.Formatter) => rs.u32Display(part15, f)]); + const _517: string = rs.fmtFormat(["key ", (f: rs.Formatter) => rs.u32Display(part15, f)]).v; Guard.note(g6, _517); const _013: rs.u32 = Guard.id(g6); g6[Symbol.dispose](); @@ -305,7 +305,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured13 = e; rs.entryAndModify(_404, rs.closure((g4: Guard.Guard): undefined => { const part12 = Guard.id(captured13); - Guard.note(g4, rs.fmtFormat(["modified ", (f: rs.Formatter) => rs.u32Display(part12, f)])); + Guard.note(g4, rs.fmtFormat(["modified ", (f: rs.Formatter) => rs.u32Display(part12, f)]).v); captured13[Symbol.dispose](); }, (): void => { captured13[Symbol.dispose](); @@ -314,7 +314,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured14 = f; const part14 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_409, rs.closure((g5: Guard.Guard): undefined => { const part13 = Guard.id(captured14); - Guard.note(g5, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part13, f)])); + Guard.note(g5, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part13, f)]).v); captured14[Symbol.dispose](); }, (): void => { captured14[Symbol.dispose](); @@ -376,7 +376,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured7 = e2; rs.entryAndModify(_538, rs.closure((g2: Guard.Guard): undefined => { const part5 = Guard.id(captured7); - Guard.note(g2, rs.fmtFormat(["modified ", (f: rs.Formatter) => rs.u32Display(part5, f)])); + Guard.note(g2, rs.fmtFormat(["modified ", (f: rs.Formatter) => rs.u32Display(part5, f)]).v); captured7[Symbol.dispose](); }, (): void => { captured7[Symbol.dispose](); @@ -385,7 +385,7 @@ export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { const captured8 = f2; const part7 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_543, rs.closure((g3: Guard.Guard): undefined => { const part6 = Guard.id(captured8); - Guard.note(g3, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part6, f)])); + Guard.note(g3, rs.fmtFormat([(f: rs.Formatter) => rs.u32Display(part6, f)]).v); captured8[Symbol.dispose](); }, (): void => { captured8[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/searched.ts b/ts/fixtures/task/expected/drops/searched.ts index b24215c89..0117bf4ad 100644 --- a/ts/fixtures/task/expected/drops/searched.ts +++ b/ts/fixtures/task/expected/drops/searched.ts @@ -219,7 +219,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured73[Symbol.dispose](); }); const _173: string = "+"; - const _171: string = rs.dropAfter(_172, () => rs.strReplace(text, _172, _173)); + const _171: rs.String = rs.dropAfter(_172, () => rs.strReplace(text, _172, _173, false)); const captured74 = (c71: rs.char): boolean => { if (!(c71 === 44)) { return c71 === 59; @@ -236,8 +236,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured75[Symbol.dispose](); }); const _176: string = "+"; - const part19 = [_171, rs.dropAfter(_175, () => rs.strReplace(text, _175, _176, 2))] as [string, string]; - Log.note(log, rs.fmtFormat(["replace ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part19[0], f), (f: rs.Formatter) => rs.fmtStr(part19[1], f)], f)])); + const part19 = [_171, rs.dropAfter(_175, () => rs.strReplacen(text, _175, _176, 2))] as [rs.String, rs.String]; + Log.note(log, rs.fmtFormat(["replace ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part19[0].v, f), (f: rs.Formatter) => rs.fmtStr(part19[1].v, f)], f)])); } else if (_8 === 1) { const a2: Guard.Guard = guard(1); const captured32 = (c31: rs.char): boolean => { @@ -456,7 +456,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["indices ", (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)])); } else if (_8 === 2) { const a3: Guard.Guard = guard(1); - let s: string = text; + const s: rs.String = rs.stringFrom(text); const captured27 = a3; const captured28 = (c29: rs.char): boolean => { if (!(c29 === 44)) { @@ -465,14 +465,14 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { return true; }; const _378: (a0: rs.char) => boolean = rs.closure((c30: rs.char): boolean => { - Guard.note(captured27, rs.fmtFormat(["retain ", (f: rs.Formatter) => rs.fmtCharDisplay(c30, f)])); + Guard.note(captured27, rs.fmtFormat(["retain ", (f: rs.Formatter) => rs.fmtCharDisplay(c30, f)]).v); return !captured28(c30); }, (): void => { captured27[Symbol.dispose](); }); - s = rs.stringRetain(s, _378); + rs.stringRetain(s, _378); rs.drop(_378); - Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, s)])); + Log.note(log, rs.fmtFormat(["retained ", (f: rs.Formatter) => rs.fmtPad(f, s.v)])); const b3: Guard.Guard = guard(2); let captured29: rs.i32 = 0; const captured30 = b3; @@ -485,22 +485,22 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { }, (): void => { captured30[Symbol.dispose](); }); - s = rs.stringRetain(s, everyOther); - Log.note(log, rs.fmtFormat(["every other ", (f: rs.Formatter) => rs.fmtPad(f, s)])); - s = rs.stringRetain(s, everyOther); - Log.note(log, rs.fmtFormat(["every other ", (f: rs.Formatter) => rs.fmtPad(f, s)])); + rs.stringRetain(s, everyOther); + Log.note(log, rs.fmtFormat(["every other ", (f: rs.Formatter) => rs.fmtPad(f, s.v)])); + rs.stringRetain(s, everyOther); + Log.note(log, rs.fmtFormat(["every other ", (f: rs.Formatter) => rs.fmtPad(f, s.v)])); rs.drop(everyOther); const c3: Guard.Guard = guard(3); - let empty: string = ""; + const empty: rs.String = rs.stringNew(); const captured31 = c3; const _427: (a0: rs.char) => boolean = rs.closure((_24: rs.char): boolean => { return Guard.id(captured31) > 0; }, (): void => { captured31[Symbol.dispose](); }); - empty = rs.stringRetain(empty, _427); + rs.stringRetain(empty, _427); rs.drop(_427); - Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtStr(empty, f)])); + Log.note(log, rs.fmtFormat(["empty ", (f: rs.Formatter) => rs.fmtStr(empty.v, f)])); } else if (_8 === 3) { const a4: Guard.Guard = guard(1); const captured25 = (c27: rs.char): boolean => { @@ -526,8 +526,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["ends ", args177[0], " ", args177[1]])); const once2: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f3), rs.strRsplitOnce(text, f3)]; const trimmed2: [string, string, string] = [rs.strTrimMatches(",a,", f3), rs.strTrimStartMatches(",a,", f3), rs.strTrimEndMatches(",a,", f3)]; - const replaced2: [string, string] = [rs.strReplace(text, f3, "+"), rs.strReplace(text, f3, "+", 2)]; - const args178 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once2[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once2[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed2[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced2[0], f), (f: rs.Formatter) => rs.fmtStr(replaced2[1], f)], f)]; + const replaced2: [rs.String, rs.String] = [rs.strReplace(text, f3, "+", false), rs.strReplacen(text, f3, "+", 2)]; + const args178 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once2[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once2[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed2[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced2[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced2[1].v, f)], f)]; Log.note(log, rs.fmtFormat(["once ", args178[0], " ", args178[1], " ", args178[2]])); const split2: rs.Iter = rs.strSplit(text, rs.lent(f3)); const _526: string | undefined = rs.iterToOption(split2.next()); @@ -562,7 +562,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args185 = [(f: rs.Formatter) => rs.fmtList(spaced.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_659, f)]; Log.note(log, rs.fmtFormat(["spaced ", args185[0], " ", args185[1]])); rs.drop(f3); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } else if (_8 === 4) { const a5: Guard.Guard = guard(1); let captured22: rs.i32 = 0; @@ -595,10 +595,10 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["ends ", args168[0], " ", args168[1], " ", args168[2]])); const once3: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f4), rs.strRsplitOnce(text, f4)]; const trimmed3: [string, string] = [rs.strTrimMatches(",,a,,", f4), rs.strTrimStartMatches(",,a", f4)]; - const replaced3: [string, string] = [rs.strReplace(text, f4, "+"), rs.strReplace(text, f4, "+", 2)]; + const replaced3: [rs.String, rs.String] = [rs.strReplace(text, f4, "+", false), rs.strReplacen(text, f4, "+", 2)]; const end: string = rs.strTrimEndMatches(",a,,", f4); const _755: boolean = f4(120); - const args169 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once3[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once3[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed3[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced3[0], f), (f: rs.Formatter) => rs.fmtStr(replaced3[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end, f), (f: rs.Formatter) => rs.fmtBool(_755, f)]; + const args169 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once3[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once3[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed3[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced3[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced3[1].v, f)], f), (f: rs.Formatter) => rs.fmtStr(end, f), (f: rs.Formatter) => rs.fmtBool(_755, f)]; Log.note(log, rs.fmtFormat(["once ", args169[0], " ", args169[1], " ", args169[2], " ", args169[3], " ", args169[4]])); const split3: rs.Iter = rs.strSplit(text, rs.lent(f4)); const _778: string | undefined = rs.iterToOption(split3.next()); @@ -630,7 +630,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args175 = [(f: rs.Formatter) => rs.fmtList(parts2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_905, f)]; Log.note(log, rs.fmtFormat(["lent ", args175[0], " ", args175[1]])); rs.drop(f4); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } else if (_8 === 5) { if (!(id < 4294967295)) { p = (a0: rs.char): boolean => { @@ -646,8 +646,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["contains ", args161[0], " ", args161[1], " ", args161[2]])); const once4: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, p), rs.strRsplitOnce(text, p)]; const trimmed4: [string, string, string] = [rs.strTrimMatches(",a,", p), rs.strTrimStartMatches(",a,", p), rs.strTrimEndMatches(",a,", p)]; - const replaced4: [string, string] = [rs.strReplace(text, p, "+"), rs.strReplace(text, p, "+", 2)]; - const args162 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once4[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once4[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed4[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced4[0], f), (f: rs.Formatter) => rs.fmtStr(replaced4[1], f)], f)]; + const replaced4: [rs.String, rs.String] = [rs.strReplace(text, p, "+", false), rs.strReplacen(text, p, "+", 2)]; + const args162 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once4[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once4[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed4[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced4[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced4[1].v, f)], f)]; Log.note(log, rs.fmtFormat(["once ", args162[0], " ", args162[1], " ", args162[2]])); const split4: rs.Iter = rs.strSplit(text, p); const _998: string | undefined = rs.iterToOption(split4.next()); @@ -714,8 +714,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const _1178: string = "+"; const once5: [[string, string] | undefined, [string, string] | undefined] = [rs.dropAfter(_1145, () => rs.strSplitOnce(text, _1145)), rs.dropAfter(_1149, () => rs.strRsplitOnce(text, _1149))]; const trimmed5: [string, string, string] = [rs.dropAfter(_1155, () => rs.strTrimMatches(_1154, _1155)), rs.dropAfter(_1160, () => rs.strTrimStartMatches(_1159, _1160)), rs.dropAfter(_1165, () => rs.strTrimEndMatches(_1164, _1165))]; - const replaced5: [string, string] = [rs.dropAfter(_1170, () => rs.strReplace(text, _1170, _1173)), rs.dropAfter(_1175, () => rs.strReplace(text, _1175, _1178, 2))]; - const args154 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once5[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once5[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed5[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced5[0], f), (f: rs.Formatter) => rs.fmtStr(replaced5[1], f)], f)]; + const replaced5: [rs.String, rs.String] = [rs.dropAfter(_1170, () => rs.strReplace(text, _1170, _1173, false)), rs.dropAfter(_1175, () => rs.strReplacen(text, _1175, _1178, 2))]; + const args154 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once5[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once5[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed5[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced5[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced5[1].v, f)], f)]; Log.note(log, rs.fmtFormat(["once ", args154[0], " ", args154[1], " ", args154[2]])); const split5: rs.Iter = rs.strSplit(text, boxed(15)); const _1203: string | undefined = rs.iterToOption(split5.next()); @@ -795,10 +795,10 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { Log.note(log, rs.fmtFormat(["ends ", args145[0], " ", args145[1], " ", args145[2]])); const once6: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, rs.place(() => b4, (value11) => b4 = value11).v), rs.strRsplitOnce(text, rs.place(() => b4, (value12) => b4 = value12).v)]; const trimmed6: [string, string] = [rs.strTrimMatches(",,a,,", rs.place(() => b4, (value13) => b4 = value13).v), rs.strTrimStartMatches(",,a", rs.place(() => b4, (value14) => b4 = value14).v)]; - const replaced6: [string, string] = [rs.strReplace(text, rs.place(() => b4, (value15) => b4 = value15).v, "+"), rs.strReplace(text, rs.place(() => b4, (value16) => b4 = value16).v, "+", 2)]; + const replaced6: [rs.String, rs.String] = [rs.strReplace(text, rs.place(() => b4, (value15) => b4 = value15).v, "+", false), rs.strReplacen(text, rs.place(() => b4, (value16) => b4 = value16).v, "+", 2)]; const end2: string = rs.strTrimEndMatches(",a,,", rs.place(() => b4, (value17) => b4 = value17).v); const _1430: boolean = b4(120); - const args146 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once6[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once6[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed6[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced6[0], f), (f: rs.Formatter) => rs.fmtStr(replaced6[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end2, f), (f: rs.Formatter) => rs.fmtBool(_1430, f)]; + const args146 = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once6[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once6[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed6[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced6[0].v, f), (f: rs.Formatter) => rs.fmtStr(replaced6[1].v, f)], f), (f: rs.Formatter) => rs.fmtStr(end2, f), (f: rs.Formatter) => rs.fmtBool(_1430, f)]; Log.note(log, rs.fmtFormat(["once ", args146[0], " ", args146[1], " ", args146[2], " ", args146[3], " ", args146[4]])); const split7: rs.Iter = rs.strSplit(text, rs.lent(rs.place(() => b4, (value18) => b4 = value18).v)); const _1453: string | undefined = rs.iterToOption(split7.next()); @@ -825,7 +825,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args151 = [(f: rs.Formatter) => rs.fmtOption(last7, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices6[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices6[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_1559, f)]; Log.note(log, rs.fmtFormat(["indices ", args151[0], " ", args151[1], " ", args151[2]])); rs.drop(b4); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } else { const _1578: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(1), guard(2), guard(3)]; const a7: Guard.Guard = _1578[0]; @@ -873,8 +873,8 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { captured5[Symbol.dispose](); }); const _1597: string = "+"; - const replaced7: string = rs.dropAfter(_1595, () => rs.strReplace(text, _1595, _1597, 2)); - const args137 = [(f: rs.Formatter) => rs.fmtBool(found8, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtPad(f, replaced7)]; + const replaced7: rs.String = rs.dropAfter(_1595, () => rs.strReplacen(text, _1595, _1597, 2)); + const args137 = [(f: rs.Formatter) => rs.fmtBool(found8, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtPad(f, replaced7.v)]; Log.note(log, rs.fmtFormat(["contains ", args137[0], " ", args137[1], " ", args137[2]])); const d3: Guard.Guard = guard(4); const captured6 = (c10: rs.char): boolean => { @@ -985,7 +985,7 @@ export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { const args143 = [(f: rs.Formatter) => rs.fmtOption(_1736, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(parts4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1739, f, rs.usizeDebug)]; Log.note(log, rs.fmtFormat(["shared ", args143[0], " ", args143[1], " ", args143[2]])); rs.drop(shared); - Log.note(log, "dropped"); + Log.note(log, rs.stringFrom("dropped")); } } diff --git a/ts/fixtures/task/expected/futures.ts b/ts/fixtures/task/expected/futures.ts index 75b592fb3..7e5ed0809 100644 --- a/ts/fixtures/task/expected/futures.ts +++ b/ts/fixtures/task/expected/futures.ts @@ -106,7 +106,7 @@ export class helpersFuture { const _422: boolean = isReady$1wybfmi(polled); const _45: boolean = isPending$0mrvg1b(polled); const args3 = [(f: rs.Formatter) => rs.fmtBool(_392, f), (f: rs.Formatter) => rs.fmtBool(_422, f), (f: rs.Formatter) => rs.fmtBool(_45, f)]; - Guard.note(captured4, rs.fmtFormat(["pending ", args3[0], " ready ", args3[1], " pending ", args3[2]])); + Guard.note(captured4, rs.fmtFormat(["pending ", args3[0], " ready ", args3[1], " pending ", args3[2]]).v); if (polled !== rs.Pending) { if (polled !== undefined) { if (rs.u64Rem(polled, 2) === 0) { @@ -272,7 +272,7 @@ export class wakersFuture { put$unit(rs.DANGLING_UNIT, undefined); put$unit(rs.DANGLING_UNIT, undefined); const arg = rs.sliceFrom(this.#checks); - const _88: string = rs.fmtFormat(["wakers ", (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.fmtBool)]); + const _88: string = rs.fmtFormat(["wakers ", (f: rs.Formatter) => rs.fmtList(rs.sliceItems(arg), f, rs.fmtBool)]).v; Guard.note(this.#guard, _88); lib_drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker([this.#a, this.#b, this.#other, this.#plain] as [rs.Waker, rs.Waker, rs.Waker, rs.Waker]); this.#last = undefined as [rs.Place, rs.WakerVTable] | undefined; @@ -305,7 +305,7 @@ export class wakersFuture { const _183: boolean = rs.willWake(lent, waker); const _222: boolean = polling(waker); const args6 = [(f: rs.Formatter) => rs.fmtBool(same, f), (f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(inner[0], f), (f: rs.Formatter) => rs.fmtBool(inner[1], f)], f), (f: rs.Formatter) => rs.fmtBool(_222, f)]; - const _85: string = rs.fmtFormat(["same ", args6[0], " clone ", args6[1], " lent ", args6[2], " inner ", args6[3], " after ", args6[4]]); + const _85: string = rs.fmtFormat(["same ", args6[0], " clone ", args6[1], " lent ", args6[2], " inner ", args6[3], " after ", args6[4]]).v; Guard.note(this.#guard, _85); const _04: rs.Poll = this.#next.poll(cx); clone[Symbol.dispose](); @@ -519,7 +519,7 @@ export class boxedFuture { rs.drop(this.#awaitee); this.#first = option_unwrapOr$15hbiwd(result, 0); const arg = this.#first; - const _17: string = rs.fmtFormat(["first ", (f: rs.Formatter) => rs.u64Display(arg, f)]); + const _17: string = rs.fmtFormat(["first ", (f: rs.Formatter) => rs.u64Display(arg, f)]).v; Guard.note(this.#guard, _17); const _28: [rs.u32, Log.Log] = [Guard.id(this.#guard), Log.clone$Clone(Guard.log(this.#guard))]; this.#id = _28[0]; @@ -578,7 +578,7 @@ export class boxedFuture { if (_81 !== rs.Pending) { this.#saved = rs.u64Add(this.#saved, _81); const arg2 = this.#saved; - const _92: string = rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.u64Display(arg2, f)]); + const _92: string = rs.fmtFormat(["lent ", (f: rs.Formatter) => rs.u64Display(arg2, f)]).v; Guard.note(this.#guard, _92); this.#saved$5 = false; this.#lend[Symbol.dispose](); @@ -638,7 +638,7 @@ export class boxedFuture { this.#old[Symbol.dispose](); this.#moved = rs.u64Add(this.#moved, result8); const arg3 = this.#moved; - const _183: string = rs.fmtFormat(["moved ", (f: rs.Formatter) => rs.u64Display(arg3, f)]); + const _183: string = rs.fmtFormat(["moved ", (f: rs.Formatter) => rs.u64Display(arg3, f)]).v; Guard.note(this.#guard, _183); const _197: [Guard.Guard, Guard.Guard, Guard.Guard] = [Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 700), Log.clone$Clone(this.#log))]; const block: Guard.Guard = _197[0]; @@ -704,7 +704,7 @@ export class boxedFuture { if (_248 !== rs.Pending) { const total: rs.u64 = _248; this.#awaitee$6[Symbol.dispose](); - const _258: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.u64Display(total, f)]); + const _258: string = rs.fmtFormat(["boxed ", (f: rs.Formatter) => rs.u64Display(total, f)]).v; Guard.note(this.#guard, _258); this.#pinned[Symbol.dispose](); this.#saved$2 = false; @@ -755,7 +755,7 @@ export class boxedFuture$closure2 { const result: rs.u64 | undefined = _7; rs.drop(this.#awaitee); const value: rs.u64 = option_unwrapOr$15hbiwd(result, 0); - const _17: string = rs.fmtFormat(["block ", (f: rs.Formatter) => rs.u64Display(value, f)]); + const _17: string = rs.fmtFormat(["block ", (f: rs.Formatter) => rs.u64Display(value, f)]).v; Guard.note(this.#block, _17); const _30: rs.u64 = rs.u64Add(value, 1); this.#rx[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index 0e283b983..3cd30872f 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -8,9 +8,9 @@ export function clone$Clone(self: Log): Log { /** A shared, append-only list of events. */ export class Log { - _0: rs.Arc>>; + _0: rs.Arc>>; - constructor(_0: rs.Arc>>) { + constructor(_0: rs.Arc>>) { this._0 = _0; } @@ -24,23 +24,23 @@ function new_(): Log { } /** Append one event. */ -export function note(self: Log, event: string): void { - const _6: rs.Mutex> = rs.mutexLock(self._0.value); +export function note(self: Log, event: rs.String): void { + const _6: rs.Mutex> = rs.mutexLock(self._0.value); _6.value.items.push(event); rs.mutexUnlock(_6); } /** Every event so far, one per line. */ export function text(self: Log): rs.ByteVec { - const events: rs.Mutex> = rs.mutexLock(self._0.value); + const events: rs.Mutex> = rs.mutexLock(self._0.value); const out: rs.ByteVec = new rs.ByteVec(); - const iter: rs.Iter = rs.iterSlice(events.value.items); + const iter: rs.Iter = rs.iterSlice(events.value.items); while (true) { - const _13: string | rs.Done = iter.next(); + const _13: rs.String | rs.Done = iter.next(); if (_13 === rs.DONE) { break; } - const _19: rs.ByteSlice = rs.stringAsBytes(_13); + const _19: rs.ByteSlice = rs.stringAsBytes(_13.v); rs.byteVecExtendFromSlice(out, _19); rs.byteVecPush(out, 10); } diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index 3b9abbdcc..9c1c23443 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -46,7 +46,7 @@ export function log(self: Guard): Log.Log { export function note(self: Guard, event: string): void { const arg = self.id; const args3 = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, event)]; - const _5: string = rs.fmtFormat(["g", args3[0], " ", args3[1]]); + const _5: rs.String = rs.fmtFormat(["g", args3[0], " ", args3[1]]); Log.note(self.log, _5); } @@ -65,7 +65,7 @@ export function unbox(self: Guard, event: string): rs.u32 { export function drop$ops_Drop(self: Guard): void { const arg = self.id; - const _4: string = rs.fmtFormat(["g", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); + const _4: rs.String = rs.fmtFormat(["g", (f: rs.Formatter) => rs.u32Display(arg, f), " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index c4802d569..a070bb29f 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -86,7 +86,7 @@ export class sumFuture { } else { const arg = this.#guard.id; const args5 = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.u64Display(value, f)]; - const _32: string = rs.fmtFormat(["g", args5[0], " got ", args5[1]]); + const _32: rs.String = rs.fmtFormat(["g", args5[0], " got ", args5[1]]); Log.note(this.#inner.log, _32); this.#total = rs.u64Add(this.#total, value); bb0 = 4; @@ -223,7 +223,7 @@ export class watchFuture { this.#awaitee[Symbol.dispose](); rs.drop(this.#pinned); const arg = this.#first; - const _22: string = rs.fmtFormat(["first ", (f: rs.Formatter) => rs.fmtOption(arg, f, rs.u64Debug)]); + const _22: string = rs.fmtFormat(["first ", (f: rs.Formatter) => rs.fmtOption(arg, f, rs.u64Debug)]).v; Guard.note(this.#guard, _22); this.#saved$2 = false; this.#pending = Pending.new$model_Watch(new Watch.Watch(this.#rx, 1)); @@ -244,7 +244,7 @@ export class watchFuture { const result2: rs.u64 | undefined = _38; if (result2 !== undefined) { value = result2; - const _50: string = rs.fmtFormat(["watched ", (f: rs.Formatter) => rs.u64Display(value, f)]); + const _50: string = rs.fmtFormat(["watched ", (f: rs.Formatter) => rs.u64Display(value, f)]).v; Guard.note(this.#guard, _50); this.#total = rs.u64Add(this.#total, value); const _62: Watch.Watch = Pending.derefMut$ops_DerefMut_model_Watch(this.#pending); @@ -278,7 +278,7 @@ export class watchFuture { rs.drop(this.#awaitee$4); const arg2 = this.#watch.index; const args9 = [(f: rs.Formatter) => rs.usizeDisplay(arg2, f), (f: rs.Formatter) => rs.fmtResult(sent, f, rs.usizeDebug, (value: Closed.Closed, f: rs.Formatter) => Closed.fmt$fmt_Debug(value, f))]; - const _92: string = rs.fmtFormat(["watched to ", args9[0], " of ", args9[1]]); + const _92: string = rs.fmtFormat(["watched to ", args9[0], " of ", args9[1]]).v; Guard.note(this.#guard, _92); const _109: rs.u64 = this.#total; this.#watch[Symbol.dispose](); @@ -393,7 +393,7 @@ export class frontFuture { return rs.Pending; case 23: const arg = this.#listing; - const _32: string = rs.fmtFormat(["listing ", (f: rs.Formatter) => rs.fmtOption(arg, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]); + const _32: string = rs.fmtFormat(["listing ", (f: rs.Formatter) => rs.fmtOption(arg, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]).v; Guard.note(this.#guard, _32); this.#awaitee$2 = wait$model_front_closure0_closure0_usize((waiter: Waiter.Waiter): rs.Poll => { while (true) { @@ -430,7 +430,7 @@ export class frontFuture { const _69: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(closed, f); const arg2 = this.#inFlight; const args6 = [_69, (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u64Debug)]; - const _60: string = rs.fmtFormat(["closed with ", args6[0], " in flight ", args6[1]]); + const _60: string = rs.fmtFormat(["closed with ", args6[0], " in flight ", args6[1]]).v; Guard.note(this.#guard, _60); const _79: rs.u64 = rs.iterSum(rs.iterSlice(this.#inFlight.items), rs.u64Add, 0); this.#guard[Symbol.dispose](); @@ -688,7 +688,7 @@ export class blocksFuture { this.#slots[result2][Symbol.dispose](); this.#slots[result2] = this.#saved; const arg = this.#waited; - const _76: string = rs.fmtFormat(["slot after ", (f: rs.Formatter) => rs.u64Display(arg, f)]); + const _76: string = rs.fmtFormat(["slot after ", (f: rs.Formatter) => rs.u64Display(arg, f)]).v; Guard.note(this.#slots[0], _76); this.#tally = { n: this.#guard.id }; const seen: rs.Future = new blocksFuture$closure1(copy$model_Tally(this.#tally)); @@ -707,7 +707,7 @@ export class blocksFuture { rs.drop(this.#awaitee$3); const arg2 = this.#saved$2; const args12 = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_98, f)]; - const _91: string = rs.fmtFormat(["tally ", args12[0], " then ", args12[1]]); + const _91: string = rs.fmtFormat(["tally ", args12[0], " then ", args12[1]]).v; Guard.note(this.#saved, _91); this.#mark = { n: 1 }; this.#awaitee$3 = new blocksFuture$closure2(this.#mark); @@ -724,7 +724,7 @@ export class blocksFuture { const _135: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg3, f); const arg4 = this.#mark.n; const args13 = [_135, (f: rs.Formatter) => rs.u32Display(arg4, f)]; - const _126: string = rs.fmtFormat(["mark ", args13[0], " ", args13[1]]); + const _126: string = rs.fmtFormat(["mark ", args13[0], " ", args13[1]]).v; Guard.note(this.#guard, _126); this.#count = this.#guard.id; this.#awaitee$3 = new blocksFuture$closure3(rs.place(() => this.#count, (value) => this.#count = value)); @@ -741,7 +741,7 @@ export class blocksFuture { const _161: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg5, f); const arg6 = this.#count; const args14 = [_161, (f: rs.Formatter) => rs.u32Display(arg6, f)]; - const _152: string = rs.fmtFormat(["count ", args14[0], " ", args14[1]]); + const _152: string = rs.fmtFormat(["count ", args14[0], " ", args14[1]]).v; Guard.note(this.#guard, _152); this.#nested = new Inner.Inner(new Outer.Outer(undefined, Guard.new(rs.u32Add(this.#guard.id, 800), Log.clone$Clone(this.#guard.log)))); const third: Guard.Guard = Guard.new(rs.u32Add(this.#guard.id, 400), Log.clone$Clone(this.#guard.log)); @@ -762,7 +762,7 @@ export class blocksFuture { this.#looped = _187; rs.drop(this.#awaitee$3); const arg7 = this.#looped; - const _197: string = rs.fmtFormat(["looped ", (f: rs.Formatter) => rs.u32Display(arg7, f)]); + const _197: string = rs.fmtFormat(["looped ", (f: rs.Formatter) => rs.u32Display(arg7, f)]).v; Guard.note(this.#saved, _197); if (this.#moves) { this.#saved$3 = false; @@ -1133,7 +1133,7 @@ export function temporaries(log: Log.Log, id: rs.u32): void { }; const _11: Guard.Guard = guard(1000); const arg = _11.id; - const _7: string = rs.fmtFormat(["temporary ", (f: rs.Formatter) => rs.u32Display(arg, f)]); + const _7: rs.String = rs.fmtFormat(["temporary ", (f: rs.Formatter) => rs.u32Display(arg, f)]); _11[Symbol.dispose](); Log.note(log, _7); const _19: Guard.Guard | undefined = guard(1010); @@ -1153,7 +1153,7 @@ export function temporaries(log: Log.Log, id: rs.u32): void { const _39: Guard.Guard = guard(1030); const arg2 = _39.id; const args14 = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.i32Display(matched, f)]; - const _35: string = rs.fmtFormat(["boxed temporary ", args14[0], " ", args14[1]]); + const _35: rs.String = rs.fmtFormat(["boxed temporary ", args14[0], " ", args14[1]]); _39[Symbol.dispose](); Log.note(log, _35); const part = first([guard(1040), guard(1050)] as [Guard.Guard, Guard.Guard]); diff --git a/ts/runtime/rs.ts b/ts/runtime/rs.ts index f4c095417..6b5f3943d 100644 --- a/ts/runtime/rs.ts +++ b/ts/runtime/rs.ts @@ -16,7 +16,7 @@ import { drop as dispose, dropAll, partPlace, type Pending } from "./rs/task.ts" import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./rs/alloc.ts"; import { AtIndex } from "./rs/collections.ts"; import { escapeDebug } from "./rs/char.ts"; -import { strFromUtf8Unchecked } from "./rs/str.ts"; +import { byteSliceUtf8Chunks, String as RsString, strFromUtf8Unchecked, stringClone, stringCloneFrom, stringFrom, stringLen, stringNew, stringOf, stringPush, stringPushStr, stringWithCapacity } from "./rs/str.ts"; export * from "./rs/alloc.ts"; export * from "./rs/ascii.ts"; export * from "./rs/bytes.ts"; @@ -40,7 +40,7 @@ export class Panic extends Error { * What `panic` runs before it throws, once a program sets a hook: `rs/hook.ts`'s, which * gives the text it formatted, if any. */ - declare static hooked?: (message: string | Arguments, at: Location | string | undefined, owned?: boolean) => string | undefined; + declare static hooked?: (message: string | Arguments, at: Location | string | undefined, owned?: boolean | RsString) => string | undefined; override name = "Panic"; } @@ -51,9 +51,10 @@ export class Abort extends Panic { /** * Panic with `message`, at `at`, or at the key of std's or `bytes`' site the hook finds it at, whose - * text is a `String` if `owned` says so, as `Panic.hooked` reads it. + * payload is the `String` `owned`, or one `message` is written into if `owned` is true, as + * `Panic.hooked` reads it. */ -export function panic(message: string, at?: Location | string, owned?: boolean): never { +export function panic(message: string, at?: Location | string, owned?: boolean | RsString): never { Panic.hooked?.(message, at, owned); throw new Panic(message); } @@ -68,7 +69,7 @@ export function resumeUnwind(): never { * to format, as std's does. A hook formats it as it runs, as std formats it once panicking. */ export function panicFmt(message: Arguments, at?: Location | string): never { - throw new Panic(Panic.hooked?.(message, at) ?? fmtWriteString("", message).s); + throw new Panic(Panic.hooked?.(message, at) ?? fmtFormatText(message)); } /** A `match` without arms, on a value Rust proved can't exist, such as a `(Void, u8)`. */ @@ -2536,7 +2537,7 @@ export type Cow = Vec | Borrowed>; /** `Cow<[u8]>`: the `Vec` it owns, or the bytes it borrows. */ export type ByteCow = ByteVec | ByteSlice; /** `Cow`: the `String` it owns, or the `str` it borrows. */ -export type StrCow = string | Borrowed; +export type StrCow = RsString | Borrowed; /** `Deref` of a `Cow<[T]>`: its slice. */ export function cowSlice(c: Cow): Slice { @@ -2621,25 +2622,58 @@ export function hashCow(hash: (value: B, s: S) => void): (value: B | Borro return (value, s) => hash(cowDeref(value), s); } -/** `Deref` of a `Cow`, and its `into_owned`: its text. */ +/** `Deref` of a `Cow`: its text. */ export function strCowStr(c: StrCow): string { - return c instanceof Borrowed ? c.slice : c; + return c instanceof Borrowed ? c.slice : c.v; +} + +/** `Cow::into_owned` of a `Cow`: the `String` it owns, or one of the text it borrows. */ +export function strCowIntoOwned(c: StrCow): RsString { + return c instanceof Borrowed ? stringFrom(c.slice) : c; } -/** `Clone` of a `Cow`: a borrow of the same text, or its text. */ +/** `Clone` of a `Cow`: a borrow of the same text, or a clone of its `String`. */ export function strCowClone(c: StrCow): StrCow { - return c instanceof Borrowed ? new Borrowed(c.slice) : c; + return c instanceof Borrowed ? new Borrowed(c.slice) : stringClone(c); +} + +/** `clone_from` of a `Cow`: an owned one's `String`, of an owned one's, as `String`'s clones into it, and else `src`'s clone. */ +export function strCowCloneFrom(c: StrCow, src: StrCow): StrCow { + if (c instanceof Borrowed || src instanceof Borrowed) return strCowClone(src); + c.v = ""; + c.len = 0 as usize; + stringPushStr(c, src.v, src.len); + return c; +} + +/** `strCowCloneFrom` as a `CloneFrom`. */ +export function strCowCloneFromFn(): CloneFrom { + return strCowCloneFrom; +} + +/** `stringCloneFrom` as a `CloneFrom`. */ +export function stringCloneFromFn(): CloneFrom { + return stringCloneFrom; } /** - * `+` of two `Cow`s, and `+=`: the right one if the left is empty, the left if the - * right is, and else the text they join, owned. + * `+` of two `Cow`s, and `+=`: the right one if the left is empty, and else the left, + * which owns room for both if it borrowed, once it pushed the right's text. */ export function strCowAdd(a: StrCow, b: StrCow): StrCow { const left = strCowStr(a); if (left === "") return b; const right = strCowStr(b); - return right === "" ? a : left + right; + if (right === "") return a; + const len = b instanceof Borrowed ? stringLen(right) : b.len; + if (!(a instanceof Borrowed)) { + stringPushStr(a, right, len); + return a; + } + const owned = stringWithCapacity((stringLen(left) + len) as usize); + stringPushStr(owned, left); + stringPushStr(owned, right, len); + return owned; } // Strings @@ -2708,38 +2742,53 @@ export function strFromUtf8(bytes: ByteSlice): Result { } } -/** `String::from_utf8_lossy`: the text of valid UTF-8, borrowed, or else with each invalid sequence replaced by U+FFFD, owned. */ +/** + * `String::from_utf8_lossy`: the text of valid UTF-8, borrowed, or else with each invalid + * sequence replaced by U+FFFD, owned, with room for a byte of each and grown by each push. + */ export function stringFromUtf8Lossy(bytes: ByteSlice): StrCow { const v = byteSliceView(bytes); try { return new Borrowed(decoder.decode(v)); } catch { - return strFromUtf8Unchecked(bytes); + const s = stringWithCapacity(bytes.length as usize); + for (const chunk of byteSliceUtf8Chunks(bytes)) { + stringPushStr(s, chunk.valid); + if (chunk.invalid.length > 0) stringPushStr(s, "\ufffd", 3 as usize); + } + return s; } } -/** `String::from_utf8`. */ -export function stringFromUtf8(bytes: ByteVec): Result { +/** `String::from_utf8`: its text, with the room `bytes` had. */ +export function stringFromUtf8(bytes: ByteVec): Result { try { - return Ok(decoder.decode(byteVecView(bytes))); + return Ok(stringOf(decoder.decode(byteVecView(bytes)), bytes.length as usize, bytes.data.length as usize)); } catch { return Err(new FromUtf8Error(bytes)); } } +/** `String::from_utf8_unchecked` of UTF-8, which keeps the room `bytes` had. */ +export function stringFromUtf8Unchecked(bytes: ByteVec): RsString { + return stringOf(strFromUtf8Unchecked(byteVecSlice(bytes)), bytes.length as usize, bytes.data.length as usize); +} + /** `str::as_bytes`: its UTF-8 bytes. */ export function stringAsBytes(s: string): ByteSlice { return byteSliceFrom(encoder.encode(s)); } -/** `String::into_bytes`: its UTF-8 bytes. */ -export function stringIntoBytes(s: string): ByteVec { - return byteVecFrom(encoder.encode(s)); +/** `String::into_bytes`: its UTF-8 bytes, with its room. */ +export function stringIntoBytes(s: RsString): ByteVec { + const v = new ByteVec(s.cap); + v.length = encoder.encodeInto(s.v, v.data).written; + return v; } -/** `str::len`: its length in UTF-8 bytes. */ -export function stringLen(s: string): number { - return encoder.encode(s).length; +/** `<[u8]>::to_vec` of a `str`'s bytes, with room for exactly them. */ +export function strToBytes(s: string): ByteVec { + return byteVecFrom(encoder.encode(s)); } /** `char::from_u32`: `n`, unless it is a surrogate or past the last char. */ @@ -2815,20 +2864,32 @@ export interface Write { writeChar(c: char): FmtResult; } +/** `impl fmt::Write for String`: each `write_str` a `push_str`, and each `write_char` a `push`. */ class StringWriter implements Write { - s = ""; + readonly s: RsString; + + constructor(s: RsString) { + this.s = s; + } writeStr(s: string): FmtResult { - this.s += s; + stringPushStr(this.s, s); return OK; } writeChar(c: char): FmtResult { - this.s += String.fromCodePoint(c); + stringPush(this.s, c); return OK; } } +/** The text `args` writes, before any value failed to, as a panic's message. */ +export function fmtFormatText(args: Arguments): string { + const s = stringNew(); + write(new StringWriter(s), args); + return s.v; +} + /** Indents each line it writes, for `{:#?}`'s nesting. */ class PadAdapter implements Write { private onNewline = true; @@ -2904,12 +2965,9 @@ export function fmtWriteFmt(f: Formatter, args: Arguments): FmtResult { return write(f.out, args); } -/** `write!` into a `String`, `s`: `s` with what was written, even before an error, and the result. */ -export function fmtWriteString(s: string, args: Arguments): { s: string; result: FmtResult } { - const out = new StringWriter(); - out.s = s; - const result = write(out, args); - return { s: out.s, result }; +/** `write!` into a `String`, which keeps what was written before an error. */ +export function fmtWriteString(s: RsString, args: Arguments): FmtResult { + return write(new StringWriter(s), args); } /** `Formatter::alternate`: whether the spec has `#`. */ @@ -3227,20 +3285,47 @@ function closePretty(f: Formatter, close: string): FmtResult { // `Debug` and `Display` of what std defines them for. A string's `Display` is `fmtPad`. -/** `format!`, from `alloc::fmt::format`. */ -export function fmtFormat(args: Arguments): string { - const out = new StringWriter(); - if (!write(out, args).ok) { +/** + * `format!`, from `alloc::fmt::format`: room for `Arguments::estimated_capacity`, which + * each write grows. + */ +export function fmtFormat(args: Arguments): RsString { + const s = stringWithCapacity(estimate(args) as usize); + if (!write(new StringWriter(s), args).ok) { panic("a formatting trait implementation returned an error when the underlying stream did not: Error", "format", true); } - return out.s; + return s; } -/** `ToString::to_string` of a `Display` value. */ -export function fmtToString(value: Fmt): string { - const out = new StringWriter(); - if (!value({ out, spec: {} }).ok) panic("a Display implementation returned an error unexpectedly: Error", "to_string", true); - return out.s; +/** + * `Arguments::estimated_capacity`: the text's bytes if it has no placeholder, none if one + * comes first and the text is under 16 bytes, and else twice the text's bytes. + */ +function estimate(args: Arguments): number { + let len = 0; + let placeholders = false; + let first = false; + for (const part of args) { + if (typeof part === "string") len += stringLen(part); + else { + first ||= len === 0; + placeholders = true; + } + } + if (!placeholders) return len; + return first && len < 16 ? 0 : len * 2; +} + +/** + * `ToString::to_string` of a `Display` value. std's room for a signed integer is `size` + * digits, and its sign if negative; for other primitives, given a `size` of 0, exactly its + * bytes; and else what each write grows from none. + */ +export function fmtToString(value: Fmt, size?: number): RsString { + const s = stringNew(); + if (!value({ out: new StringWriter(s), spec: {} }).ok) panic("a Display implementation returned an error unexpectedly: Error", "to_string", true); + if (size !== undefined) s.cap = (size === 0 ? s.len : size + (s.v.startsWith("-") ? 1 : 0)) as usize; + return s; } /** A placeholder with options, which replace the defaults its value is written with. */ diff --git a/ts/runtime/rs/char.ts b/ts/runtime/rs/char.ts index cc35ae7a6..87b0c48a4 100644 --- a/ts/runtime/rs/char.ts +++ b/ts/runtime/rs/char.ts @@ -7,7 +7,7 @@ import { type ByteSlice, type Debug, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugStructFields, fmtDebugTuple, fmtOption, fmtPad, fmtUnit, fmtWriteFmt, OK, Ok, type Place, panic, type Result, Slice } from "../rs.ts"; import { type char, type u8, type u16, u16Debug, u16LowerHex, type u32, type usize } from "./int.ts"; import { type Clones, DONE, type Done, Iter, iterFlatMap, iterHeld, type SizeHint } from "./iter.ts"; -import { strChars } from "./str.ts"; +import { type String as RsString, strChars, stringCased } from "./str.ts"; import { drop as dispose } from "./task.ts"; import { ALPHABETIC, CASE_IGNORABLE, LOWERCASE, NUMERIC, TITLECASE, TO_LOWERCASE, TO_LOWERCASE_MULTI, TO_UPPERCASE, TO_UPPERCASE_MULTI, UNPRINTABLE, UPPERCASE } from "./unicode.ts"; import type { Location } from "./location.ts"; @@ -151,7 +151,7 @@ const toLowercase = /* @__PURE__ */ new CaseMap(TO_LOWERCASE, TO_LOWERCASE_MULTI const toUppercase = /* @__PURE__ */ new CaseMap(TO_UPPERCASE, TO_UPPERCASE_MULTI); /** `str::to_lowercase`: each char's, but a capital sigma's at the end of a word, which is final. */ -export function strToLowercase(s: string): string { +export function strToLowercase(s: string): RsString { let out = ""; for (let i = 0; i < s.length; ) { const c = s.codePointAt(i) as char; @@ -160,7 +160,7 @@ export function strToLowercase(s: string): string { else out += String.fromCodePoint(...toLowercase.map(c)); i = end; } - return out; + return stringCased(s, out); } /** @@ -188,14 +188,14 @@ function isLowSurrogate(u: number): boolean { } /** `str::to_uppercase`: each char's. */ -export function strToUppercase(s: string): string { +export function strToUppercase(s: string): RsString { let out = ""; for (let i = 0; i < s.length; ) { const c = s.codePointAt(i) as char; out += String.fromCodePoint(...toUppercase.map(c)); i += c > 0xffff ? 2 : 1; } - return out; + return stringCased(s, out); } /** The chars a case map or an escape still has, from either end, exactly sized. */ diff --git a/ts/runtime/rs/collections.ts b/ts/runtime/rs/collections.ts index f8bed2d47..9ae17b459 100644 --- a/ts/runtime/rs/collections.ts +++ b/ts/runtime/rs/collections.ts @@ -15,10 +15,11 @@ // A function that may drop a key, value, or item std's would, rather than return or keep // it, takes what drops each that does, as `k`, `v`, or `f`, and drops it where std's does. -import { ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; +import { Borrowed, ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, searchBy, type Elements, Slice, sliceData, sliceFrom, sliceLength, sliceSort, sliceStart, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; -import type { Hashing } from "./hash.ts"; +import type { HashKey, Hashing } from "./hash.ts"; import { type Limbs, lt, type u64, type usize } from "./int.ts"; +import type { String as RsString } from "./str.ts"; import { type Clones, DONE, @@ -68,7 +69,9 @@ export function cmp(a: T, b: T): Ordering { * `Ord::cmp` of two strings, by code point as Rust's UTF-8 bytes sort. JS's `<` compares * UTF-16 units, which puts a character past U+FFFF, a surrogate pair, below U+E000. */ -export function cmpStr(a: string, b: string): Ordering { +export function cmpStr(x: string | RsString, y: string | RsString): Ordering { + const a = typeof x === "string" ? x : x.v; + const b = typeof y === "string" ? y : y.v; if (a === b) return 0; const n = Math.min(a.length, b.length); for (let i = 0; i < n; i++) { @@ -308,6 +311,23 @@ export function same(a: T, b: T): boolean { return a === b; } +/** `PartialEq::eq` of text of any form, a `str`, a `String`, or a `Cow`: their text. */ +export function eqStr(a: string | RsString | Borrowed, b: string | RsString | Borrowed): boolean { + return textOf(a) === textOf(b); +} + +/** The text of a `str`, a `String`, or a `Cow`. */ +function textOf(s: string | RsString | Borrowed): string { + return typeof s === "string" ? s : s instanceof Borrowed ? s.slice : s.v; +} + +/** + * How a hash collection finds a key that is a `String` or a `Cow`, or a `str` looking + * one up: by its text, which the engine hashes as a JS map key, so the keys filed under + * one are equal. + */ +export const HASH_TEXT: Hashing> = { hash: textOf, eq: () => true, all: true }; + /** `PartialEq::eq` of tuples, from each field's. */ export function eqTuple(fields: readonly ((a: never, b: never) => boolean)[]): (a: T, b: T) => boolean { return (a, b) => { @@ -442,12 +462,12 @@ interface Slot { * `HashMap`, and `HashSet` as a map to `undefined`, std's or hashbrown's. A key * that is a JS primitive, a number, string, or boolean, is its own JS map key, as Rust * compares it; a key that is an object goes by its hash, to a chain of the keys `Eq` - * tells apart. Iteration visits the first kind in insertion order and then the second by + * tells apart, or by its text where it is a `String` or a `Cow`, as `HASH_TEXT` finds one. Iteration visits the first kind in insertion order and then the second by * hash, an order Rust leaves unspecified. */ export interface HashMap { p: Map; - o: Map> | undefined; + o: Map> | undefined; /** How many keys `o` holds. */ n: number; /** How to find a key that is an object, or `undefined` if no key is one. */ @@ -482,7 +502,7 @@ function hashed(m: HashMap, key: K): boolean { * The slot holding a key equal to `key`, a hashed key whose hash is `hash` if given, which * compares by `key`'s `eq`, as std's lookups do. */ -function slot(m: HashMap, key: K, hash?: number): Slot | undefined { +function slot(m: HashMap, key: K, hash?: HashKey): Slot | undefined { const h = m.h as Hashing; for (let s = m.o?.get(hash ?? h.hash(key)); s !== undefined; s = s.next) if (h.eq(key, s.k)) return s; return undefined; @@ -689,8 +709,8 @@ export function hashRemoveEntry(m: HashMap, key: K): [K, V] | undefi } /** Take `s`, a slot whose key's hash is `hash`, out of `m`. */ -function unlink(m: HashMap, hash: number, s: Slot): void { - const o = m.o as Map>; +function unlink(m: HashMap, hash: HashKey, s: Slot): void { + const o = m.o as Map>; let prev = o.get(hash) as Slot; if (prev === s) { if (s.next !== undefined) o.set(hash, s.next); @@ -816,9 +836,9 @@ function retainHash(m: HashMap, f: (key: K, value: V | Place) => class HashExtractIf extends Iter implements Disposable { private readonly m: HashMap; private readonly p: Iterator<[K, V]>; - private readonly o: Iterator<[number, Slot]> | undefined; + private readonly o: Iterator<[HashKey, Slot]> | undefined; /** The chain it reads, by its hash, the slot it reads next, and the last it kept there. */ - private hash = 0; + private hash: HashKey = 0; private at: Slot | undefined; private kept: Slot | undefined; private readonly f: (key: K, value: V | Place) => boolean; @@ -852,7 +872,7 @@ class HashExtractIf extends Iter implements Disposable { return (this.keys ? key : [key, now]) as T; } if (this.at === undefined) { - [this.hash, this.at] = (this.o as Iterator<[number, Slot]>).next().value as [number, Slot]; + [this.hash, this.at] = (this.o as Iterator<[HashKey, Slot]>).next().value as [HashKey, Slot]; this.kept = undefined; } const s = this.at; @@ -861,7 +881,7 @@ class HashExtractIf extends Iter implements Disposable { this.kept = s; continue; } - const o = m.o as Map>; + const o = m.o as Map>; if (this.kept !== undefined) this.kept.next = s.next; else if (s.next !== undefined) o.set(this.hash, s.next); else o.delete(this.hash); @@ -2405,9 +2425,10 @@ export function btreeRangeKeys(m: BTreeMap, r: Bounds | By, eq /** * What a range of keys `K` is bounded by: a key, or for an array's or a `Vec`'s, a `Slice`, - * which `cmpSlice` orders alike. + * which `cmpSlice` orders alike, or for a `String`'s or a `Cow`'s, a `str`, which + * `cmpStr` orders alike. */ -type Key = K | (K extends (infer E)[] ? Slice : never); +type Key = K | (K extends (infer E)[] ? Slice : never) | (K extends RsString | Borrowed ? string : never); /** * The items of `m` within `r`, checked as std checks it: by `eq` and `gt`, or by the order @@ -3121,7 +3142,7 @@ export interface Entry { readonly o: boolean; /** A hashed key's slot if it is occupied, and its hash. */ readonly s: Slot | undefined; - readonly h: number | undefined; + readonly h: HashKey | undefined; /** A B-tree's node holding the key, and its index there, or else the leaf and the complement of where it goes. */ readonly l: Node | undefined; readonly i: number; diff --git a/ts/runtime/rs/float.ts b/ts/runtime/rs/float.ts index 60e5c3f55..627fe1607 100644 --- a/ts/runtime/rs/float.ts +++ b/ts/runtime/rs/float.ts @@ -313,7 +313,7 @@ function mulAddExact(a: number, b: number, c: number): number { /** `clamp`, which panics with both bounds' `Debug` unless `min <= max`. */ function clamp(x: number, min: number, max: number, debug: (x: number, f: Formatter) => FmtResult, key: string): number { if (!(min <= max)) { - const text = (v: number) => fmtToString((f) => debug(v, f)); + const text = (v: number) => fmtToString((f) => debug(v, f)).v; panic(`min > max, or either was NaN. min = ${text(min)}, max = ${text(max)}`, key, true); } return x < min ? min : x > max ? max : x; diff --git a/ts/runtime/rs/hash.ts b/ts/runtime/rs/hash.ts index 5762270f8..c5018c119 100644 --- a/ts/runtime/rs/hash.ts +++ b/ts/runtime/rs/hash.ts @@ -26,6 +26,7 @@ import { u128Cast, } from "./int.ts"; import type { LinkedList } from "./collections.ts"; +import type { String as RsString } from "./str.ts"; import type { Arc } from "./task.ts"; /** What `Hash` writes into, by `Hasher`'s methods: `DefaultHasher`, a hash collection's own, or the crate's. */ @@ -679,9 +680,9 @@ export function hashWrite(bytes: ByteSlice, s: Hasher): void { s.write(bytes.data, bytes.start, bytes.length); } -/** `Hash::hash` of a string. */ -export function hashStr(str: string, s: Hasher): void { - s.str(str); +/** `Hash::hash` of a `str` or a `String`, which hash the same. */ +export function hashStr(str: string | RsString, s: Hasher): void { + s.str(typeof str === "string" ? str : str.v); } /** `Hash::hash` of what holds nothing, as `()` and `PhantomData`: nothing written. */ @@ -756,9 +757,12 @@ export function hashFinish(s: Hasher): u64 { return s.finish(); } +/** The JS map key a hash collection files a key that is a JS object under: its hash, or its text. */ +export type HashKey = number | string; + /** How a hash collection finds a key that is a JS object: its `Hash` and `Eq`. */ export interface Hashing { - readonly hash: (key: K) => number; + readonly hash: (key: K) => HashKey; readonly eq: (a: K, b: K) => boolean; /** Whether a key that is a JS primitive goes by them too: an enum with its own `Eq`. */ readonly all: boolean; diff --git a/ts/runtime/rs/hook.ts b/ts/runtime/rs/hook.ts index 5473a709b..f197c1dd2 100644 --- a/ts/runtime/rs/hook.ts +++ b/ts/runtime/rs/hook.ts @@ -1,6 +1,7 @@ // `std::panic`'s hook, for rust2-ts output: only a program that sets one reaches this // module, so a bundler drops all of it from one that doesn't. `rs.ts` re-exports all of it. +import { type String as RsString, stringNew, stringPushStr } from "./str.ts"; import { Abort, type Arguments, type FmtResult, type Formatter, fmtWriteFmt, fmtWriteString, Panic, panic } from "../rs.ts"; import { fmtLocationDisplay, type Location } from "./location.ts"; import { drop } from "./task.ts"; @@ -9,8 +10,8 @@ import { drop } from "./task.ts"; export interface PanicHookInfo { /** `payload_as_str`: the payload, if it is a `&str` or a `String`. */ readonly text: string | undefined; - /** Whether that text is a `String`, as a message `panic!` formats is, rather than a `&'static str`. */ - readonly owned: boolean; + /** The payload, if it is a `String`, as a message `panic!` formats is, rather than a `&'static str`. */ + readonly string: RsString | undefined; /** Any other payload, as the `dyn Any` object `panic_any` made of it. */ readonly payload: object | undefined; /** Where it panicked. */ @@ -36,12 +37,13 @@ let sites: Sites | undefined; /** * Run the hook on a panic at `at`, or at the key of std's or `bytes`' site in `Sites`, whose payload is - * `message` or else `payload`: a `String` if `owned`, or if it is `Arguments` with - * placeholders, as `Arguments::as_str` says. It formats `Arguments` once the panic has - * begun, as std does, and gives the text. A panic while the hook runs aborts, as std's does, + * `message` or else `payload`: the `String` `owned`, or one written from empty as std's + * `panic!` writes its message: `message` in one write if `owned` is true, or `Arguments` + * with placeholders, as `Arguments::as_str` says, by `write_fmt` once the panic has begun. + * It gives the text. A panic while the hook runs aborts, as std's does, * without running it again. */ -function run(message: string | Arguments | undefined, at: Location | string | undefined, owned?: boolean, payload?: object): string | undefined { +function run(message: string | Arguments | undefined, at: Location | string | undefined, owned?: boolean | RsString, payload?: object): string | undefined { const literal = typeof message === "object" ? asStr(message) : message; if (hooking) throw new Abort(`${literal ?? ""}\nthread panicked while processing panic. aborting.`); if (hook === defaultHook) return undefined; @@ -49,8 +51,16 @@ function run(message: string | Arguments | undefined, at: Location | string | un if (location === undefined) throw new Error(`rust2-ts: a panic its hook can't locate: ${literal ?? "a formatted message"}`); hooking = true; try { - const text = typeof message === "object" ? fmtWriteString("", message).s : message; - hook({ text, owned: owned ?? literal === undefined, payload, location }); + let string = typeof owned === "object" ? owned : undefined; + if (typeof message === "object" && literal === undefined) { + string = stringNew(); + fmtWriteString(string, message); + } else if (owned === true) { + string = stringNew(); + stringPushStr(string, literal ?? ""); + } + const text = string?.v ?? literal; + hook({ text, string, payload, location }); return text; } finally { hooking = false; @@ -97,8 +107,9 @@ export function panicAny(payload: object, at?: Location): never { * `PanicHookInfo::payload`: what `panic_any` was given, or else the text, as a `str` or a * `String` object, whose classes translation makes. */ -export function hookPayload(info: PanicHookInfo, str: new (text: string) => object, string: new (text: string) => object): object { - return info.payload ?? new (info.owned ? string : str)(info.text ?? ""); +export function hookPayload(info: PanicHookInfo, str: new (text: string) => object, string: new (text: RsString) => object): object { + if (info.payload !== undefined) return info.payload; + return info.string !== undefined ? new string(info.string) : new str(info.text ?? ""); } /** `PanicHookInfo`'s `Display`: where it panicked, then any text, as the default hook's first lines. */ diff --git a/ts/runtime/rs/str.ts b/ts/runtime/rs/str.ts index 1cd860f7a..cde28f933 100644 --- a/ts/runtime/rs/str.ts +++ b/ts/runtime/rs/str.ts @@ -7,7 +7,13 @@ // surrogate pair. import { + Borrowed, ByteSlice, + capReserve, + capReserveExact, + capShrink, + capTryReserve, + capTryReserveExact, type Slice, byteSliceView, Err, @@ -29,8 +35,6 @@ import { panicFmt, type Result, type StrCow, - strCowStr, - stringLen, utf8Check, } from "../rs.ts"; import { CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; @@ -1114,18 +1118,6 @@ export function strFind(s: string, p: Pattern): usize | undefined { return m.nextMatch() ? (utf8Len(s, 0, m.start) as usize) : undefined; } -/** `str::replace`, and `replacen` of the first `n` matches. */ -export function strReplace(s: string, p: Pattern, to: string, n = Infinity): string { - const m = new Searcher(s, p); - let out = ""; - let last = 0; - for (let i = 0; i < n && m.nextMatch(); i++) { - out += s.slice(last, m.start) + to; - last = m.end; - } - return out + s.slice(last); -} - /** `str::rfind`: the last match's offset in UTF-8 bytes. */ export function strRfind(s: string, p: Pattern): usize | undefined { const m = new Searcher(s, p); @@ -1268,35 +1260,211 @@ export function fmtUtf8ChunkDebug(chunk: Utf8Chunk, f: Formatter): FmtResult { ]); } -// `String`'s edits, each giving the edited string, which the caller writes where the -// `&mut String` points, and what the edit returns beside it. +// `String`: a JS string, as a `str` is, and the length in UTF-8 bytes and the capacity std's +// would hold. Each step grows it as `RawVec` grows a `Vec`'s, so a `capacity` read gives +// std's. A `&mut String` is the object, edited in place, and so is a `&mut str` of it, as +// no write through one changes its length. + +/** `alloc::string::String`: its text, `v`, its length in UTF-8 bytes, and its capacity. */ +class RsString implements Place { + v: string; + len: usize; + cap: usize; + + constructor(v: string, len: usize, cap: usize) { + this.v = v; + this.len = len; + this.cap = cap; + } +} + +export { RsString as String }; /** `isize::MAX` on wasm32, past which std refuses a capacity. */ const ISIZE_MAX = 0x7fffffff; +/** `str::len`: its length in UTF-8 bytes. */ +export function stringLen(s: string): usize { + return utf8Len(s, 0, s.length) as usize; +} + +/** `String::new`, which holds nothing. */ +export function stringNew(): RsString { + return new RsString("", 0 as usize, 0 as usize); +} + +/** A `String` of `text` with room for exactly its bytes, as `str::to_owned` makes one. */ +export function stringFrom(text: string): RsString { + const len = stringLen(text); + return new RsString(text, len, len); +} + +/** A `String` of `text`, `len` bytes long, with room for `cap`. */ +export function stringOf(text: string, len: usize, cap: usize): RsString { + return new RsString(text, len, cap); +} + +/** `String::with_capacity`, which panics past what it may hold. */ +export function stringWithCapacity(capacity: usize): RsString { + return new RsString("", 0 as usize, capReserveExact(0, 0, capacity, 1) as usize); +} + +/** `String::reserve`: room for `additional` more bytes, at least doubled if it grows. */ +export function stringReserve(s: RsString, additional: usize): void { + s.cap = capReserve(s.len, s.cap, additional, 1) as usize; +} + +/** `String::reserve_exact`: room for exactly `additional` more bytes if it grows. */ +export function stringReserveExact(s: RsString, additional: usize): void { + s.cap = capReserveExact(s.len, s.cap, additional, 1) as usize; +} + +/** `String::try_reserve`: `reserve`'s room, or the error where it panics. */ +export function stringTryReserve(s: RsString, additional: usize): Result { + return reserved(s, capTryReserve(s.len, s.cap, additional, 1)); +} + +/** `String::try_reserve_exact`. */ +export function stringTryReserveExact(s: RsString, additional: usize): Result { + return reserved(s, capTryReserveExact(s.len, s.cap, additional, 1)); +} + +/** `s` with room for `cap`, or the error of an overflow, `undefined`. */ +function reserved(s: RsString, cap: number | undefined): Result { + if (cap === undefined) return CAPACITY_OVERFLOW; + s.cap = cap as usize; + return OK; +} + +/** `String::shrink_to`, and `shrink_to_fit`, of 0. */ +export function stringShrinkTo(s: RsString, min: usize): void { + s.cap = capShrink(s.len, s.cap, min) as usize; +} + +/** `String::push_str` of `text`, `len` bytes long. */ +export function stringPushStr(s: RsString, text: string, len: usize = stringLen(text)): void { + stringReserve(s, len); + s.v += text; + s.len = (s.len + len) as usize; +} + +/** `String::push`. */ +export function stringPush(s: RsString, c: char): void { + stringPushStr(s, globalThis.String.fromCodePoint(c), charLen(c) as usize); +} + +/** `String + &str`, and `+=`: `s`, once it pushed `text`. */ +export function stringAdd(s: RsString, text: string): RsString { + stringPushStr(s, text); + return s; +} + +/** Push each char of `text` in turn, as std's `push` of each grows `s`. */ +export function stringPushChars(s: RsString, text: string): void { + let { len, cap } = s; + for (let i = 0; i < text.length; i++) { + const u = text.charCodeAt(i); + // A pair's high half is two bytes, and its low half the other two. + const n = u < 0x80 ? 1 : u < 0x800 ? 2 : u >= 0xd800 && u <= 0xdbff ? 4 : u >= 0xdc00 && u <= 0xdfff ? 0 : 3; + if (n > cap - len) cap = capReserve(len, cap, n, 1); + len += n; + } + s.v += text; + s.len = len as usize; + s.cap = cap as usize; +} + +/** `Clone` of a `String`: its text, with room for exactly its bytes. */ +export function stringClone(s: RsString): RsString { + return new RsString(s.v, s.len, s.len); +} + +/** + * `clone_from` of `src` into `s`, as `Vec`'s clears it and extends it by `src`'s bytes, + * and `str::clone_into`, which clears it and pushes the text. + */ +export function stringCloneFrom(s: RsString, src: RsString | string): RsString { + s.v = ""; + s.len = 0 as usize; + if (typeof src === "string") stringPushStr(s, src); + else stringPushStr(s, src.v, src.len); + return s; +} + +/** `String::clear`, which keeps its room. */ +export function stringClear(s: RsString): void { + s.v = ""; + s.len = 0 as usize; +} + /** - * `concat` and `join` of strings by `sep`, which panic as std's do where the bytes they - * reserve pass `usize::MAX` or what a `String` may hold. + * `concat` and `join` of strings or `String`s by `sep`: a `String` with room for exactly + * their bytes, as std's reserves them, which panics as std's does where they pass + * `usize::MAX` or what a `String` may hold. */ -export function strsJoin(parts: readonly string[], sep: string): string { +export function strsJoin(parts: readonly (string | RsString)[], sep: string): RsString { const seps = Math.max(parts.length - 1, 0); - let units = sep.length * seps; - for (const part of parts) units += part.length; - // A code unit is one to three bytes, so only a long result needs its bytes counted, each - // distinct part once, as such a result mostly repeats a few. - if (units * 3 > ISIZE_MAX) { - const counted = new Map(); - const count = (s: string): number => { - let n = counted.get(s); - if (n === undefined) counted.set(s, (n = stringLen(s))); - return n; - }; - let len = count(sep) * seps; - for (const part of parts) len += count(part); - if (len > 0xffffffff) panic("attempt to join into collection with len > usize::MAX", "join_len", true); - if (len > ISIZE_MAX) panic("capacity overflow", "capacity"); - } - return parts.join(sep); + // Each distinct text's bytes counted once, as a long result mostly repeats a few. + const counted = new Map(); + const count = (s: string): number => { + let n = counted.get(s); + if (n === undefined) counted.set(s, (n = stringLen(s))); + return n; + }; + let len = count(sep) * seps; + const texts: string[] = []; + for (const part of parts) { + if (typeof part === "string") { + len += count(part); + texts.push(part); + } else { + len += part.len; + texts.push(part.v); + } + } + if (len > 0xffffffff) panic("attempt to join into collection with len > usize::MAX", "join_len", true); + if (len > ISIZE_MAX) panic("capacity overflow", "capacity"); + return new RsString(texts.join(sep), len as usize, len as usize); +} + +/** + * `str::replace` of a pattern, `utf8` if a `char`, `&str`, or `&String`: room for `s`'s + * bytes if what replaces each match is no shorter, and else none, which each push grows. + * One ASCII byte for another is a copy, with room for exactly its bytes. + */ +export function strReplace(s: string, p: Pattern, to: string, utf8: boolean): RsString { + const len = stringLen(s); + if (utf8 && typeof p === "string" && p.length === 1 && p.charCodeAt(0) < 0x80 && to.length === 1 && to.charCodeAt(0) < 0x80) { + return new RsString(s.replaceAll(p, to), len, len); + } + const toLen = stringLen(to); + const fits = utf8 && typeof p === "string" && stringLen(p) <= toLen; + return replaced(new RsString("", 0 as usize, fits ? len : (0 as usize)), s, p, to, toLen, Infinity); +} + +/** `str::replacen`: room for 32 bytes, which each push of the first `n` matches grows. */ +export function strReplacen(s: string, p: Pattern, to: string, n: usize): RsString { + return replaced(new RsString("", 0 as usize, 32 as usize), s, p, to, stringLen(to), n); +} + +/** `out`, once it pushed the text of `s` between its first `n` matches of `p`, and `to` for each. */ +function replaced(out: RsString, s: string, p: Pattern, to: string, toLen: usize, n: number): RsString { + const m = new Searcher(s, p); + let last = 0; + for (let i = 0; i < n && m.nextMatch(); i++) { + stringPushStr(out, s.slice(last, m.start)); + stringPushStr(out, to, toLen); + last = m.end; + } + stringPushStr(out, s.slice(last)); + return out; +} + +/** `str::to_lowercase` and `to_uppercase` of `s` to `text`: room for `s`'s bytes, which each char's push grows. */ +export function stringCased(s: string, text: string): RsString { + const out = new RsString("", 0 as usize, stringLen(s)); + stringPushChars(out, text); + return out; } /** `String::FromUtf16Error`: `{ kind }`, its private `FromUtf16ErrorKind`'s name. */ @@ -1317,33 +1485,51 @@ function fromUtf16Units(len: number, unit: (i: number) => number, lossy: boolean for (let i = 0; i < len; i++) { const u = unit(i); if (u < 0xd800 || u > 0xdfff) { - s += String.fromCharCode(u); + s += globalThis.String.fromCharCode(u); continue; } const next = i + 1 < len ? unit(i + 1) : 0; if (u <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) { - s += String.fromCharCode(u, next); + s += globalThis.String.fromCharCode(u, next); i++; - } else if (lossy) s += "\ufffd"; + } else if (lossy) s += "�"; else return undefined; } return s; } -/** The text of `len` units, `unit(i)` the `i`th, or a `LoneSurrogate` error, as `String::from_utf16` reads them. */ -function fromUtf16(len: number, unit: (i: number) => number): Result { - const s = fromUtf16Units(len, unit, false); - return s === undefined ? Err(new FromUtf16Error("LoneSurrogate")) : Ok(s); +/** + * The `String` of `len` units, `unit(i)` the `i`th, or a `LoneSurrogate` error, as + * `String::from_utf16` reads them: room for a byte a unit, which each char's push grows. + */ +function fromUtf16(len: number, unit: (i: number) => number): Result { + const text = fromUtf16Units(len, unit, false); + if (text === undefined) return Err(new FromUtf16Error("LoneSurrogate")); + const s = stringWithCapacity(len as usize); + stringPushChars(s, text); + return Ok(s); +} + +/** + * The `String` of `len` units, `unit(i)` the `i`th, U+FFFD for each surrogate without its + * pair, as `String::from_utf16_lossy` collects them: room for half a char a unit, which + * each char's push grows. + */ +function fromUtf16Lossy(len: number, unit: (i: number) => number): RsString { + const s = stringNew(); + stringReserve(s, Math.ceil(len / 2) as usize); + stringPushChars(s, fromUtf16Units(len, unit, true) as string); + return s; } /** `String::from_utf16`. */ -export function stringFromUtf16(v: Slice): Result { +export function stringFromUtf16(v: Slice): Result { return fromUtf16(v.length, (i) => v.data[v.start + i]); } /** `String::from_utf16_lossy`: U+FFFD for each surrogate without its pair. */ -export function stringFromUtf16Lossy(v: Slice): string { - return fromUtf16Units(v.length, (i) => v.data[v.start + i], true) as string; +export function stringFromUtf16Lossy(v: Slice): RsString { + return fromUtf16Lossy(v.length, (i) => v.data[v.start + i]); } /** The `i`th unit of `v`'s bytes, little-endian unless `big`. */ @@ -1353,23 +1539,29 @@ function byteUnit(v: ByteSlice, big: boolean): (i: number) => number { } /** `String::from_utf16le`, an `OddBytes` error of an odd number of bytes. */ -export function stringFromUtf16le(v: ByteSlice): Result { +export function stringFromUtf16le(v: ByteSlice): Result { return v.length % 2 === 1 ? Err(new FromUtf16Error("OddBytes")) : fromUtf16(v.length / 2, byteUnit(v, false)); } /** `String::from_utf16be`, an `OddBytes` error of an odd number of bytes. */ -export function stringFromUtf16be(v: ByteSlice): Result { +export function stringFromUtf16be(v: ByteSlice): Result { return v.length % 2 === 1 ? Err(new FromUtf16Error("OddBytes")) : fromUtf16(v.length / 2, byteUnit(v, true)); } -/** `String::from_utf16le_lossy`, and U+FFFD for an odd byte at the end. */ -export function stringFromUtf16leLossy(v: ByteSlice): string { - return (fromUtf16Units(v.length >>> 1, byteUnit(v, false), true) as string) + (v.length % 2 === 1 ? "\ufffd" : ""); +/** `String::from_utf16le_lossy`, and U+FFFD pushed for an odd byte at the end. */ +export function stringFromUtf16leLossy(v: ByteSlice): RsString { + return oddByte(fromUtf16Lossy(v.length >>> 1, byteUnit(v, false)), v); +} + +/** `String::from_utf16be_lossy`, and U+FFFD pushed for an odd byte at the end. */ +export function stringFromUtf16beLossy(v: ByteSlice): RsString { + return oddByte(fromUtf16Lossy(v.length >>> 1, byteUnit(v, true)), v); } -/** `String::from_utf16be_lossy`, and U+FFFD for an odd byte at the end. */ -export function stringFromUtf16beLossy(v: ByteSlice): string { - return (fromUtf16Units(v.length >>> 1, byteUnit(v, true), true) as string) + (v.length % 2 === 1 ? "\ufffd" : ""); +/** `s`, and U+FFFD pushed if `v` has an odd byte at the end. */ +function oddByte(s: RsString, v: ByteSlice): RsString { + if (v.length % 2 === 1) stringPushStr(s, "�", 3 as usize); + return s; } /** `Debug` of `FromUtf16Error`. */ @@ -1382,23 +1574,7 @@ export function fmtFromUtf16ErrorDisplay(e: FromUtf16Error, f: Formatter): FmtRe return fmtPad(f, e.kind === "LoneSurrogate" ? "invalid utf-16: lone surrogate found" : "invalid utf-16: odd number of bytes"); } -/** `String::with_capacity`: the empty string, which keeps no capacity. */ -export function stringWithCapacity(capacity: usize): string { - if (capacity > ISIZE_MAX) panic("capacity overflow", "capacity"); - return ""; -} - -/** `String::reserve` and `reserve_exact`, which panic as std's do past `isize::MAX`. */ -export function stringReserve(s: string, additional: usize): void { - if (!stringTryReserve(s, additional).ok) panic("capacity overflow", "capacity"); -} - -/** `String::try_reserve` and `try_reserve_exact`: the error where `reserve` panics. */ -export function stringTryReserve(s: string, additional: usize): Result { - // A code unit is at most three bytes, so only a large `additional` needs the length. - const over = additional > ISIZE_MAX - 3 * s.length && additional > ISIZE_MAX - utf8Len(s, 0, s.length); - return over ? CAPACITY_OVERFLOW : OK; -} +// `String`'s edits, in place. /** The code unit where byte `i` of `s` starts a char, or panic with `message`. */ function boundary(s: string, i: number, message: string, at?: Location): number { @@ -1407,127 +1583,163 @@ function boundary(s: string, i: number, message: string, at?: Location): number return pos; } -/** `String::truncate`: `s` to `len` bytes, or as it is if no longer. */ -export function stringTruncate(s: string, len: usize, at?: Location): string { - const pos = unitAt(s, 0, 0, len); - if (pos >= 0) return s.slice(0, pos); - if (len > utf8Len(s, 0, s.length)) return s; - panic("assertion failed: self.is_char_boundary(new_len)", at); +/** `String::truncate`: to `len` bytes, unless already no longer. */ +export function stringTruncate(s: RsString, len: usize, at?: Location): void { + if (len > s.len) return; + s.v = s.v.slice(0, boundary(s.v, len, "assertion failed: self.is_char_boundary(new_len)", at)); + s.len = len; } -/** `String::insert_str`, and `insert` of a char's text. */ -export function stringInsertStr(s: string, i: usize, text: string, at?: Location): string { - const pos = boundary(s, i, "assertion failed: self.is_char_boundary(idx)", at); - return s.slice(0, pos) + text + s.slice(pos); +/** `String::insert_str`, and `insert` of a char's text: room for its bytes reserved. */ +export function stringInsertStr(s: RsString, i: usize, text: string, at?: Location): void { + const pos = boundary(s.v, i, "assertion failed: self.is_char_boundary(idx)", at); + const len = stringLen(text); + stringReserve(s, len); + s.v = s.v.slice(0, pos) + text + s.v.slice(pos); + s.len = (s.len + len) as usize; } /** `String::retain`: the chars `f` keeps, calling it on each in order. */ -export function stringRetain(s: string, f: (c: char) => boolean): string { +export function stringRetain(s: RsString, f: (c: char) => boolean): void { let kept = ""; - for (const ch of s) if (f(ch.codePointAt(0) as char)) kept += ch; - return kept; -} - -/** `String::replace_range`. */ -export function stringReplaceRange(s: string, r: Bounds, text: string, at?: Location): string { - const [start, end] = boundsRange(r, utf8Len(s, 0, s.length), at); - const from = boundary(s, start, "start of range should be a character boundary", at); - const to = boundary(s, end, "end of range should be a character boundary", at); - return s.slice(0, from) + text + s.slice(to); -} - -/** `String::extend_from_within`. */ -export function stringExtendFromWithin(s: string, r: Bounds, at?: Location): string { - const [start, end] = boundsRange(r, utf8Len(s, 0, s.length), at); - const from = boundary(s, start, "assertion failed: self.is_char_boundary(start)", at); - const to = boundary(s, end, "assertion failed: self.is_char_boundary(end)", at); - return s + s.slice(from, to); -} - -/** `String::pop`: the rest, and the last char if any. */ -export function stringPop(s: string): [string, char | undefined] { - if (s.length === 0) return [s, undefined]; - const pos = before(s, s.length); - return [s.slice(0, pos), s.codePointAt(pos) as char]; -} - -/** `String::remove`: the rest, and the char at byte `i`. */ -export function stringRemove(s: string, i: usize, at?: Location): [string, char] { - const pos = unitAt(s, 0, 0, i); - if (pos < 0) sliceFailed(s, i, utf8Len(s, 0, s.length), at); - if (pos === s.length) panic("cannot remove a char from the end of a string", at); - const c = s.codePointAt(pos) as number; - return [s.slice(0, pos) + s.slice(pos + (c > 0xffff ? 2 : 1)), c as char]; -} - -/** `String::split_off`: what comes before byte `i`, and after it. */ -export function stringSplitOff(s: string, i: usize, at?: Location): [string, string] { - const pos = boundary(s, i, "assertion failed: self.is_char_boundary(at)", at); - return [s.slice(0, pos), s.slice(pos)]; + for (const ch of s.v) if (f(ch.codePointAt(0) as char)) kept += ch; + s.v = kept; + s.len = stringLen(kept); +} + +/** `String::replace_range`: room reserved for what `text` adds. */ +export function stringReplaceRange(s: RsString, r: Bounds, text: string, at?: Location): void { + const [start, end] = boundsRange(r, s.len, at); + const from = boundary(s.v, start, "start of range should be a character boundary", at); + const to = boundary(s.v, end, "end of range should be a character boundary", at); + const len = stringLen(text); + if (len > end - start) stringReserve(s, (len - (end - start)) as usize); + s.v = s.v.slice(0, from) + text + s.v.slice(to); + s.len = (s.len - (end - start) + len) as usize; +} + +/** `String::extend_from_within`: room reserved for the bytes it copies. */ +export function stringExtendFromWithin(s: RsString, r: Bounds, at?: Location): void { + const [start, end] = boundsRange(r, s.len, at); + const from = boundary(s.v, start, "assertion failed: self.is_char_boundary(start)", at); + const to = boundary(s.v, end, "assertion failed: self.is_char_boundary(end)", at); + stringPushStr(s, s.v.slice(from, to), (end - start) as usize); +} + +/** `String::pop`: the last char, if any. */ +export function stringPop(s: RsString): char | undefined { + if (s.len === 0) return undefined; + const pos = before(s.v, s.v.length); + const c = s.v.codePointAt(pos) as char; + s.v = s.v.slice(0, pos); + s.len = (s.len - charLen(c)) as usize; + return c; +} + +/** `String::remove`: the char at byte `i`. */ +export function stringRemove(s: RsString, i: usize, at?: Location): char { + const pos = unitAt(s.v, 0, 0, i); + if (pos < 0) sliceFailed(s.v, i, s.len, at); + if (pos === s.v.length) panic("cannot remove a char from the end of a string", at); + const c = s.v.codePointAt(pos) as char; + s.v = s.v.slice(0, pos) + s.v.slice(pos + (c > 0xffff ? 2 : 1)); + s.len = (s.len - charLen(c)) as usize; + return c; +} + +/** `String::split_off`: what comes after byte `i`, with room for exactly its bytes. */ +export function stringSplitOff(s: RsString, i: usize, at?: Location): RsString { + const pos = boundary(s.v, i, "assertion failed: self.is_char_boundary(at)", at); + const len = (s.len - i) as usize; + const rest = new RsString(s.v.slice(pos), len, len); + s.v = s.v.slice(0, pos); + s.len = i; + return rest; } // `String` from and into iterators. Each reads the iterator by `for_each`, as std's does, // which `drops` makes its own `fold`. /** - * `Extend` and `Extend<&char>` of `s`, and `collect` of chars from `""`: `s` and each - * char, once it reserved the iterator's lower bound, which panics past `isize::MAX`. + * `Extend` and `Extend<&char>` of `s`, and `collect` of chars from `String::new`: each + * char pushed, once it reserved the iterator's lower bound. */ -export function stringExtendChars(s: string, it: Iter, drops = false): string { - stringReserve(s, it.sizeHint()[0]); - iterForEach( - it, - (c) => { - s += String.fromCodePoint(c); - }, - drops, - ); +export function stringExtendChars(s: RsString, it: Iter, drops = false): RsString { + stringReserve(s, it.sizeHint()[0] as usize); + iterForEach(it, (c) => stringPush(s, c), drops); return s; } /** `String` as a tuple's part, of chars, which reserves as `stringReserve`. */ -export const STRING_CHARS_PART: Part = { +export const STRING_CHARS_PART: Part = { reserve: stringReserve, - one: (s, c) => s + String.fromCodePoint(c), + one: (s, c) => (stringPush(s, c), s), }; /** `String` as a tuple's part, of strings, which never reserves. */ -export const STRING_PART: Part = { one: (s, text) => s + text }; +export const STRING_PART: Part = { one: (s, text) => (pushText(s, text), s) }; /** `String` as a tuple's part, of `Cow`s, which never reserves. */ -export const STRING_COW_PART: Part = { one: (s, c) => s + strCowStr(c) }; - -/** `Extend` of `s` by strings, `&str`, `String`, or `Cow`, and `collect` of `&str`s from `""`. */ -export function stringExtend(s: string, it: Iter, drops = false): string { - iterForEach( - it, - (text) => { - s += text; - }, - drops, - ); +export const STRING_COW_PART: Part = { one: (s, c) => (pushText(s, strCowText(c)), s) }; + +/** `push_str` of a `str` or a `String`'s text. */ +function pushText(s: RsString, text: string | RsString): void { + if (typeof text === "string") stringPushStr(s, text); + else stringPushStr(s, text.v, text.len); +} + +/** A `Cow`'s text, or the `String` it owns. */ +function strCowText(c: StrCow): string | RsString { + return c instanceof Borrowed ? c.slice : c; +} + +/** + * `Extend` of `s` by `&str`, `Box`, `String`, or `Cow`, each pushed, and `collect` + * of `&str`s and `Box`s from `String::new`. + */ +export function stringExtend(s: RsString, it: Iter, drops = false): RsString { + iterForEach(it, (text) => pushText(s, text instanceof Borrowed ? text.slice : text), drops); return s; } -/** `collect` of owned strings, a `String` or `Cow`: the first by `next`, then the rest extend it. */ -export function stringFromStrings(it: Iter, drops = false): string { +/** `Extend<&str>` of an array's strings, and `from_iter` of one: room reserved for all of them, then each pushed. */ +export function stringExtendArray(s: RsString, it: Iter): RsString { + const texts: string[] = []; + const lens: usize[] = []; + let len = 0; + iterForEach(it, (text) => { + const n = stringLen(text); + texts.push(text); + lens.push(n); + len += n; + }); + // std's sum saturates, so a reserve past `usize::MAX` panics as one of it does. + stringReserve(s, Math.min(len, 0xffffffff) as usize); + texts.forEach((text, i) => stringPushStr(s, text, lens[i])); + return s; +} + +/** + * `collect` of `String`s or `Cow`s: the first, owned, by `next`, which the rest extend, + * as std's keeps the first's room. + */ +export function stringFromStrings(it: Iter, drops = false): RsString { const first = it.next(); - if (first !== DONE) return stringExtend(first, it, drops); + if (first !== DONE) return stringExtend(first instanceof Borrowed ? stringFrom(first.slice) : first, it, drops); if (drops) dispose(it); - return ""; + return stringNew(); } /** - * `String::drain`: the chars within the byte range `r` of the string at `s`, which leaves - * the string without them as it drops, and as it was if it never does, as `mem::forget` - * leaves it. + * `String::drain`: the chars within the byte range `r` of `s`, which leaves `s` without them + * as it drops, and as it was if it never does, as `mem::forget` leaves it. */ -export function stringDrain(s: Place, r: Bounds, at?: Location): Iter { +export function stringDrain(s: RsString, r: Bounds, at?: Location): Iter { const text = s.v; - const [start, end] = boundsRange(r, utf8Len(text, 0, text.length), at); + const [start, end] = boundsRange(r, s.len, at); const from = boundary(text, start, "assertion failed: self.is_char_boundary(start)", at); const to = boundary(text, end, "assertion failed: self.is_char_boundary(end)", at); - return new StringDrain(s, text, from, to); + return new StringDrain(s, text, from, to, end - start); } /** `Drain::as_str`: the chars `drain` has yet to yield. */ @@ -1541,20 +1753,23 @@ export function fmtStringDrain(drain: Iter, f: Formatter): FmtResult { } class StringDrain extends Chars implements Disposable { - readonly #s: Place; + readonly #s: RsString; readonly #text: string; readonly #from: number; readonly #to: number; + readonly #bytes: number; - constructor(s: Place, text: string, from: number, to: number) { + constructor(s: RsString, text: string, from: number, to: number, bytes: number) { super(text.slice(from, to)); this.#s = s; this.#text = text; this.#from = from; this.#to = to; + this.#bytes = bytes; } [Symbol.dispose](): void { this.#s.v = this.#text.slice(0, this.#from) + this.#text.slice(this.#to); + this.#s.len = (this.#s.len - this.#bytes) as usize; } } diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index b70094fdb..8b032496b 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -150,7 +150,10 @@ pub fn call<'tcx>( { return Err(args); } + // A `String` against text of any form, as `eqStr` reads each. + let text = library::owned_string(tcx, t) || library::owned_string(tcx, peel(b, rhs)); let eq = match name { + _ if text => Expr::Rs("eqStr".into()), "eq" => eq_fn(b, t, span), _ => not_ne_fn(b, t, span), }; @@ -165,7 +168,10 @@ pub fn call<'tcx>( let by = library::targ(call.args, 1); // A `&mut` to a value JS copies is its `rs.Place`, which `borrow` reads. let held = mut_place(b, t).is_some_and(|inner| same_key(b, inner, by)); + let text = library::owned_string(tcx, peel(b, t)) && !library::owned_string(tcx, peel(b, by)); let value = match arc_of(b, peel(b, t)) { + // A `String`'s `str` is its text. + _ if text && same_key(b, t, by) => args.pop().map(|v| v.member("v")), _ if held || same_key(b, t, by) => args.pop().map(|value| match name { "borrow" if held => b.t.pointee_value(t, value), // Given the place of its receiver, which a `&mut` holds, but where it lends @@ -270,11 +276,12 @@ pub fn call<'tcx>( } } } - // A slice or an array finds an `rs.Vec` key, which the runtime reads alike, as its type. + // A slice or an array finds an `rs.Vec` key, and a `str` an `rs.String` or an + // `rs.StrCow` key, which the runtime reads alike, as its type. if let Some(by) = by && !matches!(name, "range" | "range_mut") && let Some(at) = args.get_mut(1) - && other_shape(b, arg(coll, 0), by) + && (other_shape(b, arg(coll, 0), by) || text_key(b, arg(coll, 0), by)) { let key = b.t.ty(arg(coll, 0), span); *at = as_type(std::mem::replace(at, Expr::undefined()), key); @@ -429,12 +436,21 @@ fn own_borrow<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool } /// Whether a key of type `by` is a JS value that hashes, compares, and orders as one of -/// type `key` does: the same type through references and boxes, or a string either way. +/// type `key` does: the same type through references and boxes, or text either way, a JS +/// string or an `rs.String`, which the runtime's string functions take both of. fn same_key<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { let tcx = b.t.tcx; let (key, by) = (peel(b, key), peel(b, by)); - tcx.erase_and_anonymize_regions(key) == tcx.erase_and_anonymize_regions(by) - || (library::string(tcx, key) && library::string(tcx, by)) + let text = |ty| library::string(tcx, ty) || library::owned_string(tcx, ty); + tcx.erase_and_anonymize_regions(key) == tcx.erase_and_anonymize_regions(by) || (text(key) && text(by)) +} + +/// Whether a key of type `by` is a JS string that finds a `key` that is a `String` or a +/// `Cow`, an object. +fn text_key<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { + let tcx = b.t.tcx; + let key = peel(b, key); + (library::owned_string(tcx, key) || library::cow_str(tcx, key)) && library::string(tcx, peel(b, by)) } /// Whether a key of type `by` is a slice or an array that finds a `key` that is a `Vec`, @@ -1109,10 +1125,14 @@ fn hashing<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, key: Ty<'tcx>, span b.t.err(span, format!("hashing by the hasher of `{coll}`")); return None; }; + // Text goes by itself, as a JS map key the engine hashes. + if library::owned_string(b.t.tcx, peeled) || library::cow_str(b.t.tcx, peeled) { + return Some(Some(Expr::Rs("HASH_TEXT".into()))); + } let mut values = vec![hash_fn(b, key, hasher, span), eq_fn(b, key, span)]; // A fieldless enum is a JS string, and a bound value may be any primitive, which its - // own `Eq` may tell apart where JS can't, and an owned `Cow` is a string its - // borrowed one equals, as is the `Some` of an `Option` of one, and a `Reverse`, a + // own `Eq` may tell apart where JS can't, and a `String` and an owned `Cow` are + // objects a `str` equals, as is the `Some` of an `Option` of one, and a `Reverse`, a // `Wrapping`, or a `Saturating` of one. let mut held = peeled; while let Some(inner) = option_of(b, held) @@ -1122,6 +1142,7 @@ fn hashing<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, key: Ty<'tcx>, span held = peel(b, inner); } if library::cow_str(b.t.tcx, held) + || library::owned_string(b.t.tcx, held) || matches!(held.kind(), ty::Adt(adt, _) if fieldless(*adt) || b.t.bound_drops(adt.did()).is_some()) { values.push(Expr::lit("true")); @@ -2497,7 +2518,7 @@ fn default<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Opti .then(|| b.fn_value(default, args, span).call(Vec::new())); }; Some(match std { - Std::String => Expr::Str(String::new()), + Std::String => Expr::rs("stringNew", Vec::new()), Std::Vec if super::byte(arg(coll, 0)) => Expr::New(Box::new(Expr::Rs("ByteVec".into())), Vec::new()), Std::Vec => library::vec_new(false), Std::VecDeque => deque_new(b, coll, span), @@ -2788,6 +2809,7 @@ fn std_key<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { ty::Adt(..) if b.t.std_of(ty).is_some_and(Std::record) => true, ty::Adt(..) => { library::string(b.t.tcx, ty) + || library::owned_string(b.t.tcx, ty) || matches!( b.t.std_of(ty), Some(Std::Ordering | Std::Duration | Std::Location | Std::TryReserveError) @@ -3035,7 +3057,7 @@ pub fn cmp_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, partial: bool, spa // `None` for a NaN: only `PartialOrd`, since a float is no `Ord`. _ if partial && let Some(float) = super::float::Float::of(ty) => Expr::rs_of(float.name(), "partialCmp"), ty::Str => Expr::Rs("cmpStr".into()), - ty::Adt(..) if library::string(tcx, ty) => Expr::Rs("cmpStr".into()), + ty::Adt(..) if library::string(tcx, ty) || library::owned_string(tcx, ty) => Expr::Rs("cmpStr".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rs("cmp".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationCmp".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rs("locationCmp".into()), @@ -3116,6 +3138,7 @@ pub fn eq_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr ty::Adt(..) if library::string(tcx, ty) || matches!(b.t.std_of(ty), Some(Std::Ordering | Std::ErrorKind)) => { Expr::Rs("same".into()) } + ty::Adt(..) if library::owned_string(tcx, ty) => Expr::Rs("eqStr".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationEq".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rs("locationEq".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::TryReserveError) => Expr::Rs("tryReserveErrorEq".into()), @@ -3133,6 +3156,8 @@ pub fn eq_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr eq => Expr::rs("eqOption", [eq].into_iter().chain(b.t.none_arg(inner)).collect()), }, ty::Adt(..) if let Some(inner) = reverse_of(b, ty).or_else(|| overflowing_of(b, ty)) => eq_fn(b, inner, span), + // An owned `Cow` derefs to its `rs.String`, which `eqStr` reads. + ty::Adt(..) if library::cow_str(tcx, ty) => Expr::Rs("eqStr".into()), ty::Adt(..) if let Some(borrowed) = cow_of(b, ty) => Expr::rs("cowBy", vec![eq_fn(b, borrowed, span)]), ty::Adt(..) if let Some(bound) = range_of(b, ty) => Expr::rs("rangeEq", vec![eq_fn(b, bound, span)]), // A slice compares its elements by `!=`, as a deque does each of its halves. @@ -3346,7 +3371,7 @@ fn hash_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, hasher: Ty<'tcx>, spa .into(), ), ty::Str => Expr::Rs("hashStr".into()), - ty::Adt(..) if library::string(tcx, ty) => Expr::Rs("hashStr".into()), + ty::Adt(..) if library::string(tcx, ty) || library::owned_string(tcx, ty) => Expr::Rs("hashStr".into()), // Its derived `Hash` writes its `i8` discriminant. ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rs("hashI8".into()), ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationHash".into()), diff --git a/ts/src/lower/dynamic.rs b/ts/src/lower/dynamic.rs index bfc60fb65..9be10fe01 100644 --- a/ts/src/lower/dynamic.rs +++ b/ts/src/lower/dynamic.rs @@ -514,6 +514,14 @@ impl<'tcx> Translator<'_, 'tcx> { return; }; let mut b = Body::new(self); + // What a `&mut` receiver points at, where std's mapping takes that, as a call's + // operands pass it. + let receiver = match b.t.mapped(method.def_id, args) + && super::pointer::pointees(b.t, method.def_id, args).first() == Some(&true) + { + true => b.t.pointee_value(sig.inputs()[0], receiver), + false => receiver, + }; let mut params = Vec::new(); let mut values = Vec::new(); for (i, input) in sig.inputs()[1..].iter().enumerate() { diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index 50e6b2ce6..e381a0a8c 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -204,12 +204,8 @@ impl<'tcx> Body<'_, '_, 'tcx> { if !matches!(std, Some(Std::String | Std::Formatter)) && !self.t.translated(write_str, wargs) { return None; } - // A JS string can't change in place, so the place the `&mut` is gets a longer one. if std == Some(Std::String) { - let read = receiver.member("v"); - let (value, result) = self.string_write(name, read.clone(), arg, literal, out); - out.push(StmtKind::Expr(read.assign(value)).at(None)); - return Some(result); + return Some(self.string_write(name, receiver, arg, literal, out)); } // The crate's impl writes this method itself. if self.t.translated(def_id, wargs) { @@ -263,27 +259,25 @@ impl<'tcx> Body<'_, '_, 'tcx> { Some(self.call_def(write_str, wargs, vec![receiver, text], span, out)) } - /// `fmt::Write`'s `name` of a `String` whose value `read` reads, writing `arg`, a - /// `fmt::Arguments` whose only piece is `literal` if it is one: the longer string and - /// what the call returns. What a placeholder wrote before an error stays written. + /// `fmt::Write`'s `name` of the `String` `s`, writing `arg`, a `fmt::Arguments` whose only + /// piece is `literal` if it is one, in place: what the call returns. What a placeholder + /// wrote before an error stays written. pub fn string_write( &mut self, name: &str, - read: Expr, + s: Expr, arg: Expr, literal: Option, out: &mut Vec, - ) -> (Expr, Expr) { - let ok = Expr::Rs("OK".into()); - match (name, literal) { - ("write_char", _) => (read.binary("+", library::char_text(arg)), ok), - ("write_fmt", Some(s)) => (read.binary("+", Expr::Str(s)), ok), - ("write_fmt", None) => { - let written = self.spill(Expr::rs("fmtWriteString", vec![read, arg]), "written", out); - (written.clone().member("s"), written.member("result")) - } - _ => (read.binary("+", arg), ok), - } + ) -> Expr { + let pushed = match (name, literal) { + ("write_char", _) => Expr::rs("stringPush", vec![s, arg]), + ("write_fmt", Some(text)) => Expr::rs("stringPushStr", vec![s, Expr::Str(text)]), + ("write_fmt", None) => return Expr::rs("fmtWriteString", vec![s, arg]), + _ => Expr::rs("stringPushStr", vec![s, arg]), + }; + out.push(StmtKind::Expr(pushed).at(None)); + Expr::Rs("OK".into()) } } @@ -480,8 +474,8 @@ pub fn std_impl<'tcx>( e } ty::Adt(adt, args) => match (Std::of(tcx, adt.did())?, tr) { - (Std::String, Trait::Display) => Expr::rs("fmtPad", vec![f, value]), - (Std::String, Trait::Debug) => rs("str", vec![value, f]), + (Std::String, Trait::Display) => Expr::rs("fmtPad", vec![f, value.member("v")]), + (Std::String, Trait::Debug) => rs("str", vec![value.member("v"), f]), // A `NonZero`, a `Wrapping`, and a `Saturating` write their integer, by each trait. (Std::Box | Std::NonZero | Std::Wrapping | Std::Saturating, _) => { b.fmt_call(tr, args.type_at(0), value, f, span) diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index c1b8d21c5..577f8368a 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -1119,6 +1119,14 @@ pub fn call<'tcx>( }; let iter = iter_of(b.t, source)?; let items = into_iter(b, source, value, span)?; + // Text of an array of `&str`s, which std's reserves for at once. + if str_array(source) && library::textual(b.t.tcx, targ(0)?) { + let s = Expr::rs("stringExtendArray", vec![Expr::rs("stringNew", vec![]), items]); + return Some(match b.t.std_of(targ(0)?) { + Some(Std::Box) => s.member("v"), + _ => s, + }); + } let trusted = implements(b.t, iter, "TrustedLen"); return collect(b, targ(0)?, targ(1)?, items, iter, trusted, span); } @@ -2198,18 +2206,21 @@ fn collect<'tcx>( } }) } - // From chars or text, as `extend` of an empty one, but for an owned string's, which - // the rest extend once `next` gives it. A `Cow` and a `Box` own the `String` - // std's collects. + // From chars or text, as `extend` of `String::new`, but for an owned string's, which + // the rest extend once `next` gives it. A `Cow` owns the `String` std's collects, + // and a `Box` is its text. Std::String | Std::Cow | Std::Box if std == Std::String || args.types().next().is_some_and(|t| t.is_str()) => { - match b.t.std_of(item) { + let s = match b.t.std_of(item) { Some(Std::String | Std::Cow) => { let drops = iter_drops(b, from, span); - let texts = texts(b.t, iter, item); - Some(Expr::rs("stringFromStrings", tail(vec![texts], vec![drops]))) + Expr::rs("stringFromStrings", tail(vec![iter], vec![drops])) } - _ => string_extend(b, Expr::Str(String::new()), iter, item, from, span), - } + _ => string_extend(b, Expr::rs("stringNew", vec![]), iter, item, from, span)?, + }; + Some(match std { + Std::Box => s.member("v"), + _ => s, + }) } _ => super::collections::collect(b, ty, iter, from, trusted, span), } @@ -2242,6 +2253,11 @@ fn shunt<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>, item: Ty<'tcx>, from: Ty< sig.inputs().first()?.tuple_fields().first().copied() } +/// Whether `ty` is an array of `&str`s, whose bytes `String`'s `Extend` reserves at once. +pub(super) fn str_array(ty: Ty<'_>) -> bool { + matches!(ty.kind(), ty::Array(elem, _) if elem.is_ref() && elem.peel_refs().is_str()) +} + /// `s` extended by `items`, an iterator of type `iter` of `item`s, as `String`'s `Extend` /// reads it, by `for_each`: of chars, through any `&`, or of text, a `&str`, `String`, /// `Box`, or `Cow`. @@ -2259,15 +2275,7 @@ pub(super) fn string_extend<'tcx>( "stringExtendChars" }; let drops = iter_drops(b, iter, span); - Some(Expr::rs(extend, tail(vec![s, texts(b.t, items, item)], vec![drops]))) -} - -/// `items`, an iterator of `item`s, as one of the strings they are: a `Cow`'s text. -fn texts<'tcx>(t: &Translator<'_, 'tcx>, items: Expr, item: Ty<'tcx>) -> Expr { - match library::cow_str(t.tcx, item.peel_refs()) { - true => Expr::rs("iterMap", vec![items, Expr::Rs("strCowStr".into())]), - false => items, - } + Some(Expr::rs(extend, tail(vec![s, items], vec![drops]))) } /// Whether a `String` extends by `item`s of text, a `&str`, `String`, `Box`, or diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index a6f9a1f03..cfc95d878 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -485,38 +485,45 @@ pub fn empty_default(tcx: TyCtxt<'_>, ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Adt(adt, _) if empty_iter(tcx, adt.did()) || list_iter(tcx, adt.did())) } -/// Whether a `ty`'s value is a JS string: a `str`, a `String`, or a `Box`. +/// Whether a `ty`'s value is a JS string: a `str` or a `Box`. pub fn string<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { match ty.kind() { ty::Str => true, - ty::Adt(adt, args) => match Std::of(tcx, adt.did()) { - Some(Std::String) => true, - Some(Std::Box) => args.type_at(0).is_str(), - _ => false, - }, + ty::Adt(adt, args) => Std::of(tcx, adt.did()) == Some(Std::Box) && args.type_at(0).is_str(), _ => false, } } +/// Whether `ty` is a `String`: an `rs.String`, whose text is its `v`. +pub fn owned_string<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { + matches!(ty.kind(), ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::String)) +} + /// Whether `ty` is a `Cow`: an `rs.StrCow`, the string it owns or the `rs.Borrowed` /// one it borrows. pub fn cow_str<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { cow_borrowed(tcx, ty).is_some_and(|t| t.is_str()) } -/// Whether `ty` is text: a JS string, or a `Cow`, which [`text`] reads as one. +/// Whether `ty` is text: a JS string, a `String`, or a `Cow`, which [`text`] reads as one. pub fn textual<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { - string(tcx, ty) || cow_str(tcx, ty) + string(tcx, ty) || owned_string(tcx, ty) || cow_str(tcx, ty) } -/// `value`, of type `ty`, as the JS string it is or, for a `Cow`, derefs to. +/// `value`, of type `ty`, as the JS string it is or, for a `String` or a `Cow`, derefs to. pub fn text<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, value: Expr) -> Expr { - match cow_str(tcx, ty) { - true => Expr::rs("strCowStr", vec![value]), - false => value, + match () { + _ if cow_str(tcx, ty) => Expr::rs("strCowStr", vec![value]), + _ if owned_string(tcx, ty) => value.member("v"), + _ => value, } } +/// A `String` of `text`, a JS string, with room for exactly its bytes, as `to_owned` makes one. +pub fn string_from(text: Expr) -> Expr { + Expr::rs("stringFrom", vec![text]) +} + /// What a value of `ty` is in JS if `ty` wraps one value it is represented as: `Reverse`'s, /// `NonZero`'s, `Wrapping`'s, `Saturating`'s, and `AssertUnwindSafe`'s `T`, which /// differ only in their order, range, arithmetic, and unwind safety, a pattern type's base, @@ -1567,35 +1574,37 @@ fn mapping<'tcx>( // `Some` or `Ready` of a value is the value. let some = matches!(to.kind(), ty::Adt(adt, args) if matches!(Std::of(tcx, adt.did()), Some(Std::Option | Std::Poll)) && args.type_at(0) == targ(gargs, 1)); - if to == from || some { + // `String::from(&String)` clones the `rs.String` object. + if (to == from && !targ(gargs, 1).is_ref()) || some { return Some(value); } - // One between strings keeps the text, and a `&mut str` is the `rs.Place` of its text. - if string(tcx, to) && string(tcx, from.peel_refs()) { - return Some(b.t.pointee_value(targ(gargs, 1), value)); - } - // A `Cow` borrows the text a reference does and owns a `String`, and gives up - // its text. - if cow_str(tcx, to) && string(tcx, from.peel_refs()) { - let owned = rustc_abi::VariantIdx::from_u32((!targ(gargs, 1).is_ref()).into()); - return Some(cow_made( - tcx.types.str_, - owned, - b.t.pointee_value(targ(gargs, 1), value), - )); - } - if string(tcx, to) && cow_str(tcx, from) { - return Some(text(tcx, from, value)); + // Text into text: a `&mut str` is the `rs.Place` of its text, as a `String` is. + let (raw, peeled) = (targ(gargs, 1), from); + if textual(tcx, to) && textual(tcx, peeled) { + let value = b.t.pointee_value(targ(gargs, 1), value); + return Some(match () { + // A `String` the `Cow` owns, or one it borrows, or a clone of one. + _ if owned_string(tcx, to) && cow_str(tcx, raw) => Expr::rs("strCowIntoOwned", vec![value]), + _ if owned_string(tcx, to) && owned_string(tcx, peeled) => Expr::rs("stringClone", vec![value]), + _ if owned_string(tcx, to) => string_from(text(tcx, peeled, value)), + // A `Cow` owns a `String` and borrows what a reference does. + _ if cow_str(tcx, to) && !raw.is_ref() && owned_string(tcx, raw) => { + cow_made(tcx.types.str_, rustc_abi::VariantIdx::from_u32(1), value) + } + _ if cow_str(tcx, to) => { + cow_made(tcx.types.str_, rustc_abi::FIRST_VARIANT, text(tcx, peeled, value)) + } + // A `Box` is its text, a `String`'s once it shrinks to fit. + _ => text(tcx, peeled, value), + }); } - // A `Vec` of a `String`'s or a `&str`'s UTF-8. - if b.t.std_of(to) == Some(Std::Vec) && string(tcx, from.peel_refs()) { - if !from.is_ref() { - b.t.string_bytes(); - } - return Some(Expr::rs( - "stringIntoBytes", - vec![b.t.pointee_value(targ(gargs, 1), value)], - )); + // A `Vec` of a `String`'s UTF-8, with its capacity, or of a `&str`'s. + if b.t.std_of(to) == Some(Std::Vec) && textual(tcx, peeled) { + let value = b.t.pointee_value(targ(gargs, 1), value); + return Some(match !raw.is_ref() && owned_string(tcx, raw) { + true => Expr::rs("stringIntoBytes", vec![value]), + false => Expr::rs("strToBytes", vec![text(tcx, peeled, value)]), + }); } // A `Vec` is owned, and a reference to a slice, an array, or a `Vec` borrows its slice. if let Some(elem) = cow_slice(tcx, to) { @@ -1852,6 +1861,7 @@ fn mapping<'tcx>( Expr::rs("byteVecFrom", vec![Expr::rs("byteVecView", vec![value])]) } ty::Adt(..) if string(tcx, ty) => value, + ty::Adt(..) if owned_string(tcx, ty) => Expr::rs("stringClone", vec![value]), ty::Adt(..) if cow_str(tcx, ty) => Expr::rs("strCowClone", vec![value]), ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) => { return Some(vec_clone(b, value.member("items"), args.type_at(0), span)); @@ -2689,6 +2699,8 @@ fn mapping<'tcx>( match ty.kind() { ty::Adt(adt, vargs) => match Std::of(tcx, adt.did()) { Some(Std::Vec) => vec_view(v, vargs.type_at(0)), + // A `String` is the place of its text, as a `&mut str` of it is. + Some(Std::String) if name == "deref" => v.member("v"), Some(Std::String | Std::Box | Std::ManuallyDrop | Std::AssertUnwindSafe) => v, Some(Std::Cow) if let Some(borrowed) = cow_borrowed(tcx, ty) => cow_deref(v, borrowed), // The greatest element of a heap, which `DerefMut` marks to sift once lent. @@ -2710,19 +2722,15 @@ fn mapping<'tcx>( // Strings. // A `Box`'s bytes are their own, as `as_bytes` gives them. - ("String" | "str", "as_bytes") | ("str", "into_boxed_bytes") => Expr::rs("stringAsBytes", args), + ("String", "as_bytes") => Expr::rs("stringAsBytes", vec![args.pop()?.member("v")]), + ("str", "as_bytes" | "into_boxed_bytes") => Expr::rs("stringAsBytes", args), ("String", "from_utf8") => Expr::rs("stringFromUtf8", args), - ("String", "into_bytes") => { - b.t.string_bytes(); - Expr::rs("stringIntoBytes", args) - } + // Its bytes, with its capacity, as the vector it is. + ("String", "into_bytes") => Expr::rs("stringIntoBytes", args), ("String", "from_utf8_lossy") => Expr::rs("stringFromUtf8Lossy", args), // UTF-8 by their contract, which the lossy decoder reads as the text. ("converts" | "str", "from_utf8_unchecked") => Expr::rs("strFromUtf8Unchecked", args), - ("String", "from_utf8_unchecked") => Expr::rs( - "strFromUtf8Unchecked", - vec![Expr::rs("byteVecSlice", vec![args.pop()?])], - ), + ("String", "from_utf8_unchecked") => Expr::rs("stringFromUtf8Unchecked", args), ("FromUtf8Error", "as_bytes") => Expr::rs("byteVecSlice", vec![args.pop()?.member("bytes")]), ("FromUtf8Error", "into_bytes") => args.pop()?.member("bytes"), ("FromUtf8Error", "utf8_error") => args.pop()?.member("error"), @@ -2737,15 +2745,16 @@ fn mapping<'tcx>( ("converts" | "str", "from_utf8") => Expr::rs("strFromUtf8", args), ("Utf8Error", "valid_up_to") => args.pop()?.member("validUpTo"), ("Utf8Error", "error_len") => args.pop()?.member("errorLen"), - ("String" | "str", "len") => Expr::rs("stringLen", args), - // A `Box` is its text, as a `String` is. - ("String", "as_str" | "into_boxed_str") | ("str", "into_string") => args.pop()?, - ("String", "new") => Expr::Str(String::new()), - // `String + &str`, which pushes onto the moved text as `+=` does. - ("Add", "add") if string(tcx, targ(gargs, 0)) => { - let text = args.pop()?; - args.pop()?.binary("+", text) - } + ("String", "len") => args.pop()?.member("len"), + ("String", "capacity") => args.pop()?.member("cap"), + ("str", "len") => Expr::rs("stringLen", args), + // A `Box` is its text, as a `String`'s is once it shrinks to fit, and a `String` + // of one has room for exactly its bytes. + ("String", "as_str" | "into_boxed_str") => args.pop()?.member("v"), + ("str", "into_string") => string_from(args.pop()?), + ("String", "new") => Expr::rs("stringNew", vec![]), + // `String + &str`, which pushes onto the moved `String` as `+=` does. + ("Add", "add") if owned_string(tcx, targ(gargs, 0)) => Expr::rs("stringAdd", args), ("Add", "add") if cow_str(tcx, targ(gargs, 0)) => { let rhs = str_cow(tcx, targ(gargs, 1), args.pop()?); Expr::rs("strCowAdd", vec![args.pop()?, rhs]) @@ -2759,7 +2768,7 @@ fn mapping<'tcx>( true => s, false => b.spill(s, "s", out), }; - let len = Expr::rs("stringLen", vec![s.clone().member("v")]); + let len = s.clone().member("len"); return Some(Expr::rs("stringDrain", vec![s, ranged.within(len)])); } ("Drain", "as_str") => Expr::rs("stringDrainAsStr", args), @@ -2770,7 +2779,8 @@ fn mapping<'tcx>( } // A `char`'s steps through its chars by `&mut`, which no body of std's may. ("str", "parse") | ("FromStr", "from_str") if targ(gargs, 0).is_char() => Expr::rs("charFromStr", args), - ("String" | "str", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), + ("String", "is_empty") => args.pop()?.member("len").binary("===", Expr::lit("0")), + ("str", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), ("str", "chars") => Expr::rs("strChars", args), ("str", "bytes") => Expr::rs("strBytes", args), ("str", "is_char_boundary") => Expr::rs("strIsCharBoundary", args), @@ -2786,12 +2796,18 @@ fn mapping<'tcx>( let [s, n, p] = <[Expr; 3]>::try_from(args).ok()?; Expr::rs_of("str", &name).call(vec![s, n, pattern(b.t, targ(gargs, 0), p)?]) } - // `replacen`'s count follows what replaces each match. + // `replacen`'s count follows what replaces each match. std's `replace` reserves by + // the pattern's length if it is a `char`, a `&str`, or a `&String`. ("str", "replace" | "replacen") => { + let p = targ(gargs, 0); let mut args = args.into_iter(); - let (s, p) = (args.next()?, args.next()?); - let rest = args.collect::>(); - Expr::rs("strReplace", [vec![s, pattern(b.t, targ(gargs, 0), p)?], rest].concat()) + let (s, pat) = (args.next()?, args.next()?); + let mut values = [vec![s, pattern(b.t, p, pat)?], args.collect()].concat(); + if name == "replace" { + let utf8 = p.is_char() || matches!(p.kind(), ty::Ref(_, t, _) if t.is_str() || owned_string(tcx, *t)); + values.push(Expr::lit(utf8.to_string())); + } + Expr::rs(if name == "replace" { "strReplace" } else { "strReplacen" }, values) } // Searches by whitespace, as std's are by `char::is_whitespace`. ("char", "is_whitespace") => Expr::rs("charIsWhitespace", args), @@ -2853,13 +2869,24 @@ fn mapping<'tcx>( ) | ("slice", "escape_ascii" | "make_ascii_uppercase" | "make_ascii_lowercase") => { let of = if owner == "slice" { "byteSlice" } else { "str" }; - Expr::rs_of(of, &super::camel(&name)).call(args) + let value = Expr::rs_of(of, &super::camel(&name)).call(args); + // A copy of the bytes, as `to_vec` makes it. + match (owner.as_str(), name.as_str()) { + ("str", "to_ascii_uppercase" | "to_ascii_lowercase") => string_from(value), + _ => value, + } } - // A `Cow`'s text, whichever variant holds it. - ("Cow", "into_owned") if targ(gargs, 0).is_str() => Expr::rs("strCowStr", args), - ("AsRef", "as_ref") if string(tcx, targ(gargs, 0)) && targ(gargs, 1).is_str() => args.pop()?, - ("AsRef", "as_ref") if string(tcx, targ(gargs, 0)) && byte_slice(targ(gargs, 1)) => { - Expr::rs("stringAsBytes", args) + // The `String` a `Cow` owns, or one of the text it borrows. + ("Cow", "into_owned") if targ(gargs, 0).is_str() => Expr::rs("strCowIntoOwned", args), + ("AsRef", "as_ref") + if textual(tcx, targ(gargs, 0)) && !cow_str(tcx, targ(gargs, 0)) && targ(gargs, 1).is_str() => + { + text(tcx, targ(gargs, 0), args.pop()?) + } + ("AsRef", "as_ref") + if (string(tcx, targ(gargs, 0)) || owned_string(tcx, targ(gargs, 0))) && byte_slice(targ(gargs, 1)) => + { + Expr::rs("stringAsBytes", vec![text(tcx, targ(gargs, 0), args.pop()?)]) } // A `Cow<[T]>` borrows its slice, and its `Vec` is its own or a clone of what it // borrows, so it drops nothing. @@ -2869,8 +2896,11 @@ fn mapping<'tcx>( ("AsRef", "as_ref") | ("Borrow", "borrow") if let Some(borrowed) = cow_borrowed(tcx, targ(gargs, 0)) => { cow_deref(args.pop()?, borrowed) } - ("ToString", "to_string") | ("ToOwned", "to_owned") if matches!(self_ty()?.peel_refs().kind(), ty::Str) => { - b.t.pointee_value(self_ty()?, args.pop()?) + // A `String` with room for exactly its bytes, as `str`'s `to_owned` makes it, and its + // `to_string`, through as many references as std's impls name. + ("ToOwned", "to_owned") if self_ty()?.is_str() => string_from(args.pop()?), + ("ToString", "to_string") if self_ty()?.peel_refs().is_str() && refs(self_ty()?) <= 12 => { + string_from(b.t.pointee_value(self_ty()?, args.pop()?)) } // std's `ToOwned` for a `T: Clone` is its `clone`. ("ToOwned", "to_owned") if self_ty()?.is_sized(tcx, b.t.typing_env_pub()) => { @@ -2898,8 +2928,13 @@ fn mapping<'tcx>( ) { (true, true) => { let at = b.panic_at.clone().unwrap_or_else(Expr::undefined); - Expr::rs("panic", vec![args.pop()?, at, Expr::lit(owned.to_string())]) + let text = args.pop()?; + match owned { + true => Expr::rs("panic", vec![text.clone().member("v"), at, text]), + false => Expr::rs("panic", vec![text, at]), + } } + (true, false) if owned => Expr::rs("panic", vec![args.pop()?.member("v")]), (true, false) => Expr::rs("panic", args), (false, true) => { let class = b.t.object_class( @@ -3047,10 +3082,11 @@ fn mapping<'tcx>( _ => Expr::rs("arrayFrom", vec![a]), } } + // Text alone is `to_owned`, as std's `as_str` gives it. ("fmt", "format") => { let parts = args.pop()?; match literal(&parts) { - Some(s) => Expr::Str(s), + Some(s) => string_from(Expr::Str(s)), None => Expr::rs("fmtFormat", vec![parts]), } } @@ -3080,16 +3116,37 @@ fn mapping<'tcx>( _ => return None, } } + // std's own for a `String` and a `Cow`, and for a `char`, a `bool`, and an + // unsigned integer, have room for exactly their bytes, and for a signed integer, for + // its most digits and a sign if it has one; `fmt::Arguments`' is `format`. Any other + // grows by what its `Display` writes. ("ToString", "to_string") => { let ty = targ(gargs, 0); let value = args.pop()?; - match ty.kind() { - ty::Adt(..) if textual(tcx, ty) => text(tcx, ty, value), - _ => { - let value = b.fmt_value(fmt::Trait::Display, ty, value, span, out); - Expr::rs("fmtToString", vec![value]) + let size = match ty.kind() { + ty::Adt(..) if textual(tcx, ty) && !string(tcx, ty) => return Some(string_from(text(tcx, ty, value))), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Arguments) => { + return Some(Expr::rs("fmtFormat", vec![value])); } - } + ty::Char | ty::Bool | ty::Uint(_) => Some(0), + ty::Int(int) => Some(match int.bit_width().unwrap_or(32) { + 8 => 3, + 16 => 5, + 32 => 10, + 64 => 19, + _ => 39, + }), + _ => None, + }; + let value = b.fmt_value(fmt::Trait::Display, ty, value, span, out); + Expr::rs( + "fmtToString", + [ + vec![value], + size.map(|n: u32| Expr::lit(n.to_string())).into_iter().collect(), + ] + .concat(), + ) } // `fmt::Write`'s, of a `String`, a `Formatter`, or the crate's own writer. ("Write", "write_str" | "write_char" | "write_fmt") @@ -3303,6 +3360,13 @@ fn std_clone_from<'tcx>( format!("`clone_from` of `{ty}`, whose `clone_from` is its own, which is not supported yet"), ) }; + // A `String`'s bytes clone into its buffer, as an owned `Cow`'s do over an owned one's. + if owned_string(b.t.tcx, own) { + return Ok(("stringCloneFrom", vec![])); + } + if cow_str(b.t.tcx, own) { + return Ok(("strCowCloneFrom", vec![])); + } // A `Cow<[T]>`'s: an owned one's `Vec` clones into itself over an owned one's. if let Some(elem) = cow_slice(b.t.tcx, own) { return Ok(match elem.kind() { @@ -3404,10 +3468,12 @@ pub(super) fn clone_from_clones<'tcx>(t: &mut Translator<'_, 'tcx>, ty: Ty<'tcx> } let inner: Vec> = match (t.std_of(ty), ty.kind()) { (Some(Std::Vec | Std::VecDeque | Std::BinaryHeap), _) => return false, - // A hash table's and a B-tree set's clone each element anew, by its `clone`. Text is - // a JS string, which keeps no buffer. + // A hash table's and a B-tree set's clone each element anew, by its `clone`. A `String` + // keeps its buffer, as an owned `Cow`'s does, and a `Box` is a JS string. (Some(Std::HashMap | Std::HashSet | Std::HashTable | Std::BTreeSet), _) => vec![], - _ if textual(tcx, ty) => vec![], + (Some(Std::String), _) => return false, + _ if cow_str(tcx, ty) => return false, + _ if string(tcx, ty) => vec![], (_, ty::Adt(adt, args)) if is_std(tcx, adt.did()) => args.types().collect(), (_, ty::Array(elem, _)) => vec![*elem], _ => return false, @@ -3591,7 +3657,10 @@ fn pattern<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>, p: Expr) -> Option { Some(p) } - ty::Ref(..) if is_text(t, ty) => Some(p), + ty::Ref(..) if is_text(t, ty) => Some(match owned_string(t.tcx, ty.peel_refs()) { + true => p.member("v"), + false => p, + }), // Any of the chars of an array or slice. ty::Array(c, _) | ty::Slice(c) if c.is_char() => Some(Expr::rs("patternChars", vec![elements(p, ty)])), ty::Ref(_, inner, _) if matches!(inner.kind(), ty::Array(c, _) | ty::Slice(c) if c.is_char()) => { @@ -3637,6 +3706,16 @@ pub fn char_text(c: Expr) -> Expr { Expr::ident("String").member("fromCodePoint").call(vec![c]) } +/// How many references `ty` is through. +fn refs(mut ty: Ty<'_>) -> usize { + let mut n = 0; + while let ty::Ref(_, inner, _) = ty.kind() { + ty = *inner; + n += 1; + } + n +} + /// `rs.(args)`. fn rt2(args: Vec, of: &str, name: &str) -> Expr { Expr::rs_of(of, name).call(args) @@ -4118,9 +4197,9 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span, ty::Adt(adt, args) => match Std::of(tcx, adt.did())? { Std::Option => b.t.none(args.type_at(0)), Std::Vec => vec_new(byte(args.type_at(0))), - Std::String => Expr::Str(String::new()), + Std::String => Expr::rs("stringNew", vec![]), // An owned empty `String` or `Vec`. - Std::Cow if cow_str(tcx, ty) => Expr::Str(String::new()), + Std::Cow if cow_str(tcx, ty) => Expr::rs("stringNew", vec![]), Std::Cow if let Some(elem) = cow_slice(tcx, ty) => vec_new(byte(elem)), Std::Duration => super::time::zero(), Std::Atomic => Expr::New( diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index b32ff4e28..4da8a6602 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -720,20 +720,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ); done(next, true) } - // A JS string can't change in place, so what the `&mut` borrows gets a new one. + // A `String` is an object, which each of its own steps edits in place. ("String", "push" | "push_str") | ("AddAssign", "add_assign") if owner == "String" - || (targ(0).is_some_and(|t| library::string(tcx, t)) && !self.b.t.translated(def_id, gargs)) => + || (targ(0).is_some_and(|t| library::owned_string(tcx, t)) + && !self.b.t.translated(def_id, gargs)) => { - let place = self.borrowed_place(&args[0].node, span, out)?; - let text = self.operand(&args[1].node, span, out); - let text = match name.as_str() { - "push" => library::char_text(text), - _ => text, - }; - let pushed = place.0.clone().binary("+", text); - self.set_borrowed(&place, pushed, span, out); - done(Expr::undefined(), false) + let values = self.operands(false, &[], args, tcx.types.unit, span, out); + let f = if name == "push" { "stringPush" } else { "stringPushStr" }; + done(Expr::rs(f, values), true) } ("AddAssign", "add_assign") if targ(0).is_some_and(|t| library::cow_str(tcx, t)) && !self.b.t.translated(def_id, gargs) => @@ -746,7 +741,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { done(Expr::undefined(), false) } // What the `&mut` borrows gets the value of the other case, as a byte, a char, and a - // JS string can't change in place. + // JS string can't change in place, and the case of ASCII keeps its length. ("u8" | "char" | "str", "make_ascii_uppercase" | "make_ascii_lowercase") => { let place = self.borrowed_place(&args[0].node, span, out)?; let to = crate::lower::camel(&name.replacen("make", "to", 1)); @@ -758,37 +753,39 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.set_borrowed(&place, changed, span, out); done(Expr::undefined(), false) } - // The extended string, from the iterator read as std's `Extend` reads it. + // The string extended, by the iterator read as std's `Extend` reads it. ("Extend", "extend") if targ(0).is_some_and(|t| self.b.t.std_of(t) == Some(Std::String)) => { let (item, source) = (targ(1)?, targ(2)?); - let place = self.borrowed_place(&args[0].node, span, out)?; + let s = self.operand(&args[0].node, span, out); let items = self.operand(&args[1].node, span, out); let iter = crate::lower::iter::iter_of(self.b.t, source)?; let items = crate::lower::iter::into_iter(self.b, source, items, span)?; - let extended = crate::lower::iter::string_extend(self.b, place.0.clone(), items, item, iter, span)?; - self.set_borrowed(&place, extended, span, out); - done(Expr::undefined(), false) + if crate::lower::iter::str_array(source) { + return done(Expr::rs("stringExtendArray", vec![s, items]), true); + } + done( + crate::lower::iter::string_extend(self.b, s, items, item, iter, span)?, + true, + ) } - // No capacity is kept, and reading one is refused, but reserving past `isize::MAX` - // panics as std's does. - ("String", "reserve" | "reserve_exact") => { - let values = self.operands(false, &[true, true], args, tcx.types.unit, span, out); - done(Expr::rs("stringReserve", values), true) + ("String", "reserve" | "reserve_exact" | "try_reserve" | "try_reserve_exact") => { + let values = self.operands(false, &[], args, tcx.types.unit, span, out); + done(Expr::rs_of("string", &crate::lower::camel(&name)).call(values), true) } - // The error where `reserve` panics. - ("String", "try_reserve" | "try_reserve_exact") => { - let values = self.operands(false, &[true, true], args, tcx.types.unit, span, out); - done(Expr::rs("stringTryReserve", values), false) + ("String", "shrink_to_fit" | "shrink_to") => { + let mut values = self.operands(false, &[], args, tcx.types.unit, span, out); + if name == "shrink_to_fit" { + values.push(Expr::lit("0")); + } + done(Expr::rs("stringShrinkTo", values), true) } - ("String", "shrink_to_fit" | "shrink_to") => done(Expr::undefined(), false), - // The edited string, from the runtime with what it takes after the string. + // The string edited in place, by the runtime with what it takes after the string. ( "String", "clear" | "truncate" | "insert" | "insert_str" | "retain" | "replace_range" | "extend_from_within", ) => { - let place = self.borrowed_place(&args[0].node, span, out)?; let result = dest.ty(&self.mir.local_decls, tcx).ty; - let mut values = vec![place.0.clone()]; + let mut values = vec![self.operand(&args[0].node, span, out)]; values.extend(self.operands(false, &[], &args[1..], result, span, out)); if name == "insert" { let c = values.pop()?; @@ -814,35 +811,31 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { span, }; let range = std::mem::replace(&mut values[1], Expr::undefined()); - let len = Expr::rs("stringLen", vec![values[0].clone()]); + let len = values[0].clone().member("len"); values[1] = crate::lower::collections::bounds(self.b, &call, range).within(len); } - let edited = match name.as_str() { - "clear" => Expr::Str(String::new()), - "truncate" => Expr::rs("stringTruncate", values), - "insert" | "insert_str" => Expr::rs("stringInsertStr", values), - "retain" => Expr::rs("stringRetain", values), - "replace_range" => Expr::rs("stringReplaceRange", values), - _ => Expr::rs("stringExtendFromWithin", values), + let f = match name.as_str() { + "clear" => "stringClear", + "truncate" => "stringTruncate", + "insert" | "insert_str" => "stringInsertStr", + "retain" => "stringRetain", + "replace_range" => "stringReplaceRange", + _ => "stringExtendFromWithin", }; - self.set_borrowed(&place, edited, span, out); + out.push(StmtKind::Expr(Expr::rs(f, values)).at(None)); out.extend(spent.map(|drop| StmtKind::Expr(drop).at(None))); done(Expr::undefined(), false) } - // The runtime gives the edited string and what the edit returns. ("String", "pop" | "remove" | "split_off") => { - let place = self.borrowed_place(&args[0].node, span, out)?; let result = dest.ty(&self.mir.local_decls, tcx).ty; - let mut values = vec![place.0.clone()]; + let mut values = vec![self.operand(&args[0].node, span, out)]; values.extend(self.operands(false, &[], &args[1..], result, span, out)); let f = match name.as_str() { "pop" => "stringPop", "remove" => "stringRemove", _ => "stringSplitOff", }; - let edit = self.path(Expr::rs(f, values), "edit", out); - self.set_borrowed(&place, edit.clone().index(Expr::lit("0")), span, out); - done(edit.index(Expr::lit("1")), false) + done(Expr::rs(f, values), true) } ("Write", "write_str" | "write_char" | "write_fmt") if tcx @@ -873,16 +866,25 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.set_borrowed(&place, value, span, out); done(Expr::undefined(), false) } - // A borrowed `Cow` owns its text first, the `String` it then is, and a `String` - // is its `str`, so the `&mut` borrows the same place. + // A borrowed `Cow` owns its text first, and the `&mut` is the `String` it then is. ("Cow", "to_mut") if targ(0).is_some_and(|t| t.is_str()) => { let place = self.borrowed_place(&args[0].node, span, out)?; - self.set_borrowed(&place, Expr::rs("strCowStr", vec![place.0.clone()]), span, out); - self.same_place(args, dest, span, out) + self.set_borrowed(&place, Expr::rs("strCowIntoOwned", vec![place.0.clone()]), span, out); + done( + Expr::As(Box::new(place.0), crate::ts::Type::Rs("String", Vec::new())), + false, + ) + } + // A `String` is the place of its `str`. + ("String", "as_mut_str" | "leak") => done(self.operand(&args[0].node, span, out), false), + ("DerefMut", "deref_mut") | ("AsMut", "as_mut") | ("BorrowMut", "borrow_mut") + if targ(0).is_some_and(|t| self.b.t.std_of(t) == Some(Std::String)) + && dest.ty(&self.mir.local_decls, tcx).ty.peel_refs().is_str() => + { + done(self.operand(&args[0].node, span, out), false) } - ("String", "as_mut_str") => self.same_place(args, dest, span, out), ("DerefMut", "deref_mut") | ("AsMut", "as_mut") | ("BorrowMut", "borrow_mut") - if targ(0).is_some_and(|t| t.is_str() || self.b.t.std_of(t) == Some(Std::String)) + if targ(0).is_some_and(|t| t.is_str()) && dest.ty(&self.mir.local_decls, tcx).ty.peel_refs().is_str() => { self.same_place(args, dest, span, out) @@ -896,11 +898,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { self.same_place(args, dest, span, out) } - // A place nothing else holds: the `String` leaked, or `Default`'s empty `str`. - ("String", "leak") => { - let leaked = self.operand(&args[0].node, span, out); - done(Expr::Object(vec![(crate::ts::Key::Name("v".into()), leaked)]), true) - } + // A place nothing else holds: `Default`'s empty `str`. ("Default", "default") if targ(0) .and_then(|t| self.b.t.place_pointee(t)) @@ -1525,16 +1523,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => None, }; if std == Some(Std::String) { - let place = match through { - Some(value) => (self.path(value, "w", out).member("v"), None), - None => self.borrowed_place(&args[0].node, span, out)?, + let s = match through { + Some(value) => value, + None => self.operand(&args[0].node, span, out), }; let [arg] = <[Expr; 1]>::try_from(self.operands(true, &[], &args[1..], result, span, out)).ok()?; let mut written = Vec::new(); - let (value, result) = self.b.string_write(name, place.0.clone(), arg, literal, &mut written); + let result = self.b.string_write(name, s, arg, literal, &mut written); self.emit(written, false, out); - self.set_borrowed(&place, value, span, out); - return done(result, false); + return done(result, true); } let receiver = match through { Some(value) => value, @@ -1864,6 +1861,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if container.is_str() || self.b.t.std_of(container) == Some(Std::String) { let get = matches!(name, "get" | "get_mut"); let base = self.operand(&args[0].node, span, out); + // A `String` is the place of its text. + let base = match self.b.t.std_of(container) == Some(Std::String) && !matches!(name, "index_mut" | "get_mut") + { + true => base.member("v"), + false => base, + }; let (base, (start, end)) = match self.range_bounds(&args[1].node, index_ty, span, out) { Some(bounds) if get => (base, bounds), Some(bounds) => (self.path(base, "s", out), bounds), diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index f93619b65..03fc45246 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -659,7 +659,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let bytes = crate::lower::library::cow_slice(tcx, ty).is_some_and(crate::lower::byte); let owned = variant.is_some_and(|v| v.index() == 1); // What an `rs.Borrowed` holds, and what it owns: an `rs.Slice` and an - // `rs.Vec`, or text. + // `rs.Vec`, or text and an `rs.String`. let (held, owns) = match borrowed.kind() { ty::Slice(elem) => { let elem = self.b.t.ty(*elem, span); @@ -668,7 +668,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { crate::ts::Type::Rs("Vec", vec![elem]), ) } - _ => (crate::ts::Type::Builtin("string"), crate::ts::Type::Builtin("string")), + _ => ( + crate::ts::Type::Builtin("string"), + crate::ts::Type::Rs("String", Vec::new()), + ), }; let class = match (bytes, owned) { (true, false) => crate::ts::Type::Rs("ByteSlice", Vec::new()), diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index 92ad829a0..36c889962 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -214,11 +214,6 @@ pub struct Translator<'a, 'tcx> { census: bool, /// Refusals collected until translation settles, then reported or counted. refusals: Option>, - /// Reads of a `Bytes`' capacity, refused once translation settles if `string_bytes`, as - /// [`Self::string_capacity`] notes them. - capacity_reads: Vec<(Span, String)>, - /// Whether a crate makes a `Bytes` or a `Vec` of a `String`'s bytes, whose capacity JS keeps none of. - string_bytes: bool, /// Whether each type's drop does something JS can see, as [`Self::drops`] found. drops: rustc_data_structures::fx::FxHashMap, bool>, /// The types [`Self::drops`] is still deciding, and whether the query open now read one. @@ -446,7 +441,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { && t.comparing.is_subset(&t.compared) && (t.hooked || !t.hooking) { - t.refuse_capacity_reads(); return Some((t, out)); } read = std::mem::take(&mut t.read); @@ -505,8 +499,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { defining: None, census, refusals: Some(Vec::new()), - capacity_reads: Vec::new(), - string_bytes: false, drops: Default::default(), drops_open: Default::default(), drops_cycle: false, @@ -662,32 +654,6 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// Note a `Bytes` or a `Vec` made of a `String`'s bytes, whose capacity JS keeps none - /// of, so every crate is refused what [`Self::string_capacity`] notes: the bytes may - /// reach any of them. - pub fn string_bytes(&mut self) { - self.string_bytes = true; - } - - /// Note `what`, which reads the capacity of a `Bytes`' storage, refused once translation - /// settles if any crate makes a `Bytes` or a `Vec` of a `String`'s bytes. - pub fn string_capacity(&mut self, span: Span, what: &str) { - let msg = format!( - "`{what}` in a program that makes bytes of a String, whose capacity JS keeps none of, which is not supported" - ); - let read = self.sited(span, msg); - self.capacity_reads.push(read); - } - - fn refuse_capacity_reads(&mut self) { - let reads = std::mem::take(&mut self.capacity_reads); - if self.string_bytes { - for (span, msg) in reads { - self.refuse(span, msg); - } - } - } - fn refuse(&mut self, span: Span, msg: String) { self.failed = true; match &mut self.refusals { @@ -1342,6 +1308,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Adt(..) if let Some(slice) = stock::uninit_slice(self.tcx, ty) => self.object_kind(slice), ty::Adt(adt, args) => match library::Std::of(self.tcx, adt.did()) { Some(library::Std::Vec) => Some(ObjectKind::Vec), + // Its text, length, and capacity, edited in place. + Some(library::Std::String) => Some(ObjectKind::Class), Some( library::Std::Formatter | library::Std::DebugStruct @@ -1707,7 +1675,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { true => Type::Rs("ByteVec", vec![]), false => Type::Rs("Vec", vec![self.ty(args.type_at(0), span)]), }, - library::Std::String => Type::Builtin("string"), + library::Std::String => Type::Rs("String", vec![]), library::Std::Cow if library::cow_str(tcx, Ty::new_adt(tcx, adt, args)) => Type::Rs("StrCow", vec![]), library::Std::Cow if let Some(elem) = library::cow_slice(tcx, Ty::new_adt(tcx, adt, args)) => { match elem.kind() { diff --git a/ts/src/lower/stock.rs b/ts/src/lower/stock.rs index 5829ee101..1ea39dbf3 100644 --- a/ts/src/lower/stock.rs +++ b/ts/src/lower/stock.rs @@ -11,7 +11,7 @@ use rustc_hir::def_id::{CrateNum, DefId}; use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeVisitableExt}; use super::body::Body; -use super::library::{self, Call, Std, key, string, targ}; +use super::library::{self, Call, Std, key, owned_string, string, targ}; use super::num::Int; use crate::ts::{Expr, Stmt, StmtKind}; @@ -341,6 +341,7 @@ fn as_slice<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr) -> Option value, ty::Array(e, _) if is_u8(*e) => Expr::rs("byteSliceFrom", vec![value]), _ if string(b.t.tcx, ty) => Expr::rs("stringAsBytes", vec![value]), + _ if owned_string(b.t.tcx, ty) => Expr::rs("stringAsBytes", vec![value.member("v")]), _ => match b.t.std_of(ty)? { Std::Bytes => value, Std::BytesMut => view(value), @@ -364,11 +365,9 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> let f = match (b.t.std_of(to), b.t.std_of(from)) { (Some(Std::Bytes), Some(Std::BytesMut)) => "bytesMutFreeze", (Some(Std::Bytes), _) if byte_vec(from) => "bytesFromVec", - // A `&'static str`'s bytes are static. A `String`'s are a vector whose capacity is - // their length, as JS keeps none of the `String`'s, so the program's reads of one are refused. + // A `&'static str`'s bytes are static, and a `String`'s are its vector, with its capacity. (Some(Std::Bytes), _) if from.is_ref() && string(tcx, from.peel_refs()) => "stringAsBytes", - (Some(Std::Bytes), _) if string(tcx, from) => { - b.t.string_bytes(); + (Some(Std::Bytes), _) if owned_string(tcx, from) => { let bytes = Expr::rs("stringIntoBytes", args.collect()); return Ok(Some(Expr::rs("bytesFromVec", vec![bytes]))); } @@ -377,18 +376,12 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> (Some(Std::BytesMut), _) => { let bytes = match as_slice(b, from.peel_refs(), args.next().expect("an operand")) { Some(bytes) if from.is_ref() => Expr::rs("bytesMutFrom", vec![bytes]), - Some(bytes) if b.t.std_of(from) == Some(Std::Bytes) => { - b.t.string_capacity(call.span, "BytesMut::from(Bytes)"); - Expr::rs("bytesMutFromBytes", vec![bytes]) - } + Some(bytes) if b.t.std_of(from) == Some(Std::Bytes) => Expr::rs("bytesMutFromBytes", vec![bytes]), _ => return Ok(None), }; return Ok(Some(bytes)); } - (_, Some(Std::Bytes)) if byte_vec(to) => { - b.t.string_capacity(call.span, "Vec::from(Bytes)"); - "bytesToByteVec" - } + (_, Some(Std::Bytes)) if byte_vec(to) => "bytesToByteVec", (_, Some(Std::BytesMut)) if byte_vec(to) => "bytesMutToByteVec", (_, Some(Std::Bytes | Std::BytesMut)) => return Ok(None), _ => return Err(args.collect()), @@ -448,10 +441,6 @@ fn bytes_own<'tcx>( out: &mut Vec, ) -> Option { let tcx = b.t.tcx; - // Whether the storage is unique, and whether truncating gives it up, hinge on its capacity. - if matches!(name, "is_unique" | "try_into_mut" | "truncate" | "clear") { - b.t.string_capacity(call.span, &format!("Bytes::{name}")); - } let mut args = args.into_iter(); Some(match name { "new" => Expr::rs("bytesNew", vec![]), @@ -703,15 +692,6 @@ fn put<'tcx>( // Into a `BytesMut` of no capacity, `bytes` copies it out whole and drops it, then takes // the copy's storage if no other handle holds it, so the runtime drops it there. if buffer == Buffer::BytesMut && !through { - // `bytes`' own puts fill a `BytesMut::with_capacity` of what they put, never one of no capacity. - let file = tcx - .sess - .source_map() - .lookup_source_file(call.span.source_callsite().lo()); - let own = tcx.crate_name(file.cnum).as_str() == "bytes"; - if !own && !matches!(source, Some(Buffer::BytesMut | Buffer::Slice)) { - b.t.string_capacity(call.span, "BufMut::put"); - } let f = match source { Some(Buffer::Bytes) => "bytesMutPutStorage", Some(Buffer::BytesMut) => "bytesMutPutMut", diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index bbc881451..6a2663d74 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -625,7 +625,7 @@ import * as closures from "./closures.ts"; import {{ harness }} from {harness:?}; export {{ cases, input, ops }} from {harness:?}; -const fixture = {{ Pending: rs.Pending, u64: {{ of: rs.u64Of }}, Log, Channel, Guard, sum, drain, blocks, watch, front, drops, futures, closures }}; +const fixture = {{ Pending: rs.Pending, u64: {{ of: rs.u64Of }}, string: rs.stringFrom, Log, Channel, Guard, sum, drain, blocks, watch, front, drops, futures, closures }}; const script = harness(fixture); export const run = (input: rs.ByteSlice) => script(rs.byteSliceView(input)); "# @@ -813,19 +813,18 @@ fn bind() { /// A package and its dependency translate as one program, trait objects of the /// dependency's trait and its safe twin of its `unsafe` included, and run as native Rust /// does. Its `unsafe` that nothing binds is refused at its span, and so are a module of -/// the package's that would share the dependency's files, two instances whose suffixes -/// are alike, and the package's read of the capacity of the dependency's `String` bytes. +/// the package's that would share the dependency's files, and two instances whose +/// suffixes are alike. #[test] fn crates() { let out = translated("crates"); snapshot("crates", &out); typecheck(&out); differential(&workspace(), "crates-fixture", &[], &out, "harness.ts", 1_000); - let cases: [(&str, &str, &[&str]); 4] = [ + let cases: [(&str, &str, &[&str]); 3] = [ ("refused", "refused.toml", &[]), ("shared", "ts.toml", &["--", "--features", "shared"]), ("alike", "alike.toml", &["--", "--features", "alike"]), - ("strings", "strings.toml", &[]), ]; for (case, config, cargo) in cases { let out = scratch().join("crates").join(case); diff --git a/ts/tests/reserve.ts b/ts/tests/reserve.ts index 2199a041b..a3c6494a4 100644 --- a/ts/tests/reserve.ts +++ b/ts/tests/reserve.ts @@ -19,8 +19,8 @@ globalThis.Uint8Array = class extends Native { } } as Uint8ArrayConstructor; -const debug = (e: rs.TryReserveError, spec: rs.Spec = {}) => rs.fmtToString(rs.fmtSpec(spec, (f) => rs.fmtTryReserveErrorDebug(e, f))); -const display = (e: rs.TryReserveError) => rs.fmtToString((f) => rs.fmtTryReserveErrorDisplay(e, f)); +const debug = (e: rs.TryReserveError, spec: rs.Spec = {}) => rs.fmtToString(rs.fmtSpec(spec, (f) => rs.fmtTryReserveErrorDebug(e, f))).v; +const display = (e: rs.TryReserveError) => rs.fmtToString((f) => rs.fmtTryReserveErrorDisplay(e, f)).v; const failed = (r: rs.Result, size: number): rs.TryReserveError => { assert.ok(!r.ok); assert.deepEqual(r.error.layout, { size, align: 1 }); diff --git a/ts/tests/task.ts b/ts/tests/task.ts index 8a6dfae91..2379fc38a 100644 --- a/ts/tests/task.ts +++ b/ts/tests/task.ts @@ -24,15 +24,16 @@ export type Bytes = { data: Uint8Array; length: number }; type Channel = Disposable; /** - * What the harness drives: the translation's roots, and the runtime's `Pending` and - * `u64`, whose values are `V`. + * What the harness drives: the translation's roots, and the runtime's `Pending`, `u64`, + * whose values are `V`, and `String`, whose values are `S`. */ -export interface Fixture { +export interface Fixture { Pending: symbol; u64: { of(value: number): V }; + string(text: string): S; Log: { "new"(): Log; - note(log: Log, event: string): void; + note(log: Log, event: S): void; text(log: Log): Bytes; clone$Clone(log: Log): Log; }; @@ -202,7 +203,7 @@ class Executor { /** What a step acts on: one script's fixture, log, executor, and channels. */ interface Run { - f: Fixture; + f: Fixture; log: Log; note: (event: string) => void; exec: Executor; @@ -358,10 +359,10 @@ const steps: [string, (r: Run, arg: number) => void][] = [ ]; /** The script runner, as `harness.rs` runs it natively. */ -export function harness(f: Fixture): (input: Uint8Array) => Bytes { +export function harness(f: Fixture): (input: Uint8Array) => Bytes { return (input) => { const log = f.Log.new(); - const note = (event: string) => f.Log.note(log, event); + const note = (event: string) => f.Log.note(log, f.string(event)); const exec = new Executor(note, f.Pending); const r: Run = { f, log, note, exec, channels: [] }; for (let i = 0; i < input.length; i += 2) {