hashmap

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 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 parameter A

where A: Allocator

type struct GlobalAlloc {}

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

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.

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.

primitive u64

64-bit unsigned integer.

HashMap.seed: u64

Per-map hash seed (initial DefaultHasher state). Drawn from the process seed generator (next_map_seed) so bucket placement is unpredictable between runs; fixed via with_seed* for tests that need reproducible iteration/layout.

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.

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.

static HashMap::with_seed(seed: u64) -> HashMap<K, V, GlobalAlloc>

Construct an empty map with an explicit, fixed hash seed instead of a random one. Intended for tests and any caller that needs reproducible bucket placement / iteration order; production code should prefer new so the seed stays unpredictable.

static HashMap::with_seed_in(seed: u64, alloc: A) -> HashMap<K, V, A>

with_seed in a caller-supplied allocator.

static HashMap::with_capacity(capacity: u64) -> HashMap<K, V, GlobalAlloc>

Preallocate for at least capacity entries at the default load factor. The actual bucket count is the smallest power of two that keeps the load factor below 1.0.

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

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

HashMap::get_bucket(&this, index: u64) -> Entry<K, V>*

Return the head of the entry chain for bucket index. Returns null if the bucket is empty or index is out of range. The returned pointer is valid until the next mutation of the map.

HashMap::iter(&this) -> implement Iterator<Pair<K, V>>
where K: Copy, V: Copy

Iterate over every entry, yielding Pair<K, V> (key first, value second). Iteration order is bucket-major and undefined across resizes; do not rely on it.

-> implement Trait<T>

An opaque type: some one concrete type that implements the trait, without naming it. The compiler infers the real type and uses it everywhere; callers see only the trait's methods. How the stdlib returns iterators without exposing their engines.

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

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

type trait Copy {}

Types whose values can be duplicated by a bitwise copy. Integers, floats, pointers, and pure-POD structs qualify; anything that owns resources (heap storage, file handles, refcount) does not.

HashMap::keys(&this) -> implement Iterator<K>
where K: Copy

Iterate over the keys, yielding each by value (bitwise copy). Gated on K: Copy for the same reason as iter. Order is bucket-major and unstable across resizes.

HashMap::values(&this) -> implement Iterator<V>
where V: Copy

Iterate over the values, yielding each by value (bitwise copy). Gated on V: Copy. Order is bucket-major and unstable.

HashMap::entries(&this) -> implement Iterator<Pair<K*, V*>>

Iterate over every entry, yielding Pair<K*, V*> (borrowed key and value). Unlike iter, this is sound for **any** K/V (owning or Copy) because it hands out borrows, never bitcopies - so it is the way to walk a HashMap<String, Foo> without cloning.

HashMap::keys_ref(&this) -> implement Iterator<K*>

Iterate over the keys by shared borrow, yielding K*. Sound for any K (owning or Copy); this is how to walk the keys of a HashMap<String, V> - the common case - without the K: Copy gate on keys. Same borrow/invalidation contract as entries.

HashMap::values_ref(&this) -> implement Iterator<V*>

Iterate over the values by shared borrow, yielding V*. Sound for any V (owning or Copy). Same borrow/invalidation contract as entries; use this to read or mutate owning values in place without the V: Copy gate on values.

type trait Hash {
    hash<H>(&this, hasher: mut &H) -> void
    where H: Hasher;
}

Hashing.

type trait Eq {
    equals(&this, other: &This) -> boolean;
}

Types that support value equality. equals(a, b) must be reflexive, symmetric, and transitive.

HashMap::get(&this, key: &K) -> Option<V>
where K: Hash + Eq, V: Copy

Look up a value by key, returning a bitwise copy. Gated on V: Copy for the same reason as Array::get: handing back a duplicate of an owning value would alias storage the map still owns, double-freeing on drop. For owning V, borrow in place with get_ref (or move it out with remove).

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

Option: a value that may be absent.

HashMap::get_ref(&this, key: &K) -> Option<V*>
where K: Hash + Eq

Like get, but returns a borrow (raw pointer) into the entry's stored value rather than a copy. Use when the value owns heap resources you don't want to clone, or when callers need to mutate the stored value in place.

HashMap::insert(mut &this, key: K, value: V) -> Option<V>
where K: Hash + Eq

Insert key -> value. Returns the previous value if the key was present, otherwise None. Panics on allocation failure; use try_insert to recover from OOM.

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

Result: a value that may be an error.

HashMap::get_or_insert(mut &this, key: K, default: V) -> V*
where K: Hash + Eq

Borrow the value for key, inserting default first if the key is absent. Returns a pointer to the (existing or freshly inserted) value, valid until the next mutation that removes this key or drops the map (a resize keeps entry storage in place). A single lookup, unlike get_ref-then-insert.

HashMap::try_get_or_insert(mut &this, key: K, default: V) -> Result<V*, AllocError>
where K: Hash + Eq

Fallible get_or_insert: returns Err(AllocError) instead of panicking when a needed resize or entry allocation fails.

HashMap::remove(mut &this, key: &K) -> Option<V>
where K: Hash + Eq

Remove the entry with matching key. Returns the removed value, or None if the key wasn't present.

HashMap::clear(mut &this) -> void

Drop every entry. Retains the bucket array so subsequent inserts don't re-pay the allocation.

primitive void

No value; only valid as a return type.

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.

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

collections: growable containers built on alloc/.

namespace std::collections::hashmap;

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

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.

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

Str: a borrowed UTF-8 string slice.

HashMap::get_or_insert(mut &this, key: K, default: V) -> V*
where K: Hash + Eq

