Language reference

Keywords, operators, literals, and quick lookup — everything the lexer and parser accept today.

Keywords

Full reserved-word list, @ raw identifiers, and #[…] attributes: Nyra Keywords.

Built-in call names (no import)

Resolved in the typechecker like keywords. Full lookup: Built-in methods · Standard library → Built-ins.

• print, write, println, flush, input
• date() — returns Date with .year, .month, .day, .hour, …
• time_start, time_end, mem_start, mem_end

String methods (no import): .length(), .split(), .trim(), .contains(), .replace(), .to_upper(), … — see Built-in methods → Strings.

Type names

Every type Nyra supports in source annotations and inference. All optional unless inference fails.

Comments

// file header
let x = 1 /* inline */ + 2
/*
 * multiline doc
 */

// file header
let x = 1 /* inline */ + 2
/*
 * multiline doc
 */

See Learn → Comments · Tests: tests/nyra/block_comments_test.ny · CONF-COMMENT-*

Literals

Template strings: backticks with ${expr} — e.g. `score: ${n}`. See Learn → Strings.

Numeric separators: underscores between digits are ignored — 10_00000 equals 100000. Hex integers: 0xFF, 0xffu8.

Operators

Statements

• let name = expr / let mut name = expr
• fn f(mut x: i32) — mutable parameter (reassignable in body); mut s: Struct updates the caller's struct in place (passed by pointer)
• const NAME = expr
• name = expr (assign; requires mut)
• if cond { } else { }
• while cond { }
• for var in start..end { } — half-open integer range
• for x in arr { } — iterate array elements
• for x in str { } — string chars (char)
• for x in parts { } — split list (VecStr from .split())
• return expr / return
• print(expr) / print(expr, color: spec)
• defer expr — runs at block exit (after other statements, before parent scope)
• spawn { statements }
• unsafe { statements }
• asm "template" — LLVM inline asm (inside unsafe)
• *ptr = expr — pointer store (inside unsafe)
• no_std — file-level directive (first statement)
• import "path.ny" / import "path.ny" as alias
• import { a, b as c } from "path.ny" — selective (only named pub symbols)
• Expression statement: bare call, e.g. free(s)

Expressions

• Literals, variables, unary - / ! / & / &mut / move / clone
• Binary arithmetic, comparison, logic
• if cond { a } else { b } as expression
• cond ? a : b — ternary shorthand (same as if expression)
• match scrutinee { Arm => expr }
• Struct literal: Point { x: 1, y: 2 } or sugar Point(1, 2)
• Enum variant: Color.Red, Option.Some(1)
• Array literal: [1, 2, 3]
• Method call: obj.method(args) — struct methods and built-in string methods
• Field access: obj.field — structs, tuples, Date from date()
• Grouped: (expr)
• await expr (parsed; MVP handle type i32)
• Template literal: `text ${expr} more`
• Arrow function: (x) => expr, x => expr, ((a, b)) => expr, or typed (a: i32) => { ... } — see Closures
• expr as Type — cast (raw-pointer casts require unsafe)

Unsafe & raw pointers

Nyra is safe by default. Low-level memory requires unsafe { }:

mut x = 42
unsafe {
    let p = &x as *i32
    *p = 99
    print(*p)
}

mut x = 42
unsafe {
    let p = &x as *i32
    *p = 99
    print(*p)
}

ptr = opaque FFI handle. *T = typed raw pointer for drivers/MMIO. Inline asm: asm "nop" inside unsafe. OS APIs: import "stdlib/os.ny". See Memory → unsafe, Stdlib → os.

Ownership quick ref

Beginner track: Nyra Ownership → Nyra Borrowing. Full rules: Memory & ownership. Developer UX: Ownership UX (auto-borrow, auto-Copy, inference).

Ownership UX

Diagnostics name the callee and suggest fixes. Conformance: CONF-INF-*, CONF-COERCE-*, CONF-DIAG-*, CONF-COPY-*, CONF-F64-*.

Lifetimes & HRTB

• Function lifetime params: fn pick<'a>(a: &'a string) -> &'a string
• Elision: one input &T → return &T shares that lifetime
• Ambiguous elision (multiple input refs, no annotation) → compile error
• HRTB callback type: for<'a> fn(&'a string) -> &'a string

Traits (Drop)

impl Drop for MyType {
    fn drop(self) {
        // custom cleanup
    }
}

impl Drop for MyType {
    fn drop(self) {
        // custom cleanup
    }
}

Drop and Clone are wired in the compiler. User traits: trait defs, impl Trait for Type, and dynamic dispatch via dyn Trait / value as dyn Trait (Extended MVP). See Traits & macros and examples/trait_dyn.ny.

Compiler pipeline

Source (.ny)
  → Lexer → Parser → Macro expand
  → Monomorph (+ generic call inference)
  → Auto-borrow coercion
  → Typecheck → Ownership (Copy inference) → Borrow + Lifetimes + Send/Sync
  → Drop plan → LLVM IR (f64/double, spawn, custom drop)
  → opt → clang + Nyra runtime → binary

Stop early: nyra check . or nyra diag .. See Toolchain.