distribution

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.

type trait Distribution<T> {
    sample<R>(&this, rng: mut &R) -> T
    where R: RandomSource;
}

A sampleable distribution producing values of type T.

Distribution::sample<R>(&this, rng: mut &R) -> T
where R: RandomSource

Draw one value, advancing rng.

type parameter R

where R: RandomSource

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

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

where R: RandomSource

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.

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

std::random::distribution: samplers over any RandomSource.

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

type struct Normal {
    mean: f64;
    std_dev: f64;
}

The normal distribution, parameterized by mean and std_dev.

primitive f64

Double-precision IEEE 754 float.

Normal::sample<R>(&this, rng: mut &R) -> f64
where R: RandomSource

via trait Distribution

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 UniformU64 {
    lo: u64;
    hi: u64;
}

Uniform unsigned integers in [lo, hi).

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.

type struct UniformU64 {
    lo: u64;
    hi: u64;
}

Uniform unsigned integers in [lo, hi).

type struct UniformI64 {
    lo: i64;
    hi: i64;
}

Uniform signed integers in [lo, hi).

primitive i64

64-bit signed integer.

type struct UniformI64 {
    lo: i64;
    hi: i64;
}

Uniform signed integers in [lo, hi).

type struct UniformF64 {
    lo: f64;
    hi: f64;
}

Uniform reals in [lo, hi).

type struct UniformF64 {
    lo: f64;
    hi: f64;
}

Uniform reals in [lo, hi).

type struct Bernoulli {
    p: f64;
}

A biased coin: true with probability p, clamped to [0, 1].

type struct Bernoulli {
    p: f64;
}

A biased coin: true with probability p, clamped to [0, 1].

type struct Normal {
    mean: f64;
    std_dev: f64;
}

The normal distribution, parameterized by mean and std_dev.

type struct Exponential {
    lambda: f64;
}

The exponential distribution at rate lambda (mean 1 / lambda).

type struct Exponential {
    lambda: f64;
}

The exponential distribution at rate lambda (mean 1 / lambda).

type struct WeightedIndex {
    cumulative: Array<f64>;
    total: f64;
}

Chooses an index 0..n with probability proportional to a weight. Built once from a weight list, then sampled cheaply. Owns its cumulative table, so it carries a drop.

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 WeightedIndex::try_new(weights: Slice<f64>) -> Result<WeightedIndex, RandomError>

Build from weights. Fails with InvalidWeights if weights is empty, contains a negative entry, or sums to zero.

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

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

type enum Result<T, E> {
    Ok(T);
    Err(E);
}

Result: a value that may be an error.

type struct WeightedIndex {
    cumulative: Array<f64>;
    total: f64;
}

Chooses an index 0..n with probability proportional to a weight. Built once from a weight list, then sampled cheaply. Owns its cumulative table, so it carries a drop.

type enum RandomError {
    EntropyUnavailable;
    EmptyRange;
    InvalidWeights;
}

What went wrong in a fallible random operation.

WeightedIndex::length(&this) -> u64

The number of weights this index spans.

type trait Distribution<T> {
    sample<R>(&this, rng: mut &R) -> T
    where R: RandomSource;
}

A sampleable distribution producing values of type T.

Distribution::sample<R>(&this, rng: mut &R) -> T
where R: RandomSource

Draw one value, advancing rng.

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.

primitive boolean

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

static WeightedIndex::try_new(weights: Slice<f64>) -> Result<WeightedIndex, RandomError>

Build from weights. Fails with InvalidWeights if weights is empty, contains a negative entry, or sums to zero.

true

The boolean literal. Booleans are a distinct 1-byte type, not interchangeable with integers; if and while conditions must be boolean.

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

via trait Drop

WeightedIndex::length(&this) -> u64

The number of weights this index spans.

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

Drop: explicit destructor.