Module imm/string

Render self under spec. An unrecognised spec degrades to the plain to_string() rendering rather than failing.

Release the resources self owns — a file descriptor, a socket, a lock, a buffer the allocator handed out. Called automatically when the last reference to the value goes away, so an implementor never calls it directly and must tolerate being the only one who ever does.

It must be safe to run exactly once: the runtime calls it at refcount zero, and a type that also exposes an explicit close/release is responsible for making the second call a no-op.

Create a new empty string (zero allocation).

Create a string from a str slice (copies the bytes).

Create a string from a standard (mutable) String by copying its bytes.

Number of BYTES in this string's UTF-8 encoding — O(1).

BYTE basis, the unit every index on this type speaks: slice, index_of, byte_at and at all take or return byte offsets, and it agrees with std/string's String.len(), str.len() and Rust's str::len().

For "how many runes" use chars().count() (O(n)); to walk runes together with the byte offset each one starts at, use char_indices(). (plans/archive/STD_API_AUDIT_D4_PLAN.md D4 PR 4 — this returned a RUNE count before that flip, and a bytes_len() alias carried the byte count; the alias was DELETED with the flip because it had no consumer left.)

Check if the string is empty.

Get a str view of the string's bytes (zero-copy borrow).

Get the byte at a given index, or .None if out of bounds.

Concatenate two strings, returning a new string. Uses COW: if this string has a unique reference and enough capacity, appends in-place.

Extract a byte-range substring [start, end). Returns a new string. If indices are out of bounds, clamps to valid range.

Check if the string starts with a given prefix.

Check if the string ends with a given suffix.

Find the first occurrence of needle starting at from_index. Returns byte index or .None.

Check if the string contains a given substring.

Split the string by a separator, returning an immutable List of Strings.

Check if a byte is ASCII whitespace.

Trim leading and trailing ASCII whitespace.

Trim leading ASCII whitespace.

Trim trailing ASCII whitespace.

Convert all ASCII uppercase letters to lowercase. Uses COW: if this string has a unique reference, modifies bytes in-place.

Convert all ASCII lowercase letters to uppercase. Uses COW: if this string has a unique reference, modifies bytes in-place.

Shared left-to-right scanner behind replace, replacen and replace_first. When bounded is true it stops after limit replacements and copies the rest verbatim; limit == 0 with bounded replaces nothing. An empty search never matches (it would not terminate), matching the pre-D10 replace_all.

Replace EVERY occurrence of search with replacement (D10 — Rust's str::replace). An empty search returns self unchanged.

NOTE this replaced only the FIRST occurrence before D10. Use replacen for a bounded count.

Replace the first count occurrences of search with replacement, leaving any later ones alone — Rust's str::replacen.

replacen(s, r, usize(1)) is the pre-D10 meaning of replace.

Replace the first occurrence of search with replacement.

DEPRECATED (D10), kept for one release: this is what replace used to mean. Write replacen(search, replacement, usize(1)) instead.

Replace all occurrences of search with replacement.

DEPRECATED (D10), kept for one release: replace now means this.

Repeat the string n times.

Decode a single UTF-8 rune starting at byte index.

Decode the rune that STARTS at byte offset index.

BYTE basis (plans/archive/STD_API_AUDIT_D4_PLAN.md D4 PR 4 — this took a rune index before the flip; it now mirrors std/string's String.at). .None is returned for the three ways a byte offset can fail to name a rune: at or past len(), inside a rune (a UTF-8 continuation byte), or on bytes that do not decode.

while(i < s.len(), { s.at(i) }) therefore visits continuation bytes and yields .None at each of them — use char_indices() (or chars()) to walk runes.

Iterate the string's runes.

Iterate (byte_offset, rune) pairs — Rust's char_indices().

True when byte offset index sits on a rune boundary.

0 and len() are always boundaries; an index past the end never is. Mirrors Rust's str::is_char_boundary.

The largest byte offset <= index that sits on a rune boundary.

index is clamped to len() first, so the answer is always a boundary of THIS string.

The smallest byte offset >= index that sits on a rune boundary.

index at or past len() clamps to len(), which is a boundary, so this always terminates on a valid one.

Byte-range slice that REFUSES a bad range instead of clamping it — Rust's s.get(start..end), and the checked counterpart of slice.

.None for start > end, for end past len(), and for an endpoint inside a rune (which would produce invalid UTF-8). An empty but valid range yields .Some of the empty string.

Compare with a str for equality.

Feed this value's identity into hasher.

Render self as the text a USER should read — Rust's Display::fmt, not its Debug. Hand-written (or generated by derive(Error) from a per-variant format string) whenever the structural form would be wrong.

The default value of the type.

Advance the iterator and return the next value, or None when exhausted.

Advance the iterator and return the next value, or None when exhausted.