Types & data

Built-in types, user-defined structs and enums, arrays, and references.

Complete type catalog

Ownership rules: Memory & ownership · Ownership UX (auto-borrow, auto-Copy) · Quick lookup: Language reference → Type names

Built-in scalars

Full Rust-style integer families: i8–i128, u8–u128, plus isize / usize. All are optional — omit annotations and Nyra infers i32 for integer literals and f64 for floats.

VecStr (split lists)

string.split(sep) returns a VecStr — a heap-owned list of substring parts. You can iterate with for part in parts or annotate explicitly:

let parts = "api,ui,docs".split(",")
for part in parts {
    print(part)
}

let parts: VecStr = "api,ui,docs".split(",")
for part in parts {
    print(part)
}

Inferred without annotation; VecStr is optional sugar for documentation and APIs. See For loops and built-in string methods.

Structs

fn main() {
    // Anonymous object literal — compiler infers struct shape
    let p = { x: 1, y: 2 }
    let q = p              // Copy when all fields are Copy
    print(p.x)

    // Optional: declare struct for organization / impl / FFI
    // struct Point { x: i32, y: i32 }
    // let p = Point { x: 1, y: 2 }
}

fn main() -> void {
    // Anonymous object literal — compiler infers struct shape
    let p = { x: 1, y: 2 }
    let q = p              // Copy when all fields are Copy
    print(p.x)

    // Optional: declare struct for organization / impl / FFI
    // struct Point { x: i32, y: i32 }
    // let p: Point = Point { x: 1, y: 2 }
}

Anonymous { field: value } literals infer a compile-time struct (same LLVM layout as Point { ... }). Declare struct Point when you want a named type for impl, FFI, or clarity. Literal fields are comma-separated ({ x: 1, y: 2 }); struct definitions use newlines between fields. Constructor sugar: Point(1, 2) or User("Ada") desugars to struct literals (RFC 0006). Structs with any Move field (e.g. string) are Move.

Enums

enum Color {
    Red
    Green
    Blue
}

fn main() {
    let c = Color.Red
    let tag = match c {
        Color.Red => 1
        Color.Green => 2
        Color.Blue => 3
    }
    print(tag)
}

enum Color {
    Red
    Green
    Blue
}

fn main() -> void {
    let c = Color.Red
    let tag = match c {
        Color.Red => 1
        Color.Green => 2
        Color.Blue => 3
    }
    print(tag)
}

Variant names use the form Type.Variant (e.g. Color.Red).

Arrays & slices

let buf = [1, 2, 3, 4]
let first = buf[0]

let buf: [i32; 4] = [1, 2, 3, 4]
let first = buf[0]

Fixed-size arrays use [T; N]. Slice type [T] is parsed and type-checked (MVP stack semantics). Growable Vec<T> lives in the stdlib — see Vectors.

Tuples

let pair = (42, "ok")
print(pair.0)
print(pair.1)

let pair = (42, "ok")
print(pair.0)
print(pair.1)

Tuple fields are accessed with .0, .1, … See Learn → Tuples.

References

let x = 10
let r = &x
let m = &mut y   // y must be let mut

let x: i32 = 10
let r = &x
let m = &mut y   // y must be let mut

Borrow rules enforced at compile time. Cannot return &local. See Memory & ownership.

Raw pointers (ptr vs *T)

extern fn mmio_base(){
    unsafe {
        let addr = mmio_base()
        return *addr
    }
}

extern fn mmio_base(){
    unsafe {
        let addr = mmio_base()
        return *addr
    }
}

Obtain a raw pointer from a stack binding: &x as *i32 (inside unsafe). Full rules: Memory → unsafe.

Literals

• Integers: 42, 1_000_000 (separators) → i32
• Floats: 3.14, 19.99, 1e-3 → f64
• Characters: 'a', '\n', '\u{41}' → char
• Strings: "hello"
• Struct: Point { x: 1, y: 2 }
• Array: [1, 2, 3] with type [T; N]

Built-in enum tags

option/Option and result/Result — tag-only in v0.2 (no stored payloads). See Match.

Generics

Monomorphization in v0.2 — see Generics.

Systems & stdlib types (Rust comparison)

All annotations below are optional. Nyra infers types by default; add names when you want clarity or FFI boundaries.

size_of / align_of

Compiler intrinsics — no import. Returns layout size and alignment in bytes (×8 for bits).

fn main() {
    print(size_of<i32>())      // 4
    print(size_of<i64>())      // 8
    print(align_of<i64>())     // 8
}

fn main() -> void {
    print(size_of<i32>())      // 4
    print(size_of<i64>())      // 8
    print(align_of<i64>())     // 8
}

Output

4
8
8

Full guide: stdlib → size_of · Memory → Type layout

Example tour: examples/syntax/systems_types.ny · Full stdlib matrix: Standard library