str

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 Str {
    bytes: u8*;
    length: u64;
}

Str: a borrowed UTF-8 string slice.

primitive u8

8-bit unsigned integer.

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.

static Str::new(text: string) -> Str

Construct from a NUL-terminated C-style string literal. The caller certifies that text is valid UTF-8 and outlives this view. The NUL terminator is not included in the view.

primitive string

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

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

Str: a borrowed UTF-8 string slice.

static Str::from_raw(bytes: u8*, length: u64) -> Str

Construct from a raw pointer + length. The caller certifies that [bytes, bytes + length) is initialized UTF-8 and outlives this view.

// reserved

A reserved keyword with no syntax of its own in the current grammar. The standard library uses it freely as a method and parameter name (Str::from, from: u64).

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

Str::as_bytes(&this) -> Slice<u8>

Underlying byte view. Use this for byte-granularity algorithms (hashing, equality, substring search).

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

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

Str::as_ptr(&this) -> u8*

Raw byte pointer. Valid as long as this Str is valid.

Str::byte_at(&this, index: u64) -> Option<u8>

Bounds-checked byte lookup. For scalar iteration, use as_bytes() with a UTF-8 decoder.

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

Option: a value that may be absent.

Str::sub_bytes(&this, start: u64, end: u64) -> Str

[start, end) byte sub-slice. Panics if the range is out of bounds or if start > end. **Not UTF-8-aware**; splitting inside a multi-byte scalar is the caller's responsibility.

Str::to_ascii_lowercase(&this) -> String

Return a new String with every ASCII uppercase byte folded to lowercase. Non-ASCII bytes are passed through unchanged. Requires collections::string; callers that only need Str can byte-scan manually, but most callers want this method.

type struct String<A = GlobalAlloc> {
    buffer: RawBuffer<u8, A>;
    length: u64;
}

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

Str::starts_with(&this, prefix: &Str) -> boolean

True if this string begins with prefix (byte-wise).

Str::ends_with(&this, suffix: &Str) -> boolean

True if this string ends with suffix (byte-wise).

Str::find(&this, needle: &Str) -> Option<u64>

Byte index of the first occurrence of needle, or None. An empty needle matches at index 0. O(n*m) naive scan; inputs in practice are short. **Not UTF-8-aware** (matches on bytes).

Str::contains(&this, needle: &Str) -> boolean

True if needle appears anywhere in this string.

Str::trim_start(&this) -> Str

Borrowed sub-slice with leading ASCII whitespace removed.

Str::trim_end(&this) -> Str

Borrowed sub-slice with trailing ASCII whitespace removed.

Str::trim(&this) -> Str

Borrowed sub-slice with leading and trailing ASCII whitespace removed. ASCII whitespace is space, tab, LF, VT, FF, CR.

Str::to_ascii_uppercase(&this) -> String

Return a new String with every ASCII lowercase byte folded to uppercase. Non-ASCII bytes pass through unchanged. Mirror of to_ascii_lowercase.

Str::split(&this, sep: &Str) -> implement Iterator<Str>

Iterator over the (non-overlapping) pieces between occurrences of the byte separator sep. A leading/trailing/doubled separator yields an empty piece. Each yielded Str borrows from this one. split on a one-byte separator is the common case; multi-byte separators are supported too.

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

Str::chars(&this) -> implement Iterator<u32>

