array

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 Array<T, A = GlobalAlloc> where A: Allocator {
    ptr: T*;
    length: i64;
    capacity: i64;
    alloc: A;
}

Array<T, A>: growable, heap-backed, contiguous sequence.

type parameter A

where A: Allocator

type struct GlobalAlloc {}

Zero-sized handle to the process-wide allocator. Construct with GlobalAlloc::new(); all instances dispatch through the same underlying backend.

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

where A: Allocator

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.

primitive i64

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

static Array::new() -> Array<T, GlobalAlloc>

Empty array backed by GlobalAlloc.

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 Array::new_in(alloc: A) -> Array<T, A>

Empty array with a caller-supplied allocator.

static Array::with_capacity(capacity: u64) -> Array<T, GlobalAlloc>

Preallocate room for capacity elements. Panics on allocation failure; use try_with_capacity_in to recover.

primitive u64

64-bit unsigned integer.

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

Result: a value that may be an error.

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

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

Array::get(&this, index: u64) -> Option<T>
where T: Copy

Bounds-checked read by value. Gated on T: Copy: the result is an independent bitwise duplicate while the array retains ownership of the stored element, so handing back a copy is only sound when T carries no Drop obligation.

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

Option: a value that may be absent.

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.

Array::get_ref(&this, index: u64) -> Option<T*>

Bounds-checked borrow. Returns a pointer to the element in place; the array keeps ownership, so this is sound for every T (Copy or owning). The pointer is invalidated by any reallocating method (push, reserve, shrink_to_fit).

Array::as_ptr(&this) -> T*

Raw pointer. Invalidated by any method that may reallocate (push, reserve, shrink_to_fit).

Array::as_slice(&this) -> Slice<T>

Borrow the initialized prefix. Slice is invalidated by any reallocating method.

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

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

Array::iter(&this) -> implement Iterator<T>
where T: Copy

Iterate over the elements in order, yielding each by value (bitwise copy). Gated on T: Copy for the same reason as get: a yielded owning value would alias storage the array still owns. For owning T, walk by index with length() + get_ref.

-> implement Trait<T>

An opaque type: some one concrete type that implements the trait, without naming it. The compiler infers the real type and uses it everywhere; callers see only the trait's methods. How the stdlib returns iterators without exposing their engines.

Array::iter_ref(&this) -> implement Iterator<T*>

Iterate by shared borrow, yielding T* for each element in order. Unlike iter, this is sound for every T (Copy or owning) because it hands out borrows, never copies. The pointers are invalidated by any reallocating method (push, reserve, insert, shrink_to_fit).

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.

primitive void

No value; only valid as a return type.

primitive ()

The unit type: a value that carries no information, and the empty tuple. Distinct from void, which is the absence of a value - Result<(), E> succeeds with nothing to return. 0 bytes.

Array::set(mut &this, index: u64, value: T) -> void

Overwrite the element at index, taking ownership of value. The previous occupant is released in place before the slot is reused: a raw slot store (this.ptr[index] = value) does NOT drop the destination, so for owning T (String, Box<T>, ...) the old element's resources would otherwise leak.

Array::swap_remove(mut &this, index: u64) -> T

Remove at index by swapping in the last element. O(1) but doesn't preserve order. Panics on out-of-range.

Array::first(&this) -> Option<T*>

First element by shared borrow, or None if empty. Sound for every T (the array keeps ownership). Invalidated by any reallocating method.

Array::last(&this) -> Option<T*>

Last element by shared borrow, or None if empty.

Array::index_of(&this, value: &T) -> Option<u64>
where T: Eq

Index of the first element equal to value, or None. Linear scan; T: Eq.

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

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

Array::contains(&this, value: &T) -> boolean
where T: Eq

True if some element equals value. T: Eq.

Array::reverse(mut &this) -> void

