func main(): i32 { let value = load_value() catch failure { fallback_for(failure.message()) } if value == 42 { return 0 } return 1 } func load_value(): i32! { return error.new("example.unavailable", "the primary value is unavailable") } func fallback_for(message: &str): i32 { return 42 }

use std/fmt.Format use std/io struct Point { x: i32 y: i32 } instance Point { impl Format method &self.try_format_into(output: &+String): void! { output.try_push_str("(")? self.x.try_format_into(output)? output.try_push_str(", ")? self.y.try_format_into(output)? output.try_push_str(")")? return } } func main(): i32! { let point = Point { x: 3, y: 4 } let message = "point = ${point}\n" io.print(&message)? return 0 }

use std/io use std/vec.Vec struct Point { x: i32 y: i32 } instance Point { operator (&self == other: &Self): bool { return self.x == other.x && self.y == other.y } } func main(): i32! { let first = Point { x: 3, y: 4 } let same = Point { x: 3, y: 4 } let other = Point { x: 5, y: 6 } if first != same || first == other { return 1 } let points = Vec [move first, move other] if points[0] != same { return 1 } var values = Vec [1, 2, 3] values[1] = 4 if values[0] + values[1] + values[2] != 8 { return 1 } io.print("equality found the point\n")? return 0 }

struct Buffer { values: [i32; 3] } instance Buffer { operator (&self[index: usize]): &i32 { return &self.values[index] } operator (&+self[index: usize]): &+i32 { return &+self.values[index] } } func at<C>(container: &C, index: usize): i32 where (&C[usize]): &i32 { return container[index] } func main(): i32 { var buffer = Buffer { values: [3, 4, 5] } buffer[1] = 9 if at(&buffer, 1) != 9 { return 1 } return 0 }

v0.35.0 Phase 0 Static-data and Unicode-text Design Review

Result: complete with no open design finding (2026-09-04). This review fixes the architecture before implementation and does not claim that candidate syntax or APIs are available.

Findings

The published compiler can embed static string literal bytes but has no typed, addressable, immutable aggregate declaration. Unicode property and casing data therefore cannot be represented directly by the current language.

Generating thousands of if branches would preserve behavior but force every standard-library analysis to parse implementation-shaped data and would couple lookup cost to generated control flow. Adding primitives such as char_is_alphabetic would move Unicode versioning and properties into compiler and backend registries. Both approaches create a second authority and are rejected.

The accepted prerequisite is a general static product. Constant evaluation freezes a narrow, destructor-free initializer domain once; checked semantics expose only a readonly static place; target lowering owns layout and bytes; executable lowering owns readonly placement. Unicode is one client and does not appear in those compiler contracts.

Unicode 17.0.0 is the latest final standard at this design point. Unicode 18.0.0 remains beta, and the beta guidance says implementations should not be released based on beta data. v0.35.0 therefore pins 17.0.0 rather than a moving latest URL.

Full default casing is defined on text rather than char because one scalar can expand to multiple scalars. Locale-specific mappings, normalization, and case folding remain distinct future features. Unicode trim returns borrowed views, while owned suffix removal mutates only at proven scalar boundaries.

Responsibility Test

Unicode data can change in a later release without changing parser, checker, or backend code;
the generator can change internally while producing byte-identical checked table definitions;
static layout can change for another target without changing initializer evaluation;
standard lookup representation can change without changing public char, str, or String contracts;
editor presentation can change without reading generated tables;
ASCII APIs can remain stable when the pinned Unicode property sets change.

Each substitution crosses an exported typed product. No step depends on a caller remembering to revalidate data, preserve initialization order, or keep a second range table synchronized.