Iterator over the Unicode scalar values of this string, decoding UTF-8 on the fly. Each scalar is yielded as a u32 in the range [0, 0x10FFFF] (Cryo's char is a single byte, so a full scalar is a u32, not a char). This is the scalar-level counterpart to byte_at/as_bytes, which stay byte-level.

primitive u32

32-bit unsigned integer.

Str::char_indices(&this) -> implement Iterator<Pair<u64, u32>>

Iterator over (byte_offset, scalar) pairs: the same scalars as chars, each paired with the byte index at which it begins. The pair is Pair<u64, u32> (p.first is the byte offset, p.second the scalar). Byte offsets are into this view's bytes, so a four-byte scalar advances the next offset by four.

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

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

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

Result: a value that may be an error.

type struct ConversionError {
    reason: string;
}

What went wrong in a TryFrom / TryInto. Carries a short static message describing the failure; richer diagnostics are a caller concern.

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

Str: a borrowed UTF-8 string slice.

namespace std::core;

core: foundation of the stdlib.

namespace std::core::convert;

Conversions between types.

match (subject) {
    Pattern(x) => { ... }
    _          => { ... }
}

The primary discriminator: branches on enum variants, integers, ranges, and destructuring patterns, and the compiler rejects a match that misses a case. There is no fallthrough. As an expression it evaluates to the chosen arm's value, so every arm must produce the same type.

static u32::try_from(source: Str) -> Result<u32, ConversionError>

via trait TryFrom

pattern => { body }

Separates a match arm's pattern from its body. Arms do not fall through.

function eprintln(text: String) -> void

Like eprint, followed by a newline.

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

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.

static Str::from_raw(bytes: u8*, length: u64) -> Str

Construct from a raw pointer + length. The caller certifies that [bytes, bytes + length) is initialized UTF-8 and outlives this view.

Str::find(&this, needle: &Str) -> Option<u64>

Byte index of the first occurrence of needle, or None. An empty needle matches at index 0. O(n*m) naive scan; inputs in practice are short. **Not UTF-8-aware** (matches on bytes).

Str::trim(&this) -> Str

Borrowed sub-slice with leading and trailing ASCII whitespace removed. ASCII whitespace is space, tab, LF, VT, FF, CR.

Str::to_ascii_lowercase(&this) -> String

Return a new String with every ASCII uppercase byte folded to lowercase. Non-ASCII bytes are passed through unchanged. Requires collections::string; callers that only need Str can byte-scan manually, but most callers want this method.

Str::to_ascii_uppercase(&this) -> String

Return a new String with every ASCII lowercase byte folded to uppercase. Non-ASCII bytes pass through unchanged. Mirror of to_ascii_lowercase.

Str::chars(&this) -> implement Iterator<u32>

Iterator over the Unicode scalar values of this string, decoding UTF-8 on the fly. Each scalar is yielded as a u32 in the range [0, 0x10FFFF] (Cryo's char is a single byte, so a full scalar is a u32, not a char). This is the scalar-level counterpart to byte_at/as_bytes, which stay byte-level.

Str::char_indices(&this) -> implement Iterator<Pair<u64, u32>>

Iterator over (byte_offset, scalar) pairs: the same scalars as chars, each paired with the byte index at which it begins. The pair is Pair<u64, u32> (p.first is the byte offset, p.second the scalar). Byte offsets are into this view's bytes, so a four-byte scalar advances the next offset by four.

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.

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.

static Str::new(text: string) -> Str

Construct from a NUL-terminated C-style string literal. The caller certifies that text is valid UTF-8 and outlives this view. The NUL terminator is not included in the view.

primitive i8

8-bit signed integer.

Str::as_bytes(&this) -> Slice<u8>

Underlying byte view. Use this for byte-granularity algorithms (hashing, equality, substring search).

Str::as_ptr(&this) -> u8*

Raw byte pointer. Valid as long as this Str is valid.

Str::byte_at(&this, index: u64) -> Option<u8>

Bounds-checked byte lookup. For scalar iteration, use as_bytes() with a UTF-8 decoder.

Str::sub_bytes(&this, start: u64, end: u64) -> Str

[start, end) byte sub-slice. Panics if the range is out of bounds or if start > end. **Not UTF-8-aware**; splitting inside a multi-byte scalar is the caller's responsibility.

namespace std::collections::string;

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

Str::starts_with(&this, prefix: &Str) -> boolean

True if this string begins with prefix (byte-wise).

Str::ends_with(&this, suffix: &Str) -> boolean

True if this string ends with suffix (byte-wise).

Str::contains(&this, needle: &Str) -> boolean

True if needle appears anywhere in this string.

Str::trim_start(&this) -> Str

Borrowed sub-slice with leading ASCII whitespace removed.

Str::trim_end(&this) -> Str

Borrowed sub-slice with trailing ASCII whitespace removed.

Str::split(&this, sep: &Str) -> implement Iterator<Str>

Iterator over the (non-overlapping) pieces between occurrences of the byte separator sep. A leading/trailing/doubled separator yields an empty piece. Each yielded Str borrows from this one. split on a one-byte separator is the common case; multi-byte separators are supported too.

primitive char

8-bit character (byte).

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.

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

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

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

Hashing.

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 Display {
    fmt<W>(&this, f: mut &Formatter<W>) -> Result<(), FmtError>
    where W: FmtWrite;
}

Display / Debug / Formatter.

type enum JsonValue {
    Null;
    Bool(boolean);
    Number(JsonNumber);
    String(String);
    Array(Array<JsonValue>);
    Object(JsonObject);
}

One JSON value. Recursive through Array and Object.

primitive u16

16-bit unsigned integer.

primitive i64

64-bit signed integer.

primitive i32

32-bit signed integer.

primitive i16

16-bit signed integer.

primitive f64

Double-precision IEEE 754 float.

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.