net::http

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

http: HTTP/1.1 with keep-alive.

namespace std::net::http::method;

HTTP method.

namespace std::net::http::status;

HTTP status codes.

namespace std::net::http::headers;

HTTP headers: case-insensitive name/value map.

namespace std::net::http::request;

HTTP request.

namespace std::net::http::response;

HTTP response.

namespace std::net::http::conn;

HTTP/1.1 message framing over a buffered async connection.

namespace std::net::http::router;

HTTP router: method- and path-based request dispatch.

namespace std::net::http::server;

HTTP server: non-blocking, one connection at a time, HTTP/1.1 keep-alive within a connection.

namespace std::net::http::client;

HTTP client: simple one-shot requests over plain TCP.

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

std::future: stackless async foundations — Future, Poll, Context, Waker, and the drivers that poll them.

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.

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

HTTP request.

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

HTTP response.

return value;

Leaves the current function with the given value. A function whose return type is not void must return one; a bare return; is for void. In an async function it completes the future with the value.

static Response::text(status: StatusCode, body: Str) -> Response

Convenience: Response::text(StatusCode::ok(), "hello") with Content-Type text/plain; charset=utf-8 and Content-Length set.

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.

primitive i32

32-bit signed integer.

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.

type struct Router {
    routes: Array<Route>;
}

Method- and path-based request dispatcher.

static Router::new() -> Router

Create an empty router with no registered routes and built-in fallback handlers (plain-text 404 / 405).

Router::get(mut &this, pattern: Str, handler: (Request) -> Response) -> &Router

Register a GET exact route.

type struct HttpServer {
    addr: SocketAddr;
    router: Router*;
    read_timeout_secs: i64;
}

A configured HTTP server ready to bind and run.

static HttpServer::with_router(addr: SocketAddr, router: mut &Router) -> HttpServer

Build a server backed by a Router. Pass &router; the router must outlive the server (declare both in the same scope).

type struct Executor {
    inner: ExecInner*;
    worker_tids: [u64];
}

A multi-threaded, poll-driven task executor. Construct one, spawn futures onto it (keeping the JoinHandle to await a result, or dropping it to fire-and-forget), and block_on to drive a root future to its value. A pool of worker threads does all polling; the calling thread only ever blocks on a completion condvar.

static Executor::new() -> Executor

Create an executor whose pool is sized to the hardware parallelism.

Executor::block_on<F, O>(mut &this, root: F) -> O
where F: Future<O>

Spawn root and block the calling thread until a worker drives it to completion, then return its value. Panics if root was cancelled or could not complete; use spawn(root).join() for the Result.

async HttpServer::run(mut &this) -> Result<(), IoError>

Bind to this.addr and serve requests forever. Returns Err only on a fatal listener error (e.g. EMFILE, ENFILE).

type enum Method {
    Get;
    Head;
    Post;
    Put;
    Delete;
    Connect;
    Options;
    Trace;
    Patch;
}

HTTP method.

type struct Headers {
    inner: HashMap<String, String>;
}

HTTP headers: case-insensitive name/value map.

type enum RouteKind {
    Exact;
    Prefix;
}

Whether the route pattern must consume the entire request path or only a leading prefix.

type struct Client {}

HTTP client: simple one-shot 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.