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 2 UTF-8 Iteration Review

Result: complete with no open finding (2026-09-04). UTF-8 validation and borrowed scalar iteration now consume one decode-step authority.

Closed Product

std/internal/utf8.decode_scalar owns leading-byte classes, continuation requirements, overlong rejection, surrogate rejection, maximum-scalar rejection, and exact byte width. Complete UTF-8 validation advances only through its returned width. str.chars retains the borrowed text and a single byte-boundary offset; Chars.next advances through the same step and uses the trusted package-internal character representation bridge only after decode success. str.char_count consumes Chars rather than maintaining another traversal.

Unchecked character transport now lives in std/internal/character. The public char module owns dynamic scalar validation, while the internal UTF-8 consumer can transport a scalar it has already validated. The standard profile is the sole physical locator for these primitive roles and Target requires their package-only signatures. No module-name workaround or duplicated validity check remains.

Findings Closed During Implementation

The first integration run exposed that a consuming accessor on a copy decode-step made sequential field observation depend on implicit copying. The decode-step is now a package-visible immutable data contract with readonly scalar and width fields; consumers do not need wrapper methods or hidden copy behavior.

Fixed-array test input also exposed that an explicit array-reference cast was not an applicable borrow coercion. The tests construct byte views through the existing pointer projection authority, which is the same explicit unsafe boundary used by other internal fixed-buffer code.

Evidence

decoder tests cover one-, two-, three-, and four-byte scalars plus overlong, surrogate, and above-maximum rejection;
the complete bundled-standard target session accepts the physical package and all primitive contracts;
the native Unicode test executes mixed ASCII, two-byte, and four-byte iteration, exact byte and scalar counts, scalar order, end-of-iteration, and dynamic surrogate rejection;
source audit finds no second UTF-8 leading-byte table in the standard package;
cargo test --workspace --lib --quiet, Rust formatting, documentation generation, and diff hygiene pass for the closed phase.