child

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 Child {
    stdin: Option<ChildStdin>;
    stdout: Option<ChildStdout>;
    stderr: Option<ChildStderr>;
}

Child: a running subprocess.

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

Option: a value that may be absent.

type struct ChildStdin {
    fd: i32;
}

Write end of a pipe whose read end is the child's stdin.

type struct ChildStdout {
    fd: i32;
}

Read end of a pipe whose write end is the child's stdout.

type struct ChildStderr {
    fd: i32;
}

Read end of a pipe whose write end is the child's stderr.

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 Child::new(pid: i32, handle: u64, stdin: Option<ChildStdin>, stdout: Option<ChildStdout>, stderr: Option<ChildStderr>) -> Child

Low-level constructor used by Command::spawn. Application code should not call this directly. handle is 0 on POSIX and the Win32 process HANDLE on Windows.

primitive i32

32-bit signed integer.

primitive u64

64-bit unsigned integer.

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

Child: a running subprocess.

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

Child::wait(mut &this) -> Result<ExitStatus, IoError>

Block until the child exits. Closes stdin first so the child sees EOF; this is deadlock-avoidant for children that read all of stdin before writing to stdout.

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.

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

Result: a value that may be an error.

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 Child::join(mut &this) -> Result<ExitStatus, IoError>

Await the child's exit without blocking the calling thread: the async spelling of wait. Same stdin-close, same status, same waited bookkeeping — but the task parks and the executor worker stays free. ChildWait documents which of the two routes each platform takes.

Child::try_wait(mut &this) -> Result<Option<ExitStatus>, IoError>

Non-blocking check. Ok(Some(status)) means the child has exited; Ok(None) means it's still running.

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

Send SIGKILL (POSIX) / terminate the process (Windows). Does not wait; call wait afterwards to reap the zombie on POSIX.

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.

type struct Signal {
    value: SigNo;
}

POSIX signal numbers.

type struct ChildStdin {
    fd: i32;
}

Write end of a pipe whose read end is the child's stdin.

type struct ChildStdout {
    fd: i32;
}

Read end of a pipe whose write end is the child's stdout.

type struct ChildStderr {
    fd: i32;
}

Read end of a pipe whose write end is the child's stderr.

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.

primitive boolean

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

ExitStatus::success(&this) -> boolean

Convenience: did the child exit with status 0?

ExitStatus::exit_code(&this) -> Option<i32>

Some(code) for a normal exit, None if the child was killed by a signal.

ExitStatus::terminating_signal(&this) -> Option<i32>

Some(signal) if the child was killed by a signal.

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

Child: a running subprocess.

Child::wait(mut &this) -> Result<ExitStatus, IoError>

Block until the child exits. Closes stdin first so the child sees EOF; this is deadlock-avoidant for children that read all of stdin before writing to stdout.

async Child::join(mut &this) -> Result<ExitStatus, IoError>

Await the child's exit without blocking the calling thread: the async spelling of wait. Same stdin-close, same status, same waited bookkeeping — but the task parks and the executor worker stays free. ChildWait documents which of the two routes each platform takes.

Child::try_wait(mut &this) -> Result<Option<ExitStatus>, IoError>

Non-blocking check. Ok(Some(status)) means the child has exited; Ok(None) means it's still running.

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

Send SIGKILL (POSIX) / terminate the process (Windows). Does not wait; call wait afterwards to reap the zombie on POSIX.

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.

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.

static Child::new(pid: i32, handle: u64, stdin: Option<ChildStdin>, stdout: Option<ChildStdout>, stderr: Option<ChildStderr>) -> Child

Low-level constructor used by Command::spawn. Application code should not call this directly. handle is 0 on POSIX and the Win32 process HANDLE on Windows.

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

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

type struct ChildWait {
    pid: i32;
    handle: u64;
    exit_fd: i32;
    rt: Reactor*;
    job: ChildWaitJob*;
    routed: boolean;
}

Wait for a child to exit without stalling the executor. The machinery behind Child::join; await that rather than driving this directly, because only the method updates the Child's bookkeeping.

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

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

Stdio::Piped

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

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

via trait Drop

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.

ExitStatus::success(&this) -> boolean

Convenience: did the child exit with status 0?

ExitStatus::exit_code(&this) -> Option<i32>

Some(code) for a normal exit, None if the child was killed by a signal.

ExitStatus::terminating_signal(&this) -> Option<i32>

Some(signal) if the child was killed by a signal.