frame

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 struct Name { ... }

Names the struct an inherent block extends. The methods inside are interchangeable with ones declared in the struct body.

BufStream::queue_frame(mut &this, fin: boolean, opcode: OpCode, payload: Slice<u8>, mask: boolean) -> Result<(), IoError>

Queue one frame into the outgoing buffer. mask selects client framing (a fresh masking key from the OS CSPRNG is generated and applied) from server framing (no mask), per RFC 6455 section 5.1. The payload is not consumed. Nothing is sent until the caller flushes.

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.

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

primitive boolean

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

type struct Slice<T> {
    ptr: T*;
    length: u64;
}

Slice<T>: a borrowed view into a contiguous sequence.

primitive u8

8-bit unsigned integer.

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

Result: a value that may be an error.

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.

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 BufStream::read_frame(mut &this) -> Result<Frame, IoError>
where S: AsyncTransport

Read one frame, enforcing the role-independent RFC 6455 framing rules: a set reserved bit (RSV1-3, section 5.2, no extension negotiated), an over-long or fragmented control frame (section 5.4-5.5), a reserved opcode, and an oversized payload are all rejected with InvalidData.

type struct Frame {
    fin: boolean;
    opcode: OpCode;
    masked: boolean;
    payload: Array<u8>;
}

One decoded frame. Owns its payload bytes; call drop. masked records whether the wire frame set the mask bit, so the connection layer - which knows whether it is the client or the server - can enforce the RFC 6455 section 5.1 mask-direction rule (the frame reader itself is role-agnostic).

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 trait AsyncTransport {
    async read_into(mut &this, buf: Array<u8>) -> Transfer;
    async write_from(mut &this, buf: Array<u8>) -> Transfer;
}

One raw, unbuffered async byte channel: what BufStream<S> needs of a transport, and nothing more.

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 Frame {
    fin: boolean;
    opcode: OpCode;
    masked: boolean;
    payload: Array<u8>;
}

One decoded frame. Owns its payload bytes; call drop. masked records whether the wire frame set the mask bit, so the connection layer - which knows whether it is the client or the server - can enforce the RFC 6455 section 5.1 mask-direction rule (the frame reader itself is role-agnostic).

type struct Array<T, A = GlobalAlloc> where A: Allocator {
    ptr: T*;
    length: i64;
    capacity: i64;
    alloc: A;
}

Array<T, A>: growable, heap-backed, contiguous sequence.

type enum Name {
    Unit,
    Payload(T),
    Named { x: i32 },
}

An algebraic data type. Variants may be bare or carry a tuple or struct payload, and a match on an enum must cover every variant. Name::Variant names a variant; methods are added with implement enum Name { ... }.

const NAME: Type = value;

At module level, a true compile-time constant, conventionally SCREAMING_SNAKE_CASE. (mut at module level declares mutable global state instead.)

primitive u64

64-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::net;

net: network primitives + HTTP.

namespace std::net::ws;

net::ws: WebSocket (RFC 6455) client + server.

namespace std::net::ws::frame;

WebSocket framing (RFC 6455 section 5).

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.