default

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 Default {
    static default() -> This;
}

Default: a canonical "zero value" for a type.

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.

This

The implementing type, inside a trait or implement body. other: &This in a trait method is a reference to whichever type implements it; This::Item names an associated type.

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

core: foundation of the stdlib.

namespace std::core::default;

Default: a canonical "zero value" for a type.

type trait Default {
    static default() -> This;
}

Default: a canonical "zero value" for a type.

false

The boolean literal. Booleans are a distinct 1-byte type, not interchangeable with integers; if and while conditions must be boolean.

primitive boolean

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

primitive char

8-bit character (byte).

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 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.

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.

implement trait Trait for Type { ... }

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

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 u8

8-bit unsigned integer.

primitive u16

16-bit unsigned integer.

primitive u32

32-bit unsigned integer.

primitive u64

64-bit unsigned integer.

primitive i128

128-bit signed integer.

primitive u128

128-bit unsigned 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.

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 struct GlobalAlloc {}

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

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

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

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

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