display

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 trait Name : Base {
    method(&this, other: &This) -> Ret;
}

Names a set of methods a type may implement. Inside the body This is the implementing type; methods may carry default bodies, and a trait may require a base trait (type trait Ord : Eq). Generic code asks for a trait with where T: Name.

type trait Display {
    fmt<W>(&this, f: mut &Formatter<W>) -> Result<(), FmtError>
    where W: FmtWrite;
}

Display / Debug / Formatter.

type parameter W

where W: FmtWrite

&this
mut &this
this

The receiver of a method. Its first parameter declares how the method takes it: &this borrows read-only, mut &this borrows exclusively, and this / mut this move the value in and consume it. In the body, this.field reaches the members.

mut &this
mut &Type

An exclusive, mutating borrow. As a receiver, mut &this lets the method modify the fields - and callers can see that from the signature alone. As a parameter type, mut &T lets the callee mutate through the reference while the caller keeps ownership.

type parameter W

where W: FmtWrite

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.

where T: Ord + Clone, U: Hash

Constrains generic parameters to types that implement the listed traits, which is what makes those traits' methods callable on T. Bounds on one parameter join with +; parameters separate with ,. A where on a single method narrows the type's parameter for that method only.

implement struct Name { ... }
implement trait Trait for Type { ... }
implement u64 { ... }

Adds methods to a type outside its declaration. implement struct T (or enum, or a bare primitive) opens an inherent block; implement trait Tr for T supplies a trait's methods for one type. Resolution is at compile time - no dynamic dispatch.

implement trait Trait for Type { ... }

Introduces a trait implementation: the block supplies, for one concrete type, the method bodies the trait requires.

type trait Display {
    fmt<W>(&this, f: mut &Formatter<W>) -> Result<(), FmtError>
    where W: FmtWrite;
}

Display / Debug / Formatter.

implement trait Trait for Type { ... }

Names the type a trait implementation is for. The block that follows supplies the bodies the trait requires.

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.

type parameter W

where W: FmtWrite

Formatter::write_str(mut &this, source: Str) -> Result<(), FmtError>
where W: FmtWrite

Write a Str. The usual path for fixed text and for pre-rendered ASCII (integer digits, escapes) wrapped as a Str.

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

Str: a borrowed UTF-8 string slice.

static Str::new(text: string) -> Str

Construct from a NUL-terminated C-style string literal. The caller certifies that text is valid UTF-8 and outlives this view. The NUL terminator is not included in the view.

value?

Error propagation. On a Result<T, E> it yields the T of an Ok and otherwise returns the Err(e) from the enclosing function unchanged; on an Option<T> it yields the T of a Some or returns None. The enclosing function must return a matching Result / Option.

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.

type parameter W

where W: FmtWrite

static name(param: Type) -> Ret { ... }

A method that belongs to the type rather than an instance, called as Type::name(..). For structs, static new(..) returning a struct literal is the idiomatic constructor.

static Formatter::new(writer: W*) -> Formatter<W>
where W: FmtWrite

Construct over any FmtWrite sink. The bound is restated on each instance method below; Cryo's monomorphizer doesn't carry where-clauses from a static factory into the surrounding impl block, so methods that route through W must declare the bound themselves.

Formatter::write_str(mut &this, source: Str) -> Result<(), FmtError>
where W: FmtWrite

Write a Str. The usual path for fixed text and for pre-rendered ASCII (integer digits, escapes) wrapped as a Str.

Formatter::write_char(mut &this, c: char) -> Result<(), FmtError>
where W: FmtWrite

Write a single Unicode scalar, UTF-8-encoded.

primitive char

8-bit character (byte).

Formatter::get_writer(&this) -> W*

Surface the underlying writer. For advanced composition where the caller wants to dispatch a second formatter against the same sink, or to flush mid-stream.

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 format_to_string<T>(value: &T) -> Result<String, FmtError>
where T: Display

Format value into a fresh heap-backed String. Caller owns the result and is responsible for dropping it.

pattern => { body }

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

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::fmt;

fmt: formatting values as text.

namespace std::fmt::display;

Display / Debug / Formatter.

type struct String<A = GlobalAlloc> {
    buffer: RawBuffer<u8, A>;
    length: u64;
}

String: owned, heap-allocated, length-typed UTF-8.

type enum Option<T> {
    Some(T);
    None;
}

Option: a value that may be absent.

type struct Pair<A, B> {
    first: A;
    second: B;
}

Pair<A, B>: an owned two-element tuple.

type struct Duration {
    secs: u64;
    nanos: u32;
}

A length of time: whole secs plus a sub-second nanos remainder (0 <= nanos < 1_000_000_000). POD; copy-by-value, no drop.

