allocator

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

Allocator::allocate(mut &this, layout: Layout) -> Result<NonNull<u8>, AllocError>

Return a pointer to at least layout.size bytes aligned to layout.alignment. The returned memory is uninitialized; the caller writes to it before any read.

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.

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

type struct Layout {
    size: u64;
    alignment: u64;
}

Layout: size + alignment of a memory block.

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

Result: a value that may be an error.

primitive u8

8-bit unsigned integer.

Allocator::deallocate(mut &this, ptr: NonNull<u8>, layout: Layout) -> void

Return memory to the allocator. ptr must have come from a previous allocate on **this** allocator with a matching layout. Using the pointer after this call is undefined.

primitive void

No value; only valid as a return type.

Allocator::reallocate(mut &this, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout) -> Result<NonNull<u8>, AllocError>

Default implementation: allocate fresh memory, copy, free old. Allocators that can grow a block in place (real realloc) should override for the win.

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.

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.

AllocError::describe(&this) -> Str

A short, stable description of what went wrong, as a borrowed Str. The convergent accessor every stdlib error type exposes (describe(&this) -> Str); Display/Debug for AllocError delegate to it. The requested layout remains available as a field.

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

Str: a borrowed UTF-8 string slice.

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

AllocErrorKind::OutOfMemory

The underlying allocator returned null; the system is out of memory or hit an address-space limit.

AllocErrorKind::ZeroSized

The allocator refuses zero-sized requests. Callers that want a non-null dangling pointer for a zero-sized type should handle the zero case themselves before calling allocate.

AllocErrorKind::Exhausted

A bounded allocator (arena, pool) has no room for this request.

AllocErrorKind::InvalidLayout

The requested layout is incompatible with this allocator (e.g., the size or alignment doesn't match a Pool's fixed slot). The caller passed the wrong allocator for the requested layout.

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

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

const NAME: Type = value;

At module level, a true compile-time constant, conventionally SCREAMING_SNAKE_CASE. (mut at module level declares mutable global state instead.)

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

alloc: heap allocation primitives.

namespace std::alloc::allocator;

Allocator: the trait every heap strategy implements.

Allocator::allocate(mut &this, layout: Layout) -> Result<NonNull<u8>, AllocError>

Return a pointer to at least layout.size bytes aligned to layout.alignment. The returned memory is uninitialized; the caller writes to it before any read.

Allocator::deallocate(mut &this, ptr: NonNull<u8>, layout: Layout) -> void

Return memory to the allocator. ptr must have come from a previous allocate on **this** allocator with a matching layout. Using the pointer after this call is undefined.

Allocator::reallocate(mut &this, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout) -> Result<NonNull<u8>, AllocError>

Default implementation: allocate fresh memory, copy, free old. Allocators that can grow a block in place (real realloc) should override for the win.

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.

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.

type struct Arena {
    head: Chunk*;
    current: Chunk*;
    chunk_size: u64;
}

Arena: bump allocator with bulk release.

type struct Pool {
    slot: Layout;
    slots_per_block: u64;
    free_list: FreeNode*;
    blocks: Block*;
}

Pool: O(1) allocator for uniformly-sized slots.

AllocError::describe(&this) -> Str

A short, stable description of what went wrong, as a borrowed Str. The convergent accessor every stdlib error type exposes (describe(&this) -> Str); Display/Debug for AllocError delegate to it. The requested layout remains available as a field.

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

Display / Debug / Formatter.

AllocErrorKind::OutOfMemory

The underlying allocator returned null; the system is out of memory or hit an address-space limit.

AllocErrorKind::ZeroSized

The allocator refuses zero-sized requests. Callers that want a non-null dangling pointer for a zero-sized type should handle the zero case themselves before calling allocate.

AllocErrorKind::Exhausted

A bounded allocator (arena, pool) has no room for this request.

AllocErrorKind::InvalidLayout

The requested layout is incompatible with this allocator (e.g., the size or alignment doesn't match a Pool's fixed slot). The caller passed the wrong allocator for the requested layout.

type struct Box<T, A = GlobalAlloc> where A: Allocator {
    ptr: T*;
    alloc: A;
}

Box<T, A>: single-owner heap allocation.

namespace std::alloc::heap;

heap: the mmap-backed process heap (Low-Level Plan Stage 3).

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 next_capacity(current: u64, required: u64, min_capacity: u64) -> u64

Geometric growth-size for a contiguous buffer that must hold at least required slots. Doubles current (seeded by min_capacity so empty-to-nonempty transitions don't start at a single slot) until it reaches required.

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 RawBuffer<T, A = GlobalAlloc> where A: Allocator {
    ptr: T*;
    capacity: u64;
    alloc: A;
}

RawBuffer: the allocator-backed storage half of a growable container.

RawBuffer::reserve(mut &this, used: u64, additional: u64, min_capacity: u64) -> Result<(), AllocError>

Ensure at least additional more slots past used fit. Over-allocates along the doubling curve, seeded by min_capacity when the buffer is small (so empty-to-nonempty transitions don't start at a single slot).

public function name() { ... }
public:

Visible to any module that imports this one - the default for top-level items and for struct fields, so it is mostly written to be explicit. public: opens a visibility block that groups the members after it.

public function alloc(size: u64, align: u64) -> void*

Allocate size bytes aligned to align via GlobalAlloc. Null/zero guarded; returns null on OOM so the emitter's existing null-check on the old malloc result is unchanged.

public function free(ptr: void*, align: u64) -> void

Free a block from alloc via GlobalAlloc::deallocate, which already no-ops arena-owned pointers (bulk-reclaimed at the target boundary) and frees libc-owned ones. align must match the new site; deallocate ignores the layout size, so a 1-byte placeholder is fine.

public function alloc(size: u64, align: u64) -> void*

Allocate size bytes aligned to align via GlobalAlloc. Null/zero guarded; returns null on OOM so the emitter's existing null-check on the old malloc result is unchanged.

GlobalAlloc::deallocate(mut &this, ptr: NonNull<u8>, layout: Layout) -> void

via trait Allocator

new T { field: value }
new E::Variant(args)
new T[n]

Heap allocation. new T { .. } places a struct literal on the heap and yields a T*, and new E::V(args) does the same for an enum variant; new T[n] reserves n uninitialised T - the typed malloc. The storage comes from T's Allocate implementation, or else the global allocator. Parentheses after a struct's name are refused (E0117): there are no constructors, and a struct's static new(..) is an ordinary method.

delete p;

Releases what new T { .. } allocated: the pointee's Drop and the values its fields own, then its storage, through T's Allocate::release. Memory from new T[n] or malloc is released with free instead.

public function free(ptr: void*, align: u64) -> void

Free a block from alloc via GlobalAlloc::deallocate, which already no-ops arena-owned pointers (bulk-reclaimed at the target boundary) and frees libc-owned ones. align must match the new site; deallocate ignores the layout size, so a 1-byte placeholder is fine.