hash

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

Hashing.

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 DefaultHasher {
    state: u64;
}

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

DefaultHasher::fold<T>(mut &this, value: T) -> void

via trait Hasher

Fold one delimited value into the running digest, dispatched at compile time via static match (T) (no runtime cost, no trait bound - the arms ARE the accepted types). Lets a digest be composed from heterogeneous typed parts (h.fold(x); h.fold(y); h.finish()) without a per-type helper name.

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.

DefaultHasher::finish(&this) -> u64

via trait Hasher

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.

Hasher::write_u8(mut &this, value: u8) -> void

Feed a single byte into the hash state.

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 u8

8-bit unsigned integer.

primitive void

No value; only valid as a return type.

Hasher::write_bytes(mut &this, bytes: Slice<u8>) -> void

Feed a byte slice. Implementations should override with a faster bulk path; the default falls back to write_u8 per byte.

type struct Slice<T> {
    ptr: T*;
    length: u64;
}

Slice<T>: a borrowed view into a contiguous sequence.

Hasher::write_uint(mut &this, value: u128, byte_count: u32) -> void

Feed the low byte_count bytes of value, least-significant byte first (little-endian, platform-independent). The single entry point for hashing any fixed-width integer: write_u8 is the 1-byte special case; this covers 2/4/8/16-byte values.

primitive u128

128-bit unsigned integer.

primitive u32

32-bit unsigned integer.

Hasher::fold<T>(mut &this, value: T) -> void

Fold one delimited value into the running digest, dispatched at compile time via static match (T) (no runtime cost, no trait bound - the arms ARE the accepted types). Lets a digest be composed from heterogeneous typed parts (h.fold(x); h.fold(y); h.finish()) without a per-type helper name.

Hasher::finish(&this) -> u64

Finalize the hash and return the digest. After calling finish the hasher should not be written to again.

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

Hashing.

type parameter H

where H: Hasher

type parameter H

where H: Hasher

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 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 DefaultHasher {
    state: u64;
}

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

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 DefaultHasher::from_state(state: u64) -> DefaultHasher

Resume hashing from a previously-finished u64 state. Lets an incremental fold thread a running digest through several steps (e.g. build fingerprinting) without re-deriving the FNV-1a update inline.

static DefaultHasher::offset_basis() -> u64

The FNV-1a offset basis: the initial state of a fresh hasher.

type struct Fnv128Hasher {
    state: u128;
}

128-bit FNV-1a. Same construction as DefaultHasher, twice the width.

type struct Fnv128Hasher {
    state: u128;
}

128-bit FNV-1a. Same construction as DefaultHasher, twice the width.

static Fnv128Hasher::from_state(state: u128) -> Fnv128Hasher

Resume from a previously-finish128ed state, so a digest can be threaded through several steps without re-deriving the update.

Fnv128Hasher::finish128(&this) -> u128

The full 128-bit digest. finish narrows to 64 bits to satisfy Hasher; callers that want the width this type exists for use this.

Fnv128Hasher::high64(&this) -> u64

The digest's two halves, high first, for callers rendering it as text. Returned rather than formatted here so core::hash keeps depending on nothing but core - hex formatting lives on u64, and pulling String in for it would put the collections module underneath every HashMap that uses this file.

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

Hashing.

Hasher::write_u8(mut &this, value: u8) -> void

Feed a single byte into the hash state.

Hasher::write_bytes(mut &this, bytes: Slice<u8>) -> void

Feed a byte slice. Implementations should override with a faster bulk path; the default falls back to write_u8 per byte.

Hasher::write_uint(mut &this, value: u128, byte_count: u32) -> void

Feed the low byte_count bytes of value, least-significant byte first (little-endian, platform-independent). The single entry point for hashing any fixed-width integer: write_u8 is the 1-byte special case; this covers 2/4/8/16-byte values.

Hasher::fold<T>(mut &this, value: T) -> void

Fold one delimited value into the running digest, dispatched at compile time via static match (T) (no runtime cost, no trait bound - the arms ARE the accepted types). Lets a digest be composed from heterogeneous typed parts (h.fold(x); h.fold(y); h.finish()) without a per-type helper name.

static match (T) { ... }

Opens a compile-time match on a type parameter: the one arm whose type matches is kept during monomorphisation and the rest are discarded.

static match (T) {
    u8 | u16 => { ... }
    _        => { ... }
}

Selects a body by inspecting a type parameter at compile time. The subject is a type and each arm is a type (| groups several; _ takes the rest). During monomorphisation the one matching arm is kept and the others discarded, so there is no runtime branch.

primitive char

8-bit character (byte).

primitive boolean

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

primitive string

NUL-terminated raw string (u8*), matching the C ABI. Length-typed text is Str / String.

primitive i8

8-bit signed integer.

primitive i128

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

Hasher::finish(&this) -> u64

Finalize the hash and return the digest. After calling finish the hasher should not be written to again.

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 trait Eq {
    equals(&this, other: &This) -> boolean;
}

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

primitive u16

16-bit unsigned integer.

primitive i16

16-bit signed integer.

primitive i32

32-bit signed integer.

primitive i64

64-bit signed integer.

type parameter T

where T: Hash

type parameter A

where A: Allocator

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

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

Str: a borrowed UTF-8 string slice.

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

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

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 DefaultHasher::from_state(state: u64) -> DefaultHasher

Resume hashing from a previously-finished u64 state. Lets an incremental fold thread a running digest through several steps (e.g. build fingerprinting) without re-deriving the FNV-1a update inline.

static DefaultHasher::offset_basis() -> u64

The FNV-1a offset basis: the initial state of a fresh hasher.

Fnv128Hasher::finish128(&this) -> u128

The full 128-bit digest. finish narrows to 64 bits to satisfy Hasher; callers that want the width this type exists for use this.

Fnv128Hasher::high64(&this) -> u64

The digest's two halves, high first, for callers rendering it as text. Returned rather than formatted here so core::hash keeps depending on nothing but core - hex formatting lives on u64, and pulling String in for it would put the collections module underneath every HashMap that uses this file.

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.