file

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 File {
    fd: i32;
}

File: Read/Write over a file descriptor.

primitive i32

32-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 File::open(p: Path) -> Result<File, IoError>

Open p for reading. Fails with NotFound, PermissionDenied, or a mapped errno-derived kind on failure.

type struct Path {
    inner: Str;
}

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

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

Result: a value that may be an error.

type struct File {
    fd: i32;
}

File: Read/Write over a file descriptor.

static File::create(p: Path) -> Result<File, IoError>

Create (or truncate) p for writing.

File::seek_set(mut &this, offset: i64) -> Result<u64, IoError>

Seek to offset bytes from the start. Returns the new absolute position.

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.

primitive i64

64-bit signed integer.

primitive u64

64-bit unsigned integer.

File::seek_cur(mut &this, offset: i64) -> Result<u64, IoError>

Seek by offset bytes relative to the current position (offset may be negative). Returns the new absolute position.

File::seek_end(mut &this, offset: i64) -> Result<u64, IoError>

Seek to offset bytes relative to the end of the file (offset is usually <= 0). Returns the new absolute position.

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

File: Read/Write over a file descriptor.

namespace std::fs::path;

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

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 File::open(p: Path) -> Result<File, IoError>

Open p for reading. Fails with NotFound, PermissionDenied, or a mapped errno-derived kind on failure.

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

Str: a borrowed UTF-8 string slice.

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.

pattern => { body }

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

primitive boolean

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

OpenOptions::to_flags(&this) -> i32

Flatten the options into the platform open/_open flags bitmask.

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.

true

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

value?

Error propagation. On a Result<T, E> it yields the T of an Ok and otherwise returns the Err(e) from the enclosing function unchanged; on an Option<T> it yields the T of a Some or returns None. The enclosing function must return a matching Result / Option.

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

primitive u32

32-bit unsigned integer.

type trait Seek {
    seek(mut &this, from: SeekFrom) -> Result<u64, IoError>;
    stream_position(mut &this) -> Result<u64, IoError>;
    rewind(mut &this) -> Result<(), IoError>;
}

A byte stream whose read/write cursor can be repositioned. Absolute positions are u64 offsets from the start; every seek returns the resulting absolute position.

File::seek_set(mut &this, offset: i64) -> Result<u64, IoError>

Seek to offset bytes from the start. Returns the new absolute position.

File::seek_cur(mut &this, offset: i64) -> Result<u64, IoError>

Seek by offset bytes relative to the current position (offset may be negative). Returns the new absolute position.

File::seek_end(mut &this, offset: i64) -> Result<u64, IoError>

Seek to offset bytes relative to the end of the file (offset is usually <= 0). Returns the new absolute position.

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

via trait Drop

OpenOptions::to_flags(&this) -> i32

Flatten the options into the platform open/_open flags bitmask.

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.

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

Drop: explicit destructor.

File::flush(mut &this) -> Result<(), IoError>

via trait Write

File::write_some(mut &this, bytes: Slice<u8>) -> Result<u64, IoError>

via trait Write

File::read_to_string(mut &this, out: mut &String) -> Result<u64, IoError>

via trait Read

Read every remaining byte into out as UTF-8. Convenience wrapper around read_to_end for the common "slurp text from this source" case. The bytes are **not** validated; the caller certifies the source is UTF-8 (or accepts the consequences of invalid continuation bytes in a String).

function copy(from: Path, to: Path) -> Result<u64, IoError>

Copy the contents of from to to, returning the number of bytes copied. to is created if missing and truncated if it already exists; the source's Unix permission bits are then applied to it, mirroring cp (and std::fs::copy).

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

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 read(p: Path) -> Result<Array<u8>, IoError>

Read the entire contents of p into a fresh Array<u8>. Panics on allocation failure; caller handles I/O failure via the Result.

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.

primitive u8

8-bit unsigned integer.

function read_to_string(p: Path) -> Result<String, IoError>

Read the entire contents of p into a fresh String. The bytes are taken verbatim; no UTF-8 validation is performed (the caller is responsible for that if it matters). Panics on allocation failure; I/O failure surfaces through the Result.

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

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

function write(p: Path, bytes: Slice<u8>) -> Result<(), IoError>

Write bytes to p, creating or truncating.

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

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

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.

function copy(from: Path, to: Path) -> Result<u64, IoError>

Copy the contents of from to to, returning the number of bytes copied. to is created if missing and truncated if it already exists; the source's Unix permission bits are then applied to it, mirroring cp (and std::fs::copy).