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

Owned Strings

The compiler-checked String module contract is the sole authority for exact public declarations. This chapter defines the longer invariants of owned UTF-8 storage without repeating those signatures.

String owns initialized UTF-8 bytes and exposes borrowed observation through its readonly coercion to str. An original String member wins before receiver coercion; general search, comparison, slicing, trimming, and borrowed iteration are therefore defined once by str.

Normal copying, reservation, and append operations use the current aborting allocator. Their try_ counterparts use a TryAllocator and report recoverable storage failure. Byte append first validates the complete input and publishes no bytes when validation or allocation fails. Scalar append uses the shared UTF-8 encoder. No public operation may leave invalid UTF-8 in the initialized prefix.

empty defers allocator selection until first growth. with_capacity, including a zero-capacity request, records the allocator selected by construction so later growth cannot silently move to a different allocation context. Capacity is measured in bytes and never changes logical text length by itself.

Scalar-safe suffix mutation, Unicode case conversion, and their exact failure rules are defined in Unicode Text and Scalars. Raw internal buffer operations are implementation details and are not importable String APIs.