pair

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 Pair<A, B> {
    first: A;
    second: B;
}

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

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 Pair::new(first: A, second: B) -> Pair<A, B>

Construct a pair from its two members. Both are moved in by value; if a member owns heap state, that ownership transfers to the pair and will be released when the pair itself is dropped.

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

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

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

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

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 trait Hash {
    hash<H>(&this, hasher: mut &H) -> void
    where H: Hasher;
}

Hashing.

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.

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.

primitive i64

64-bit signed integer.

Iterator::zip<J>(this, other: J) -> ZipIter<This, J>

Yield pairs (a, b) drawing a from this and b from other, stopping as soon as either iterator is exhausted. The pair is Pair<Item, B> where B is other's element type: p.first comes from this, p.second from other. (Cryo has no heterogeneous tuple literal, so Pair is the element type.)

Iterator::enumerate(this) -> EnumerateIter<This>

Yield (index, value) pairs, the index counting up from 0 as a u64. The pair is Pair<u64, Item>: p.first is the index, p.second the element. (Cryo has no heterogeneous tuple literal, so Pair is the element type.)

static Pair::new(first: A, second: B) -> Pair<A, B>

Construct a pair from its two members. Both are moved in by value; if a member owns heap state, that ownership transfers to the pair and will be released when the pair itself is dropped.

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

where A: Clone

type parameter B

where B: Clone

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 Clone {
    clone(&this) -> This;
}

Clone: explicit duplication.

implement trait Trait for Type { ... }

Names the type a trait implementation is for. The block that follows supplies the bodies the trait requires.

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

Drop: explicit destructor.

type parameter A

where A: Eq

type parameter B

where B: Eq

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

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

type parameter A

where A: Display

type parameter B

where B: Display

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

Display / Debug / Formatter.

type parameter A

where A: Debug

type parameter B

where B: Debug