iter

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 Item;
type Output = i64;

An associated type on a trait: named in the trait body, filled in by each implementation, and referred to as This::Item or I::Item.

Iterator::type Item

The element type this iterator yields. Each implementor binds it once (positional sugar: implement Iterator<T> for X => Item = T); refer to it as This::Item inside the trait and X::Item outside.

Iterator::next(mut &this) -> Option<This::Item>

Advance the sequence and return the next value, or None when exhausted. Calling next again after None may return None forever or may panic; implementations should document which.

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.

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

Option: a value that may be absent.

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.

Iterator::type Item

The element type this iterator yields. Each implementor binds it once (positional sugar: implement Iterator<T> for X => Item = T); refer to it as This::Item inside the trait and X::Item outside.

Iterator::count(mut &this) -> u64

Number of remaining elements. The default walks the iterator to count, consuming it. Implementations with O(1) knowledge of their length should override.

primitive u64

64-bit unsigned integer.

Iterator::fold<Acc>(mut &this, initial: Acc, f: (Acc, This::Item) -> Acc) -> Acc

Reduce the sequence to a single value. initial is the starting accumulator; f folds each element into it.

Iterator::for_each(mut &this, f: (This::Item) -> void) -> void

Call f on each element, discarding the results. The natural way to consume an iterator purely for its side effects.

primitive void

No value; only valid as a return type.

Iterator::take(this, n: u64) -> TakeIter<This>

Yield at most the first n elements, then stop.

type struct TakeIter<I> {
    inner: I;
    remaining: u64;
}

Adapter yielding at most remaining elements from inner.

Iterator::skip(this, n: u64) -> SkipIter<This>

Discard the first n elements, then yield the rest. An iterator with fewer than n elements is drained and yields nothing.

type struct SkipIter<I> {
    inner: I;
    remaining: u64;
}

Adapter that drops the first remaining elements of inner on the first next, then passes the rest through. remaining counts DOWN as elements are skipped; once it hits 0 the adapter is transparent.

Iterator::map<B>(this, f: (This::Item) -> B) -> MapIter<This, B>

Transform each element with f, yielding the results. f must be a non-capturing function (a plain fn or a non-capturing lambda).

type struct MapIter<I, O> where I: Iterator {
    inner: I;
}

Adapter applying f to each element of inner. The input element type is the inner iterator's associated item I::Item; O is the mapped result (Output) type, the only element-type struct parameter needed.

Iterator::filter(this, pred: (&This::Item) -> boolean) -> FilterIter<This>

Yield only the elements for which pred returns true. pred must be a non-capturing function. It BORROWS each element: the element it keeps is the one yielded, so it cannot also be handed to pred.

primitive boolean

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

type struct FilterIter<I> where I: Iterator {
    inner: I;
}

Adapter yielding only the elements of inner for which pred holds.

Iterator::chain<J>(this, other: J) -> ChainIter<This, J>

Yield every element of this, then every element of other. other must be an Iterator with the same Item type - the shared element type is enforced by ChainIter's impl bounds.

type struct ChainIter<I, J> {
    first: I;
    second: J;
    first_done: boolean;
}

Adapter concatenating two iterators of the same element type: it drains first, then second. Both inner element types are pinned to the shared A by the where-bounds.

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

type struct EnumerateIter<I> {
    inner: I;
    index: u64;
}

Adapter pairing each element of inner with its 0-based index. The element type is the inner iterator's associated item I::Item; the yielded item is Pair<u64, I::Item>.

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

type struct ZipIter<I, J> {
    first: I;
    second: J;
}

Adapter pairing two iterators positionally, yielding Pair<A, O> until either side runs out. Chain-shaped: the element types A (from I) and O (from J) live only in the impl where-bounds, not as struct parameters, so the receiver type only mentions the two inner iterators.

Iterator::any(mut &this, pred: (This::Item) -> boolean) -> boolean

True if pred holds for at least one element. Short-circuits on the first match; consumes elements up to it.

Iterator::all(mut &this, pred: (This::Item) -> boolean) -> boolean

True if pred holds for every element. Short-circuits on the first failure; vacuously true for an empty iterator.

Iterator::find(mut &this, pred: (&This::Item) -> boolean) -> Option<This::Item>

The first element for which pred holds, or None. Consumes elements up to and including the match. pred borrows each element, since the one it accepts is returned.

Iterator::min(mut &this) -> Option<This::Item>
where This::Item: Ord

The smallest element by Ord, or None for an empty iterator. Consumes the iterator. On ties the FIRST minimal element wins (only a strictly smaller element displaces the running best), so min and max of equal elements differ.

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

Iterator::max(mut &this) -> Option<This::Item>
where This::Item: Ord

The largest element by Ord, or None for an empty iterator. Consumes the iterator. On ties the LAST maximal element wins (an equal-or-greater element displaces the running best), the mirror of min.

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.

primitive i32

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

if (condition) { ... } else if (condition) { ... } else { ... }

Branches on a parenthesised boolean condition. Bodies are always braced; there is no single-statement form. Used as an expression, both arms are required and must produce the same type: const sign = if (n < 0) { -1 } else { 1 };.

return value;

Leaves the current function with the given value. A function whose return type is not void must return one; a bare return; is for void. In an async function it completes the future with the value.

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.

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

function println(text: String) -> void

Like print, followed by a newline.

type struct TakeIter<I> {
    inner: I;
    remaining: u64;
}

Adapter yielding at most remaining elements from inner.

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 SkipIter<I> {
    inner: I;
    remaining: u64;
}

