future

public function name() { ... }
public:

Visible to any module that imports this one - the default for top-level items and for struct fields, so it is mostly written to be explicit. public: opens a visibility block that groups the members after it.

public module collections::array;

In a directory's _module.cryo aggregator, lists a submodule and whether it is public. Importing the directory's namespace sees only the modules declared public here.

namespace std::future;

std::future: stackless async foundations — Future, Poll, Context, Waker, and the drivers that poll them.

namespace std::future::poll;

Poll<T>: the result of polling a Future.

namespace std::future::waker;

Waker and Context: how a stalled future gets re-scheduled.

namespace std::future::traits;

The Future trait.

namespace std::future::ready;

Hand-written sample futures: Ready<T> and PendingThenReady<T>.

namespace std::future::reactor;

std::future::reactor: the I/O readiness driver behind async I/O.

namespace std::future::blocking;

std::future::blocking: an off-executor home for work that cannot be polled.

namespace std::future::executor;

std::future::executor: a multi-threaded, poll-driven task executor.

namespace std::future::timer;

std::future::timer: Sleep, the future that completes when a deadline arrives.

namespace std::future::combinator;

std::future::combinator: running futures against each other — Join, TryJoin, Select, and Timeout.

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.

await future

Suspends the enclosing async body until the operand - which must implement Future - completes, and evaluates to its output. A prefix operator allowed anywhere an expression is (conditions, arms, guards), but only inside async code.

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.

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.

type trait Future {
    type Output;
    poll(mut &this, cx: Context*) -> Poll<This::Output>;
}

An asynchronous computation. poll drives it one step: Ready(v) when the value is available, Pending when it is not yet (the future has arranged, via cx's waker, to be polled again later).

type enum Poll<T> {
    Ready(T);
    Pending;
}

The result of polling a Future: either the final value, or a signal that the value is not ready yet and the task should be re-polled after its Waker fires.

type struct Context {
    waker: Waker;
}

The context threaded through a poll call. Holds the Waker a future registers when it returns Pending. Passed by pointer down the poll tree, matching the stdlib convention of moving aggregates by pointer.

type struct Waker {
    data: u8*;
}

A handle a stalled future stores so it can be re-scheduled: wake_fn(data) tells the executor "poll my task again". This is the manual-vtable shape used throughout the runtime — non-capturing function pointers plus an opaque data pointer identifying the task.

type struct Ready<T> {
    value: Option<T>;
}

A future that is already complete: the first poll returns Ready(value). The value is held in an Option and moved out on completion, so polling a Ready a second time is a contract violation (it panics) rather than a double-move.

type struct PendingThenReady<T> {
    remaining: u32;
    value: Option<T>;
}

A future that reports Pending for its first pending_count polls and then completes with value. Exercises the suspend/resume path end-to-end under a driver without any I/O or threads — the canonical Phase-1 validation future.

type struct Executor {
    inner: ExecInner*;
    worker_tids: [u64];
}

A multi-threaded, poll-driven task executor. Construct one, spawn futures onto it (keeping the JoinHandle to await a result, or dropping it to fire-and-forget), and block_on to drive a root future to its value. A pool of worker threads does all polling; the calling thread only ever blocks on a completion condvar.

type struct JoinHandle<O> {
    shared: TaskShared<O>*;
    exec: ExecInner*;
}

A handle to a spawned task, yielding its Output via join(). Dropping a handle without join/detach detaches (the task runs on, its result discarded). abort() requests cancellation.

type enum JoinError {
    Cancelled;
    Panicked(PanicInfo);
}

Why a join did not yield a value.

type struct Futures {}

Constructors for the combinators above.

static Futures::join<A, B, OA, OB>(a: A, b: B) -> Join<A, B, OA, OB>
where A: Future<OA>, B: Future<OB>

Run a and b concurrently; complete with both values.

type struct Sleep {
    deadline: i64;
    id: u64;
    rt: Reactor*;
}

A future that completes once the monotonic clock reaches its deadline.

type struct Reactor {
    mtx: [u8;
    40];
    buckets: [Registration*;
    64];
    poll_h: i64;
    kick_h: i64;
    aux_h: i64;
    shutdown: Atomic<u8>;
    thread: u64;
    timers: Timer*;
    // … 1 more
}

The I/O readiness driver for one Executor. Heap-allocated: worker threads and parked futures hold raw pointers to it, and the backend hands the OS interior addresses, so it must not move.

type struct BlockingPool {
    mtx: [u8;
    40];
    cv: [u8;
    48];
    head: BlockingJob*;
    tail: BlockingJob*;
    shutdown: boolean;
    live: u32;
    idle: u32;
    max: u32;
    // … 1 more
}

A pool of OS threads running blocking jobs for one Executor. Heap-allocated: worker threads and submitted jobs hold raw pointers to it, so it must not move.

type struct BlockingJob {
    rc: Atomic<u32>;
    status: Atomic<u8>;
    waker: Waker;
    next: BlockingJob*;
    pool: BlockingPool*;
}

The header of a blocking job: the erased vtable, the waker to fire when the work finishes, and the refcount that decides who frees the block.

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

Drop: explicit destructor.