table

type struct Name { ... }
type enum Name { ... }
type trait Name { ... }
type union Name { ... }

Begins a type declaration; the keyword that follows says which kind. On its own, type Name = Existing; declares an alias.

type struct Name {
    field: Type;
    method(&this) -> Ret { ... }
}

A value type with named fields and optional methods. Structs live on the stack and are passed by value. Fields are public by default and may carry = default values; methods take their receiver as &this, mut &this, or this.

primitive i32

32-bit signed integer.

function name<T>(param: Type) -> Ret { ... }

Declares a function. Parameters are written name: Type and are never inferred; the return type follows -> and defaults to void. Declaration order does not matter: every signature is collected before any body is checked, so functions may call each other freely and recurse.

type enum Result<T, E> {
    Ok(T);
    Err(E);
}

Result: a value that may be an error.

primitive ()

The unit type: a value that carries no information, and the empty tuple. Distinct from void, which is the absence of a value - Result<(), E> succeeds with nothing to return. 0 bytes.

type enum TestError {
    Failed(String);
    Other(String);
}

Why a test failed. The runner prints the variant's message verbatim to stderr from the child process before exiting non-zero, so the parent can show the failing message in the test summary.

const name: Type = value;

An immutable binding: it cannot be reassigned after initialisation. The annotation may be omitted when an initialiser is present - the binding takes the initialiser's concrete type, inferred locally. Mutability is opt-in through mut.

mut name: Type = value;

A mutable binding, reassignable after declaration - mutability is opt-in, const is the default. At module level it declares mutable global state. Before & it marks an exclusive reference or receiver instead.

primitive i64

64-bit signed integer.

while (condition) { ... }

Repeats its body while the condition holds. The condition is checked before every iteration, so the body may run zero times.

match (subject) {
    Pattern(x) => { ... }
    _          => { ... }
}

The primary discriminator: branches on enum variants, integers, ranges, and destructuring patterns, and the compiler rejects a match that misses a case. There is no fallthrough. As an expression it evaluates to the chosen arm's value, so every arm must produce the same type.

function expect_eq<T>(a: T, b: T) -> Result<(), TestError>
where T: Eq + Display

Ok(()) if a.equals(&b), otherwise Err carrying a multi-line "assertion left == right failed" message that Display-formats both values. Allocates the message on the heap; on allocation failure during message building, returns a generic fallback message.

pattern => { body }

Separates a match arm's pattern from its body. Arms do not fall through.

return value;

Leaves the current function with the given value. A function whose return type is not void must return one; a bare return; is for void. In an async function it completes the future with the value.

function prefix_case(index: u64, e: TestError) -> TestError

Wrap e's message with a case [<index>]: prefix, preserving the error's variant (Failed vs Other). Consumes e and returns the new error; call it on the failing-row path: return Result::Err(prefix_case(i as u64, e));

value as Type

Explicit conversion: between numeric types, or reinterpreting one pointer type as another. Cryo never converts implicitly, and as inserts no range checks - a narrowing cast is the programmer's responsibility.

primitive u64

64-bit unsigned integer.

import a::b;
import a::b::{ X, Y };
import a::b as c;
import a::b::*;

Brings a module, or selected items from it, into scope. One path per declaration: use the brace form for several items, as to alias, and * for everything public (prefer the brace form; wildcards invite name collisions).

namespace std;

std: the Cryo standard library.

namespace std::test;

test: Cryo's built-in unit-test framework.

namespace std::test::table;

Parametrized (data-driven) tests: run one test body over a table of cases and identify which row failed.

function name(count: i32, args...)

A variadic parameter: the trailing bucket receives any number of further arguments with C's calling convention, so the function stays ABI-compatible with the printf family. Wrap the bucket in VaArgs to read typed values from it.

function prefix_named_case(name: Str, e: TestError) -> TestError

Like prefix_case but uses a caller-supplied case label instead of a numeric index: case [empty input]: .... Useful when the table rows carry their own names.

function prefix_case(index: u64, e: TestError) -> TestError

Wrap e's message with a case [<index>]: prefix, preserving the error's variant (Failed vs Other). Consumes e and returns the new error; call it on the failing-row path: return Result::Err(prefix_case(i as u64, e));

TestError::Failed(String)

A user assertion failed. Carries the assertion message.

TestError::Other(String)

Any other reason a test could not produce a definitive result: I/O error during setup, environment problem, etc.

function prefix_named_case(name: Str, e: TestError) -> TestError

Like prefix_case but uses a caller-supplied case label instead of a numeric index: case [empty input]: .... Useful when the table rows carry their own names.

type struct Str {
    bytes: u8*;
    length: u64;
}

Str: a borrowed UTF-8 string slice.