condvar

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 CondVar {
    inner: CondVarInner*;
}

CondVar: condition variable for blocking until a predicate holds.

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 CondVar::new() -> CondVar

Construct a fresh condition variable with default attributes. Panics on allocation failure or pthread init failure.

type struct CondVar {
    inner: CondVarInner*;
}

CondVar: condition variable for blocking until a predicate holds.

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

Result: a value that may be an error.

CondVar::wait<T, A>(&this, mutex: &Mutex<T, A>, guard: mut &MutexGuard<T, A>) -> void

Block the current thread until another thread signals this condition variable. Atomically releases mutex, waits, and reacquires mutex before returning. guard is not invalidated - its address still refers to the same MutexInner - but inspect the guarded value only after wait returns.

&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 Mutex<T, A = GlobalAlloc> where A: Allocator {
    inner: MutexInner<T, A>*;
}

Mutex<T>: mutual-exclusion lock around a value.

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 struct MutexGuard<T, A> {
    inner: MutexInner<T, A>*;
}

RAII guard returned by Mutex::lock. Carries a raw pointer to the inner so it can release the lock on drop. Deref via as_ptr() to read or mutate the guarded value.

primitive void

No value; only valid as a return type.

CondVar::notify_one(&this) -> void

Wake up one thread waiting on this condition variable. If no thread is currently waiting, the signal is lost (this is the standard pthread semantics; the producer should arrange for the consumer to check the predicate before sleeping).

CondVar::notify_all(&this) -> void

Wake up every thread currently waiting on this condition variable. Spurious wake-ups are possible regardless; the consumer must re-check the predicate after waking.

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 GlobalAlloc {}

Zero-sized handle to the process-wide allocator. Construct with GlobalAlloc::new(); all instances dispatch through the same underlying backend.

while (condition) { ... }

Repeats its body while the condition holds. The condition is checked before every iteration, so the body may run zero times.

MutexGuard::as_ptr(&this) -> T*

Pointer to the guarded value. Valid for the lifetime of this guard; never null.

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

std::sync: synchronization primitives for concurrent code.

namespace std::sync::condvar;

CondVar: condition variable for blocking until a predicate holds.

CondVar::wait<T, A>(&this, mutex: &Mutex<T, A>, guard: mut &MutexGuard<T, A>) -> void

Block the current thread until another thread signals this condition variable. Atomically releases mutex, waits, and reacquires mutex before returning. guard is not invalidated - its address still refers to the same MutexInner - but inspect the guarded value only after wait returns.

CondVar::notify_one(&this) -> void

Wake up one thread waiting on this condition variable. If no thread is currently waiting, the signal is lost (this is the standard pthread semantics; the producer should arrange for the consumer to check the predicate before sleeping).

CondVar::notify_all(&this) -> void

Wake up every thread currently waiting on this condition variable. Spurious wake-ups are possible regardless; the consumer must re-check the predicate after waking.

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

type trait Send {}

Types that are safe to transfer between threads. An owning value of a Send type may cross a thread boundary without violating memory safety.

type trait Sync {}

Types that are safe to share between threads by shared reference. T: Sync if &T: Send.

static CondVar::new() -> CondVar

Construct a fresh condition variable with default attributes. Panics on allocation failure or pthread init failure.

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.