type struct DateTime {
    year: i64;
    month: u32;
    day: u32;
    hour: u32;
    minute: u32;
    second: u32;
}

A UTC civil calendar reading. All fields are UTC and already normalized: month in 1..=12, day in 1..=31, hour in 0..=23, minute/second in 0..=59. year is the proleptic Gregorian year and may be negative for timestamps far before the Common Era. POD.

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.

primitive u8

8-bit unsigned integer.

primitive u16

16-bit unsigned integer.

primitive u32

32-bit unsigned integer.

primitive u64

64-bit unsigned integer.

primitive u128

128-bit unsigned integer.

primitive i8

8-bit signed integer.

primitive i16

16-bit signed integer.

primitive i32

32-bit signed integer.

primitive i64

64-bit signed integer.

primitive i128

128-bit signed integer.

primitive usize

Pointer-width unsigned integer; the natural type for sizes and indices.

primitive isize

Pointer-width signed integer.

primitive f32

Single-precision IEEE 754 float.

primitive f64

Double-precision IEEE 754 float.

primitive boolean

true / false. Not interchangeable with integers. 1 byte.

primitive string

NUL-terminated raw string (u8*), matching the C ABI. Length-typed text is Str / String.

type parameter A

where A: Allocator

type trait Allocator {
    allocate(mut &this, layout: Layout) -> Result<NonNull<u8>, AllocError>;
    deallocate(mut &this, ptr: NonNull<u8>, layout: Layout) -> void;
    reallocate(mut &this, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout) -> Result<NonNull<u8>, AllocError>;
}

Allocator: the trait every heap strategy implements.

type parameter T

where T: Display

type enum Name {
    Unit,
    Payload(T),
    Named { x: i32 },
}

An algebraic data type. Variants may be bare or carry a tuple or struct payload, and a match on an enum must cover every variant. Name::Variant names a variant; methods are added with implement enum Name { ... }.

type parameter E

where E: Display

type struct Array<T, A = GlobalAlloc> where A: Allocator {
    ptr: T*;
    length: i64;
    capacity: i64;
    alloc: A;
}

Array<T, A>: growable, heap-backed, contiguous sequence.

type parameter K

where K: Display

type parameter V

where V: Display

type struct HashMap<K, V, A = GlobalAlloc> where A: Allocator {
    buckets: Entry<K, V>**;
    bucket_count: u64;
    length: u64;
    alloc: A;
    seed: u64;
}

HashMap<K, V, A>: key-value map with amortized O(1) operations.

type struct HashSet<T, A = GlobalAlloc> {
    map: HashMap<T, (), A>;
}

HashSet<T, A>: unordered collection of unique values.

type parameter A

where A: Display

type parameter B

where B: Display

type enum RandomError {
    EntropyUnavailable;
    EmptyRange;
    InvalidWeights;
}

What went wrong in a fallible random operation.

type struct ConversionError {
    reason: string;
}

What went wrong in a TryFrom / TryInto. Carries a short static message describing the failure; richer diagnostics are a caller concern.

for (mut i: i32 = 0; i < n; i++) { ... }
for (item in iterable) { ... }

Two forms. The C-style for (init; condition; step) scopes its loop variable to the body. for (x in expr) iterates anything with next() -> Option<T>: an iterator, a range such as 0..n, an Array or Slice (their iter() is inserted for you), or a fixed-size array.

type struct GlobalAlloc {}

Zero-sized handle to the process-wide allocator. Construct with GlobalAlloc::new(); all instances dispatch through the same underlying backend.

type parameter T

where T: Debug

type parameter E

where E: Debug

type parameter K

where K: Debug

type parameter V

where V: Debug

type parameter A

where A: Debug

type parameter B

where B: Debug

Formatter::get_writer(&this) -> W*

Surface the underlying writer. For advanced composition where the caller wants to dispatch a second formatter against the same sink, or to flush mid-stream.

static Formatter::new(writer: W*) -> Formatter<W>
where W: FmtWrite

Construct over any FmtWrite sink. The bound is restated on each instance method below; Cryo's monomorphizer doesn't carry where-clauses from a static factory into the surrounding impl block, so methods that route through W must declare the bound themselves.

Formatter::write_char(mut &this, c: char) -> Result<(), FmtError>
where W: FmtWrite

Write a single Unicode scalar, UTF-8-encoded.

function format_debug_to_string<T>(value: &T) -> Result<String, FmtError>
where T: Debug

Same shape for Debug.

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.

function format_to_string<T>(value: &T) -> Result<String, FmtError>
where T: Display

Format value into a fresh heap-backed String. Caller owns the result and is responsible for dropping it.

function format_debug_to_string<T>(value: &T) -> Result<String, FmtError>
where T: Debug

Same shape for Debug.