buf

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 BufWriter<W> where W: Write {
    writer: W*;
    buffer: u8*;
    capacity: u64;
    length: u64;
}

Coalesces writes destined for W into larger flushes. The inner writer is borrowed via pointer; the caller owns it and drops it.

type parameter W

where W: Write

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 parameter W

where W: Write

primitive u8

8-bit unsigned integer.

primitive u64

64-bit unsigned integer.

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 BufWriter::new(writer: W*) -> BufWriter<W>
where W: Write

Wrap writer with a DEFAULT_BUFFER_SIZE-byte buffer. Panics on allocation failure.

type struct BufWriter<W> where W: Write {
    writer: W*;
    buffer: u8*;
    capacity: u64;
    length: u64;
}

Coalesces writes destined for W into larger flushes. The inner writer is borrowed via pointer; the caller owns it and drops it.

static BufWriter::with_capacity(writer: W*, capacity: u64) -> BufWriter<W>
where W: Write

Wrap with an explicit buffer size. capacity == 0 is permitted but degenerate: every write hits the sink directly. Panics on allocation failure.

BufWriter::get_ref(&this) -> W*

Borrow the inner writer. Useful for operations that bypass buffering (e.g., a direct flush on the underlying fd). Callers mutating through this must call BufWriter::flush first, or buffered bytes will land out of order.

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

BufWriter::buffered(&this) -> u64

Number of bytes currently buffered but not yet flushed.

BufWriter::clear(mut &this) -> void

Discard buffered bytes without writing them. Useful on error paths where the caller knows the output is garbage.

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.

BufWriter::flush_buffer(mut &this) -> Result<(), IoError>

Write buffered bytes to the sink and reset. Retries are delegated to the sink's write_all.

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.

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

io: byte-level input/output.

namespace std::io::buf;

Buffered readers and writers.

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

Handle to process standard output. Unbuffered; wrap in LineWriter<Stdout> or BufWriter<Stdout> from io::buf for the common "coalesce many small writes" case.

static BufWriter::new(writer: W*) -> BufWriter<W>
where W: Write

Wrap writer with a DEFAULT_BUFFER_SIZE-byte buffer. Panics on allocation failure.

BufWriter::write<T>(mut &this, data: T) -> Result<(), IoError>

via trait Write

Write data in full, retrying short writes and Interrupted errors. Generic over the payload, dispatched at compile time via static match: a raw byte Slice<u8>, a Str view, a NUL-terminated C string, or a single u8.

BufWriter::flush(mut &this) -> Result<(), IoError>

via trait Write

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 struct LineWriter<W> {
    inner: BufWriter<W>;
}

A BufWriter that flushes after any write containing a \n. Appropriate for interactive stdout on a TTY, where "the user saw the line as soon as it was emitted" matters more than coalescing.

type struct LineWriter<W> {
    inner: BufWriter<W>;
}

A BufWriter that flushes after any write containing a \n. Appropriate for interactive stdout on a TTY, where "the user saw the line as soon as it was emitted" matters more than coalescing.

type struct BufReader<R> where R: Read {
    reader: R*;
    buffer: u8*;
    capacity: u64;
    position: u64;
    filled: u64;
}

Pulls from R in buffer-sized chunks and serves reads from the buffer. Transforms a stream of small reads into a few large ones and makes read_line fast: no per-byte syscall.

type parameter R

where R: Read

type parameter R

where R: Read

BufReader.position: u64

First unread byte in the buffer.

BufReader.filled: u64

One past the last filled byte.

type struct BufReader<R> where R: Read {
    reader: R*;
    buffer: u8*;
    capacity: u64;
    position: u64;
    filled: u64;
}

Pulls from R in buffer-sized chunks and serves reads from the buffer. Transforms a stream of small reads into a few large ones and makes read_line fast: no per-byte syscall.

BufReader::available(&this) -> u64

Bytes currently buffered and unread.

BufReader::consume(mut &this, amount: u64) -> void

Advance the buffer cursor past amount bytes. amount must not exceed available(); a larger value is a caller bug.

BufReader::fill_buf(mut &this) -> Result<Slice<u8>, IoError>

Fill the buffer from the source if empty, then surface the filled region. Returns an empty slice at EOF. Paired with consume for zero-copy parsing: read a prefix, decide how many bytes are actually wanted, consume that many.

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

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

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.

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

Wrap an already-connected transport.

BufStream::compact(mut &this) -> void

