path

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 Path {
    inner: Str;
}

Path / PathBuf: filesystem paths as length-typed UTF-8.

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

Str: a borrowed UTF-8 string slice.

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 Path::from(source: Str) -> Path

Borrow a Str as a Path. A NUL-terminated string (C-string / i8*) converts implicitly at the call site via Str's ![implicit] new, so Path::from("/tmp") and Path::from(some_str) both work; a C-string's terminating NUL is not part of the path bytes. The borrowed bytes must outlive the Path.

type struct Path {
    inner: Str;
}

Path / PathBuf: filesystem paths as length-typed UTF-8.

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

64-bit unsigned integer.

primitive boolean

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

static Path::is_separator(byte: u8) -> boolean

Whether byte separates segments on this target.

primitive u8

8-bit unsigned integer.

static Path::byte_or_zero(source: Str, index: u64) -> u8

source's byte at index, or 0 when out of range. Path syntax never gives 0 a meaning, so callers can compare it without unwrapping.

static Path::root_len(source: Str) -> u64

Length of source's leading root, including its trailing separator when one is present; 0 when the path is fully relative.

static Path::is_absolute_str(source: Str) -> boolean

Whether source resolves without reference to a working DIRECTORY.

static Path::last_separator(source: Str, floor: u64) -> i64

Index of the last separator at or after floor, or -1 when there is none. Searching from floor is what keeps the root's own separators from being mistaken for segment breaks.

primitive i64

64-bit signed integer.

static Path::last_dot(name: Str) -> i64

Index of the last . in name, or -1 when there is none. name is a single path component, not a whole path, so this never has to skip a root or separators - the caller passes the output of file_name.

Path::is_absolute(&this) -> boolean

Whether this path is absolute; see is_absolute_str.

Path::file_name(&this) -> Option<Str>

Last path segment, or None if the path ends with a separator, is empty, or is nothing but a root. Does not consult the filesystem.

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

Option: a value that may be absent.

Path::parent(&this) -> Option<Path>

Path minus its final segment, or None if there is no parent - a single relative segment, a bare root, or empty. A rooted path whose last segment is stripped yields the root itself, never "".

Path::extension(&this) -> Option<Str>

Extension of the final component: the bytes after its last ., or None. It consults only the file name - parent().extension() cannot leak in a dot from a directory:

Path::join(&this, segment: Str) -> PathBuf

Append segment to a COPY of this path, leaving the borrowed path untouched. The non-mutating twin of PathBuf::push, and it inherits push's root semantics: a segment carrying its own root - /etc, C:\dir, \\server\share - replaces rather than extends: join("/etc") is /etc whatever the path was.

type struct GlobalAlloc {}

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

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

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

static PathBuf::from(source: Str) -> PathBuf

