Nocter v0.13.0 Release Notes

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

Nocter v0.13.0 completes source-defined collection behavior and consolidates practical standard library APIs around canonical type-owned declarations. Indexing, iteration, ordering, recovery, and borrow coercion now compose through explicit source contracts instead of closed collection tables or parallel declaration systems.

Type-Owned Indexing

An instance can define readonly and readwrite indexing directly:

instance Buffer<T> {
    pub operator (&self[index: usize]): &T {
        return &self.values[index]
    }

    pub operator (&+self[index: usize]): &+T {
        return &+self.values[index]
    }
}

Generic requirements use the same structural operation, and concrete specialization selects the same source declaration as an ordinary index expression. Indexed borrows retain owner provenance, mutable access requires a readwrite receiver, and source-defined bodies own their bounds policy.

Value-Producing Recovery

catch can now recover with the block's final value, while _ explicitly discards an unused error:

let value = parse(text) catch _ {
    default_value()
}

Recovery composes in arguments, fields, assignments, returns, aggregate construction, and stored outcomes. Terminal handlers and empty void recovery remain valid, and failed destinations are never treated as initialized during cleanup.

The obsolete standard Error alias is removed. error values are constructed through their source-backed built-in surface, and the core owning types and iterator contracts are available through the standard prelude.

Expansion and Mutable Iteration

Collections define how they expand into readonly, readwrite, or consuming iterators. The same source-defined expansion plan drives for and sequence spread:

for item in &+values {
    update(item)
}

for item in move values {
    consume(move item)
}

Mutable iteration retains one exclusive source loan and yields mutable element borrows. Consuming iteration moves each element once, and every exit path performs deterministic iterator and source cleanup. The removed Iterable and IntoIterator conversion interfaces have no compatibility path.

Source-Defined Ordering

Types define strict ordering with one borrowed operator:

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

>, <=, and >= derive from the same selected less-than declaration while preserving left-to- right source evaluation. Generic algorithms state where (&T < &T): bool. Standard str and slices own lexical ordering, while String and Vec<T> reach it through ordinary borrow coercions.

Canonical Standard-Library Surfaces

Each audited operation now has one public declaration identity. Slices own optional contiguous access and indexing; Vec<T> reuses them through coercion. Construction belongs to construct, receiver behavior belongs to instance, generic dispatch remains in interfaces, and exact forwarding aliases are private or removed. Optional, trapping, fallible, allocation-recoverable, and consuming operations remain separate when their contracts differ.

std/testing.assert_eq is generic over the structural equality requirement rather than duplicating integer and text-specific assertions.

Instance-Owned Borrow Coercions

Borrow coercions now live beside other behavior in instance:

instance String {
    pub coerce &self as &str {
        return view(self)
    }
}

Generic code can require the same conversion structurally:

func text_view<T>(value: &T): &str
where &T as &str
{
    return value
}

Contextual conversion, explicit as, method receivers, comparison, and indexing all use the same visible one-step selector. Coercions do not chain or rank implicitly, and generic evidence becomes the concrete accessible declaration during static specialization.

Tooling and Compatibility

Formatting, diagnostics, hover, completion, semantic tokens, definition, references, rename, and signature presentation understand source indexing, expansion, ordering, recovery, and instance coercions. The standalone coerce Type { ... } declaration, nominal collection-conversion interfaces, the Sequence<T> interface, the Error alias, and superseded forwarding exports are removed without deprecated spellings or compatibility namespaces.

v0.13.0 does not add dynamic interface dispatch, runtime coercion witnesses, coercion chaining or ranking, fallible conversions, multi-index operators, user-defined arithmetic, sorting, a stable cross-version ABI, or another host or native target. The supported host and target remain arm64-darwin.

Qualification

The qualified arm64-darwin archive is 3,888,262 bytes with SHA-256 515b4c696bfc3f3a9bd96d9278904d16ca70a8cd32d57ddaa159836aa04bd761. 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.

Public download links are added to this page and the release index when publication completes.