dir

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

primitive void

No value; only valid as a return type.

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

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

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

Directory iteration and whole-path operations.

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.

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.

function read_dir(p: Path) -> Result<ReadDir, IoError>

Open p for iteration. The returned ReadDir must be dropped to close the directory handle.

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.

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

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

function println(text: String) -> void

Like print, followed by a newline.

DirEntry::name(&this) -> Str

The entry's file name (no directory components). Borrows this entry's storage.

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

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

primitive u8

8-bit unsigned integer.

DirEntry::name(&this) -> Str

The entry's file name (no directory components). Borrows this entry's storage.

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

Str: a borrowed UTF-8 string slice.

DirEntry::file_type(&this) -> FileType

File type from the dirent d_type field. Some filesystems report DT_UNKNOWN; call metadata on the full path for an authoritative answer in that case.

type enum FileType {
    File;
    Dir;
    Symlink;
    Other;
}

The broad category of a filesystem entry.

primitive boolean

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

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 u64

64-bit unsigned integer.

primitive u32

32-bit unsigned integer.

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

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

DirEntry::file_type(&this) -> FileType

File type from the dirent d_type field. Some filesystems report DT_UNKNOWN; call metadata on the full path for an authoritative answer in that case.

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.

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

Create a single directory (mode 0755). Fails if it already exists or a parent component is missing; use create_dir_all for the latter.

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

Recursively create p and any missing parent directories, like mkdir -p. Succeeds if p already exists as a directory. Each created component uses mode 0755. A concurrent creator racing on the same path is tolerated (an AlreadyExists that resolves to a directory is success); any other failure is returned as-is.

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

Remove a file (or symlink). unlink(2).

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

Remove an empty directory. rmdir(2).

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

Recursively remove p and everything under it, like rm -r on a directory. p must be a real directory. Entries that are symlinks are unlinked, not followed (a symlink reports a non-directory d_type, so it routes to remove_file). Returns the first failure.

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

Rename / move from to to. rename(2) (atomic within a filesystem; fails with EXDEV across filesystems).

// 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 canonicalize(p: Path) -> Result<PathBuf, IoError>

Resolve p to an absolute, symlink-free canonical path (realpath(3)). The result fits in PATH_MAX (4096) bytes.

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

Open p for iteration. The returned ReadDir must be dropped to close the directory handle.

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.

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

Create a single directory (mode 0755). Fails if it already exists or a parent component is missing; use create_dir_all for the latter.

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

Recursively create p and any missing parent directories, like mkdir -p. Succeeds if p already exists as a directory. Each created component uses mode 0755. A concurrent creator racing on the same path is tolerated (an AlreadyExists that resolves to a directory is success); any other failure is returned as-is.

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

Remove a file (or symlink). unlink(2).

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

Remove an empty directory. rmdir(2).

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

Recursively remove p and everything under it, like rm -r on a directory. p must be a real directory. Entries that are symlinks are unlinked, not followed (a symlink reports a non-directory d_type, so it routes to remove_file). Returns the first failure.

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

Rename / move from to to. rename(2) (atomic within a filesystem; fails with EXDEV across filesystems).

function canonicalize(p: Path) -> Result<PathBuf, IoError>

Resolve p to an absolute, symlink-free canonical path (realpath(3)). The result fits in PATH_MAX (4096) bytes.