Own a copy of a Str (or, implicitly, a NUL-terminated string via Str's ![implicit] new). The bytes are copied into the owned buffer, so source need not outlive the result.

PathBuf::push(mut &this, segment: Str) -> void

Append segment, inserting a separator if needed. A segment carrying a root of its own - /etc, C:\dir, \dir, \\server\share - replaces the current path rather than extending it, since appending one path's root inside another would name nothing.

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.

PathBuf::pop(mut &this) -> boolean

Remove the last segment. Returns true if anything was popped; false at a bare root or an empty path, so this cannot climb out of the volume the path names.

PathBuf::join(&this, segment: Str) -> PathBuf

Append segment to a COPY of this path and return it, leaving self intact. push mutates in place; join is the owning, non-mutating twin. Same root semantics as push (a rooted segment replaces).

PathBuf::extension(&this) -> Option<Str>

Extension of the final component; see Path::extension.

PathBuf::into_raw(mut this) -> string

Consume the PathBuf and return its bytes as an owned, NUL-terminated raw string, leaking the allocation so the caller owns it with no borrow lifetime. Mirrors String::into_raw for handing an owned C-string across the raw-string boundary.

mut this

A by-value receiver the body may also reassign. The receiver is moved into the method and consumed; the caller's value may not be used afterwards.

primitive string

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

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

true

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

false

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

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

fs: filesystem access.

namespace std::fs::path;

Path / PathBuf: filesystem paths as length-typed UTF-8.

static String::with_null(source: Str) -> String

Construct a NUL-terminated copy of source for handing to C. The terminating NUL lives in the buffer (so as_ptr() yields a valid const char*) but is excluded from the logical length, so as_str() / length() see only source. Matches C semantics on an interior NUL: the C side stops reading at the first one.

PathBuf::into_raw(mut this) -> string

Consume the PathBuf and return its bytes as an owned, NUL-terminated raw string, leaking the allocation so the caller owns it with no borrow lifetime. Mirrors String::into_raw for handing an owned C-string across the raw-string boundary.

static Path::root_len(source: Str) -> u64

Length of source's leading root, including its trailing separator when one is present; 0 when the path is fully relative.

static Path::is_separator(byte: u8) -> boolean

Whether byte separates segments on this target.

static Path::is_absolute_str(source: Str) -> boolean

Whether source resolves without reference to a working DIRECTORY.

Path::file_name(&this) -> Option<Str>

Last path segment, or None if the path ends with a separator, is empty, or is nothing but a root. Does not consult the filesystem.

Path::parent(&this) -> Option<Path>

Path minus its final segment, or None if there is no parent - a single relative segment, a bare root, or empty. A rooted path whose last segment is stripped yields the root itself, never "".

Path::join(&this, segment: Str) -> PathBuf

Append segment to a COPY of this path, leaving the borrowed path untouched. The non-mutating twin of PathBuf::push, and it inherits push's root semantics: a segment carrying its own root - /etc, C:\dir, \\server\share - replaces rather than extends: join("/etc") is /etc whatever the path was.

Path::extension(&this) -> Option<Str>

Extension of the final component: the bytes after its last ., or None. It consults only the file name - parent().extension() cannot leak in a dot from a directory:

static Path::from(source: Str) -> Path

Borrow a Str as a Path. A NUL-terminated string (C-string / i8*) converts implicitly at the call site via Str's ![implicit] new, so Path::from("/tmp") and Path::from(some_str) both work; a C-string's terminating NUL is not part of the path bytes. The borrowed bytes must outlive the Path.

primitive i8

8-bit signed integer.

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 Path::byte_or_zero(source: Str, index: u64) -> u8

source's byte at index, or 0 when out of range. Path syntax never gives 0 a meaning, so callers can compare it without unwrapping.

static Path::last_separator(source: Str, floor: u64) -> i64

Index of the last separator at or after floor, or -1 when there is none. Searching from floor is what keeps the root's own separators from being mistaken for segment breaks.

static Path::last_dot(name: Str) -> i64

Index of the last . in name, or -1 when there is none. name is a single path component, not a whole path, so this never has to skip a root or separators - the caller passes the output of file_name.

Path::is_absolute(&this) -> boolean

Whether this path is absolute; see is_absolute_str.

PathBuf::push(mut &this, segment: Str) -> void

Append segment, inserting a separator if needed. A segment carrying a root of its own - /etc, C:\dir, \dir, \\server\share - replaces the current path rather than extending it, since appending one path's root inside another would name nothing.

PathBuf::pop(mut &this) -> boolean

Remove the last segment. Returns true if anything was popped; false at a bare root or an empty path, so this cannot climb out of the volume the path names.

String::into_raw(mut this) -> string

Consume the String and return its NUL-terminated buffer as a raw string (C-string view), leaking the allocation so the caller owns the bytes with no borrow lifetime. A NUL terminator is appended first. The owning companion of Str::sub_bytes etc. for handing an owned C-string across the FFI / raw-string boundary.

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: Allocator

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

Drop: explicit destructor.

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