Programming Language

Nocter

A self-contained systems language built around simplicity, encapsulation, and foolproof design.

Specification GitHub

use std/io

func main(): i32! {
    io.print("Hello from Nocter\n")?
    return 0
}

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
}

/std/error/README.md

Recoverable Errors

The compiler-checked std/error contract is the sole authority for the exact public declaration and members of the built-in error type. The language-level T! outcome and propagation rules belong to Errors and Optionals.

An error is an owned, move-only handle to immutable failure information. Construction snapshots the code and message into storage independent of the input views. Adding context consumes the previous handle, preserves its root code, snapshots the new message, and returns a new outer error node. Code and message accessors return readonly views tied to the error handle; exact code comparison returns an independent boolean.

Error codes are open UTF-8 strings. Standard-library codes use stable dotted names such as std.io.not_found, std.mem.out_of_memory, and std.process.invalid_encoding; applications and packages may define their own prefixes. No Error or ErrorCode compatibility alias exists.

Dynamic construction is infallible at the source boundary. If private error-storage allocation cannot continue, execution terminates. A recoverable allocation-failure path uses a prebuilt static error and therefore cannot recursively allocate another error while reporting exhaustion.

Public standard-library operations expose only error through T!. Target-specific raw error records and helpers that construct standard errors remain private implementation details.