net::ws

public function name() { ... }
public:

Visible to any module that imports this one - the default for top-level items and for struct fields, so it is mostly written to be explicit. public: opens a visibility block that groups the members after it.

public module collections::array;

In a directory's _module.cryo aggregator, lists a submodule and whether it is public. Importing the directory's namespace sees only the modules declared public here.

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

namespace std::net::ws::handshake;

WebSocket opening handshake (RFC 6455 section 4).

namespace std::net::ws::conn;

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

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.

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.

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

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.

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

Send a text message in a single frame.

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

Str: a borrowed UTF-8 string slice.

static Str::new(text: string) -> Str

Construct from a NUL-terminated C-style string literal. The caller certifies that text is valid UTF-8 and outlives this view. The NUL terminator is not included in the view.

match (subject) {
    Pattern(x) => { ... }
    _          => { ... }
}

The primary discriminator: branches on enum variants, integers, ranges, and destructuring patterns, and the compiler rejects a match that misses a case. There is no fallthrough. As an expression it evaluates to the chosen arm's value, so every arm must produce the same type.

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 Result<T, E> {
    Ok(T);
    Err(E);
}

Result: a value that may be an error.

pattern => { body }

Separates a match arm's pattern from its body. Arms do not fall through.

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

A complete application message. Owns its payload.

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