mutex

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

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

type parameter A

where A: Allocator

type struct GlobalAlloc {}

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

where T: Ord + Clone, U: Hash

Constrains generic parameters to types that implement the listed traits, which is what makes those traits' methods callable on T. Bounds on one parameter join with +; parameters separate with ,. A where on a single method narrows the type's parameter for that method only.

type parameter A

where A: Allocator

type trait Allocator {
    allocate(mut &this, layout: Layout) -> Result<NonNull<u8>, AllocError>;
    deallocate(mut &this, ptr: NonNull<u8>, layout: Layout) -> void;
    reallocate(mut &this, ptr: NonNull<u8>, old_layout: Layout, new_layout: Layout) -> Result<NonNull<u8>, AllocError>;
}

Allocator: the trait every heap strategy implements.

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 Mutex::new(value: T) -> Mutex<T, GlobalAlloc>

Construct a Mutex<T> initialized to hold value, using GlobalAlloc for the inner allocation. Panics on allocation failure; use try_new to handle the error.

type struct Mutex<T, A = GlobalAlloc> where A: Allocator {
    inner: MutexInner<T, A>*;
}

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

static Mutex::try_new(value: T) -> Result<Mutex<T, GlobalAlloc>, AllocError>

Fallible constructor. Initializes the pthread mutex with default attributes (PTHREAD_MUTEX_NORMAL).

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

Result: a value that may be an error.

Mutex::lock(&this) -> MutexGuard<T, A>

Acquire the lock, blocking the current thread until it is available. Returns a guard whose drop() will release the lock. Panics only on a programming error reported by pthread_mutex_lock (EINVAL from a recursively-locked non-recursive mutex or a destroyed mutex).

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

Mutex::try_lock(&this) -> Option<MutexGuard<T, A>>

Non-blocking lock attempt. Returns Some(guard) when the lock was acquired; None when the lock was already held by another thread.

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

Option: a value that may be absent.

Mutex::raw_pthread_buf(&this) -> u8*

Raw pointer to the inner pthread buffer. Used by CondVar to pair the mutex with a condition variable in pthread_cond_wait; not a stable public API.

primitive u8

8-bit unsigned 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::sync;

std::sync: synchronization primitives for concurrent code.

namespace std::sync::mutex;

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

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 Mutex::new(value: T) -> Mutex<T, GlobalAlloc>

Construct a Mutex<T> initialized to hold value, using GlobalAlloc for the inner allocation. Panics on allocation failure; use try_new to handle the error.

Mutex::lock(&this) -> MutexGuard<T, A>

Acquire the lock, blocking the current thread until it is available. Returns a guard whose drop() will release the lock. Panics only on a programming error reported by pthread_mutex_lock (EINVAL from a recursively-locked non-recursive mutex or a destroyed mutex).

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

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

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.

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

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

static Mutex::try_new(value: T) -> Result<Mutex<T, GlobalAlloc>, AllocError>

Fallible constructor. Initializes the pthread mutex with default attributes (PTHREAD_MUTEX_NORMAL).

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

via trait Drop

Mutex::try_lock(&this) -> Option<MutexGuard<T, A>>

Non-blocking lock attempt. Returns Some(guard) when the lock was acquired; None when the lock was already held by another thread.

Mutex::raw_pthread_buf(&this) -> u8*

Raw pointer to the inner pthread buffer. Used by CondVar to pair the mutex with a condition variable in pthread_cond_wait; not a stable public API.

type struct CondVar {
    inner: CondVarInner*;
}

CondVar: condition variable for blocking until a predicate holds.

null

The null pointer literal, valid in any pointer context - including the primitive string, which is a NUL-terminated u8*. Compare with == null; it is not an Option.

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.

type trait Name : Base {
    method(&this, other: &This) -> Ret;
}

Names a set of methods a type may implement. Inside the body This is the implementing type; methods may carry default bodies, and a trait may require a base trait (type trait Ord : Eq). Generic code asks for a trait with where T: Name.

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.