std/string

Iterator yielding Unicode codepoints: one per UTF-8 sequence, regardless of whether the codepoint is encoded in 1, 2, 3, or 4 bytes. The cursor moves in bytes over the string itself.

Error raised by parse_int on malformed input. Also the canonical parse-error type imported by std/numbers and std/semver.

True for the empty string. Equivalent to s.byte_len() == 0 but reads cleanly at call sites: emptiness is the same in byte and codepoint views.

True when sub occurs in s at byte offset. False when sub would run past the end of s.

True iff s starts with prefix. Byte-wise comparison.

True iff s ends with suffix. Byte-wise comparison.

Iterate s codepoint-by-codepoint, as an iterator value: for c in s walks the same codepoints through the Into<Iterator<char>> impl below, without one. It walks s once, where s[i] walks from the start at every index.

Comparator suitable for sort(arr, compare_ascending) : a < b as a function value: byte order, which is codepoint order in UTF-8.

Case-insensitive ASCII variant of compare_ascending. Matches JavaScript's default String.localeCompare() ordering for the ASCII subset (case-folded comparison ; ties broken by code point).

Byte offset of the last occurrence of c in s at or after min_index. Walks codepoint-by-codepoint (UTF-8 safe: the byte cursor advances by each codepoint's encoded width), tracking the latest match. Returns -1 when not found ; the signed i64 return type lets callers branch on result < 0 instead of folding "absent" into a zero offset.

Byte offset of the first occurrence of c in s, starting at the codepoint that begins at byte from (inclusive). UTF-8 safe, see last_index_of for the iteration model. from should align to a leading byte ; out-of-range values short-circuit to -1.

Split s on every occurrence of sep, returning the resulting segments. Empty segments are preserved (between consecutive sep runs and at the ends). For predicate-based splitting see split_where.

Concatenate parts, inserting sep between consecutive elements. The inverse of split: join(split(s, sep), sep) == s.

Replace the first occurrence of old in s with new (literal substring, not a pattern: use std/regex for pattern replacement). Returns s unchanged when old does not occur.

Replace every occurrence of old in s with new (literal). Equivalent to s.split(old).join(new). Use std/regex for pattern replacement.

Concatenate n copies of s ; n == 0 yields the empty string.

True when codepoint c occurs in s: a char-presence predicate built on index_of. For substring containment use sub in s (the Contains trait).

Strip leading and trailing ASCII whitespace (' ', '\t', '\n', '\r'). Unicode whitespace is not recognised in MVP.

Strip leading ASCII whitespace (' ', '\t', '\n', '\r') only ; trailing whitespace is preserved. See trim for both ends.

Strip trailing ASCII whitespace (' ', '\t', '\n', '\r') only ; leading whitespace is preserved. See trim for both ends.

Uppercase s over ASCII and the Latin-1 Supplement (a..z, à..þ, ÿ). UTF-8 aware: codepoints outside those ranges (incl. ß, non-Latin scripts) pass through unchanged ; no full Unicode case tables.

Lowercase s over ASCII and the Latin-1 Supplement (A..Z, À..Þ, Ÿ). UTF-8 aware: codepoints outside those ranges pass through unchanged ; no full Unicode case tables.

Parse s as a base-10 i32. No prefix, no underscores, no leading + sign ; a leading - is accepted.

Returns the explicit union i32 | ParseError : callers match the concrete is ParseError (a plain field read) instead of is Error. The existential Error-trait dispatch on a stdlib error value mis-executes on the self-host VM ; the concrete-type match sidesteps it.

Parse s as an f64: sign, mantissa, optional exponent. Correctly rounded : delegates to std/core::parse_f64 (Eisel-Lemire fast path + an exact big-int slow path), so the VM and native backends agree bit-for-bit: unlike the old strtod host, whose VM twin diverged on subnormals / long fractions.

Returns the explicit union f64 | ParseError (concrete, like parse_int) : the existential Error-trait dispatch mis-executes on the self-host VM, so callers match is ParseError.

Pad s on the LEFT with copies of fill until it holds width codepoints. Returns s unchanged when it already holds at least width. A codepoint is not a terminal column: a wide CJK glyph or a combining mark still counts one.

Pad s on the RIGHT with copies of fill until it holds width codepoints. Symmetric with pad_start.

The most codepoints any of texts holds, as pad_end counts: the width a column of them takes.

Cut text at its spaces into lines of at most width codepoints. A word longer than a line has a line of its own, and runs of spaces count as one.

Strip suffix if s ends with it ; otherwise return s unchanged. Trims at most one occurrence.

Strip prefix if s starts with it ; otherwise return s unchanged. Trims at most one occurrence.

Decode the common C-style escape sequences in body: \n (LF), \t (TAB), \r (CR), \", \\ and \0 (NUL). A backslash at the very end of body is preserved verbatim. A string with no backslash is returned as it is, without a copy.

Lenient: an unknown escape (\q) drops its backslash and passes the following byte through ("a\\qb" gives "aqb"), as the lexer and the VM parser do. A caller that wants unknown escapes rejected validates beforehand.

Replace every codepoint that satisfies pred with replacement. Subsumes the regex pattern replace(/[<class>]/g, "…").

Split s on runs of characters matching pred, dropping empty segments. Mirrors replace_chars_where(s, pred, ...): same predicate convention, same pair-with-is_* ergonomics. For whitespace splitting, pass is_white_char ; for word-boundary splitting (alphanumeric runs), pass c -> !c.is_alnum(). Empty inputs return an empty array.

UTF-8 encoded byte length (1–4) of codepoint c, as utf8_encode writes it:

• U+0000..U+007F → 1 byte
• U+0080..U+07FF → 2 bytes
• U+0800..U+FFFF → 3 bytes
• U+10000..U+10FFFF → 4 bytes

The width a char takes once encoded, not the width it was decoded from: codepoint_at_byte answers that one.

True for a high (leading) surrogate code unit, 0xD800..0xDBFF.

True for a low (trailing) surrogate code unit, 0xDC00..0xDFFF.

True for either half of a surrogate pair, 0xD800..0xDFFF: no char holds one, and a decoder that sees one in isolation substitutes REPLACEMENT_CHAR.

Recombine a UTF-16 surrogate pair into the astral scalar it encodes. The caller must have verified is_high_surrogate(hi) and is_low_surrogate(lo).

The highest Unicode scalar value (U+10FFFF), @max(char). Codepoints above this are invalid ; \u{...} escapes past it are rejected.

Lets sub in s desugar to s.contains(sub). The Contains trait (std/core) is what the in operator dispatches through ; without this impl in on string falls back to "language feature unsupported" at the lower stage. The method delegates to the module-private byte_contains (a byte-wise scan).