Programming Language

Nocter

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

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

/development/std/internal/os/darwin/pair_tests.nct

pair_tests.nct

//! Native qualification for Darwin syscalls with two successful return words.

see ./index.nct

use /ptr

test pipe_syscall_preserves_both_descriptor_results {
    let result = syscall_pair0(SYS_PIPE)
    if result.errno != 0 {
        return error.new("std.internal.os.test", "pipe syscall failed")
    }
    if result.first == result.second {
        let _ = syscall1(SYS_CLOSE, result.first)
        return error.new("std.internal.os.test", "pipe returned one descriptor twice")
    }

    let sent: u8 = 91
    let write_result = syscall3(SYS_WRITE, result.second, ptr.addr(ptr.from_ref(&sent)), 1)
    if write_result.errno != 0 || write_result.value != 1 {
        let _ = syscall1(SYS_CLOSE, result.first)
        let _ = syscall1(SYS_CLOSE, result.second)
        return error.new("std.internal.os.test", "pipe write descriptor is invalid")
    }

    var received: u8 = 0
    let read_result = syscall3(SYS_READ, result.first, ptr.addr(ptr.from_ref_mut(&+received)), 1)
    if read_result.errno != 0 || read_result.value != 1 || received != sent {
        let _ = syscall1(SYS_CLOSE, result.first)
        let _ = syscall1(SYS_CLOSE, result.second)
        return error.new("std.internal.os.test", "pipe read descriptor is invalid")
    }

    let read_close = syscall1(SYS_CLOSE, result.first)
    let write_close = syscall1(SYS_CLOSE, result.second)
    if read_close.errno != 0 || write_close.errno != 0 {
        return error.new("std.internal.os.test", "pipe descriptor close failed")
    }
    return
}