Module string/string

Create a new empty string (zero allocation)

Create a new empty string with pre-allocated capacity for the given number of bytes. The string starts empty but can hold capacity bytes without reallocating.

Create a string from raw bytes (assumes valid UTF-8) No validation is performed - the caller must ensure bytes are valid UTF-8

Create a string from a slice of bytes str The slice is a fat pointer containing data pointer and length Example: String.from(slice) where slice is str

Create a string from a C null-terminated string *(u8) Copies bytes until it finds a null byte (0) Example: String.from_cstr(c_string_ptr)

Note: We manually search for the null terminator by iterating

Convert the string to a null-terminated C string. Returns an ArrayList(u8) with the string bytes followed by a \0.

Get the length of the string in Unicode characters (runes) For "你好世界", this returns 4

Check if the string is empty

Get a reference to the internal byte array Returns an empty ArrayList if the string is empty

Get a str view into the string's UTF-8 bytes Returns a fat pointer (pointer + length) without copying

Decode a UTF-8 encoded rune starting at the given byte index Internal helper method

Get the rune at the specified character index (0-based) Returns None if index is out of bounds For "你好世界", at(0) returns '你', at(1) returns '好', etc.

Concatenate two strings (like JavaScript +)

Append another String to this string in-place (mutates self).

Append a str slice to this string in-place (mutates self).

Append a single byte to this string in-place (mutates self). The caller must ensure the byte maintains valid UTF-8.

Reserve capacity for at least additional more bytes. If the string is empty, creates a new buffer with the given capacity.

Clear the string content but keep the allocated buffer for reuse.

Get the number of bytes in the string (not Unicode characters). Use len() for Unicode character count.

Extract a substring from start to end character indices (like JavaScript substring) Returns a new string containing characters from start (inclusive) to end (exclusive) If end is greater than length, it will substring to the end of the string

Find the first occurrence of a substring (like JavaScript indexOf) Returns the character index of the first match, or None if not found from_index specifies the character index to start searching from

Check if the string contains a substring

Split the string by a separator into an array of strings (like JavaScript split) Returns an ArrayList of String

Find the last occurrence of a substring (like JavaScript lastIndexOf) Returns the character index of the last match, or None if not found from_index specifies the character index to start searching backwards from

Check if the string starts with the specified substring (like JavaScript startsWith) position: The character index to start checking from (default 0)

Check if the string ends with the specified substring (like JavaScript endsWith) end_position: The character length to consider (default is string length)

Replace the first occurrence of search_value with new_value (like JavaScript replace)

Replace all occurrences of search_value with new_value (like JavaScript replaceAll)

Convert ASCII lowercase letters to uppercase (like JavaScript toUpperCase) Note: Only handles ASCII a-z, not full Unicode case mapping

Convert ASCII uppercase letters to lowercase (like JavaScript toLowerCase) Note: Only handles ASCII A-Z, not full Unicode case mapping

Helper to check if a byte is ASCII whitespace Space (0x20), Tab (0x09), Newline (0x0A), Carriage Return (0x0D), Form Feed (0x0C), Vertical Tab (0x0B)

Remove whitespace from both ends of the string (like JavaScript trim)

Remove whitespace from the start of the string (like JavaScript trimStart)

Remove whitespace from the end of the string (like JavaScript trimEnd)

Returns a rune iterator over the string's Unicode characters

Returns a byte iterator over the string's raw UTF-8 bytes

Byte-position iterator for for(s, ref(b) => body). Yields usize byte indices; the for-macro pairs each with s.project(pos) (Indexable) so the body sees ref(u8) bound to each byte. Iteration is byte-level, not rune-level — for codepoint iteration use chars() explicitly.

Consume the string and return a rune iterator (default iteration)

Returns a line iterator over the string. Each call to next() yields the next line (without the trailing \n).

Example

s := `hello\nworld`;
iter := s.lines();
assert(iter.next() == .Some(`hello`), "first line");
assert(iter.next() == .Some(`world`), "second line");
assert(iter.next() == .None, "done");

Returns a new string containing n copies of self. Returns an empty string when n == 0 or self is empty.

Example

assert(`ab`.repeat(usize(3)) == `ababab`, "repeat");
assert(`x`.repeat(usize(0)) == ``, "repeat 0");

Join an ArrayList(String) with this string as separator. Returns an empty string when items is empty.

Example

items := ArrayList(String).new();
items.push(`a`);
items.push(`b`);
items.push(`c`);
result := `, `.join(items);
assert(result == `a, b, c`, "join");

Helper: check if a byte is an ASCII digit '0'-'9'

Parse the string as a signed 32-bit integer. Returns .Some(value) on success, .None on failure (empty, invalid chars, overflow).

Parse the string as a signed 64-bit integer. Returns .Some(value) on success, .None on failure. Note: does not detect i64 overflow during accumulation.

Parse the string as an unsigned 32-bit integer. Returns .Some(value) on success, .None on failure (empty, invalid chars, overflow, negative sign).

Parse the string as an unsigned 64-bit integer. Returns .Some(value) on success, .None on failure. Note: does not detect u64 overflow during accumulation.

Parse the string as a boolean. Returns .Some(true) for "true", .Some(false) for "false", .None for anything else.

Consume the string and return a rune iterator (default iteration)

Consume the string and return a rune iterator (default iteration)

Consume the string and return a rune iterator (default iteration)