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/testing/README.md

Native Assertions

The compiler-checked std/testing contract is the sole authority for exact public declarations. This guide defines the assertion behavior shared by native tests and ordinary source without repeating signatures.

Assertions are ordinary fallible functions, not compiler intrinsics. A failed boolean assertion uses the stable code std.testing.assertion_failed; a failed equality assertion uses std.testing.not_equal. Their static messages require no allocation, so constructing the failure cannot itself become an allocation failure.

Equality assertions borrow both values and select the same structural equality operation as an ordinary comparison expression. They neither consume their operands nor introduce a separate equality interface. Failure uses normal error propagation and follows the same cleanup rules as any other fallible call.