barrier

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 Barrier {
    inner: BarrierInner*;
}

Barrier: thread rendezvous point.

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 Barrier::new(count: u32) -> Barrier

Construct a barrier that requires count threads before releasing them. Panics on allocation failure or pthread init failure (a non-zero count is the only requirement).

primitive u32

32-bit unsigned integer.

type struct Barrier {
    inner: BarrierInner*;
}

Barrier: thread rendezvous point.

Barrier::wait(&this) -> BarrierWaitResult

Block the current thread until every thread participating in the barrier has called wait(). Returns a BarrierWaitResult whose is_leader flag is true on exactly one of the awakening threads. The barrier is automatically reset for the next cycle once all waiters resume.

&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 BarrierWaitResult {
    is_leader: boolean;
}

Result of Barrier::wait(). Exactly one of the threads at each barrier cycle observes is_leader == true; this is the standard way to designate one thread to do per-phase cleanup work.

type struct BarrierWaitResult {
    is_leader: boolean;
}

Result of Barrier::wait(). Exactly one of the threads at each barrier cycle observes is_leader == true; this is the standard way to designate one thread to do per-phase cleanup work.

primitive boolean

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

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

Barrier: thread rendezvous point.

Barrier::wait(&this) -> BarrierWaitResult

Block the current thread until every thread participating in the barrier has called wait(). Returns a BarrierWaitResult whose is_leader flag is true on exactly one of the awakening threads. The barrier is automatically reset for the next cycle once all waiters resume.

static Barrier::new(count: u32) -> Barrier

Construct a barrier that requires count threads before releasing them. Panics on allocation failure or pthread init failure (a non-zero count is the only requirement).

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.

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.