dns

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 ResolvedAddrs {
    addrs: Array<IpAddr>;
}

The addresses a hostname resolved to. Owns the backing Array; call drop when done.

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.

ResolvedAddrs::length(&this) -> u64

Number of resolved addresses (>= 1 on a successful resolve).

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

primitive u64

64-bit unsigned integer.

ResolvedAddrs::get(&this, index: u64) -> Option<IpAddr>

The i-th resolved address, or None if out of range.

type enum Option<T> {
    Some(T);
    None;
}

Option: a value that may be absent.

ResolvedAddrs::first_ipv4(&this, port: u16) -> Option<SocketAddr>

The first IPv4 address in the result, paired with port, or None if the name resolved only to AAAA records. Callers that can dial a v6 address should walk get instead; this exists for the layers that cannot yet.

primitive u16

16-bit unsigned integer.

type struct SocketAddr {
    ip: IpAddr;
    port: u16;
}

SocketAddr: (IP, port).

type struct Resolve {
    host: Str;
    job: ResolveJob*;
}

Resolve host without stalling the executor: the lookup runs on the BlockingPool's threads and the task parks until it answers.

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

Str: a borrowed UTF-8 string slice.

type struct ResolveJob {
    job: BlockingJob;
    host: String;
    addrs: ResolvedAddrs;
    err: IoError;
    produced: boolean;
    ok: boolean;
}

The block a Resolve hands to the blocking pool: the pool's job header, the request, and the slot the answer lands in.

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 Resolve::start(host: Str) -> Resolve

Begin resolving host. Nothing is submitted until the first poll, so a Resolve that is never awaited costs nothing.

type struct Resolve {
    host: Str;
    job: ResolveJob*;
}

Resolve host without stalling the executor: the lookup runs on the BlockingPool's threads and the task parks until it answers.

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 u32

32-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::dns;

DNS resolution via getaddrinfo.

ResolvedAddrs::first_ipv4(&this, port: u16) -> Option<SocketAddr>

The first IPv4 address in the result, paired with port, or None if the name resolved only to AAAA records. Callers that can dial a v6 address should walk get instead; this exists for the layers that cannot yet.

ResolvedAddrs::length(&this) -> u64

Number of resolved addresses (>= 1 on a successful resolve).

function resolve(host: Str) -> Result<ResolvedAddrs, IoError>

Resolve host to every A / AAAA record the resolver returns, in the order it returns them (already preference-sorted by glibc's RFC 3484 rules). host may be a name or a numeric literal - a numeric address resolves to itself. Fails with NotFound for an unknown name, WouldBlock for a temporary resolver failure.

ResolvedAddrs::get(&this, index: u64) -> Option<IpAddr>

The i-th resolved address, or None if out of range.

static Resolve::start(host: Str) -> Resolve

Begin resolving host. Nothing is submitted until the first poll, so a Resolve that is never awaited costs nothing.

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 Future {
    type Output;
    poll(mut &this, cx: Context*) -> Poll<This::Output>;
}

An asynchronous computation. poll drives it one step: Ready(v) when the value is available, Pending when it is not yet (the future has arranged, via cx's waker, to be polled again later).

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

Result: a value that may be an error.

type struct ResolvedAddrs {
    addrs: Array<IpAddr>;
}

The addresses a hostname resolved to. Owns the backing Array; call drop when done.

function resolve_one(host: Str) -> Result<IpAddr, IoError>

Resolve host to a single address - the first (most-preferred) record. The common case for "connect to this name".

function lookup(host: Str, port: u16) -> Result<Array<SocketAddr>, IoError>

Resolve host and pair every address with port, ready to hand to TcpConnect::start / UdpSocket::connect. The returned Array must be dropped by the caller.

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.

function resolve(host: Str) -> Result<ResolvedAddrs, IoError>

Resolve host to every A / AAAA record the resolver returns, in the order it returns them (already preference-sorted by glibc's RFC 3484 rules). host may be a name or a numeric literal - a numeric address resolves to itself. Fails with NotFound for an unknown name, WouldBlock for a temporary resolver failure.

function resolve_one(host: Str) -> Result<IpAddr, IoError>

Resolve host to a single address - the first (most-preferred) record. The common case for "connect to this name".

function lookup(host: Str, port: u16) -> Result<Array<SocketAddr>, IoError>

Resolve host and pair every address with port, ready to hand to TcpConnect::start / UdpSocket::connect. The returned Array must be dropped by the caller.

type struct TcpConnect {
    fd: i32;
    addr: [u8;
    28];
    addrlen: u32;
    err: IoError;
    rt: Reactor*;
}

Connect to a remote address without blocking. The socket is opened and the handshake started when the future is created; each poll asks the OS whether it finished, parking on writability in between. The socket is closed if the future is dropped before it completes.

static TcpConnect::start(remote: SocketAddr) -> TcpConnect

Open a non-blocking socket and start connecting to remote.

UdpSocket::connect(mut &this, remote: SocketAddr) -> Result<(), IoError>

Pin a default peer. After this, UdpSend/UdpRecv talk to remote and the kernel filters incoming datagrams to that source. Does not exchange packets - UDP connect is local bookkeeping only, so it cannot block and stays a plain call.