cmp

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

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

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

This

The implementing type, inside a trait or implement body. other: &This in a trait method is a reference to whichever type implements it; This::Item names an associated type.

primitive boolean

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

type trait Ord : Eq {
    compare(&this, other: &This) -> Ordering;
}

Types that have a total order: every pair is Less, Equal, or Greater. compare must be consistent with equals: if a.equals(b) then a.compare(b) == Equal.

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

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

type enum Name {
    Unit,
    Payload(T),
    Named { x: i32 },
}

An algebraic data type. Variants may be bare or carry a tuple or struct payload, and a match on an enum must cover every variant. Name::Variant names a variant; methods are added with implement enum Name { ... }.

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 enum Name { ... }

Names the enum an inherent block extends - the only way to give an enum methods.

Ordering::reverse(&this) -> Ordering

Flip the direction of the comparison. Useful when sorting by a reversed key without duplicating the comparator.

Ordering::is_lt(&this) -> boolean

Ordering predicates backing the relational operators on Ord types. The compiler rewrites a < b into a.compare(&b).is_lt() (and >, <=, >= into is_gt/is_le/is_ge), so these keep the operator semantics in one place and let Ord-only types get < > <= >= for free once they implement compare.

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

Comparison: equality and ordering.

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.

primitive f32

Single-precision IEEE 754 float.

primitive f64

Double-precision IEEE 754 float.

type trait Ord : Eq {
    compare(&this, other: &This) -> Ordering;
}

Types that have a total order: every pair is Less, Equal, or Greater. compare must be consistent with equals: if a.equals(b) then a.compare(b) == Equal.

false

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

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.

primitive i8

8-bit signed integer.

primitive i16

16-bit signed integer.

primitive i32

32-bit signed integer.

primitive i64

64-bit signed integer.

primitive u8

8-bit unsigned integer.

primitive u16

16-bit unsigned integer.

primitive u32

32-bit unsigned integer.

primitive u64

64-bit unsigned integer.

primitive i128

128-bit signed integer.

primitive u128

128-bit unsigned integer.

primitive usize

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

primitive isize

Pointer-width signed integer.

primitive char

8-bit character (byte).

primitive string

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

type parameter T

where T: Eq

type parameter A

where A: Allocator

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.

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

where A: Eq

type parameter B

where B: Eq

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

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

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 enum Option<T> {
    Some(T);
    None;
}

Option: a value that may be absent.

type parameter E

where E: Eq

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

Result: a value that may be an error.

type enum RandomError {
    EntropyUnavailable;
    EmptyRange;
    InvalidWeights;
}

What went wrong in a fallible random operation.

type struct Instant {
    secs: i64;
    nanos: i64;
}

A measurement of the monotonic clock. Opaque: the fields are the raw timespec, meaningful only relative to another Instant. POD.

type struct Duration {
    secs: u64;
    nanos: u32;
}

A length of time: whole secs plus a sub-second nanos remainder (0 <= nanos < 1_000_000_000). POD; copy-by-value, no drop.

Ordering::reverse(&this) -> Ordering

Flip the direction of the comparison. Useful when sorting by a reversed key without duplicating the comparator.

Ordering::is_lt(&this) -> boolean

Ordering predicates backing the relational operators on Ord types. The compiler rewrites a < b into a.compare(&b).is_lt() (and >, <=, >= into is_gt/is_le/is_ge), so these keep the operator semantics in one place and let Ord-only types get < > <= >= for free once they implement compare.

function clamp<T>(value: T, lo: T, hi: T) -> T
where T: Ord

Constrain value to [lo, hi]. Panics if lo > hi; the caller gave a nonsense range.

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.

type parameter T

where T: Ord

function clamp<T>(value: T, lo: T, hi: T) -> T
where T: Ord

Constrain value to [lo, hi]. Panics if lo > hi; the caller gave a nonsense range.