Drop the consumed prefix so a long-lived connection's buffer tracks what is live rather than everything ever read. Called only at the start of a fill: moving bytes at any other time would shift buffered() under a caller mid-parse.

BufStream::transport(mut &this) -> S*

The transport, for callers that need it directly (socket options, the negotiated ALPN protocol). Not for reading or writing — that would desynchronize the buffers.

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

BufWriter::buffered(&this) -> u64

Number of bytes currently buffered but not yet flushed.

BufWriter::clear(mut &this) -> void

Discard buffered bytes without writing them. Useful on error paths where the caller knows the output is garbage.

BufWriter::flush_buffer(mut &this) -> Result<(), IoError>

Write buffered bytes to the sink and reset. Retries are delegated to the sink's write_all.

BufWriter::get_ref(&this) -> W*

Borrow the inner writer. Useful for operations that bypass buffering (e.g., a direct flush on the underlying fd). Callers mutating through this must call BufWriter::flush first, or buffered bytes will land out of order.

BufWriter::drop(mut &this) -> void

via trait Drop

static BufWriter::with_capacity(writer: W*, capacity: u64) -> BufWriter<W>
where W: Write

Wrap with an explicit buffer size. capacity == 0 is permitted but degenerate: every write hits the sink directly. Panics on allocation failure.

BufReader::read_line(mut &this, out: mut &String) -> Result<u64, IoError>

via trait Read

Override the trait default; line-reading is the whole point of BufReader, so we do it the fast way: scan the filled region for \n, copy the prefix wholesale, consume, refill only if we didn't hit the newline.

BufReader::fill_buf(mut &this) -> Result<Slice<u8>, IoError>

Fill the buffer from the source if empty, then surface the filled region. Returns an empty slice at EOF. Paired with consume for zero-copy parsing: read a prefix, decide how many bytes are actually wanted, consume that many.

BufReader::consume(mut &this, amount: u64) -> void

Advance the buffer cursor past amount bytes. amount must not exceed available(); a larger value is a caller bug.

BufReader::available(&this) -> u64

Bytes currently buffered and unread.

BufReader.position: u64

First unread byte in the buffer.

BufReader.filled: u64

One past the last filled byte.

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.

implement trait Trait for Type { ... }

Names the type a trait implementation is for. The block that follows supplies the bodies the trait requires.

type trait Drop {
    drop(mut &this) -> void;
}

Drop: explicit destructor.

type trait AsyncRead {
    async fill(mut &this) -> Result<u64, IoError>;
    buffered(&this) -> Slice<u8>;
    consume(mut &this, count: u64) -> void;
    scan_for(&this, delimiter: u8, from: u64) -> u64;
    take_front(mut &this, count: u64) -> Result<Array<u8>, IoError>;
    async ensure(mut &this, count: u64) -> Result<(), IoError>;
    async read_exact(mut &this, count: u64) -> Result<Array<u8>, IoError>;
    async read_some(mut &this, limit: u64) -> Result<Array<u8>, IoError>;
    async read_until(mut &this, delimiter: u8, limit: u64) -> Result<Array<u8>, IoError>;
    async read_line(mut &this, limit: u64) -> Result<String, IoError>;
    // … 1 more
}

A byte source that buffers what it reads inside itself.

type trait AsyncWrite {
    pending(mut &this) -> Array<u8>*;
    async flush(mut &this) -> Result<(), IoError>;
    queue<T>(mut &this, data: T) -> Result<(), IoError>;
    async send<T>(mut &this, data: T) -> Result<(), IoError>;
}

A byte sink that buffers what it is given until told to send it.

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.

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

Wrap an already-connected transport.

BufStream::transport(mut &this) -> S*

The transport, for callers that need it directly (socket options, the negotiated ALPN protocol). Not for reading or writing — that would desynchronize the buffers.

BufStream::compact(mut &this) -> void

Drop the consumed prefix so a long-lived connection's buffer tracks what is live rather than everything ever read. Called only at the start of a fill: moving bytes at any other time would shift buffered() under a caller mid-parse.

namespace std::net;

net: network primitives + HTTP.

namespace std::net::http;

http: HTTP/1.1 with keep-alive.

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

HTTP/1.1 message framing over a buffered async connection.

namespace std::net::ws;

net::ws: WebSocket (RFC 6455) client + server.

namespace std::net::ws::frame;

WebSocket framing (RFC 6455 section 5).

private type struct Name { ... }
private:

On a field: only the declaring type's own methods may touch it (E0353). On a top-level item: confined to its own module, and naming a private type elsewhere is E0503. private: opens a block of such members.