arena

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 Arena {
    head: Chunk*;
    current: Chunk*;
    chunk_size: u64;
}

Arena: bump allocator with bulk release.

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 Arena::new() -> Arena

Create an arena whose chunks are DEFAULT_CHUNK_SIZE bytes each.

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

Arena: bump allocator with bulk release.

static Arena::with_chunk_size(chunk_size: u64) -> Arena

Create an arena with a custom chunk size. Requests larger than chunk_size get their own chunk sized to fit, so the choice is a hint about *typical* allocation size, not a hard cap.

Arena::reset(mut &this) -> void

Reset every chunk's high-water mark to zero, making the arena's full capacity available for re-allocation without releasing the underlying chunks back to the system allocator. This is the amortizing power of an arena: repeated reset reuses the same memory instead of round-tripping through malloc/free.

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.

primitive void

No value; only valid as a return type.

Arena::capacity(&this) -> u64

Total bytes currently held in chunks (including unused tail).

Arena::used(&this) -> u64

Bytes handed out so far; this is the high-water mark for the arena.

Arena::bump(mut &this, size: u64, align: u64) -> void*

Hand out size bytes aligned to align from the arena. Returns null on out-of-memory or a zero-sized request. Marches through the chunk list (reusing chunks emptied by reset) before growing.

Arena::owns(&this, ptr: void*) -> boolean

True when ptr lies inside any chunk this arena owns. Used by GlobalAlloc's free/realloc routing to recognise arena-backed pointers so they are never handed to libc free. Range-scan of the chunk list (mirrors capacity); a pointer one-past-the-end of a chunk is intentionally excluded.

primitive boolean

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

Arena::grow(mut &this, ptr: void*, old_size: u64, new_size: u64, align: u64) -> void*

Grow (or shrink) a block previously handed out by bump. If ptr is the most-recent allocation in the frontier chunk and that chunk has room for the delta, the block is extended in place and the same pointer returned - this kills realloc-stranding for monotonic single-growers (e.g.

Arena::release(mut &this) -> void

Release every chunk back to the platform allocator. Invoked by the Drop impl in alloc::arena_alloc; exposed as an inherent method so the drop logic lives next to the allocation logic.

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

Arena: bump allocator with bulk release.

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.

static Arena::new() -> Arena

Create an arena whose chunks are DEFAULT_CHUNK_SIZE bytes each.

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.

static Array::new_in(alloc: A) -> Array<T, A>

Empty array with a caller-supplied allocator.

Arena::reset(mut &this) -> void

Reset every chunk's high-water mark to zero, making the arena's full capacity available for re-allocation without releasing the underlying chunks back to the system allocator. This is the amortizing power of an arena: repeated reset reuses the same memory instead of round-tripping through malloc/free.

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

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

via trait Drop

static Arena::with_chunk_size(chunk_size: u64) -> Arena

Create an arena with a custom chunk size. Requests larger than chunk_size get their own chunk sized to fit, so the choice is a hint about *typical* allocation size, not a hard cap.

Arena::used(&this) -> u64

Bytes handed out so far; this is the high-water mark for the arena.

Arena::bump(mut &this, size: u64, align: u64) -> void*

Hand out size bytes aligned to align from the arena. Returns null on out-of-memory or a zero-sized request. Marches through the chunk list (reusing chunks emptied by reset) before growing.

null

The null pointer literal, valid in any pointer context - including the primitive string, which is a NUL-terminated u8*. Compare with == null; it is not an Option.

Arena::owns(&this, ptr: void*) -> boolean

True when ptr lies inside any chunk this arena owns. Used by GlobalAlloc's free/realloc routing to recognise arena-backed pointers so they are never handed to libc free. Range-scan of the chunk list (mirrors capacity); a pointer one-past-the-end of a chunk is intentionally excluded.

type struct GlobalAlloc {}

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

Arena::grow(mut &this, ptr: void*, old_size: u64, new_size: u64, align: u64) -> void*

Grow (or shrink) a block previously handed out by bump. If ptr is the most-recent allocation in the frontier chunk and that chunk has room for the delta, the block is extended in place and the same pointer returned - this kills realloc-stranding for monotonic single-growers (e.g.

Arena::release(mut &this) -> void

Release every chunk back to the platform allocator. Invoked by the Drop impl in alloc::arena_alloc; exposed as an inherent method so the drop logic lives next to the allocation logic.

type trait Drop {
    drop(mut &this) -> void;
}

Drop: explicit destructor.

namespace std::alloc::arena_alloc;

Arena trait impls: Allocator and Drop for Arena.

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 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 trait Trait for Type { ... }

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

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

via trait Allocator

Arenas don't free individuals. This is a no-op; memory comes back at reset or drop.

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

via trait Allocator

Grow in place at the frontier when possible (see Arena::grow), else allocate-new + copy.