Reverse the elements in place. Sound for owning T: each pair is exchanged with a three-step move (identical to mem::swap's body, inlined here so the method stays self-contained - see note below).

Array::insert(mut &this, index: u64, value: T) -> void

Insert value at index, shifting later elements right by one. index == length appends. Panics if index > length. Panics on allocation failure; use the Result-returning forms for recovery via try_push if you need fallibility on the common (append) path.

Array::remove(mut &this, index: u64) -> T

Remove and return the element at index, shifting later elements left by one to preserve order (O(n)). Panics if out of range. For O(1) removal when order doesn't matter, use swap_remove.

Array::truncate(mut &this, new_length: u64) -> void

Shorten to at most new_length, releasing the truncated elements in place. A no-op if new_length >= length. Keeps capacity.

Array::clear(mut &this) -> void

Release every initialized element (the [0, length) prefix) in place, then reset the length to zero while keeping the backing capacity. Mirrors drop's element teardown so Array<String>, Array<Box<...>>, and similar owning shapes don't leak their contents.

Array::sort(mut &this) -> void
where T: Ord

Sort the array in place, ascending, by T::compare.

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.

Array::sort_by(mut &this, less: (&T, &T) -> boolean) -> void

Sort in place using a user-supplied "less-than" predicate. Returns no value; mutates the array. Same complexity and stability as sort(). The predicate must impose a strict weak ordering (irreflexive, transitive, with the implied equivalence being transitive) or the result is unspecified.

Array::append(mut &this, source: Slice<T>) -> void
where T: Copy

Append every element of source to the end of this array. Panics on allocation failure; use try_append to recover.

Array::try_append(mut &this, source: Slice<T>) -> Result<(), AllocError>
where T: Copy

Fallible bulk append. Reserves space for all elements first so partial copies are impossible; either all elements are appended or none are. Gated on T: Copy (see append): the append is a bitwise memcpy out of the borrowed source.

Array::resize(mut &this, new_length: u64, value: T) -> void
where T: Copy

Set the length to exactly new_length, filling any new slots with value. Shrinking drops the elements above new_length, exactly as truncate does; growing leaves every slot initialized, so the whole [0, new_length) range is readable afterwards.

Array::try_resize(mut &this, new_length: u64, value: T) -> Result<(), AllocError>
where T: Copy

Fallible resize. Reserves the whole growth up front, so the array is either resized or left exactly as it was - never partially grown.

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 String<A = GlobalAlloc> {
    buffer: RawBuffer<u8, A>;
    length: u64;
}

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

static Array::new() -> Array<T, GlobalAlloc>

Empty array backed by GlobalAlloc.

static String::from<T>(item: T) -> String

Create a String from item, using the SAME compile-time static match (T) dispatch as push - the central T-generic constructor. String::from("hi"), String::from(65 as u32), String::from(true), String::from(some_str) all route through push. Panics on allocation failure.

for (mut i: i32 = 0; i < n; i++) { ... }
for (item in iterable) { ... }

Two forms. The C-style for (init; condition; step) scopes its loop variable to the body. for (x in expr) iterates anything with next() -> Option<T>: an iterator, a range such as 0..n, an Array or Slice (their iter() is inserted for you), or a fixed-size array.

for (item in iterable) { ... }

Separates the loop variable from the sequence in a for loop. The sequence is evaluated once; the loop lowers to loop { match (it.next()) { Some(x) => .., None => break } }.

Array::iter_ref(&this) -> implement Iterator<T*>

Iterate by shared borrow, yielding T* for each element in order. Unlike iter, this is sound for every T (Copy or owning) because it hands out borrows, never copies. The pointers are invalidated by any reallocating method (push, reserve, insert, shrink_to_fit).

function println(text: String) -> void

Like print, followed by a newline.

primitive i32

32-bit signed integer.

function from_iter<I, T>(it: I) -> Array<T>
where I: Iterator<T>

Collect every element an iterator yields into a fresh Array<T>, in order. it is consumed. T is recovered from the iterator's Iterator<T> impl, and the result element type is fixed by the expected type at the call site:

start..end

A half-open range - start up to but excluding end - and sugar for Range::new(start, end): an iterator usable in for, and an ordinary value anywhere else. It binds looser than arithmetic, so a..b + 1 is a..(b + 1).

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

collections: growable containers built on alloc/.

namespace std::collections::array;

Array<T, A>: growable, heap-backed, contiguous sequence.

primitive string

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

Array::as_slice(&this) -> Slice<T>

Borrow the initialized prefix. Slice is invalidated by any reallocating method.

static Array::new_in(alloc: A) -> Array<T, A>

Empty array with a caller-supplied allocator.

static Array::with_capacity(capacity: u64) -> Array<T, GlobalAlloc>

Preallocate room for capacity elements. Panics on allocation failure; use try_with_capacity_in to recover.

Array::get(&this, index: u64) -> Option<T>
where T: Copy

Bounds-checked read by value. Gated on T: Copy: the result is an independent bitwise duplicate while the array retains ownership of the stored element, so handing back a copy is only sound when T carries no Drop obligation.

type trait Drop {
    drop(mut &this) -> void;
}

Drop: explicit destructor.

Array::get_ref(&this, index: u64) -> Option<T*>

Bounds-checked borrow. Returns a pointer to the element in place; the array keeps ownership, so this is sound for every T (Copy or owning). The pointer is invalidated by any reallocating method (push, reserve, shrink_to_fit).

Array::swap_remove(mut &this, index: u64) -> T

Remove at index by swapping in the last element. O(1) but doesn't preserve order. Panics on out-of-range.

Array::as_ptr(&this) -> T*

Raw pointer. Invalidated by any method that may reallocate (push, reserve, shrink_to_fit).

Array::iter(&this) -> implement Iterator<T>
where T: Copy

Iterate over the elements in order, yielding each by value (bitwise copy). Gated on T: Copy for the same reason as get: a yielded owning value would alias storage the array still owns. For owning T, walk by index with length() + get_ref.

Array::insert(mut &this, index: u64, value: T) -> void

Insert value at index, shifting later elements right by one. index == length appends. Panics if index > length. Panics on allocation failure; use the Result-returning forms for recovery via try_push if you need fallibility on the common (append) path.

type struct Box<T, A = GlobalAlloc> where A: Allocator {
    ptr: T*;
    alloc: A;
}

Box<T, A>: single-owner heap allocation.

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.

Array::set(mut &this, index: u64, value: T) -> void

Overwrite the element at index, taking ownership of value. The previous occupant is released in place before the slot is reused: a raw slot store (this.ptr[index] = value) does NOT drop the destination, so for owning T (String, Box<T>, ...) the old element's resources would otherwise leak.

Array::index(&this, i: i8) -> T*

via trait Index

Array::first(&this) -> Option<T*>

First element by shared borrow, or None if empty. Sound for every T (the array keeps ownership). Invalidated by any reallocating method.

Array::last(&this) -> Option<T*>

Last element by shared borrow, or None if empty.

Array::index_of(&this, value: &T) -> Option<u64>
where T: Eq

Index of the first element equal to value, or None. Linear scan; T: Eq.

Array::contains(&this, value: &T) -> boolean
where T: Eq

True if some element equals value. T: Eq.

Array::reverse(mut &this) -> void

Reverse the elements in place. Sound for owning T: each pair is exchanged with a three-step move (identical to mem::swap's body, inlined here so the method stays self-contained - see note below).

Array::remove(mut &this, index: u64) -> T

Remove and return the element at index, shifting later elements left by one to preserve order (O(n)). Panics if out of range. For O(1) removal when order doesn't matter, use swap_remove.

Array::truncate(mut &this, new_length: u64) -> void

Shorten to at most new_length, releasing the truncated elements in place. A no-op if new_length >= length. Keeps capacity.

Array::clear(mut &this) -> void

Release every initialized element (the [0, length) prefix) in place, then reset the length to zero while keeping the backing capacity. Mirrors drop's element teardown so Array<String>, Array<Box<...>>, and similar owning shapes don't leak their contents.

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

via trait Drop

Array::sort(mut &this) -> void
where T: Ord

Sort the array in place, ascending, by T::compare.

Array::sort_by(mut &this, less: (&T, &T) -> boolean) -> void

Sort in place using a user-supplied "less-than" predicate. Returns no value; mutates the array. Same complexity and stability as sort(). The predicate must impose a strict weak ordering (irreflexive, transitive, with the implied equivalence being transitive) or the result is unspecified.

Array::append(mut &this, source: Slice<T>) -> void
where T: Copy

Append every element of source to the end of this array. Panics on allocation failure; use try_append to recover.

Array::try_append(mut &this, source: Slice<T>) -> Result<(), AllocError>
where T: Copy

Fallible bulk append. Reserves space for all elements first so partial copies are impossible; either all elements are appended or none are. Gated on T: Copy (see append): the append is a bitwise memcpy out of the borrowed source.

Array::resize(mut &this, new_length: u64, value: T) -> void
where T: Copy

Set the length to exactly new_length, filling any new slots with value. Shrinking drops the elements above new_length, exactly as truncate does; growing leaves every slot initialized, so the whole [0, new_length) range is readable afterwards.

Array::try_resize(mut &this, new_length: u64, value: T) -> Result<(), AllocError>
where T: Copy

Fallible resize. Reserves the whole growth up front, so the array is either resized or left exactly as it was - never partially grown.

new T { field: value }
new E::Variant(args)
new T[n]

Heap allocation. new T { .. } places a struct literal on the heap and yields a T*, and new E::V(args) does the same for an enum variant; new T[n] reserves n uninitialised T - the typed malloc. The storage comes from T's Allocate implementation, or else the global allocator. Parentheses after a struct's name are refused (E0117): there are no constructors, and a struct's static new(..) is an ordinary method.

type trait Clone {
    clone(&this) -> This;
}

Clone: explicit duplication.

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 T

where T: Drop

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.

implement trait Trait for Type { ... }

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

type parameter T

where T: Clone

type trait Default {
    static default() -> This;
}

Default: a canonical "zero value" for a type.

type parameter T

where T: Eq

type parameter T

where T: Hash

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

Hashing.

type trait Index<Idx, Output> {
    index(&this, idx: Idx) -> Output*;
}

Index<Idx, Output> is the contract for container[idx]-style access, returning a pointer to the element. The compiler rewrites a[i] into *(a.index(i)); because the deref of the returned Output* is a place, the one impl serves reads (v = a[i]), writes (a[i] = v), and compound assignment (a[i] += v).

primitive i8

8-bit signed integer.

primitive i16

16-bit signed integer.

primitive isize

Pointer-width signed integer.

primitive u8

8-bit unsigned integer.

primitive u16

16-bit unsigned integer.

primitive u32

32-bit unsigned integer.

primitive usize

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

type parameter T

where T: Display

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

Display / Debug / Formatter.

type parameter T

where T: Debug

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 from_iter<I, T>(it: I) -> Array<T>
where I: Iterator<T>

Collect every element an iterator yields into a fresh Array<T>, in order. it is consumed. T is recovered from the iterator's Iterator<T> impl, and the result element type is fixed by the expected type at the call site:

type parameter I

where I: Iterator