source

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.

RandomSource::next_64(mut &this) -> u64

The single required primitive: the next 64 random bits.

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 u64

64-bit unsigned integer.

RandomSource::next<T>(mut &this) -> T

A uniform draw of type T, dispatched at compile time via static match (T) over the primitive next_64.

RandomSource::next_below(mut &this, bound: u64) -> u64

A uniform integer in [0, bound). Unbiased: the top partial bucket is rejected so the modulo introduces no skew. Panics when bound == 0 - an empty range has no value to return.

RandomSource::next_range<T>(mut &this, lo: T, hi: T) -> T

A uniform integer of type T in [lo, hi). Requires lo < hi. static match (T) covers every integer width: the spans of the 64-bit-and-narrower types are drawn unbiased through next_below; u128/i128 use an inline 128-bit rejection sampler.

RandomSource::next_below_wide(mut &this, bound: u128) -> u128

A uniform u128 in [0, bound), unbiased by the same top-bucket rejection as next_below but over the full 128-bit range. Backs the u128/i128 arms of next_range.

primitive u128

128-bit unsigned integer.

RandomSource::fill(mut &this, dst: Slice<u8>) -> void

Fill dst with random bytes, writing through the view.

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

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

primitive u8

8-bit unsigned integer.

primitive void

No value; only valid as a return type.

RandomSource::shuffle<T>(mut &this, items: &Slice<T>) -> void

Shuffle items in place with a uniform Fisher-Yates pass. Works for any element type - elements are swapped, never copied out, so no Copy bound is needed.

RandomSource::choose<T>(mut &this, items: &Slice<T>) -> Option<T*>

Borrow a uniformly chosen element of items, or None when items is empty. Returns a pointer in place, so no Copy is required and owning element types are fine.

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

Option: a value that may be absent.

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

std::random: pseudo-random and OS-backed randomness.

namespace std::random::source;

std::random::source: the RandomSource trait.

RandomSource::next_64(mut &this) -> u64

The single required primitive: the next 64 random bits.

RandomSource::next<T>(mut &this) -> T

A uniform draw of type T, dispatched at compile time via static match (T) over the primitive next_64.

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 usize

Pointer-width unsigned integer; the natural type for sizes and indices.

primitive isize

Pointer-width signed integer.

primitive boolean

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

primitive f32

Single-precision IEEE 754 float.

primitive f64

Double-precision IEEE 754 float.

primitive char

8-bit character (byte).

primitive i128

128-bit signed integer.

RandomSource::next_below(mut &this, bound: u64) -> u64

A uniform integer in [0, bound). Unbiased: the top partial bucket is rejected so the modulo introduces no skew. Panics when bound == 0 - an empty range has no value to return.

RandomSource::next_range<T>(mut &this, lo: T, hi: T) -> T

A uniform integer of type T in [lo, hi). Requires lo < hi. static match (T) covers every integer width: the spans of the 64-bit-and-narrower types are drawn unbiased through next_below; u128/i128 use an inline 128-bit rejection sampler.

RandomSource::next_below_wide(mut &this, bound: u128) -> u128

A uniform u128 in [0, bound), unbiased by the same top-bucket rejection as next_below but over the full 128-bit range. Backs the u128/i128 arms of next_range.

RandomSource::fill(mut &this, dst: Slice<u8>) -> void

Fill dst with random bytes, writing through the view.

RandomSource::shuffle<T>(mut &this, items: &Slice<T>) -> void

Shuffle items in place with a uniform Fisher-Yates pass. Works for any element type - elements are swapped, never copied out, so no Copy bound is needed.

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.

RandomSource::choose<T>(mut &this, items: &Slice<T>) -> Option<T*>

Borrow a uniformly chosen element of items, or None when items is empty. Returns a pointer in place, so no Copy is required and owning element types are fine.

primitive u32

32-bit unsigned integer.

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 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 Rng {
    s0: u64;
    s1: u64;
    s2: u64;
    s3: u64;
}

A fast non-cryptographic PRNG (xoshiro256**). The 256-bit state is the four words s0..s3.

type struct SecureRng {}

Cryptographically secure source backed by the kernel CSPRNG. Slower than Rng; use it only where unpredictability matters.