request

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 Request {
    method: Method;
    path: String;
    version: String;
    headers: Headers;
    body: Array<u8>;
    params: HashMap<String, String>;
}

HTTP request.

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

HTTP method.

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

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

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

HTTP headers: case-insensitive name/value map.

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.

Request.params: HashMap<String, String>

Path parameters captured by the router (/users/:id -> id). Empty for requests dispatched without a Router.

type struct HashMap<K, V, A = GlobalAlloc> where A: Allocator {
    buckets: Entry<K, V>**;
    bucket_count: u64;
    length: u64;
    alloc: A;
    seed: u64;
}

HashMap<K, V, A>: key-value map with amortized O(1) operations.

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 Request::new(method: Method, path: Str) -> Request

Construct a minimal request. Clients build on top of this with with_header / with_body.

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

Str: a borrowed UTF-8 string slice.

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

HTTP request.

Request::param(&this, name: Str) -> Option<String>

Look up a path parameter captured by the router (e.g., :id in /users/:id). Returns an owned copy of the captured segment The caller is responsible for dropping it. Returns None when the parameter was not captured (no router, or pattern did not include a segment with that name).

&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 enum Option<T> {
    Some(T);
    None;
}

Option: a value that may be absent.

Request::with_header(mut this, name: Str, value: Str) -> Request

Builder: insert a header and return the request so calls chain. Consumes and returns this (the owning fields are moved, not copied): Request::new(m, p).with_header(n, v).with_body(b).

mut this

A by-value receiver the body may also reassign. The receiver is moved into the method and consumed; the caller's value may not be used afterwards.

Request::with_body(mut this, body: Array<u8>) -> Request

Builder: set the body (and Content-Length) and return the request.

Request::set_body(mut &this, body: Array<u8>) -> void

Replace the body and set Content-Length accordingly.

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.

primitive void

No value; only valid as a return type.

static Request::from_request_line(line: Str) -> Result<Request, IoError>

Parse a Request-Line (METHOD SP PATH SP VERSION, no CRLF) into a request with empty headers and no body. Malformed input is InvalidData, which a server surfaces as 400.

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

Result: a value that may be an error.

Request::encode_into(&this, out: Array<u8>*) -> Result<(), IoError>

Append the whole message — request line, headers, blank line, body — to out, normally the connection's pending() buffer.

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.

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 Request::new(method: Method, path: Str) -> Request

Construct a minimal request. Clients build on top of this with with_header / with_body.

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.

Request::with_header(mut this, name: Str, value: Str) -> Request

Builder: insert a header and return the request so calls chain. Consumes and returns this (the owning fields are moved, not copied): Request::new(m, p).with_header(n, v).with_body(b).

Request::with_body(mut this, body: Array<u8>) -> Request

Builder: set the body (and Content-Length) and return the request.

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

http: HTTP/1.1 with keep-alive.

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

HTTP request.

Request::set_body(mut &this, body: Array<u8>) -> void

Replace the body and set Content-Length accordingly.

Request::param(&this, name: Str) -> Option<String>

Look up a path parameter captured by the router (e.g., :id in /users/:id). Returns an owned copy of the captured segment The caller is responsible for dropping it. Returns None when the parameter was not captured (no router, or pattern did not include a segment with that name).

Request::encode_into(&this, out: Array<u8>*) -> Result<(), IoError>

Append the whole message — request line, headers, blank line, body — to out, normally the connection's pending() buffer.

static Request::from_request_line(line: Str) -> Result<Request, IoError>

Parse a Request-Line (METHOD SP PATH SP VERSION, no CRLF) into a request with empty headers and no body. Malformed input is InvalidData, which a server surfaces as 400.

Request.params: HashMap<String, String>

Path parameters captured by the router (/users/:id -> id). Empty for requests dispatched without a Router.

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

Method- and path-based request dispatcher.

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 trait Trait for Type { ... }

Introduces a trait implementation: the block supplies, for one concrete type, the method bodies the trait requires.

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.