command

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 Command {
    program: String;
    args: Array<String>;
    envs: Array<EnvEntry>;
    clear_env_flag: boolean;
    cwd: Option<String>;
    stdin_cfg: Stdio;
    stdout_cfg: Stdio;
    stderr_cfg: Stdio;
}

Command: builder for spawning a subprocess.

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

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

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 boolean

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

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

Option: a value that may be absent.

type enum Stdio {
    Inherit;
    Null;
    Piped;
    Fd(i32);
}

How a child's stdin / stdout / stderr is wired up.

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 Command::new(program: Str) -> Command

Start a new command targeting program. The program name is resolved against $PATH by execvp at spawn time; pass an absolute path to skip the lookup.

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

Str: a borrowed UTF-8 string slice.

type struct Command {
    program: String;
    args: Array<String>;
    envs: Array<EnvEntry>;
    clear_env_flag: boolean;
    cwd: Option<String>;
    stdin_cfg: Stdio;
    stdout_cfg: Stdio;
    stderr_cfg: Stdio;
}

Command: builder for spawning a subprocess.

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 void

No value; only valid as a return type.

Command::env_clear(mut &this) -> void

Don't inherit the parent's environment. Only the entries added with env() reach the child.

Command::spawn(&this) -> Result<Child, IoError>

fork + configure fds/env + execvp. Returns a Child the caller must eventually wait on.

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

Result: a value that may be an error.

type struct Child {
    stdin: Option<ChildStdin>;
    stdout: Option<ChildStdout>;
    stderr: Option<ChildStderr>;
}

Child: a running subprocess.

Command::output(&this) -> Result<Output, IoError>

spawn + wait + collect stdout/stderr into arrays. Stdin is left Inherit (or whatever the caller set). Use this for the common "run this and tell me what it printed" case.

Command::status(&this) -> Result<ExitStatus, IoError>

spawn + wait. Stdin/out/err go wherever the caller configured (typically Inherit).

type struct ExitStatus {
    code: i32;
    signal: i32;
    signaled: boolean;
}

Result of a child's termination. Either it exited normally with a code, or it was killed by a signal. POSIX encodes both into a single wstatus word; ExitStatus is the decoded form.

async function name(param: Type) -> T { ... }

Compiles the function into a stackless state machine. Calling it builds a future whose output is the declared return type; nothing runs until that future is polled. Allowed on free functions, methods, and trait methods.

async Command::collect(&this) -> Result<Output, IoError>

Spawn, capture both streams, and await the exit without blocking the calling thread: the async spelling of output.

async Command::run(&this) -> Result<ExitStatus, IoError>

Spawn and await the exit without capturing anything: the async spelling of status. Stdio goes wherever the caller configured it.

static Command::shell(command: string) -> i32

Run command through the platform shell (/bin/sh -c on POSIX, cmd /c on Windows), inheriting stdio, and return the child's exit code (0 on success), or -1 if the shell could not be spawned or the child was killed by a signal.

primitive string

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

primitive i32

32-bit signed integer.

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

process: subprocess spawning.

namespace std::process::command;

Command: builder for spawning a subprocess.

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.

static Command::new(program: Str) -> Command

Start a new command targeting program. The program name is resolved against $PATH by execvp at spawn time; pass an absolute path to skip the lookup.

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.

Stdio::Piped

Create a pipe; the parent keeps its end in the resulting Child::stdin / stdout / stderr.

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.

Command::output(&this) -> Result<Output, IoError>

spawn + wait + collect stdout/stderr into arrays. Stdin is left Inherit (or whatever the caller set). Use this for the common "run this and tell me what it printed" case.

pattern => { body }

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

primitive u8

8-bit unsigned integer.

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

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

type enum Name {
    Unit,
    Payload(T),
    Named { x: i32 },
}

An algebraic data type. Variants may be bare or carry a tuple or struct payload, and a match on an enum must cover every variant. Name::Variant names a variant; methods are added with implement enum Name { ... }.

type enum Stdio {
    Inherit;
    Null;
    Piped;
    Fd(i32);
}

How a child's stdin / stdout / stderr is wired up.

Stdio::Inherit

Share the parent's fd (the default).

Stdio::Null

Redirect to / from /dev/null.

Stdio::Piped

Create a pipe; the parent keeps its end in the resulting Child::stdin / stdout / stderr.

Stdio::Fd(i32)

Use a specific fd. Ownership transfers; the spawn closes the fd in the parent after duping it into the child.

Command::spawn(&this) -> Result<Child, IoError>

fork + configure fds/env + execvp. Returns a Child the caller must eventually wait on.

Command::status(&this) -> Result<ExitStatus, IoError>

spawn + wait. Stdin/out/err go wherever the caller configured (typically Inherit).

async Command::collect(&this) -> Result<Output, IoError>

Spawn, capture both streams, and await the exit without blocking the calling thread: the async spelling of output.

async Command::run(&this) -> Result<ExitStatus, IoError>

Spawn and await the exit without capturing anything: the async spelling of status. Stdio goes wherever the caller configured it.

Command::env_clear(mut &this) -> void

Don't inherit the parent's environment. Only the entries added with env() reach the child.

static Command::shell(command: string) -> i32

Run command through the platform shell (/bin/sh -c on POSIX, cmd /c on Windows), inheriting stdio, and return the child's exit code (0 on success), or -1 if the shell could not be spawned or the child was killed by a signal.

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.

Stdio::Inherit

Share the parent's fd (the default).

Stdio::Null

Redirect to / from /dev/null.

Stdio::Fd(i32)

Use a specific fd. Ownership transfers; the spawn closes the fd in the parent after duping it into the child.

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