Programming Language

Nocter

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

Specification GitHub

use std/io

blocking 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
    }
}

blocking 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
    }
}

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

Binary Scalar Codecs

The compiler-checked bytes module contract is the sole authority for public signatures. This guide records the failure and composition guarantees shared by those declarations.

Every decoder reads a fixed-width prefix and returns none before producing a value when the input is too short. Bytes after that prefix are not inspected. Integer decoding is mathematical and does not depend on the target's native byte order. Floating-point decoding preserves the complete IEEE bit representation, including signed zero and NaN payloads.

Every encoder writes a fixed-width prefix. It checks output capacity before the first mutation, so insufficient output returns false with every byte unchanged. Bytes after the encoded prefix are untouched. Encoding performs no allocation.

This module does not own input position or storage. Use scan.ByteCursor to select and advance through borrowed input, fixed.ByteBuffer for inline bounded staging, and io for external streams. Those modules delegate scalar conversion to this contract rather than defining additional byte-order rules.

Dynamic output copies one completely encoded fixed-buffer view through Vec.extend_from_slice. Blocking and asynchronous writers already accept the same complete slice. No dynamic or stream adapter owns another endian implementation, and failed fixed-buffer encoding cannot expose a partial value to either destination.