pool

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.

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

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

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

Layout: size + alignment of a memory block.

primitive u64

64-bit unsigned integer.

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 Pool::new(slot: Layout) -> Pool

Create a pool serving slot-sized allocations with the default block granularity. Panics if slot.size() < sizeof(FreeNode*): the intrusive free list needs a pointer's worth of room in each slot.

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

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

static Pool::with_block_size(slot: Layout, slots_per_block: u64) -> Pool

Create a pool with a custom number of slots per backing block. Larger blocks reduce malloc frequency at the cost of more unused tail memory for small pools.

Pool::allocate_slot(mut &this) -> Result<NonNull<u8>, AllocError>

Grab a free slot, carving a new block if the free list is empty. Returns Err(OutOfMemory) if the backing allocator refuses the block request.

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 enum Result<T, E> {
    Ok(T);
    Err(E);
}

Result: a value that may be an error.

primitive u8

8-bit unsigned integer.

Pool::deallocate_slot(mut &this, ptr: NonNull<u8>) -> void

Return a slot to the pool. ptr must have come from a previous allocate_slot on **this** pool and must not have been freed.

primitive void

No value; only valid as a return type.

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

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

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

static Pool::new(slot: Layout) -> Pool

Create a pool serving slot-sized allocations with the default block granularity. Panics if slot.size() < sizeof(FreeNode*): the intrusive free list needs a pointer's worth of room in each slot.

sizeof(T)

The size of a type in bytes, as a compile-time constant - usable in static_assert. alignof(T) gives the alignment.

static Pool::with_block_size(slot: Layout, slots_per_block: u64) -> Pool

Create a pool with a custom number of slots per backing block. Larger blocks reduce malloc frequency at the cost of more unused tail memory for small pools.

Pool::allocate_slot(mut &this) -> Result<NonNull<u8>, AllocError>

Grab a free slot, carving a new block if the free list is empty. Returns Err(OutOfMemory) if the backing allocator refuses the block request.

AllocErrorKind::OutOfMemory

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

Pool::deallocate_slot(mut &this, ptr: NonNull<u8>) -> void

Return a slot to the pool. ptr must have come from a previous allocate_slot on **this** pool and must not have been freed.

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 Drop {
    drop(mut &this) -> void;
}

Drop: explicit destructor.

implement trait Trait for Type { ... }

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

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.

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.

Pool::drop(mut &this) -> void

via trait Drop