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 1 Scalar-product Review

Result: complete with no open finding (2026-09-04). Character and byte literals now cross one closed syntax-to-native pipeline.

Closed Product

Syntax owns delimiter scanning, escapes, byte cardinality, and Unicode scalar validity. Checking consumes decode_byte_literal and decode_character_literal; it no longer receives a byte token that it cannot type. Character values retain distinct variants through checked constants, constant evaluation, MIR, runtime primitives, machine constants, and semantic presentation. Machine layout alone maps char to an unsigned 32-bit scalar shape, and ARM64 selection consumes that shape and an already validated immediate.

The standard char.from_u32 implementation owns dynamic scalar validation in ordinary Nocter source. Its two exact package-internal primitives only transport a validated value between char and u32; Target validates their signatures and ARM64 treats each as a one-register identity move. The backend does not duplicate surrogate or maximum-scalar rules.

Review Findings Closed During Implementation

The first native integration run rejected calling a consuming char method directly through the borrowed operator receiver. The source implementation now uses the existing package-internal copyability boundary explicitly before scalar observation. No checker exception or implicit borrow-to-value conversion was added.

Hard-coded test standard packages initially omitted the new closed built-in declaration. Every shared fixture authority now declares char, while the broad test-support package models it as its own standard module. This is fixture data only; production mapping remains solely in the bundled standard profile.

Evidence

lexer tests cover direct Unicode, simple escapes, Unicode escapes, invalid escapes, surrogate and range rejection, newlines, and unterminated input;
checking verifies the previously incomplete byte literal and the new character constant as distinct types;
declaration lowering evaluates a character constant;
the complete native-session test executes character literals, code-point observation, scalar construction and rejection, classification, equality, and ordering on ARM64 Darwin;
cargo test --lib --quiet, focused syntax/diagnostic/constant tests, formatting, and diff hygiene pass for the Phase 1 product.