slice

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 Slice<T> {
    ptr: T*;
    length: u64;
}

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

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 Slice::from_raw(ptr: T*, length: u64) -> Slice<T>

Construct from a raw pointer and length. The caller certifies that [ptr, ptr + length) is valid initialized memory for as long as the slice exists.

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

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

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

Slice::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 backing storage still owns the element, so this is only sound when T carries no Drop obligation. For owning T, borrow in place with get_ref.

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

Option: a value that may be absent.

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

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

Bounds-checked borrow. Returns a pointer to the element in place, sound for every T. The pointer is valid only while the backing storage outlives the slice.

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

Raw pointer to the first element. Callers must respect length.

Slice::subslice(&this, start: u64, end: u64) -> Slice<T>

The sub-slice [start, end). Panics if start > end or end > length.

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

Return an iterator that yields each element by value (bitwise copy). Gated on T: Copy for the same reason as get; 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.

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

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

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

static Slice::from_raw(ptr: T*, length: u64) -> Slice<T>

Construct from a raw pointer and length. The caller certifies that [ptr, ptr + length) is valid initialized memory for as long as the slice exists.

Slice::subslice(&this, start: u64, end: u64) -> Slice<T>

The sub-slice [start, end). Panics if start > end or end > length.

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

Raw pointer to the first element. Callers must respect length.

Slice::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 backing storage still owns the element, so this is only sound when T carries no Drop obligation. For owning T, borrow in place with get_ref.

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

Return an iterator that yields each element by value (bitwise copy). Gated on T: Copy for the same reason as get; for owning T, walk by index with length() + get_ref.

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

Bounds-checked borrow. Returns a pointer to the element in place, sound for every T. The pointer is valid only while the backing storage outlives the slice.

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

Drop: explicit destructor.

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

via trait Iterator

Override the default; slice length is known O(1).

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