conn

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.

primitive boolean

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

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 WebSocket::of(conn: BufStream<S>, is_client: boolean) -> WebSocket<S>

Take ownership of an already-upgraded connection. is_client selects masked (client) vs unmasked (server) framing per RFC 6455. Use client_handshake / server_handshake to run the upgrade first.

WebSocket::connection(mut &this) -> BufStream<S>*

The buffered connection, for callers that need the transport itself (socket options, the negotiated ALPN protocol). Not for reading or writing — that would desynchronize the framing.

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.

WebSocket::is_closed(&this) -> boolean

Has a Close frame been sent or received on this connection?

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 WebSocket::client_handshake(mut &this, host: Str, path: Str) -> Result<(), IoError>
where S: AsyncTransport

Client handshake: send the GET upgrade, then verify the 101 and the Sec-WebSocket-Accept echo. Bytes that arrived after the blank line stay buffered for recv.

type struct Str {
    bytes: u8*;
    length: u64;
}

Str: a borrowed UTF-8 string slice.

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.

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.

async WebSocket::server_handshake(mut &this) -> Result<(), IoError>
where S: AsyncTransport

Server handshake: read the client GET, reply 101 with the computed accept value. Bytes that arrived after the blank line — a client that pipelined its first frame into the same write — stay buffered.

async WebSocket::send_text(mut &this, text: Str) -> Result<(), IoError>
where S: AsyncTransport

Send a text message in a single frame.

async WebSocket::send_binary(mut &this, data: Slice<u8>) -> Result<(), IoError>
where S: AsyncTransport

Send a binary message in a single frame.

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

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

primitive u8

8-bit unsigned integer.

async WebSocket::ping(mut &this, data: Slice<u8>) -> Result<(), IoError>
where S: AsyncTransport

Send a Ping with optional application data.

async WebSocket::close(mut &this, code: u16, reason: Str) -> Result<(), IoError>
where S: AsyncTransport

Send a Close frame with a status code and reason. The transport itself is closed when the WebSocket is dropped.

primitive u16

16-bit unsigned integer.

async WebSocket::recv(mut &this) -> Result<Message, IoError>
where S: AsyncTransport

Receive the next application message, reassembling fragments and transparently answering Pings with Pongs and skipping Pongs. A Close frame surfaces as Message::Close.

type enum Message {
    Text(String);
    Binary(Array<u8>);
    Close;
}

A complete application message. Owns its payload.

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 WebSocket::of(conn: BufStream<S>, is_client: boolean) -> WebSocket<S>

Take ownership of an already-upgraded connection. is_client selects masked (client) vs unmasked (server) framing per RFC 6455. Use client_handshake / server_handshake to run the upgrade first.

static BufStream::of(inner: S) -> BufStream<S>

Wrap an already-connected transport.

true

The boolean literal. Booleans are a distinct 1-byte type, not interchangeable with integers; if and while conditions must be boolean.

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.

async WebSocket::client_handshake(mut &this, host: Str, path: Str) -> Result<(), IoError>
where S: AsyncTransport

Client handshake: send the GET upgrade, then verify the 101 and the Sec-WebSocket-Accept echo. Bytes that arrived after the blank line stay buffered for recv.

value?

Error propagation. On a Result<T, E> it yields the T of an Ok and otherwise returns the Err(e) from the enclosing function unchanged; on an Option<T> it yields the T of a Some or returns None. The enclosing function must return a matching Result / Option.

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

type enum Message {
    Text(String);
    Binary(Array<u8>);
    Close;
}

A complete application message. Owns its payload.

type struct String<A = GlobalAlloc> {
    buffer: RawBuffer<u8, A>;
    length: u64;
}

String: owned, heap-allocated, length-typed UTF-8.

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.

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

WebSocket connection: handshake + message send/recv over a buffered async connection.

async function connect(sock: TcpStream, host: Str, path: Str) -> Result<WebSocket<TcpStream>, IoError>

Connect a WebSocket over an already-connected TCP socket: wrap it, run the client handshake, and hand back the upgraded connection. The socket is consumed — the WebSocket owns it from here.

async function accept(sock: TcpStream) -> Result<WebSocket<TcpStream>, IoError>

Accept a WebSocket over an accepted TCP socket: wrap it, run the server handshake, and hand back the upgraded connection.

async WebSocket::server_handshake(mut &this) -> Result<(), IoError>
where S: AsyncTransport

Server handshake: read the client GET, reply 101 with the computed accept value. Bytes that arrived after the blank line — a client that pipelined its first frame into the same write — stay buffered.

async WebSocket::send_text(mut &this, text: Str) -> Result<(), IoError>
where S: AsyncTransport

Send a text message in a single frame.

async WebSocket::send_binary(mut &this, data: Slice<u8>) -> Result<(), IoError>
where S: AsyncTransport

Send a binary message in a single frame.

async WebSocket::ping(mut &this, data: Slice<u8>) -> Result<(), IoError>
where S: AsyncTransport

Send a Ping with optional application data.

async WebSocket::close(mut &this, code: u16, reason: Str) -> Result<(), IoError>
where S: AsyncTransport

Send a Close frame with a status code and reason. The transport itself is closed when the WebSocket is dropped.

async WebSocket::recv(mut &this) -> Result<Message, IoError>
where S: AsyncTransport

Receive the next application message, reassembling fragments and transparently answering Pings with Pongs and skipping Pongs. A Close frame surfaces as Message::Close.

WebSocket::is_closed(&this) -> boolean

Has a Close frame been sent or received on this connection?

WebSocket::connection(mut &this) -> BufStream<S>*

The buffered connection, for callers that need the transport itself (socket options, the negotiated ALPN protocol). Not for reading or writing — that would desynchronize the framing.

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.

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.

async function connect(sock: TcpStream, host: Str, path: Str) -> Result<WebSocket<TcpStream>, IoError>

Connect a WebSocket over an already-connected TCP socket: wrap it, run the client handshake, and hand back the upgraded connection. The socket is consumed — the WebSocket owns it from here.

async function accept(sock: TcpStream) -> Result<WebSocket<TcpStream>, IoError>

Accept a WebSocket over an accepted TCP socket: wrap it, run the server handshake, and hand back the upgraded connection.