Adapter that drops the first remaining elements of inner on the first next, then passes the rest through. remaining counts DOWN as elements are skipped; once it hits 0 the adapter is transparent.

type struct MapIter<I, O> where I: Iterator {
    inner: I;
}

Adapter applying f to each element of inner. The input element type is the inner iterator's associated item I::Item; O is the mapped result (Output) type, the only element-type struct parameter needed.

type parameter I

where I: Iterator

type parameter I

where I: Iterator

type struct FilterIter<I> where I: Iterator {
    inner: I;
}

Adapter yielding only the elements of inner for which pred holds.

type parameter I

where I: Iterator

type struct ChainIter<I, J> {
    first: I;
    second: J;
    first_done: boolean;
}

Adapter concatenating two iterators of the same element type: it drains first, then second. Both inner element types are pinned to the shared A by the where-bounds.

type struct EnumerateIter<I> {
    inner: I;
    index: u64;
}

Adapter pairing each element of inner with its 0-based index. The element type is the inner iterator's associated item I::Item; the yielded item is Pair<u64, I::Item>.

type struct ZipIter<I, J> {
    first: I;
    second: J;
}

Adapter pairing two iterators positionally, yielding Pair<A, O> until either side runs out. Chain-shaped: the element types A (from I) and O (from J) live only in the impl where-bounds, not as struct parameters, so the receiver type only mentions the two inner iterators.

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

Iterator: a lazy sequence.

Iterator::next(mut &this) -> Option<This::Item>

Advance the sequence and return the next value, or None when exhausted. Calling next again after None may return None forever or may panic; implementations should document which.

Iterator::count(mut &this) -> u64

Number of remaining elements. The default walks the iterator to count, consuming it. Implementations with O(1) knowledge of their length should override.

Iterator::fold<Acc>(mut &this, initial: Acc, f: (Acc, This::Item) -> Acc) -> Acc

Reduce the sequence to a single value. initial is the starting accumulator; f folds each element into it.

Iterator::for_each(mut &this, f: (This::Item) -> void) -> void

Call f on each element, discarding the results. The natural way to consume an iterator purely for its side effects.

Iterator::take(this, n: u64) -> TakeIter<This>

Yield at most the first n elements, then stop.

Iterator::skip(this, n: u64) -> SkipIter<This>

Discard the first n elements, then yield the rest. An iterator with fewer than n elements is drained and yields nothing.

Iterator::map<B>(this, f: (This::Item) -> B) -> MapIter<This, B>

Transform each element with f, yielding the results. f must be a non-capturing function (a plain fn or a non-capturing lambda).

Iterator::filter(this, pred: (&This::Item) -> boolean) -> FilterIter<This>

Yield only the elements for which pred returns true. pred must be a non-capturing function. It BORROWS each element: the element it keeps is the one yielded, so it cannot also be handed to pred.

true

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

Iterator::chain<J>(this, other: J) -> ChainIter<This, J>

Yield every element of this, then every element of other. other must be an Iterator with the same Item type - the shared element type is enforced by ChainIter's impl bounds.

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

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

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

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::any(mut &this, pred: (This::Item) -> boolean) -> boolean

True if pred holds for at least one element. Short-circuits on the first match; consumes elements up to it.

Iterator::all(mut &this, pred: (This::Item) -> boolean) -> boolean

True if pred holds for every element. Short-circuits on the first failure; vacuously true for an empty iterator.

Iterator::find(mut &this, pred: (&This::Item) -> boolean) -> Option<This::Item>

The first element for which pred holds, or None. Consumes elements up to and including the match. pred borrows each element, since the one it accepts is returned.

Iterator::min(mut &this) -> Option<This::Item>
where This::Item: Ord

The smallest element by Ord, or None for an empty iterator. Consumes the iterator. On ties the FIRST minimal element wins (only a strictly smaller element displaces the running best), so min and max of equal elements differ.

Iterator::max(mut &this) -> Option<This::Item>
where This::Item: Ord

The largest element by Ord, or None for an empty iterator. Consumes the iterator. On ties the LAST maximal element wins (an equal-or-greater element displaces the running best), the mirror of min.

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

type parameter J

where J: Iterator

type parameter T

where T: Copy

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.

type parameter T

where T: Clone

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

Clone: explicit duplication.

type parameter K

where K: Copy

type parameter V

where V: Copy

type struct Str {
    bytes: u8*;
    length: u64;
}

Str: a borrowed UTF-8 string slice.

type struct SplitIter {
    bytes: u8*;
    length: u64;
    sep_bytes: u8*;
    sep_length: u64;
    pos: u64;
    done: boolean;
}

Lazy iterator over the pieces of a Str separated by a byte sequence. Yields borrowed Str views; see Str::split. Borrows from the source Str, which must outlive the iterator.

primitive u32

32-bit unsigned integer.

type struct Chars {
    bytes: u8*;
    length: u64;
    pos: u64;
}

Lazy UTF-8 scalar iterator over a Str; see Str::chars. Borrows from the source Str, which must outlive the iterator.

type struct CharIndices {
    bytes: u8*;
    length: u64;
    pos: u64;
}

Lazy (byte_offset, scalar) iterator over a Str; see Str::char_indices. Borrows from the source Str. Public for the same cross-module reason as Chars.

type parameter T

where T: Step

type struct DirEntry {
    entry_name: String;
    dtype: u8;
}

One entry returned by ReadDir. Owns its name; drop releases it.

type struct ReadDir {
    dirp: void*;
    base: String;
}

Forward iterator over the entries of a directory. Yields owned DirEntry values, skipping . and ... Closes the underlying DIR* on drop. Order is filesystem-defined.