client

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

One-shot h2c (cleartext) requests over plain TCP.

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.

type struct Http2Client {}

One-shot h2c (cleartext) requests over plain TCP.

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 Http2Client::get(&this, addr: SocketAddr, authority: Str, path: Str) -> Result<Response, IoError>

GET over h2c. authority is the :authority pseudo-header (host[:port]); path is the request target.

&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 SocketAddr {
    ip: IpAddr;
    port: u16;
}

SocketAddr: (IP, port).

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.

type struct Response {
    status: StatusCode;
    version: String;
    headers: Headers;
    body: Array<u8>;
}

HTTP response.

async Http2Client::post(&this, addr: SocketAddr, authority: Str, path: Str, content_type: Str, body: Array<u8>) -> Result<Response, IoError>

POST over h2c with a body and Content-Type.

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.

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

net: network primitives + HTTP.

namespace std::net::http2;

net::http2: HTTP/2 (RFC 7540) with HPACK header compression (RFC 7541).

namespace std::net::http2::client;

HTTP/2 client.

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.

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

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 Http2Client::get(&this, addr: SocketAddr, authority: Str, path: Str) -> Result<Response, IoError>

GET over h2c. authority is the :authority pseudo-header (host[:port]); path is the request target.

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.

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 Http2Client::post(&this, addr: SocketAddr, authority: Str, path: Str, content_type: Str, body: Array<u8>) -> Result<Response, IoError>

POST over h2c with a body and Content-Type.

async function one_shot(addr: SocketAddr, authority: Str, req: Request) -> Result<Response, IoError>

Dial addr, upgrade to h2c, run one request/response, close.

async function connect<S>(conn: BufStream<S>) -> Result<Http2Connection<S>, IoError>
where S: AsyncTransport

Upgrade conn to an HTTP/2 client connection by performing the preface + SETTINGS handshake. Takes ownership; the returned connection closes the transport when dropped. A failed handshake releases it.

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<S>(conn: BufStream<S>) -> Result<Http2Connection<S>, IoError>
where S: AsyncTransport

Upgrade conn to an HTTP/2 client connection by performing the preface + SETTINGS handshake. Takes ownership; the returned connection closes the transport when dropped. A failed handshake releases it.

type parameter S

where S: AsyncTransport

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 function one_shot(addr: SocketAddr, authority: Str, req: Request) -> Result<Response, IoError>

Dial addr, upgrade to h2c, run one request/response, close.

type struct Request {
    method: Method;
    path: String;
    version: String;
    headers: Headers;
    body: Array<u8>;
    params: HashMap<String, String>;
}

HTTP request.