Nocter v0.12.0 Release Notes

Download nocter-v0.12.0-arm64-darwin.tar.gz

Nocter v0.12.0 returns development to practical standard-library use. Formatting, equality, and indexing now use source-defined contracts, uniform generic requirements, static dispatch, and ordinary borrow coercions instead of closed compiler tables or collection-specific execution paths.

Extensible String Interpolation

std/fmt.Format is the source-defined static contract for interpolation:

pub interface Format {
    pub method &self.format_into(output: &+String): void
}

The standard library conforms text, owned strings, booleans, and every built-in integer. A project type can participate through an ordinary conformance:

conform Format for Point {
    method &self.format_into(output: &+String): void {
        append_str(output, "(")
        append_i32(output, self.x)
        append_str(output, ", ")
        append_i32(output, self.y)
        append_str(output, ")")
        return
    }
}

Formatting dispatch is static. It adds no vtable, box, implicit recoverable error, or compiler-owned type switch. Interpolation still evaluates parts left to right, borrows formatted values, destroys temporaries exactly once, and produces an owned String in the current allocation context.

Source-Defined Equality

Types define borrowed equality inside instance:

instance Point {
    pub operator (&self == other: &Self): bool {
        return self.x == other.x && self.y == other.y
    }
}

Generic algorithms state the same operation structurally:

func values_equal<T>(left: &T, right: &T): bool
where (&T == &T): bool {
    return left == right
}

str defines text equality once. String reaches it through readonly coercion, and [T] supplies element-wise equality, contains, and position under the same generic requirement. Vec<T> uses the slice behavior through its existing borrow coercion. Equality calls are statically selected and do not use a runtime interface object.

Uniform Operator Requirements and Indexing

Operator requirements use one canonical where (operation): Result form:

where (&T == &T): bool
where (&C[K]): &V
where (&+C[K]): &+V

Direct arrays and slices, lexical generic requirements, and one visible receiver coercion feed one index plan. Vec<T> therefore supports readonly and readwrite indexing through its slice coercions:

var values = Vec [1, 2, 3]
values[1] = 4
let first = values[0]

Indexed borrows retain the original owner loan. Readwrite access requires a writable source, out-of-bounds access keeps the checked slice behavior, operands evaluate left to right, and multiple distinct coercion targets require an explicit as selection.

Tooling and Performance

Hover, completion, signature help, semantic tokens, definition, references, and rename preserve the exact operator, conformance, coercion, and declaration identities selected by the compiler. Interpolation labels are resolved from the trusted source declarations rather than inferred from hard-coded display names.

Compile-unit module qualification and callable-provenance fixed points are shared across source analyses. On the qualification machine, process-cold release checking of examples/hello.nct improved from 18.318 seconds at the start of the stabilization work to a three-run median of 0.301 seconds without weakening diagnostics or test coverage.

Compatibility and Limits

The earlier unparenthesized equality requirement syntax is removed; use where (&T == &T): bool. User-defined operator declarations in this release cover equality only. Indexing is selected from arrays, views, structural generic requirements, and one-step borrow coercions; v0.12.0 does not add arbitrary source-defined index bodies, transitive coercion, coercion ranking, dynamic interface dispatch, unwinding, a stable cross-version ABI, or another host or native target. The supported host and target remain arm64-darwin.

Qualification

The published arm64-darwin archive is 3,783,354 bytes with SHA-256 65514f5b5f5bddbbcd883b72026566109302e96203d3702503615ca26f2f4e60. A fresh extraction without environment configuration passed package creation, locked/offline check and native test, deterministic graph generation, run, explicit build, direct Mach-O execution, and the complete LSP initialize, initialized, shutdown, and exit lifecycle.

The public download and version history are available from the release index.