HewStandard Library

Module std::string

string conversion and manipulation utilities.

Most string operations (.find(), .slice(), .trim(), etc.) are built-in methods available on all strings. This module provides type-conversion helpers and additional string utilities.

Examples

import std::string;

fn main() {
    let s = string.from_int(42);        // "42"
    let n = string.to_int("42");        // 42
    let f = string.to_float("3.14");    // 3.14
    let nl = string.from_char(10);      // "\n"
    let stars = string.repeat("*", 3);  // "***"
    let padded = string.pad_left("7", 3, "0");  // "007"
}

Contents

Functions

Function from_int

pub fn from_int(n: i64) -> string

Convert an integer to its string representation.

Examples

let s = string.from_int(42);  // "42"

Function from_float

pub fn from_float(f: f64) -> string

Convert a float to its string representation.

Function from_bool

pub fn from_bool(b: bool) -> string

Convert a bool to "true" or "false".

Function from_char

pub fn from_char(code: i64) -> string

Convert a character code to a single-character string.

Examples

let newline = string.from_char(10);

Function to_int

pub fn to_int(s: string) -> i64

Parse a string as an integer. Returns 0 if parsing fails.

Unlike C's atoi, this function does not stop at the first non-digit character — any non-digit anywhere in the string (after an optional leading +/-) causes the whole parse to fail and return 0. For example, "42abc" returns 0, not 42.

Invalid or out-of-range input returns 0.

Examples

let n = string.to_int("42");     // 42
let m = string.to_int("42abc");  // 0 — partial numbers return 0
let z = string.to_int("");       // 0 — empty string returns 0

Function try_to_int

pub fn try_to_int(s: string) -> Result<i64, string>

Parse a string as an integer, returning a structured error on failure.

Function to_float

pub fn to_float(s: string) -> f64

Parse a string as a float. Returns 0.0 if parsing fails.

The parser accepts:

The entire string must be a valid float literal; partial parses fail.

Examples

let pi = string.to_float("3.14");   // 3.14
let n = string.to_float("-2e3");    // -2000.0
let z = string.to_float("3.14x");   // 0.0

Function try_to_float

pub fn try_to_float(s: string) -> Result<f64, string>

Parse a string as a float, returning a structured error on failure.

Function is_empty

pub fn is_empty(s: string) -> bool

Check if a string is empty.

Examples

string.is_empty("")    // true
string.is_empty("hi")  // false

Function repeat

pub fn repeat(s: string, n: i64) -> string

Repeat a string n times.

Examples

let stars = string.repeat("*", 5);  // "*****"

Function pad_left

pub fn pad_left(s: string, width: i64, pad: string) -> string

Pad a string on the left to reach the given width.

If s is already at least width characters, returns s unchanged.

Examples

string.pad_left("42", 5, " ")   // "   42"
string.pad_left("42", 5, "0")   // "00042"

Function pad_right

pub fn pad_right(s: string, width: i64, pad: string) -> string

Pad a string on the right to reach the given width.

If s is already at least width characters, returns s unchanged.

Examples

string.pad_right("hi", 5, " ")  // "hi   "

Function is_numeric

pub fn is_numeric(s: string) -> bool

Check if a string contains only ASCII digits (0-9).

Returns false for empty strings.

Examples

string.is_numeric("123")   // true
string.is_numeric("12a")   // false
string.is_numeric("")      // false

Function count

pub fn count(haystack: string, needle: string) -> i64

Count the number of non-overlapping occurrences of needle in haystack.

Examples

string.count("abcabc", "abc")  // 2
string.count("hello", "x")     // 0

Function starts_with

pub fn starts_with(s: string, prefix: string) -> bool

Check if a string starts with the given prefix.

Examples

string.starts_with("hello", "he")   // true
string.starts_with("hello", "lo")   // false

Function ends_with

pub fn ends_with(s: string, suffix: string) -> bool

Check if a string ends with the given suffix.

Examples

string.ends_with("hello", "lo")   // true
string.ends_with("hello", "he")   // false

Function contains

pub fn contains(s: string, sub: string) -> bool

Check if a string contains the given substring.

Examples

string.contains("hello world", "world")  // true
string.contains("hello", "xyz")          // false

Function is_ascii

pub fn is_ascii(s: string) -> bool

Check if a string contains only ASCII characters (code points 0–127).

Examples

string.is_ascii("hello")  // true
string.is_ascii("héllo")  // false

Function to_lower

pub fn to_lower(s: string) -> string

Convert a string to lowercase.

Function to_upper

pub fn to_upper(s: string) -> string

Convert a string to uppercase.

Function trim

pub fn trim(s: string) -> string

Trim leading and trailing whitespace from a string.

Function replace

pub fn replace(s: string, old: string, new_val: string) -> string

Replace all occurrences of old in s with new_val.

Function split

pub fn split(s: string, sep: string) -> Vec<string>

Split a string by sep into a list of substrings.

An empty separator returns a single-element list containing the original string unchanged (mirrors the FFI behaviour). A trailing delimiter produces a trailing empty element.

Examples

import std::string;

let parts = string.split("a,b,c", ",");  // ["a", "b", "c"]
let trail = string.split("a,b,", ",");   // ["a", "b", ""]
let empty = string.split("x", "");       // ["x"]

Function lines

pub fn lines(s: string) -> Vec<string>

Split a string into lines, stripping \r\n or \n endings.

Always emits a final element for the text after the last newline (which will be empty when the string ends with a newline), matching the FFI behaviour.

Examples

import std::string;

let lines = string.lines("foo\nbar");   // ["foo", "bar"]
let crlf  = string.lines("a\r\nb");    // ["a", "b"]
let trail = string.lines("foo\n");     // ["foo", ""]

Function join

pub fn join(parts: Vec<string>, sep: string) -> string

Join a list of strings with sep between each element.

Returns an empty string for an empty list.

Examples

import std::string;

let s = string.join(["a", "b", "c"], ", ");  // "a, b, c"
let e = string.join([], ",");                // ""

Traits

Trait ToString

Trait for types that can be converted to a string representation.

Provides a standard interface for string conversion across modules.

Examples

import std::string;

// Implement for custom types:
// impl ToString for MyType {
//     fn to_str(m: MyType) -> string { ... }
// }

Methods

fn to_str(val: Self) -> string

Convert this value to its string representation.