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.34.0 Phase 0 Unicode-scalar Design Review

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

Findings

The existing UTF-8 implementation already has a package-internal encoder and validator, but the validator owns a private traversal that cannot be reused by scalar iteration. Phase 2 will replace that traversal with a decoder-owned step rather than adding another Chars decoder.

The existing byte literal is less complete: syntax tokenizes and parses b'…', but checking has no ByteLiteral branch and would treat valid documented source as unsupported syntax. Character literal work cannot copy that pipeline. Syntax will publish typed decoded literal values for both forms, and checking will consume them exhaustively.

Using u32 as the runtime primitive identity for char would collide in the runtime primitive table and allow MIR validation to accept integer constants at character sites. The design therefore retains distinct character variants through checked constants, MIR constants, runtime primitives, and machine constants while sharing only the layout-owned 32-bit scalar shape.

Putting Unicode validity inside ARM64 conversion selection would make a target backend a second language authority. Public from_u32 validates in source, while exact package-internal conversion primitives transport already validated bits. Syntax validates literal scalars. No later phase rechecks authored escape text.

Responsibility Test

syntax can change its lossless token representation without changing checking;
checking can change constant storage without changing quote parsing;
the standard UTF-8 decoder can change its algorithm without changing Chars or validation policy;
machine layout can change target representation without changing semantic scalar validity;
ARM64 can change instruction selection without learning about Unicode ranges;
tooling can change presentation without interpreting literal contents.

These substitutions require only the exported contract of the replaced responsibility. No caller- discipline-only invariant or compatibility fallback is part of the accepted design.