Borrow the value for key, inserting default first if the key is absent. Returns a pointer to the (existing or freshly inserted) value, valid until the next mutation that removes this key or drops the map (a resize keeps entry storage in place). A single lookup, unlike get_ref-then-insert.

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

HashMap::get(&this, key: &K) -> Option<V>
where K: Hash + Eq, V: Copy

Look up a value by key, returning a bitwise copy. Gated on V: Copy for the same reason as Array::get: handing back a duplicate of an owning value would alias storage the map still owns, double-freeing on drop. For owning V, borrow in place with get_ref (or move it out with remove).

HashMap::get_ref(&this, key: &K) -> Option<V*>
where K: Hash + Eq

Like get, but returns a borrow (raw pointer) into the entry's stored value rather than a copy. Use when the value owns heap resources you don't want to clone, or when callers need to mutate the stored value in place.

HashMap::insert(mut &this, key: K, value: V) -> Option<V>
where K: Hash + Eq

Insert key -> value. Returns the previous value if the key was present, otherwise None. Panics on allocation failure; use try_insert to recover from OOM.

HashMap::remove(mut &this, key: &K) -> Option<V>
where K: Hash + Eq

Remove the entry with matching key. Returns the removed value, or None if the key wasn't present.

HashMap::get_bucket(&this, index: u64) -> Entry<K, V>*

Return the head of the entry chain for bucket index. Returns null if the bucket is empty or index is out of range. The returned pointer is valid until the next mutation of the map.

HashMap::try_get_or_insert(mut &this, key: K, default: V) -> Result<V*, AllocError>
where K: Hash + Eq

Fallible get_or_insert: returns Err(AllocError) instead of panicking when a needed resize or entry allocation fails.

HashMap.seed: u64

Per-map hash seed (initial DefaultHasher state). Drawn from the process seed generator (next_map_seed) so bucket placement is unpredictable between runs; fixed via with_seed* for tests that need reproducible iteration/layout.

type struct DefaultHasher {
    state: u64;
}

64-bit FNV-1a. Simple; not DoS-resistant. Fine as a HashMap default when inputs are trusted.

function next_map_seed() -> u64

Return the next per-map seed, initializing the process seed from the kernel CSPRNG on first use.

static HashMap::with_seed(seed: u64) -> HashMap<K, V, GlobalAlloc>

Construct an empty map with an explicit, fixed hash seed instead of a random one. Intended for tests and any caller that needs reproducible bucket placement / iteration order; production code should prefer new so the seed stays unpredictable.

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.

static HashMap::with_seed_in(seed: u64, alloc: A) -> HashMap<K, V, A>

with_seed in a caller-supplied allocator.

static HashMap::with_capacity(capacity: u64) -> HashMap<K, V, GlobalAlloc>

Preallocate for at least capacity entries at the default load factor. The actual bucket count is the smallest power of two that keeps the load factor below 1.0.

HashMap::iter(&this) -> implement Iterator<Pair<K, V>>
where K: Copy, V: Copy

Iterate over every entry, yielding Pair<K, V> (key first, value second). Iteration order is bucket-major and undefined across resizes; do not rely on it.

HashMap::keys(&this) -> implement Iterator<K>
where K: Copy

Iterate over the keys, yielding each by value (bitwise copy). Gated on K: Copy for the same reason as iter. Order is bucket-major and unstable across resizes.

HashMap::values(&this) -> implement Iterator<V>
where V: Copy

Iterate over the values, yielding each by value (bitwise copy). Gated on V: Copy. Order is bucket-major and unstable.

HashMap::entries(&this) -> implement Iterator<Pair<K*, V*>>

Iterate over every entry, yielding Pair<K*, V*> (borrowed key and value). Unlike iter, this is sound for **any** K/V (owning or Copy) because it hands out borrows, never bitcopies - so it is the way to walk a HashMap<String, Foo> without cloning.

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

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

HashMap::keys_ref(&this) -> implement Iterator<K*>

Iterate over the keys by shared borrow, yielding K*. Sound for any K (owning or Copy); this is how to walk the keys of a HashMap<String, V> - the common case - without the K: Copy gate on keys. Same borrow/invalidation contract as entries.

HashMap::values_ref(&this) -> implement Iterator<V*>

Iterate over the values by shared borrow, yielding V*. Sound for any V (owning or Copy). Same borrow/invalidation contract as entries; use this to read or mutate owning values in place without the V: Copy gate on values.

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.

Array::get(&this, index: u64) -> Option<T>
where T: Copy

Bounds-checked read by value. Gated on T: Copy: the result is an independent bitwise duplicate while the array retains ownership of the stored element, so handing back a copy is only sound when T carries no Drop obligation.

// reserved

Opens no form of the language: a declaration or member written with it is refused where it is written (E0117). It still names a method: Default::default() is the trait's constructor.

HashMap::clear(mut &this) -> void

Drop every entry. Retains the bucket array so subsequent inserts don't re-pay the allocation.

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.

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 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 parameter K

where K: Hash + Eq + Clone

type parameter V

where V: Clone

type trait Clone {
    clone(&this) -> This;
}

Clone: explicit duplication.

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

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

type parameter K

where K: Display

type parameter V

where V: Display

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

Display / Debug / Formatter.

type parameter K

where K: Debug

type parameter V

where V: Debug

function name(count: i32, args...)

A variadic parameter: the trailing bucket receives any number of further arguments with C's calling convention, so the function stays ABI-compatible with the printf family. Wrap the bucket in VaArgs to read typed values from it.