Standard library signatures

Every public declaration of each std module, one line each, so you can check that an operation exists and what it returns before reading its module page. The page states the contracts: ownership, allocation, error variants, and limits. pub is omitted. Fields, methods, and variants are indented under their owner. Summaries come from the module table.

After changing a standard module, regenerate this page with UPDATE_STDLIB_INDEX=1 cargo test --locked --test integration test_stdlib_index::.

Modules

Each section’s lines in this file, so one module can be read alone.

• std.actor: 110-187
• std.actor.net: 189-252
• std.actor.tls: 254-283
• std.actor.http.server: 285-348
• std.archive: 350-416
• std.atomic: 418-427
• std.bytes: 429-476
• std.cache.lru: 478-500
• std.channel: 502-506
• std.cli: 508-538
• std.cli.fileinput: 540-549
• std.cli.progress: 551-575
• std.collections: 577-604
• std.complex: 606-632
• std.compress: 634-664
• std.concurrent: 666-670
• std.crypto: 672-753
• std.csv: 755-818
• std.dataframe: 820-1019
• std.db.kv: 1021-1053
• std.db.sqlite: 1055-1119
• std.deque: 1121-1135
• std.diff: 1137-1166
• std.encoding: 1168-1235
• std.env: 1237-1251
• std.error: 1253-1273
• std.fmt: 1275-1342
• std.fs: 1344-1443
• std.fs.dirs: 1445-1455
• std.fs.lock: 1457-1471
• std.fs.watch: 1473-1508
• std.graph: 1510-1598
• std.http: 1600-1670
• std.http.decoder: 1672-1689
• std.http.body: 1691-1726
• std.http.client: 1728-1838
• std.http.cookie: 1840-1872
• std.http.files: 1874-1887
• std.http.https: 1889-1903
• std.http.proxy: 1905-1926
• std.http.server: 1928-2013
• std.http.sse: 2015-2034
• std.http.tls: 2036-2053
• std.http.typed: 2055-2088
• std.http.websocket: 2090-2125
• std.http.wss: 2127-2133
• std.image: 2135-2181
• std.io: 2183-2289
• std.io.typed: 2291-2329
• std.json: 2331-2395
• std.jwt: 2397-2444
• std.log: 2446-2513
• std.markdown: 2515-2549
• std.template: 2551-2575
• std.math: 2577-2648
• std.mime: 2650-2676
• std.net: 2678-2760
• std.path: 2762-2779
• std.process: 2781-2830
• std.random: 2832-2853
• std.ready: 2855-2886
• std.regex: 2888-2941
• std.report: 2943-2950
• std.secrets: 2952-2978
• std.shlex: 2980-2989
• std.sketch: 2991-3029
• std.sketch.xor: 3031-3042
• std.sketch.cuckoo: 3044-3059
• std.signal: 3061-3078
• std.simd: 3080-3181
• std.stat: 3183-3216
• std.plot: 3218-3307
• std.linalg: 3309-3350
• std.sync: 3352-3370
• std.system: 3372-3430
• std.tempfile: 3432-3464
• std.test: 3466-3508
• std.text: 3510-3553
• std.thread: 3555-3559
• std.time: 3561-3605
• std.tls: 3607-3689
• std.toml: 3691-3740
• std.unicode: 3742-3754
• std.units: 3756-3993
• std.units.catalogue: 3995-4773
• std.url: 4775-4803
• std.uuid: 4805-4828
• std.xml: 4830-4863

std.actor

Supervised actors on one thread, each with its own heap, bounded mailbox and copied messages; a trap discards only that actor’s heap and files; timers, request-reply and restart. Errors: StartError, Undelivered[M], TimerError, RequestError[M]. Reference.

const max_heap_limit: i64 = 67108864
const max_spawns: i64 = 16
const max_capacity: i64 = 1048576
class Address
    def key(self) -> u64
class Watch
    def key(self) -> u64
class Timer
    def key(self) -> u64
    def tag(self) -> i64
class Request
    def key(self) -> u64
enum Reply[M]
    Answer(M) | TimedOut | Gone
enum TimerError
    Capacity | Range
enum RequestError[M]
    Full(M) | Gone(M) | Capacity(M)
enum Exit[E]
    # Stopped by `Context.stop`, a `Stop` request, or a spawn hook that | Failed(E) | Trapped(TrapKind)
enum TrapKind
    Memory | Index | Arithmetic | Unwrap | Other
enum Mail[M, E]
    Message(M) | Ready(Watch, Readiness) | Down(Address, i64, Exit[E]) | Stop | Timer(Timer) | Request(Request, M) | Reply(Request, Reply[M])
enum Undelivered[M]
    Full(M) | Gone(M)
enum StageError
    Allocation(AllocError) | Wait(WaitError)
enum StartError
    Unsupported | Capacity | Heaps | Mailbox
class Stats
    started: i64
    stopped: i64
    failed: i64
    trapped: i64
    restarted: i64
    delivered: i64
    full: i64
    gone: i64
    lost: i64
def supported() -> bool
def heaps_live() -> i64
def heap_bytes_used() -> i64
def heap_bytes_committed() -> i64
class Context[M, E]
    def address(self) -> Address
    def stop(self: &mut Context[M, E]) -> ()
    def heap_used(self) -> i64
    def send(self: &mut Context[M, E], to: Address, message: M) -> Result[(), Undelivered[M]]
    def stop_actor(self: &mut Context[M, E], to: Address) -> bool
    def spawn(self: &mut Context[M, E], tag: i64, limit: Positive[i64]) -> Result[Address, StartError]
    def spawn_isolated(self: &mut Context[M, E], tag: i64, limit: Positive[i64]) -> Result[Address, StartError]
    def restart(self: &mut Context[M, E], child: Address, limit: i64, window: &Duration) -> bool
    def after(self: &mut Context[M, E], delay: &Duration, tag: i64) -> Result[Timer, TimerError]
    def every(self: &mut Context[M, E], period: &Duration, tag: i64) -> Result[Timer, TimerError]
    def cancel(self: &mut Context[M, E], timer: Timer) -> bool
    def request(self: &mut Context[M, E], to: Address, message: M, timeout: &Duration) -> Result[Request, RequestError[M]]
    def reply(self: &mut Context[M, E], request: Request, message: M) -> Result[(), Undelivered[M]]
    def watch[H: Watchable](self: &mut Context[M, E], handle: &H, interest: Interest) -> Result[Watch, WaitError]
    def unwatch[H: Watchable](self: &mut Context[M, E], handle: &H) -> Result[(), WaitError]
class Stage[N, M, E]
    def shutdown(self: &mut Stage[N, M, E]) -> ()
    def start(self: &mut Stage[N, M, E], node: N, limit: Positive[i64]) -> Result[Address, StartError]
    def send(self: &mut Stage[N, M, E], to: Address, message: M) -> Result[(), Undelivered[M]]
    def stop_actor(self: &mut Stage[N, M, E], to: Address) -> bool
    def add_timers(self: &mut Stage[N, M, E], count: i64) -> Result[(), AllocError]
    def live(self) -> i64
    def stats(self) -> Stats
    def node(self, actor: Address) -> Option[&N]
    def heap_used(self, actor: Address) -> Option[i64]
    def run(self: &mut Stage[N, M, E], deadline: &Deadline, cancel: &CancellationToken) -> Result[(), WaitError]
def stage[N, M, E](capacity: i64, mailbox: i64, events: i64) -> Result[Stage[N, M, E], StageError]

std.actor.net

TCP for actors: a listener that starts one actor per connection with admission limits, connections with bounded buffers, back-pressure and deadlines, and nonblocking connect and lookup. Errors: NetError, TimerError, BytesError. Reference.

class Limits
    input: Positive[i64]
    output: Positive[i64]
    idle: Duration
    stall: Duration
enum Expired
    Idle | Read | Write
class Events
    mine: bool
    received: i64
    ended: bool
    writable: bool
    drained: bool
    expired: Option[Expired]
class Connection
    def start[M, E](self: &mut Connection, context: &mut Context[M, E]) -> Result[(), NetError | TimerError]
    def handle[M, E](self: &mut Connection, mail: &Mail[M, E], context: &mut Context[M, E]) -> Result[Events, NetError | TimerError]
    def input(self) -> &Bytes
    def input_start(self) -> i64
    def input_stop(self) -> i64
    def available(self) -> i64
    def consume[M, E](self: &mut Connection, count: i64, context: &mut Context[M, E]) -> Result[(), NetError | TimerError]
    def pending(self) -> i64
    def space(self) -> i64
    def write[M, E](self: &mut Connection, source: &[u8], context: &mut Context[M, E]) -> Result[i64, NetError | TimerError]
    def reserve(self: &mut Connection, wanted: NonNegative[i64]) -> Result[i64, NetError]
    def output(self: &mut Connection) -> &mut Bytes
    def output_stop(self) -> i64
    def commit[M, E](self: &mut Connection, count: i64, context: &mut Context[M, E]) -> Result[(), NetError | TimerError]
    def forward[M, E](self: &mut Connection, count: i64, context: &mut Context[M, E]) -> Result[i64, NetError | TimerError]
    def read_within[M, E](self: &mut Connection, span: &Duration, context: &mut Context[M, E]) -> Result[(), NetError | TimerError]
    def clear_read_deadline(self: &mut Connection) -> ()
    def shutdown_write[M, E](self: &mut Connection, context: &mut Context[M, E]) -> Result[(), NetError | TimerError]
    def close[M, E](self: &mut Connection, context: &mut Context[M, E]) -> Result[(), NetError]
    def acknowledge_now(self: &mut Connection) -> ()
    def reading(self) -> bool
    def closed(self) -> bool
    def stream(self) -> &TcpStream
def connection(stream: TcpStream, limits: &Limits) -> Result[Connection, AllocError]
enum Admission
    Pause | Refuse
class Listener
    def start[M, E](self: &mut Listener, context: &mut Context[M, E]) -> Result[(), NetError]
    def handle[M, E](self: &mut Listener, mail: &Mail[M, E], context: &mut Context[M, E]) -> Result[bool, NetError]
    def accept(self) -> Result[Option[Connection], NetError | AllocError]
    def live(self) -> i64
    def refused(self) -> i64
    def tag(self) -> i64
    def local_address(self) -> Result[SocketAddress, NetError]
def listener(socket: TcpListener, limits: Limits, capacity: Positive[i64], heap: Positive[i64], tag: i64, admission: Admission) -> Result[Listener, NetError]
class Dialing
    def handle[M, E](self: &mut Dialing, mail: &Mail[M, E], context: &mut Context[M, E]) -> Result[Option[TcpStream], NetError]
    def abandon[M, E](self: &mut Dialing, context: &mut Context[M, E]) -> Result[(), NetError]
def dial[M, E](address: &SocketAddress, timeout: &Duration, context: &mut Context[M, E]) -> Result[Dialing, NetError | TimerError]
class Resolving
    def handle[M, E](self: &mut Resolving, mail: &Mail[M, E], context: &mut Context[M, E]) -> Result[Option[list[SocketAddress]], NetError]
    def abandon[M, E](self: &mut Resolving, context: &mut Context[M, E]) -> Result[(), NetError]
def lookup[M, E](host: &str, port: u16, timeout: &Duration, context: &mut Context[M, E]) -> Result[Resolving, NetError | TimerError]

std.actor.tls

TLS for actor connections: a std.tls session over a std.actor.net connection, with plaintext back-pressure and the session in the connection actor’s heap. Errors: TlsError, TimerError. Reference.

class TlsConnection
    def start[M, E](self: &mut TlsConnection, context: &mut Context[M, E]) -> Result[(), TlsError | TimerError]
    def handle[M, E](self: &mut TlsConnection, mail: &Mail[M, E], context: &mut Context[M, E]) -> Result[Events, TlsError | TimerError]
    def input(self) -> &Bytes
    def input_start(self) -> i64
    def input_stop(self) -> i64
    def available(self) -> i64
    def consume[M, E](self: &mut TlsConnection, count: i64, context: &mut Context[M, E]) -> Result[(), TlsError | TimerError]
    def pending(self) -> i64
    def space(self) -> i64
    def write[M, E](self: &mut TlsConnection, source: &[u8], context: &mut Context[M, E]) -> Result[i64, TlsError | TimerError]
    def forward[M, E](self: &mut TlsConnection, count: i64, context: &mut Context[M, E]) -> Result[i64, TlsError | TimerError]
    def read_within[M, E](self: &mut TlsConnection, span: &Duration, context: &mut Context[M, E]) -> Result[(), TlsError | TimerError]
    def clear_read_deadline(self: &mut TlsConnection) -> ()
    def shutdown_write[M, E](self: &mut TlsConnection, context: &mut Context[M, E]) -> Result[(), TlsError | TimerError]
    def close[M, E](self: &mut TlsConnection, context: &mut Context[M, E]) -> Result[(), TlsError]
    def established(self) -> bool
    def reading(self) -> bool
    def closed(self) -> bool
    def session(self) -> &Session
    def connection(self) -> &Connection
def over(net: Connection, session: Session, input: Positive[i64]) -> Result[TlsConnection, TlsError]
def server(net: Connection, config: &ServerConfig, input: Positive[i64]) -> Result[TlsConnection, TlsError]
def client(net: Connection, config: &ClientConfig, server_name: &str, input: Positive[i64]) -> Result[TlsConnection, TlsError]

std.actor.http.server

HTTP/1.1 and HTTPS on isolated connection actors, bounded request/response handlers or resumable streaming events, deadlines and draining. Errors: ServerError. Reference.

enum ServerError
    InvalidConfig | AdmissionStopped | Allocation(AllocError) | Bytes(BytesError) | Http(HttpError) | Net(NetError) | Tls(TlsError) | Timer(TimerError) | Wait(WaitError) | Actor(std.actor.StartError) | Range(RangeError) | Handler
enum Notice[M]
    Message(M) | Drain | Resume | Completed | CompletedBy(Address) | Rejected
enum Event[M]
    Head(RequestHead, RequestTarget) | Body(Bytes) | Trailers(list[std.http.Header]) | End | Writable | Actor(Mail[Notice[M], ServerError]) | Message(M) | Stopping
class Config
    capacity: i64
    heap_limit: i64
    input_buffer: i64
    output_buffer: i64
    pending_output: i64
    limits: Limits
    idle_timeout: Duration
    head_timeout: Duration
    body_timeout: Duration
    write_timeout: Duration
    response_timeout: Duration
    handshake_timeout: Duration
    drain_timeout: Duration
    max_requests: Positive[i64]
class Report
    actors: Stats
    requests: u64
    rejected: u64
    protocol_errors: u64
protocol Handler[M, E]
    def receive(self: &mut Handler[M, E], event: Event[M], response: &mut Response, context: &mut Context[Notice[M], ServerError]) -> Result[(), E]
class Response
    def is_stopping(self) -> bool
    def close_after(self: &mut Response) -> ()
    def shutdown_server(self: &mut Response) -> ()
    def is_started(self) -> bool
    def is_done(self) -> bool
    def pending(self) -> i64
    def space(self) -> i64
    def start(self: &mut Response, head: ResponseHead) -> Result[(), ServerError]
    def write(self: &mut Response, source: &[u8]) -> Result[i64, ServerError]
    def finish(self: &mut Response) -> Result[(), ServerError]
    def respond(self: &mut Response, head: ResponseHead, body: &[u8]) -> Result[(), ServerError]
    def send(self: &mut Response, status: i64, content_type: &str, body: &[u8]) -> Result[(), ServerError]
    def send_text(self: &mut Response, status: i64, text: &str) -> Result[(), ServerError]
def config() -> Config
class Node[F, H]
    def started[M](self: &mut Node[F, H], context: &mut Context[Notice[M], ServerError]) -> Result[(), ServerError]
    def receive[M](self: &mut Node[F, H], mail: Mail[Notice[M], ServerError], context: &mut Context[Notice[M], ServerError]) -> Result[(), ServerError]
    def spawn[M](self, tag: i64, child: Address, context: &mut Context[Notice[M], ServerError]) -> Result[Option[Node[F, H]], ServerError]
class Request
    head: RequestHead
    target: RequestTarget
    body: Bytes
    trailers: list[std.http.Header]
protocol RequestHandler[E]
    def handle(self: &mut RequestHandler[E], request: Request, response: &mut Response) -> Result[(), E]
def serve[F: Callable[[], Result[H, FE]], H: RequestHandler[HE], FE, HE](listener: TcpListener, factory: F, config: &Config, stop: &CancellationToken) -> Result[Report, ServerError]
def serve_tls[F: Callable[[], Result[H, FE]], H: RequestHandler[HE], FE, HE](listener: TcpListener, tls: ServerConfig, factory: F, config: &Config, stop: &CancellationToken) -> Result[Report, ServerError]
def serve_events[F: Callable[[], Result[H, FE]], H: Handler[M, HE], M, FE, HE](listener: TcpListener, factory: F, config: &Config, stop: &CancellationToken) -> Result[Report, ServerError]
def serve_tls_events[F: Callable[[], Result[H, FE]], H: Handler[M, HE], M, FE, HE](listener: TcpListener, tls: ServerConfig, factory: F, config: &Config, stop: &CancellationToken) -> Result[Report, ServerError]

std.archive

TAR and ZIP readers and writers over std.io, and extraction into a new directory under explicit path, link, and size limits. Errors: ArchiveError. Reference.

enum ArchiveError
    Stream(StreamError) | Io(IoError) | Fs(FsError) | Allocation(AllocError) | Corrupt | Checksum | Truncated | Unsupported | UnsafePath | Link | Special | Duplicate | Exists | Limit | Cancelled | InvalidInput
enum EntryKind
    File | Directory | Symlink | Hardlink | Other
class Entry
    name: Path
    kind: EntryKind
    size: i64
    compressed: i64
    mode: i64
    mtime: i64
    link: Path
class Policy
    max_entries: i64
    max_entry_size: i64
    max_total_size: i64
    max_ratio: i64
    max_depth: i64
    max_name: i64
    skip_links: bool
    skip_special: bool
def policy() -> Policy
class Summary
    entries: i64
    files: i64
    bytes: i64
    skipped: i64
def stream_error(error: ArchiveError) -> StreamError
class TarReader[R]
    inner: R
    def failure(self) -> Option[ArchiveError]
    def next(self: &mut TarReader[R]) -> Result[Option[Entry], ArchiveError]
    def read(self: &mut TarReader[R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
def tar_reader[R](inner: R) -> Result[TarReader[R], ArchiveError]
class TarWriter[W]
    inner: W
    def add_file(self: &mut TarWriter[W], name: &Path, data: &[u8], mode: i64, mtime: i64) -> Result[(), ArchiveError]
    def add_from[S](self: &mut TarWriter[W], name: &Path, size: i64, source: &mut S, mode: i64, mtime: i64) -> Result[(), ArchiveError]
    def add_dir(self: &mut TarWriter[W], name: &Path, mode: i64, mtime: i64) -> Result[(), ArchiveError]
    def add_symlink(self: &mut TarWriter[W], name: &Path, target: &Path, mtime: i64) -> Result[(), ArchiveError]
    def finish(self: &mut TarWriter[W]) -> Result[(), ArchiveError]
def tar_writer[W](inner: W) -> Result[TarWriter[W], ArchiveError]
class ZipReader[R]
    inner: R
    def len(self) -> i64
    def entries(self) -> &list[Entry]
    def failure(self) -> Option[ArchiveError]
    def open(self: &mut ZipReader[R], index: i64) -> Result[(), ArchiveError]
    def read(self: &mut ZipReader[R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
def zip_reader[R](inner: R, max_entries: NonNegative[i64]) -> Result[ZipReader[R], ArchiveError]
enum Method
    Stored | Deflate
class ZipWriter[W]
    inner: W
    def add_file(self: &mut ZipWriter[W], name: &Path, data: &[u8], method: Method, mode: i64, mtime: i64) -> Result[(), ArchiveError]
    def add_dir(self: &mut ZipWriter[W], name: &Path, mode: i64, mtime: i64) -> Result[(), ArchiveError]
    def add_symlink(self: &mut ZipWriter[W], name: &Path, target: &Path, mtime: i64) -> Result[(), ArchiveError]
    def finish(self: &mut ZipWriter[W]) -> Result[(), ArchiveError]
def zip_writer[W](inner: W) -> Result[ZipWriter[W], ArchiveError]
def extract_tar[R](archive: &mut TarReader[R], parent: &Root, destination: &Path, policy: &Policy, cancel: &CancellationToken) -> Result[Summary, ArchiveError]
def extract_zip[R](archive: &mut ZipReader[R], parent: &Root, destination: &Path, policy: &Policy, cancel: &CancellationToken) -> Result[Summary, ArchiveError]

std.atomic

Inline atomic integers and booleans with compile-time checked orderings, and fences. Reference.

Compiler-provided: Atomic, fence. Their signatures are on the reference page.

enum Ordering
    Relaxed | Release | Acquire | AcqRel | SeqCst

std.bytes

Compact owning byte buffers with checked ranges, explicit copies and validated text conversion. Errors: BytesError. Reference.

enum BytesError
    InvalidUtf8 | Allocation(AllocError)
class Bytes
    def len(self) -> i64
    def is_empty(self) -> bool
    def write_float(self: &mut Bytes, value: f64) -> i64
    def write_float_spec(self: &mut Bytes, value: f64, style: i64, precision: i64, offset: i64) -> i64
    def capacity(self) -> i64
    def get(self, index: i64) -> u8
    def set(self: &mut Bytes, index: i64, value: u8) -> ()
    def push(self: &mut Bytes, value: u8) -> Result[(), AllocError]
    def pop(self: &mut Bytes) -> Option[u8]
    def reserve(self: &mut Bytes, additional: i64) -> Result[(), AllocError]
    def resize(self: &mut Bytes, count: i64, fill: u8) -> Result[(), AllocError]
    def truncate(self: &mut Bytes, count: i64) -> ()
    def clear(self: &mut Bytes) -> ()
    def fill(self: &mut Bytes, start: i64, stop: i64, value: u8) -> ()
    def extend(self: &mut Bytes, source: &[u8]) -> Result[(), AllocError]
    def overwrite(self: &mut Bytes, offset: i64, source: &[u8]) -> ()
    def copy_within(self: &mut Bytes, start: i64, stop: i64, to: i64) -> ()
    def slice(self, start: i64, stop: i64) -> Result[Bytes, AllocError]
    def copy(self) -> Result[Bytes, AllocError]
    def find(self, value: u8, start: i64, stop: i64) -> Option[i64]
    def find_in(self, set: &[u8], start: i64, stop: i64) -> Option[i64]
    def find_not_in(self, set: &[u8], start: i64, stop: i64) -> Option[i64]
    def find_bytes(self, needle: &[u8], start: i64, stop: i64) -> Option[i64]
    def count(self, value: u8, start: i64, stop: i64) -> i64
    def matches(self, offset: i64, source: &[u8]) -> bool
    def matches_text(self, offset: i64, text: &str) -> bool
    def ascii_run(self, start: i64, stop: i64) -> i64
    def utf8_run(self, start: i64, stop: i64) -> i64
    def to_list(self) -> Result[list[u8], AllocError]
    def to_text(self) -> Result[str, BytesError]
    def to_text_range(self, start: i64, stop: i64) -> Result[str, BytesError]
    def read_file(self: &mut Bytes, file: &mut File, start: i64, stop: i64) -> Result[i64, IoError]
    def read_stdin(self: &mut Bytes, start: i64, stop: i64) -> Result[i64, IoError]
def empty() -> Result[Bytes, AllocError]
def with_capacity(capacity: i64) -> Result[Bytes, AllocError]
def from_list(values: &list[u8]) -> Result[Bytes, AllocError]
def from_text(text: &str) -> Result[Bytes, AllocError]
def from_bytes(source: &[u8]) -> Result[Bytes, AllocError]
def write_file(file: &mut File, source: &[u8]) -> Result[i64, IoError]

std.cache.lru

Fixed-capacity caches that evict the least recently used entry, with constant-time lookup, promotion and eviction. Errors: AllocError. Reference.

class LruCache[K, V]
    def __init__(self, capacity: i64) -> Result[(), AllocError]
    def capacity(self) -> i64
    def len(self) -> i64
    def is_empty(self) -> bool
    def contains(self, key: &K) -> bool
    def get(self: &mut LruCache[K, V], key: &K) -> Option[V]
    def peek(self, key: &K) -> Option[V]
    def get_ref(self: &mut LruCache[K, V], key: &K) -> Option[&V]
    def get_mut(self: &mut LruCache[K, V], key: &K) -> Option[&mut V]
    def peek_ref(self, key: &K) -> Option[&V]
    def peek_mut(self: &mut LruCache[K, V], key: &K) -> Option[&mut V]
    def promote(self: &mut LruCache[K, V], key: &K) -> bool
    def put(self: &mut LruCache[K, V], key: K, value: V) -> Result[Option[(K, V)], AllocError]
    def remove(self: &mut LruCache[K, V], key: &K) -> Option[V]
    def pop_lru(self: &mut LruCache[K, V]) -> Option[(K, V)]
    def clear(self: &mut LruCache[K, V]) -> ()

std.channel

Bounded channels, endpoints and selection. Errors: Channel/send/receive/selection errors. Reference.

Compiler-provided: channel, Sender, Receiver, SendError, RecvError, SendTimeoutError, RecvTimeoutError, Selected, SelectError, select_recv, select_recv_nowait, select_recv_timeout, select_recv_timeout_ms. Their signatures are on the reference page.

std.cli

Explicit typed options/positionals, repeatable values, generated help and lossless path arguments. Errors: CliError. Reference.

enum Kind
    Flag | Integer | Text | Path
class Spec
    name: str
    kind: Kind
    positional: bool
    required: bool
    repeatable: bool
    help: str
enum Value
    Flag | Integer(i64) | Text(str) | Path(Path)
class Entry
    spec: i64
    value: Value
class Parsed
    help_requested: bool
    entries: list[Entry]
enum CliError
    Schema(i64) | UnknownOption(i64) | UnexpectedArgument(i64) | MissingValue(i64) | Duplicate(i64) | Missing(i64) | InvalidInteger(i64) | InvalidUtf8(i64) | Allocation(AllocError)
def validate(schema: &list[Spec]) -> Result[(), CliError]
def parse(schema: &list[Spec], arguments: &list[list[u8]], start: i64) -> Result[Parsed, CliError]
def help(schema: &list[Spec], program: &str) -> Result[str, CliError]
def exit_status(error: &CliError) -> i32
def describe(error: &CliError) -> Result[str, AllocError]
def describe_for(error: &CliError, schema: &list[Spec]) -> Result[str, AllocError]

std.cli.fileinput

Buffered fallible UTF-8 lines across native paths or command-line files, with stdin fallback. Errors: FileInputError. Reference.

enum FileInputError
    Open(Option[Path], StreamError) | Read(Option[Path], StreamError) | Text(Option[Path], BytesError) | Close(Option[Path], StreamError)
def files(paths: list[Path]) -> Generator[Result[str, FileInputError]]
def lines() -> Result[Generator[Result[str, FileInputError]], IoError]

std.cli.progress

Terminal-only stderr bars and spinners with counts, rates, ETA and throttled redraws. Errors: ProgressError. Reference.

enum ProgressError
    InvalidPosition | Finished | Output(FormatError)
class Progress
    def position(self) -> u64
    def total(self) -> Option[u64]
    def is_finished(self) -> bool
    def rate(self, now: &Instant) -> Option[f64]
    def eta(self, now: &Instant) -> Option[f64]
    def render[W](self, now: &Instant, output: &mut Formatter[W]) -> Result[(), FormatError]
    def set_position_at(self: &mut Progress, position: u64, now: &Instant) -> Result[(), ProgressError]
    def set_position(self: &mut Progress, position: u64) -> Result[(), ProgressError]
    def advance(self: &mut Progress, count: u64 = 1u64) -> Result[(), ProgressError]
    def tick(self: &mut Progress) -> Result[(), ProgressError]
    def finish_at(self: &mut Progress, now: &Instant) -> Result[(), ProgressError]
    def finish(self: &mut Progress) -> Result[(), ProgressError]
def bar_at(total: u64, now: &Instant) -> Progress
def bar(total: u64) -> Progress
def spinner_at(now: &Instant) -> Progress
def spinner() -> Progress

std.collections

Owned binary heaps ordered by < or by a stored comparator. Errors: AllocError. Reference.

class Heap[T]
    def __init__(self) -> Result[(), AllocError]
    def len(self) -> i64
    def is_empty(self) -> bool
    def reserve(self: &mut Heap[T], additional: i64) -> Result[(), AllocError]
    def peek(self) -> Option[T]
    def peek_ref(self) -> Option[&T]
    def push(self: &mut Heap[T], value: T) -> Result[(), AllocError]
    def pop(self: &mut Heap[T]) -> Option[T]
    def clear(self: &mut Heap[T]) -> ()
class HeapBy[T, F: Callable[[&T, &T], bool]]
    def __init__(self, before: F) -> Result[(), AllocError]
    def len(self) -> i64
    def is_empty(self) -> bool
    def reserve(self: &mut HeapBy[T, F], additional: i64) -> Result[(), AllocError]
    def peek(self) -> Option[T]
    def peek_ref(self) -> Option[&T]
    def push(self: &mut HeapBy[T, F], value: T) -> Result[(), AllocError]
    def pop(self: &mut HeapBy[T, F]) -> Option[T]
    def clear(self: &mut HeapBy[T, F]) -> ()
def drain[T](heap: Heap[T]) -> Generator[T]
def drain_by[T, F: Callable[[&T, &T], bool]](heap: HeapBy[T, F]) -> Generator[T]

std.complex

Complex numbers over f64 with arithmetic operators, polar form, exp, log, sqrt, pow, and a+bi display. Reference.

class Complex
    re: f64
    im: f64
    def __add__(self, other: &Complex) -> Complex
    def __sub__(self, other: &Complex) -> Complex
    def __mul__(self, other: &Complex) -> Complex
    def __truediv__(self, other: &Complex) -> Complex
    def __neg__(self) -> Complex
    def scale(self, factor: f64) -> Complex
    def conj(self) -> Complex
    def norm(self) -> f64
    def abs(self) -> f64
    def arg(self) -> f64
    def to_polar(self) -> (f64, f64)
    def exp(self) -> Complex
    def log(self) -> Complex
    def sqrt(self) -> Complex
    def pow(self, exponent: &Complex) -> Complex
    def powi(self, n: i64) -> Complex
    def display[W](self, out: &mut Formatter[W]) -> Result[(), FormatError]
def from_polar(r: f64, theta: f64) -> Complex

std.compress

Bounded gzip, zlib, DEFLATE and Brotli compression of buffers and std.io streams, and CRC-32. Errors: CompressError. Reference.

enum Format
    Deflate | Zlib | Gzip | Brotli
enum CompressError
    OutOfRange | Corrupt | Checksum | Truncated | TrailingData | LimitExceeded | Allocation(AllocError)
def stream_error(error: CompressError) -> StreamError
class Inflater
    def step(self: &mut Inflater, input: &[u8]) -> Result[i64, CompressError]
    def complete(self) -> bool
    def output(self) -> &Bytes
    def clear(self: &mut Inflater) -> ()
def inflater(format: Format, limit: NonNegative[i64]) -> Result[Inflater, CompressError]
def compress(format: Format, data: &[u8], level: i64) -> Result[Bytes, CompressError]
def decompress(format: Format, data: &[u8], limit: NonNegative[i64]) -> Result[Bytes, CompressError]
def crc32(seed: i64, data: &[u8]) -> Result[i64, CompressError]
class Compressor[W]
    inner: W
    def write(self: &mut Compressor[W], source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut Compressor[W]) -> Result[(), StreamError]
    def finish(self: &mut Compressor[W]) -> Result[(), StreamError]
def compressor[W](format: Format, inner: W, level: i64) -> Result[Compressor[W], CompressError]
class Decompressor[R]
    inner: R
    def failure(self) -> Option[CompressError]
    def read(self: &mut Decompressor[R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
def decompressor[R](format: Format, inner: R, limit: NonNegative[i64]) -> Result[Decompressor[R], CompressError]

std.concurrent

Executors, futures and parallel operations. Errors: Pool/submission/future/parallel errors. Reference.

Compiler-provided: ThreadPoolExecutor, Future, PoolError, SubmitError, FutureError, PoolMapError, ParallelError. Their signatures are on the reference page.

std.crypto

Digests, HMAC, BLAKE3 hashing/key derivation, constant-time comparison, AEAD encryption, Ed25519, X25519, and HKDF over std.bytes. Errors: CryptoError, AdvancedError. Reference.

enum CryptoError
    Finished | InvalidKeyLength | UnsupportedAlgorithm | Allocation(AllocError)
enum Algorithm
    Sha256 | Sha512 | Sha1 | Blake3
def output_size(algorithm: Algorithm) -> i64
class Digest
    def size(self) -> i64
    def update(self: &mut Digest, data: &[u8]) -> Result[(), CryptoError]
    def update_text(self: &mut Digest, text: &str) -> Result[(), CryptoError]
    def finish(self: &mut Digest) -> Result[Bytes, CryptoError]
    def finish_into(self: &mut Digest, target: &mut Bytes, offset: i64) -> Result[(), CryptoError]
class Mac
    def size(self) -> i64
    def update(self: &mut Mac, data: &[u8]) -> Result[(), CryptoError]
    def update_text(self: &mut Mac, text: &str) -> Result[(), CryptoError]
    def finish(self: &mut Mac) -> Result[Bytes, CryptoError]
    def finish_into(self: &mut Mac, target: &mut Bytes, offset: i64) -> Result[(), CryptoError]
    def verify(self: &mut Mac, expected: &[u8]) -> Result[bool, CryptoError]
def digest(algorithm: Algorithm) -> Result[Digest, CryptoError]
def hmac(algorithm: Algorithm, key: &[u8]) -> Result[Mac, CryptoError]
def sha256(data: &[u8]) -> Result[Bytes, CryptoError]
def sha512(data: &[u8]) -> Result[Bytes, CryptoError]
def blake3(data: &[u8]) -> Result[Bytes, CryptoError]
def blake3_keyed_hasher(key: &[u8]) -> Result[Mac, CryptoError]
def blake3_keyed(key: &[u8], data: &[u8]) -> Result[Bytes, CryptoError]
def blake3_derive_hasher(context: &str) -> Result[Digest, CryptoError]
def blake3_derive_key(context: &str, key_material: &[u8]) -> Result[Bytes, CryptoError]
def sha1(data: &[u8]) -> Result[Bytes, CryptoError]
def hmac_sha256(key: &[u8], data: &[u8]) -> Result[Bytes, CryptoError]
def hmac_sha512(key: &[u8], data: &[u8]) -> Result[Bytes, CryptoError]
def equal(a: &[u8], b: &[u8]) -> bool
enum AdvancedError
    InvalidLength | AuthenticationFailed | InvalidPeer | Finished | RandomFailure | InvalidKey | WeakKey | SmallOrderKey | Allocation(AllocError)
    def format[W](self, output: &mut Formatter[W]) -> Result[(), FormatError]
enum AeadAlgorithm
    Aes256Gcm | ChaCha20Poly1305
def seal_in_place(algorithm: AeadAlgorithm, key: &[u8], nonce: &[u8], aad: &[u8], data: &mut Bytes) -> Result[(), AdvancedError]
def open_in_place(algorithm: AeadAlgorithm, key: &[u8], nonce: &[u8], aad: &[u8], data: &mut Bytes) -> Result[(), AdvancedError]
def ed25519_public_key_into(seed: &[u8], target: &mut Bytes) -> Result[(), AdvancedError]
def ed25519_public_key(seed: &[u8]) -> Result[Bytes, AdvancedError]
def ed25519_sign_into(seed: &[u8], message: &[u8], target: &mut Bytes) -> Result[(), AdvancedError]
def ed25519_sign(seed: &[u8], message: &[u8]) -> Result[Bytes, AdvancedError]
def ed25519_verify(public_key: &[u8], message: &[u8], signature: &[u8]) -> Result[bool, AdvancedError]
def hkdf_sha256_into(salt: &[u8], key_material: &[u8], info: &[u8], target: &mut Bytes) -> Result[(), AdvancedError]
def hkdf_sha256(salt: &[u8], key_material: &[u8], info: &[u8], size: NonNegative[i64]) -> Result[Bytes, AdvancedError]
class X25519Key
    def public_key_into(self, target: &mut Bytes) -> Result[(), AdvancedError]
    def public_key(self) -> Result[Bytes, AdvancedError]
    def agree_into(self: &mut X25519Key, peer_public_key: &[u8], target: &mut Bytes) -> Result[(), AdvancedError]
    def agree(self: &mut X25519Key, peer_public_key: &[u8]) -> Result[Bytes, AdvancedError]
def x25519() -> Result[X25519Key, AdvancedError]
enum RsaScheme
    Pkcs1Sha256 | Pkcs1Sha384 | Pkcs1Sha512 | PssSha256 | PssSha384 | PssSha512
class RsaPublicKey
    def signature_size(self) -> i64
    def verify(self, scheme: RsaScheme, message: &[u8], signature: &[u8]) -> Result[bool, AdvancedError]
class RsaPrivateKey
    def signature_size(self) -> i64
    def public_key(self) -> Result[RsaPublicKey, AdvancedError]
    def sign_into(self, scheme: RsaScheme, message: &[u8], target: &mut Bytes) -> Result[(), AdvancedError]
    def sign(self, scheme: RsaScheme, message: &[u8]) -> Result[Bytes, AdvancedError]
class P256PublicKey
    def verify(self, message: &[u8], signature: &[u8]) -> Result[bool, AdvancedError]
class P256PrivateKey
    def public_key(self) -> Result[P256PublicKey, AdvancedError]
    def sign_into(self, message: &[u8], target: &mut Bytes) -> Result[(), AdvancedError]
    def sign(self, message: &[u8]) -> Result[Bytes, AdvancedError]
def rsa_public_key_from_spki(der: &[u8]) -> Result[RsaPublicKey, AdvancedError]
def rsa_public_key_from_components(n: &[u8], e: &[u8]) -> Result[RsaPublicKey, AdvancedError]
def rsa_private_key_from_pkcs8(der: &[u8]) -> Result[RsaPrivateKey, AdvancedError]
def p256_public_key_from_point(point: &[u8]) -> Result[P256PublicKey, AdvancedError]
def p256_public_key_from_coordinates(x: &[u8], y: &[u8]) -> Result[P256PublicKey, AdvancedError]
def p256_public_key_from_spki(der: &[u8]) -> Result[P256PublicKey, AdvancedError]
def p256_private_key_from_pkcs8(der: &[u8]) -> Result[P256PrivateKey, AdvancedError]
def ed25519_public_key_from_spki(der: &[u8]) -> Result[Bytes, AdvancedError]
def ed25519_seed_from_pkcs8(der: &[u8]) -> Result[Bytes, AdvancedError]

std.csv

Streaming CSV readers and writers over std.io with explicit dialects, size limits, and positioned errors. Errors: CsvError. Reference.

enum Fault
    BareQuote | AfterQuote | UnterminatedQuote | FieldTooLong | RecordTooLong | TooManyFields
class Position
    record: i64
    field: i64
    line: i64
    offset: i64
enum CsvError
    Invalid(Fault, Position) | Rejected(Fault, i64, i64) | Width(i64, i64, i64) | EmptyRecord(i64) | InvalidUtf8(i64, i64) | InvalidDialect | Stopped | Stream(StreamError) | Allocation(AllocError)
enum Width
    Any | First | Exactly(i64)
enum Newline
    Lf | CrLf
enum Quoting
    Needed | Always
class Dialect
    delimiter: u8
    quote: u8
    newline: Newline
    quoting: Quoting
    width: Width
    skip_bom: bool
    max_field: i64
    max_record: i64
    max_fields: i64
def rfc4180() -> Dialect
class Record
    def len(self) -> i64
    def number(self) -> i64
    def line(self) -> i64
    def data(self) -> &Bytes
    def start(self, index: i64) -> i64
    def stop(self, index: i64) -> i64
    def bytes(self, index: i64) -> Result[Bytes, CsvError]
    def append_to(self, index: i64, out: &mut Bytes) -> Result[(), CsvError]
    def text(self, index: i64) -> Result[str, CsvError]
    def texts(self) -> Result[list[str], CsvError]
    def clear(self: &mut Record) -> ()
def record() -> Result[Record, CsvError]
class Reader[R]
    inner: R
    def records(self) -> i64
    def line(self) -> i64
    def offset(self) -> i64
    def read(self: &mut Reader[R], record: &mut Record) -> Result[bool, CsvError]
def reader[R](inner: R, dialect: &Dialect, capacity: Positive[i64]) -> Result[Reader[R], CsvError]
class Writer[W]
    inner: W
    def records(self) -> i64
    def pending(self) -> i64
    def field(self: &mut Writer[W], source: &[u8]) -> Result[(), CsvError]
    def text(self: &mut Writer[W], value: &str) -> Result[(), CsvError]
    def discard(self: &mut Writer[W]) -> ()
    def end_record(self: &mut Writer[W]) -> Result[(), CsvError]
    def record(self: &mut Writer[W], record: &Record) -> Result[(), CsvError]
    def texts(self: &mut Writer[W], fields: &list[str]) -> Result[(), CsvError]
    def flush(self: &mut Writer[W]) -> Result[(), CsvError]
def writer[W](inner: W, dialect: &Dialect) -> Result[Writer[W], CsvError]

std.dataframe

Optional Polars analytical expression plans, typed nullable columns, schema inspection, grouping, and CSV/Parquet I/O. Errors: DataFrameError. Reference.

enum TimeUnit
    Milliseconds | Microseconds | Nanoseconds
enum DType
    I8 | I16 | I32 | U8 | U16 | U32 | U64 | F32 | I64 | F64 | Bool | String | Binary | Date | Datetime(TimeUnit, Option[str]) | List | Struct | Other(str)
class Field
    name: str
    dtype: DType
class SchemaNode
    parent: i64
    name: str
    dtype: DType
class ListParts
    values: Column
    offsets: list[i64]
    valid: list[bool]
class StructParts
    fields: DataFrame
    valid: list[bool]
enum JoinKind
    Inner | Left | Full | Semi | Anti
enum AsOfStrategy
    Backward | Forward | Nearest
class SortKey
    def __init__(self, expression: Expr, descending: bool = False, nulls_last: bool = True) -> ()
enum DataFrameError
    Schema(str) | Query(str) | Io(str) | NativePanic(str) | Null(str) | Bounds(str) | Allocation(AllocError) | Message(IoError)
class Column
    def len(self) -> Result[i64, DataFrameError]
    def to_frame(self) -> Result[DataFrame, DataFrameError]
    def list_parts(self) -> Result[ListParts, DataFrameError]
    def struct_parts(self) -> Result[StructParts, DataFrameError]
class DataFrame
    def column(self, name: &str) -> Result[Column, DataFrameError]
    def schema_tree(self) -> Result[list[SchemaNode], DataFrameError]
    def height(self) -> Result[i64, DataFrameError]
    def lazy(self) -> Result[Query, DataFrameError]
    def write_parquet(self, path: &str) -> Result[(), DataFrameError]
    def write_csv(self, path: &str, has_header: bool = True, separator: &str = ",", null_value: &str = "") -> Result[(), DataFrameError]
    def get_date_days(self, name: &str, row: i64) -> Result[Option[i32], DataFrameError]
    def get_datetime_ticks(self, name: &str, row: i64, unit: TimeUnit, utc: bool = False) -> Result[Option[i64], DataFrameError]
    def values_date_days(self, name: &str) -> Result[list[i32], DataFrameError]
    def values_date_days_nullable(self, name: &str) -> Result[list[Option[i32]], DataFrameError]
    def values_datetime_ticks(self, name: &str, unit: TimeUnit, utc: bool = False) -> Result[list[i64], DataFrameError]
    def values_datetime_ticks_nullable(self, name: &str, unit: TimeUnit, utc: bool = False) -> Result[list[Option[i64]], DataFrameError]
    def get_i8(self, name: &str, row: i64) -> Result[Option[i8], DataFrameError]
    def values_i8(self, name: &str) -> Result[list[i8], DataFrameError]
    def values_i8_nullable(self, name: &str) -> Result[list[Option[i8]], DataFrameError]
    def get_i16(self, name: &str, row: i64) -> Result[Option[i16], DataFrameError]
    def values_i16(self, name: &str) -> Result[list[i16], DataFrameError]
    def values_i16_nullable(self, name: &str) -> Result[list[Option[i16]], DataFrameError]
    def get_i32(self, name: &str, row: i64) -> Result[Option[i32], DataFrameError]
    def values_i32(self, name: &str) -> Result[list[i32], DataFrameError]
    def values_i32_nullable(self, name: &str) -> Result[list[Option[i32]], DataFrameError]
    def get_u8(self, name: &str, row: i64) -> Result[Option[u8], DataFrameError]
    def values_u8(self, name: &str) -> Result[list[u8], DataFrameError]
    def values_u8_nullable(self, name: &str) -> Result[list[Option[u8]], DataFrameError]
    def get_u16(self, name: &str, row: i64) -> Result[Option[u16], DataFrameError]
    def values_u16(self, name: &str) -> Result[list[u16], DataFrameError]
    def values_u16_nullable(self, name: &str) -> Result[list[Option[u16]], DataFrameError]
    def get_u32(self, name: &str, row: i64) -> Result[Option[u32], DataFrameError]
    def values_u32(self, name: &str) -> Result[list[u32], DataFrameError]
    def values_u32_nullable(self, name: &str) -> Result[list[Option[u32]], DataFrameError]
    def get_u64(self, name: &str, row: i64) -> Result[Option[u64], DataFrameError]
    def values_u64(self, name: &str) -> Result[list[u64], DataFrameError]
    def values_u64_nullable(self, name: &str) -> Result[list[Option[u64]], DataFrameError]
    def get_f32(self, name: &str, row: i64) -> Result[Option[f32], DataFrameError]
    def values_f32(self, name: &str) -> Result[list[f32], DataFrameError]
    def values_f32_nullable(self, name: &str) -> Result[list[Option[f32]], DataFrameError]
    def get_i64(self, name: &str, row: i64) -> Result[Option[i64], DataFrameError]
    def values_i64(self, name: &str) -> Result[list[i64], DataFrameError]
    def get_f64(self, name: &str, row: i64) -> Result[Option[f64], DataFrameError]
    def values_f64(self, name: &str) -> Result[list[f64], DataFrameError]
    def schema(self) -> Result[list[Field], DataFrameError]
    def get_bool(self, name: &str, row: i64) -> Result[Option[bool], DataFrameError]
    def get_binary(self, name: &str, row: i64) -> Result[Option[Bytes], DataFrameError]
    def values_binary(self, name: &str) -> Result[list[Bytes], DataFrameError]
    def values_binary_nullable(self, name: &str) -> Result[list[Option[Bytes]], DataFrameError]
    def get_str(self, name: &str, row: i64) -> Result[Option[str], DataFrameError]
    def values_bool(self, name: &str) -> Result[list[bool], DataFrameError]
    def values_str(self, name: &str) -> Result[list[str], DataFrameError]
    def values_str_nullable(self, name: &str) -> Result[list[Option[str]], DataFrameError]
    def values_i64_nullable(self, name: &str) -> Result[list[Option[i64]], DataFrameError]
    def values_f64_nullable(self, name: &str) -> Result[list[Option[f64]], DataFrameError]
    def values_bool_nullable(self, name: &str) -> Result[list[Option[bool]], DataFrameError]
class Expr
    def list_len(self) -> Result[Expr, DataFrameError]
    def list_get(self, index: i64) -> Result[Expr, DataFrameError]
    def struct_field(self, name: &str) -> Result[Expr, DataFrameError]
    def str_to_date(self, format: &str = "%Y-%m-%d", strict: bool = True) -> Result[Expr, DataFrameError]
    def str_to_datetime(self, format: &str, unit: TimeUnit, utc: bool = False, strict: bool = True) -> Result[Expr, DataFrameError]
    def dt_year(self) -> Result[Expr, DataFrameError]
    def dt_month(self) -> Result[Expr, DataFrameError]
    def dt_day(self) -> Result[Expr, DataFrameError]
    def dt_hour(self) -> Result[Expr, DataFrameError]
    def dt_minute(self) -> Result[Expr, DataFrameError]
    def dt_second(self) -> Result[Expr, DataFrameError]
    def dt_date(self) -> Result[Expr, DataFrameError]
    def dt_format(self, format: &str) -> Result[Expr, DataFrameError]
    def cast(self, dtype: DType, strict: bool = True) -> Result[Expr, DataFrameError]
    def str_lower(self) -> Result[Expr, DataFrameError]
    def str_upper(self) -> Result[Expr, DataFrameError]
    def str_len(self) -> Result[Expr, DataFrameError]
    def str_contains(self, pattern: &Expr) -> Result[Expr, DataFrameError]
    def str_starts_with(self, prefix: &Expr) -> Result[Expr, DataFrameError]
    def str_ends_with(self, suffix: &Expr) -> Result[Expr, DataFrameError]
    def n_unique(self) -> Result[Expr, DataFrameError]
    def over(self, partition_by: &list[Expr]) -> Result[Expr, DataFrameError]
    def gt(self, other: &Expr) -> Result[Expr, DataFrameError]
    def mul(self, other: &Expr) -> Result[Expr, DataFrameError]
    def add(self, other: &Expr) -> Result[Expr, DataFrameError]
    def sub(self, other: &Expr) -> Result[Expr, DataFrameError]
    def div(self, other: &Expr) -> Result[Expr, DataFrameError]
    def eq(self, other: &Expr) -> Result[Expr, DataFrameError]
    def lt(self, other: &Expr) -> Result[Expr, DataFrameError]
    def ge(self, other: &Expr) -> Result[Expr, DataFrameError]
    def le(self, other: &Expr) -> Result[Expr, DataFrameError]
    def and_(self, other: &Expr) -> Result[Expr, DataFrameError]
    def or_(self, other: &Expr) -> Result[Expr, DataFrameError]
    def fill_null(self, other: &Expr) -> Result[Expr, DataFrameError]
    def sum(self) -> Result[Expr, DataFrameError]
    def count(self) -> Result[Expr, DataFrameError]
    def mean(self) -> Result[Expr, DataFrameError]
    def min(self) -> Result[Expr, DataFrameError]
    def max(self) -> Result[Expr, DataFrameError]
    def is_null(self) -> Result[Expr, DataFrameError]
    def alias(self, name: &str) -> Result[Expr, DataFrameError]
class Query
    def schema_tree(self) -> Result[list[SchemaNode], DataFrameError]
    def schema(self) -> Result[list[Field], DataFrameError]
    def filter(self, predicate: &Expr) -> Result[Query, DataFrameError]
    def with_columns(self, expressions: &list[Expr]) -> Result[Query, DataFrameError]
    def select(self, expressions: &list[Expr]) -> Result[Query, DataFrameError]
    def group_by(self, keys: &list[Expr], aggregates: &list[Expr]) -> Result[Query, DataFrameError]
    def collect(self) -> Result[DataFrame, DataFrameError]
    def collect_streaming(self) -> Result[DataFrame, DataFrameError]
    def sink_parquet(self, path: &str) -> Result[(), DataFrameError]
    def join(self, other: &Query, left_keys: &list[Expr], right_keys: &list[Expr], how: JoinKind = JoinKind.Inner, suffix: &str = "_right", nulls_equal: bool = False) -> Result[Query, DataFrameError]
    def join_asof(self, other: &Query, left_on: &str, right_on: &str, strategy: AsOfStrategy = AsOfStrategy.Backward, tolerance: Option[i64] = Nothing, allow_exact_matches: bool = True, suffix: &str = "_right") -> Result[Query, DataFrameError]
    def sort(self, keys: &list[SortKey]) -> Result[Query, DataFrameError]
    def slice(self, offset: i64, length: i64) -> Result[Query, DataFrameError]
    def limit(self, count: i64) -> Result[Query, DataFrameError]
def column_list(name: &str, values: &Column, offsets: &list[i64]) -> Result[Column, DataFrameError]
def column_list_nullable(name: &str, values: &Column, offsets: &list[i64], valid: &list[bool]) -> Result[Column, DataFrameError]
def column_struct(name: &str, fields: &DataFrame) -> Result[Column, DataFrameError]
def column_struct_nullable(name: &str, fields: &DataFrame, valid: &list[bool]) -> Result[Column, DataFrameError]
def frame(columns: &list[Column]) -> Result[DataFrame, DataFrameError]
def column_i8(name: &str, values: &list[i8]) -> Result[Column, DataFrameError]
def column_i8_nullable(name: &str, values: &list[Option[i8]]) -> Result[Column, DataFrameError]
def lit_i8(value: i8) -> Result[Expr, DataFrameError]
def column_i16(name: &str, values: &list[i16]) -> Result[Column, DataFrameError]
def column_i16_nullable(name: &str, values: &list[Option[i16]]) -> Result[Column, DataFrameError]
def lit_i16(value: i16) -> Result[Expr, DataFrameError]
def column_i32(name: &str, values: &list[i32]) -> Result[Column, DataFrameError]
def column_i32_nullable(name: &str, values: &list[Option[i32]]) -> Result[Column, DataFrameError]
def lit_i32(value: i32) -> Result[Expr, DataFrameError]
def column_u8(name: &str, values: &list[u8]) -> Result[Column, DataFrameError]
def column_u8_nullable(name: &str, values: &list[Option[u8]]) -> Result[Column, DataFrameError]
def lit_u8(value: u8) -> Result[Expr, DataFrameError]
def column_u16(name: &str, values: &list[u16]) -> Result[Column, DataFrameError]
def column_u16_nullable(name: &str, values: &list[Option[u16]]) -> Result[Column, DataFrameError]
def lit_u16(value: u16) -> Result[Expr, DataFrameError]
def column_u32(name: &str, values: &list[u32]) -> Result[Column, DataFrameError]
def column_u32_nullable(name: &str, values: &list[Option[u32]]) -> Result[Column, DataFrameError]
def lit_u32(value: u32) -> Result[Expr, DataFrameError]
def column_u64(name: &str, values: &list[u64]) -> Result[Column, DataFrameError]
def column_u64_nullable(name: &str, values: &list[Option[u64]]) -> Result[Column, DataFrameError]
def lit_u64(value: u64) -> Result[Expr, DataFrameError]
def column_f32(name: &str, values: &list[f32]) -> Result[Column, DataFrameError]
def column_f32_nullable(name: &str, values: &list[Option[f32]]) -> Result[Column, DataFrameError]
def lit_f32(value: f32) -> Result[Expr, DataFrameError]
def column_i64(name: &str, values: &list[i64]) -> Result[Column, DataFrameError]
def column_date(name: &str, days: &list[i32]) -> Result[Column, DataFrameError]
def column_date_nullable(name: &str, days: &list[Option[i32]]) -> Result[Column, DataFrameError]
def column_datetime(name: &str, ticks: &list[i64], unit: TimeUnit, utc: bool = False) -> Result[Column, DataFrameError]
def column_datetime_nullable(name: &str, ticks: &list[Option[i64]], unit: TimeUnit, utc: bool = False) -> Result[Column, DataFrameError]
def column_f64(name: &str, values: &list[f64]) -> Result[Column, DataFrameError]
def col(name: &str) -> Result[Expr, DataFrameError]
def lit(value: f64) -> Result[Expr, DataFrameError]
def lit_i64(value: i64) -> Result[Expr, DataFrameError]
def lit_str(value: &str) -> Result[Expr, DataFrameError]
def lit_bool(value: bool) -> Result[Expr, DataFrameError]
def lit_binary(value: &[u8]) -> Result[Expr, DataFrameError]
def when(predicate: &Expr, then_value: &Expr, otherwise: &Expr) -> Result[Expr, DataFrameError]
def null_f64() -> Result[Expr, DataFrameError]
def scan_parquet(path: &str) -> Result[Query, DataFrameError]
def scan_csv(path: &str, has_header: bool = True, separator: &str = ",", infer_rows: i64 = 100, null_value: Option[str] = Nothing, schema_overrides: Option[list[Field]] = Nothing) -> Result[Query, DataFrameError]
def column_bool(name: &str, values: &list[bool]) -> Result[Column, DataFrameError]
def column_binary(name: &str, values: &list[Bytes]) -> Result[Column, DataFrameError]
def column_binary_nullable(name: &str, values: &list[Option[Bytes]]) -> Result[Column, DataFrameError]
def column_str(name: &str, values: &list[str]) -> Result[Column, DataFrameError]
def column_i64_nullable(name: &str, values: &list[Option[i64]]) -> Result[Column, DataFrameError]
def column_f64_nullable(name: &str, values: &list[Option[f64]]) -> Result[Column, DataFrameError]
def column_bool_nullable(name: &str, values: &list[Option[bool]]) -> Result[Column, DataFrameError]
def column_str_nullable(name: &str, values: &list[Option[str]]) -> Result[Column, DataFrameError]

std.db.kv

Ordered byte-key maps, atomic transactions and bounded scans over a versioned SQLite store. Errors: KvError. Reference.

enum Mode
    ReadOnly | ReadWrite | Create
enum KvError
    Database(sqlite.DbError) | Allocation(AllocError) | InvalidName | ForeignDatabase | UnsupportedVersion(i64)
const format_version: i64 = 1
class Entry
    key: Bytes
    value: Bytes
class Scan
    def next(self: &mut Scan) -> Result[Option[Entry], KvError]
class Transaction
    def commit(self: &mut Transaction) -> Result[(), KvError]
    def rollback(self: &mut Transaction) -> Result[(), KvError]
class Store
    def begin(self: &mut Store, immediate: bool = True) -> Result[Transaction, KvError]
    def set_busy_timeout(self: &mut Store, budget: &Duration) -> Result[(), KvError]
    def close(self: &mut Store) -> Result[(), KvError]
    def put(self: &mut Store, table: &str, key: &[u8], value: &[u8]) -> Result[(), KvError]
    def get(self: &mut Store, table: &str, key: &[u8]) -> Result[Option[Bytes], KvError]
    def contains(self: &mut Store, table: &str, key: &[u8]) -> Result[bool, KvError]
    def remove(self: &mut Store, table: &str, key: &[u8]) -> Result[bool, KvError]
    def clear(self: &mut Store, table: &str) -> Result[i64, KvError]
    def len(self: &mut Store, table: &str) -> Result[i64, KvError]
    def scan(self: &mut Store, table: &str, start: &[u8], stop: &[u8], max_rows: NonNegative[i64], after: bool = False, reverse: bool = False) -> Result[Scan, KvError]
    def scan_all(self: &mut Store, table: &str, max_rows: NonNegative[i64], reverse: bool = False) -> Result[Scan, KvError]
def connect(path: &str, mode: Mode = Mode.Create, max_length: i64 = 1048576) -> Result[Store, KvError]
def memory(max_length: i64 = 1048576) -> Result[Store, KvError]

std.db.sqlite

SQLite databases through prepared statements with typed parameters and reads, owned transactions that roll back on drop, and an explicit value-size limit. Errors: DbError. Reference.

enum Mode
    ReadOnly | ReadWrite | Create
enum Begin
    Deferred | Immediate | Exclusive
enum ValueType
    Integer | Real | Text | Blob | Null
class SqliteError
    code: i64
    message: str
    def primary(self) -> i64
enum DbError
    Sqlite(SqliteError) | Closed | InUse | EmptySql | TrailingSql | TransactionActive | TransactionFinished | InvalidPath | InvalidExtensionEntry | OutOfRange | NoRow | TypeMismatch(ValueType) | TooLarge | InvalidUtf8 | Allocation(AllocError)
const error: i64 = 1
const busy: i64 = 5
const locked: i64 = 6
const read_only: i64 = 8
const cant_open: i64 = 14
const constraint: i64 = 19
const mismatch: i64 = 20
const min_length_limit: i64 = 1024
const max_length_limit: i64 = 1000000000
class Connection
    def execute(self: &mut Connection, sql: &str) -> Result[(), DbError]
    def prepare(self: &mut Connection, sql: &str) -> Result[Statement, DbError]
    def begin(self: &mut Connection, mode: Begin) -> Result[Transaction, DbError]
    def changes(self) -> i64
    def last_insert_rowid(self) -> i64
    def set_busy_timeout(self: &mut Connection, budget: &Duration) -> Result[(), DbError]
    def load_extension(self: &mut Connection, path: &str, entrypoint: &str = "") -> Result[(), DbError]
    def close(self: &mut Connection) -> Result[(), DbError]
def connect(path: &str, mode: Mode, max_length: i64) -> Result[Connection, DbError]
def memory(max_length: i64) -> Result[Connection, DbError]
class Statement
    def parameter_count(self) -> i64
    def parameter_index(self, name: &str) -> Result[i64, DbError]
    def bind_null(self: &mut Statement, index: i64) -> Result[(), DbError]
    def bind_integer(self: &mut Statement, index: i64, value: i64) -> Result[(), DbError]
    def bind_real(self: &mut Statement, index: i64, value: f64) -> Result[(), DbError]
    def bind_text(self: &mut Statement, index: i64, value: &str) -> Result[(), DbError]
    def bind_blob(self: &mut Statement, index: i64, value: &[u8]) -> Result[(), DbError]
    def clear_bindings(self: &mut Statement) -> Result[(), DbError]
    def step(self: &mut Statement) -> Result[bool, DbError]
    def reset(self: &mut Statement) -> ()
    def run(self: &mut Statement) -> Result[(), DbError]
    def column_count(self) -> i64
    def column_name(self, column: i64) -> Result[str, DbError]
    def kind(self, column: i64) -> Result[ValueType, DbError]
    def is_null(self, column: i64) -> Result[bool, DbError]
    def integer(self, column: i64) -> Result[i64, DbError]
    def real(self, column: i64) -> Result[f64, DbError]
    def text(self, column: i64) -> Result[str, DbError]
    def blob(self, column: i64) -> Result[Bytes, DbError]
    def optional_integer(self, column: i64) -> Result[Option[i64], DbError]
    def optional_real(self, column: i64) -> Result[Option[f64], DbError]
    def optional_text(self, column: i64) -> Result[Option[str], DbError]
    def optional_blob(self, column: i64) -> Result[Option[Bytes], DbError]
class Transaction
    def commit(self: &mut Transaction) -> Result[(), DbError]
    def rollback(self: &mut Transaction) -> Result[(), DbError]

std.deque

Owned generic ring buffers with constant-time removal at either end. Errors: AllocError. Reference.

class Deque[T]
    def __init__(self) -> Result[(), AllocError]
    def len(self) -> i64
    def is_empty(self) -> bool
    def append(self: &mut Deque[T], value: T) -> Result[(), AllocError]
    def appendleft(self: &mut Deque[T], value: T) -> Result[(), AllocError]
    def pop(self: &mut Deque[T]) -> Option[T]
    def popleft(self: &mut Deque[T]) -> Option[T]
    def clear(self: &mut Deque[T]) -> ()

std.diff

Line, word, character, byte, and list differences as edit operations, with Myers and patience algorithms and unified-diff output. Errors: AllocError. Reference.

enum Algorithm
    Myers | Patience
enum Kind
    Equal | Delete | Insert
class Op
    kind: Kind
    old_start: i64
    old_end: i64
    new_start: i64
    new_end: i64
    def old_len(self) -> Result[i64, OverflowError[i64]]
    def new_len(self) -> Result[i64, OverflowError[i64]]
    def is_equal(self) -> bool
def diff[T](old: &list[T], new: &list[T], algorithm: Algorithm = Algorithm.Myers, max_cost: Option[i64] = Nothing) -> Result[list[Op], AllocError]
def diff_bytes(old: &[u8], new: &[u8], algorithm: Algorithm = Algorithm.Myers, max_cost: Option[i64] = Nothing) -> Result[list[Op], AllocError]
class TextDiff
    def ops(self) -> &list[Op]
    def old_tokens(self) -> &list[str]
    def new_tokens(self) -> &list[str]
    def has_changes(self) -> bool
    def unified(self, context: i64, old_name: &str, new_name: &str) -> Result[str, AllocError]
def lines(old: &str, new: &str, algorithm: Algorithm = Algorithm.Myers, max_cost: Option[i64] = Nothing) -> Result[TextDiff, AllocError]
def words(old: &str, new: &str, algorithm: Algorithm = Algorithm.Myers, max_cost: Option[i64] = Nothing) -> Result[TextDiff, AllocError]
def chars(old: &str, new: &str, algorithm: Algorithm = Algorithm.Myers, max_cost: Option[i64] = Nothing) -> Result[TextDiff, AllocError]

std.encoding

Hex, base32/base64, MIME base64 and validated custom alphabets, plus fixed-width integer and IEEE 754 float packing with explicit byte order, over std.bytes. Errors: EncodingError. Reference.

enum EncodingError
    InvalidLength | InvalidByte(i64) | InvalidPadding(i64) | NonCanonical(i64) | InvalidAlphabet | InvalidPem(i64) | PemLabel | Allocation(AllocError)
enum Endian
    Little | Big
class Encoding
    def encode(self, source: &[u8]) -> Result[Bytes, EncodingError]
    def decode(self, source: &[u8]) -> Result[Bytes, EncodingError]
    def text(self, source: &[u8]) -> Result[str, EncodingError]
    def from_text(self, text: &str) -> Result[Bytes, EncodingError]
def custom(symbols: &str, padding: Option[u8] = Some(61u8)) -> Result[Encoding, EncodingError]
def base32_encode(source: &[u8]) -> Result[Bytes, EncodingError]
def base32_decode(source: &[u8]) -> Result[Bytes, EncodingError]
def base32_text(source: &[u8]) -> Result[str, EncodingError]
def base32_from_text(text: &str) -> Result[Bytes, EncodingError]
def base32hex_encode(source: &[u8]) -> Result[Bytes, EncodingError]
def base32hex_decode(source: &[u8]) -> Result[Bytes, EncodingError]
def base32hex_text(source: &[u8]) -> Result[str, EncodingError]
def base32hex_from_text(text: &str) -> Result[Bytes, EncodingError]
def base64mime_encode(source: &[u8]) -> Result[Bytes, EncodingError]
def base64mime_decode(source: &[u8]) -> Result[Bytes, EncodingError]
def base64mime_text(source: &[u8]) -> Result[str, EncodingError]
def base64mime_from_text(text: &str) -> Result[Bytes, EncodingError]
def pem_encode(source: &[u8], label: &[u8]) -> Result[Bytes, EncodingError]
def pem_text(source: &[u8], label: &[u8]) -> Result[str, EncodingError]
def pem_decode(source: &[u8], label: &[u8]) -> Result[Bytes, EncodingError]
def pem_from_text(text: &str, label: &[u8]) -> Result[Bytes, EncodingError]
def hex_encode(source: &[u8]) -> Result[Bytes, EncodingError]
def hex_decode(source: &[u8]) -> Result[Bytes, EncodingError]
def hex_text(source: &[u8]) -> Result[str, EncodingError]
def hex_from_text(text: &str) -> Result[Bytes, EncodingError]
def base64_encode(source: &[u8]) -> Result[Bytes, EncodingError]
def base64_decode(source: &[u8]) -> Result[Bytes, EncodingError]
def base64_text(source: &[u8]) -> Result[str, EncodingError]
def base64_from_text(text: &str) -> Result[Bytes, EncodingError]
def base64url_encode(source: &[u8]) -> Result[Bytes, EncodingError]
def base64url_decode(source: &[u8]) -> Result[Bytes, EncodingError]
def base64url_text(source: &[u8]) -> Result[str, EncodingError]
def base64url_from_text(text: &str) -> Result[Bytes, EncodingError]
def pack_u16(target: &mut Bytes, offset: i64, value: u16, order: Endian) -> ()
def pack_u32(target: &mut Bytes, offset: i64, value: u32, order: Endian) -> ()
def pack_u64(target: &mut Bytes, offset: i64, value: u64, order: Endian) -> ()
def pack_i16(target: &mut Bytes, offset: i64, value: i16, order: Endian) -> ()
def pack_i32(target: &mut Bytes, offset: i64, value: i32, order: Endian) -> ()
def pack_i64(target: &mut Bytes, offset: i64, value: i64, order: Endian) -> ()
def append_u16(target: &mut Bytes, value: u16, order: Endian) -> Result[(), EncodingError]
def append_u32(target: &mut Bytes, value: u32, order: Endian) -> Result[(), EncodingError]
def append_u64(target: &mut Bytes, value: u64, order: Endian) -> Result[(), EncodingError]
def append_i16(target: &mut Bytes, value: i16, order: Endian) -> Result[(), EncodingError]
def append_i32(target: &mut Bytes, value: i32, order: Endian) -> Result[(), EncodingError]
def append_i64(target: &mut Bytes, value: i64, order: Endian) -> Result[(), EncodingError]
def unpack_u16(source: &[u8], offset: i64, order: Endian) -> u16
def unpack_u32(source: &[u8], offset: i64, order: Endian) -> u32
def unpack_u64(source: &[u8], offset: i64, order: Endian) -> u64
def unpack_i16(source: &[u8], offset: i64, order: Endian) -> i16
def unpack_i32(source: &[u8], offset: i64, order: Endian) -> i32
def unpack_i64(source: &[u8], offset: i64, order: Endian) -> i64
def pack_f32(target: &mut Bytes, offset: i64, value: f32, order: Endian) -> ()
def pack_f64(target: &mut Bytes, offset: i64, value: f64, order: Endian) -> ()
def append_f32(target: &mut Bytes, value: f32, order: Endian) -> Result[(), EncodingError]
def append_f64(target: &mut Bytes, value: f64, order: Endian) -> Result[(), EncodingError]
def unpack_f32(source: &[u8], offset: i64, order: Endian) -> f32
def unpack_f64(source: &[u8], offset: i64, order: Endian) -> f64

std.env

Environment variables as text or bytes, a detached snapshot, and the working directory. Errors: IoError. Reference.

class Variable
    name: list[u8]
    value: list[u8]
def valid_name(name: &list[u8]) -> bool
def get_bytes(name: &list[u8]) -> Result[Option[list[u8]], IoError]
def get(name: &str) -> Result[Option[str], IoError]
def vars() -> Result[list[Variable], IoError]
def current_dir() -> Result[Path, IoError]
def set_current_dir(path: &Path) -> Result[(), IoError]

std.error

Explicit error mapping, operation/path context, descriptions, and standard-error reports. Errors: Mapper-selected error, Context[E], AllocError. Reference.

def map_error[T, E, G, F: OnceCallable[[E], G]](result: Result[T, E], mapper: F) -> Result[T, G]
enum Subject
    Absent | At(Path) | Unavailable(AllocError)
class Context[E]
    operation: str
    subject: Subject
    cause: E
    def format[W](self, output: &mut Formatter[W]) -> Result[(), FormatError]
    def describe(self) -> Result[str, AllocError]
    def describe_with(self, cause: &str) -> Result[str, AllocError]
    def report(self) -> ()
    def report_with(self, description: Result[str, AllocError]) -> ()
def context[T, E](result: Result[T, E], operation: str) -> Result[T, Context[E]]
def path_context[T, E](result: Result[T, E], operation: str, path: &Path) -> Result[T, Context[E]]
def native_code(error: IoError) -> Option[i32]

std.fmt

Writer-generic value/report formatting, bounded output and fallible strings. Errors: FormatError. Reference.

enum FormatError
    InvalidSpec | LimitExceeded | RecursionLimit | Allocation(AllocError) | Output(StreamError) | OutputClosed
class Spec
    fill: str
    align: str
    sign: str
    coerce_zero: bool
    alternate: bool
    zero: bool
    width: i64
    grouping: str
    precision: i64
    kind: str
def spec(fill: str = " ", align: str = "", sign: str = "", coerce_zero: bool = False, alternate: bool = False, zero: bool = False, width: i64 = 0, grouping: str = "", precision: i64 = -1, kind: str = "") -> Spec
def spec_fill(fill: &str, align: &str) -> Result[str, FormatError]
def spec_align(align: &str) -> Result[str, FormatError]
def spec_count(value: i64) -> Result[i64, FormatError]
class Formatter[W]
    writer: W
    def completed(self) -> i64
    def has_failed(self) -> bool
    def text(self: &mut Formatter[W], value: &str) -> Result[(), FormatError]
    def substr(self: &mut Formatter[W], value: &substr) -> Result[(), FormatError]
    def boolean(self: &mut Formatter[W], value: bool) -> Result[(), FormatError]
    def floating(self: &mut Formatter[W], value: f64, width: NonNegative[i64]) -> Result[(), FormatError]
    def unsigned(self: &mut Formatter[W], value: u64, base: i64, width: NonNegative[i64] = 0) -> Result[(), FormatError]
    def integer(self: &mut Formatter[W], value: i64, width: NonNegative[i64] = 0) -> Result[(), FormatError]
    def debug_text(self: &mut Formatter[W], value: &str) -> Result[(), FormatError]
    def debug_substr(self: &mut Formatter[W], value: &substr) -> Result[(), FormatError]
    def ascii_text(self: &mut Formatter[W], value: &str) -> Result[(), FormatError]
    def char_spec(self: &mut Formatter[W], code: i64, spec: &Spec) -> Result[(), FormatError]
    def text_spec(self: &mut Formatter[W], value: &str, spec: &Spec) -> Result[(), FormatError]
    def substr_spec(self: &mut Formatter[W], value: &substr, spec: &Spec) -> Result[(), FormatError]
    def signed_spec(self: &mut Formatter[W], value: i64, spec: &Spec) -> Result[(), FormatError]
    def unsigned_spec(self: &mut Formatter[W], value: u64, spec: &Spec) -> Result[(), FormatError]
    def float_spec(self: &mut Formatter[W], value: f64, spec: &Spec) -> Result[(), FormatError]
    def float32_spec(self: &mut Formatter[W], value: f32, spec: &Spec) -> Result[(), FormatError]
    def enter(self: &mut Formatter[W]) -> Result[(), FormatError]
    def leave(self: &mut Formatter[W]) -> ()
def formatter[W: Writer](writer: W, scratch: Bytes, max_bytes: NonNegative[i64], max_depth: NonNegative[i64]) -> Result[Formatter[W], FormatError]
def stderr_formatter(max_bytes: NonNegative[i64], max_depth: NonNegative[i64]) -> Result[Formatter[Stderr], FormatError]
def string_formatter(max_bytes: NonNegative[i64], max_depth: NonNegative[i64]) -> Result[Formatter[Cursor], FormatError]
def finish(output: &Formatter[Cursor]) -> Result[str, FormatError]
def display[T, W](value: &T, output: &mut Formatter[W]) -> Result[(), FormatError]
def debug[T, W](value: &T, output: &mut Formatter[W]) -> Result[(), FormatError]
def to_string[T](value: &T, max_bytes: NonNegative[i64], max_depth: NonNegative[i64]) -> Result[str, FormatError]
def to_debug[T](value: &T, max_bytes: NonNegative[i64], max_depth: NonNegative[i64]) -> Result[str, FormatError]
def represent[T, W](value: &T, output: &mut Formatter[W]) -> Result[(), FormatError]
def repr_string[T](value: &T) -> Result[str, FormatError]
def represent_view[T, W](value: &[T], output: &mut Formatter[W]) -> Result[(), FormatError]
def repr_view_string[T](value: &[T]) -> Result[str, FormatError]
def repr_text[W](spelled: Result[str, AllocError | FormatError], output: &mut Formatter[W]) -> Result[(), FormatError]
def repr_result(spelled: Result[str, AllocError | FormatError]) -> Result[str, FormatError]
def allocation_only(built: Result[str, FormatError]) -> Result[str, AllocError]
def allocation_or_format(built: Result[str, FormatError]) -> Result[str, AllocError | FormatError]
def debug_string(value: &str) -> Result[str, FormatError]
def repr_substr_string(value: &substr) -> Result[str, FormatError]
def ascii_string(value: &str) -> Result[str, FormatError]
def list_with[T, W, F: Callable[[&T, &mut Formatter[W]], Result[(), FormatError]]](values: &list[T], output: &mut Formatter[W], render: F) -> Result[(), FormatError]
def pair_with[A, B, W, F: Callable[[&A, &mut Formatter[W]], Result[(), FormatError]], G: Callable[[&B, &mut Formatter[W]], Result[(), FormatError]]](value: &(A, B), output: &mut Formatter[W], first: F, second: G) -> Result[(), FormatError]
protocol Formattable
    def format[W](self, output: &mut Formatter[W]) -> Result[(), FormatError]

std.fs

Directories, metadata/walking, symbolic links and canonical paths, rooted mutation, owned temporary resources, bounded file/tree copy, metadata preservation, delete/glob. Errors: IoError, AllocError, WalkError, FsError, TreeCopyError. Reference.

enum FsError
    Io(IoError) | Stream(StreamError) | Allocation(AllocError) | Entropy(SecretsError) | InvalidInput | Limit | Cancelled | Replaced | Collisions | UnsupportedType | Overlap | InvalidLimits
class Root
    def open_dir(self, name: &Path) -> Result[Root, IoError]
    def read_file(self, name: &Path) -> Result[FileStream, IoError]
    def create_dir(self, name: &Path, unix_mode: u32 = 0o700u32) -> Result[(), IoError]
    def create_file(self, name: &Path, unix_mode: u32 = 0o600u32) -> Result[FileStream, IoError]
    def set_unix_mode(self, unix_mode: u32) -> Result[(), IoError]
    def remove_file(self, name: &Path) -> Result[(), IoError]
    def remove_dir(self, name: &Path) -> Result[(), IoError]
    def move(self, source: &Path, destination: &Path) -> Result[(), IoError]
    def names(self) -> Result[Names, IoError]
def set_file_unix_mode(stream: &FileStream, unix_mode: u32) -> Result[(), IoError]
def root(path: &Path) -> Result[Root, IoError]
class Names
    def next(self: &mut Names) -> Result[Option[Path], IoError]
    def close(self: &mut Names) -> Result[(), IoError]
class TempFile
    stream: FileStream
    def publish(self: &mut TempFile, name: &Path) -> Result[(), IoError]
    def close(self: &mut TempFile) -> Result[(), StreamError]
    def remove_published(self: &mut TempFile, name: &Path) -> Result[(), FsError]
def temporary_file(parent: &Root) -> Result[TempFile, IoError]
class TempDir
    def name(self) -> &Path
    def root(self) -> &Root
    def cleanup(self: &mut TempDir) -> Result[(), FsError]
    def keep(self: &mut TempDir) -> ()
    def cleanup_tree(self: &mut TempDir, max_entries: Positive[i64], max_depth: Positive[i64], cancel: &CancellationToken) -> Result[(), FsError]
def temporary_dir_named(parent: &Root, name: &Path) -> Result[TempDir, FsError]
def temporary_dir(parent: &Root, prefix: &Path, attempts: Positive[i64]) -> Result[TempDir, FsError]
enum CopyMetadata
    ContentsOnly | PermissionsAndTimes
def copy_from[R: Reader](source: &mut R, parent: &Root, destination: &Path, max_bytes: NonNegative[i64], cancel: &CancellationToken) -> Result[i64, FsError]
def copy_file(parent: &Root, source: &Path, destination: &Path, max_bytes: NonNegative[i64], cancel: &CancellationToken, preserve: CopyMetadata = CopyMetadata.ContentsOnly) -> Result[i64, FsError]
class CopyLimits
    max_entries: i64
    max_depth: i64
    max_bytes: i64
    max_open_handles: i64
def copy_limits() -> CopyLimits
enum TreeCopyError
    Setup(FsError) | Partial(FsError) | Entry(Path, i64, FsError)
def copy_tree(source_parent: &Root, source: &Path, destination_parent: &Root, destination: &Path, limits: &CopyLimits, cancel: &CancellationToken, preserve: CopyMetadata = CopyMetadata.ContentsOnly) -> Result[i64, TreeCopyError]
def remove_tree(parent: &Root, name: &Path, max_entries: Positive[i64], max_depth: Positive[i64], cancel: &CancellationToken) -> Result[(), FsError]
def glob(parent: &Root, pattern: &Path, max_entries: NonNegative[i64], max_matches: NonNegative[i64], max_steps: NonNegative[i64]) -> Result[list[Path], FsError]
enum FileType
    File | Directory | Symlink | Other
class Permissions
    readonly: bool
    unix_mode: u32
class Metadata
    def file_type(self) -> FileType
    def is_file(self) -> bool
    def is_dir(self) -> bool
    def is_symlink(self) -> bool
    def size(self) -> u64
    def permissions(self) -> Permissions
    def modified(self) -> Option[Timestamp]
    def accessed(self) -> Option[Timestamp]
    def created(self) -> Option[Timestamp]
    def unix_changed(self) -> Timestamp
    def unix_uid(self) -> u32
    def unix_gid(self) -> u32
    def unix_device(self) -> u64
    def unix_inode(self) -> u64
class DirEntry
    def file_name(self) -> Result[Path, IoError]
    def path(self) -> Result[Path, IoError]
    def file_type(self) -> Result[FileType, IoError]
    def metadata(self) -> Result[Metadata, IoError]
class ReadDir
    def next(self: &mut ReadDir) -> Result[Option[DirEntry], IoError]
    def close(self: &mut ReadDir) -> Result[(), IoError]
    def closed(self) -> bool
def read_dir(path: &Path) -> Result[ReadDir, IoError]
def metadata(path: &Path) -> Result[Metadata, IoError]
def symlink_metadata(path: &Path) -> Result[Metadata, IoError]
def file_metadata(stream: &FileStream) -> Result[Metadata, IoError]
def read_link(path: &Path) -> Result[Path, IoError]
def canonicalize(path: &Path) -> Result[Path, IoError]
def symlink(target: &Path, link: &Path) -> Result[(), IoError]
def entries(owner: ReadDir) -> Generator[Result[DirEntry, IoError]]
enum WalkError
    Io(Path, str, IoError) | Allocation(AllocError)
class WalkDir
    path: Path
    directories: list[Path]
    files: list[DirEntry]
class Walk
    current: WalkDir
    def close(self: &mut Walk) -> ()
    def next(self: &mut Walk) -> Result[bool, WalkError]
def walk(root: &Path, top_down: bool) -> Result[Walk, AllocError]

std.fs.dirs

The home directory and the XDG configuration, cache, data, and state directories, from the environment. Errors: IoError. Reference.

def home_dir() -> Result[Option[Path], IoError]
def config_dir() -> Result[Option[Path], IoError]
def cache_dir() -> Result[Option[Path], IoError]
def data_dir() -> Result[Option[Path], IoError]
def state_dir() -> Result[Option[Path], IoError]

std.fs.lock

Owned Linux shared/exclusive advisory locks, nonblocking and cancellable deadline acquisition. Errors: LockError. Reference.

enum Mode
    Shared | Exclusive
enum LockError
    WouldBlock | TimedOut | Cancelled | InvalidPath | Io(IoError) | Allocation(AllocError)
class Lock
    def close(self: &mut Lock) -> Result[(), LockError]
    def is_closed(self) -> bool
def acquire_now(path: &Path, mode: Mode) -> Result[Lock, LockError]
def acquire_before(path: &Path, mode: Mode, deadline: &Deadline, cancel: &CancellationToken) -> Result[Lock, LockError]

std.fs.watch

Bounded Linux filesystem change batches, rename cookies, overflow and readiness waits. Errors: WatchError, WaitError. Reference.

enum WatchError
    OutOfRange | InvalidData | Io(IoError) | Wait(WaitError) | Allocation(AllocError)
class Event
    watch: i32
    cookie: u32
    name: Path
    def created(self) -> bool
    def deleted(self) -> bool
    def modified(self) -> bool
    def metadata_changed(self) -> bool
    def closed_after_write(self) -> bool
    def moved_from(self) -> bool
    def moved_to(self) -> bool
    def deleted_self(self) -> bool
    def moved_self(self) -> bool
    def unmounted(self) -> bool
    def overflowed(self) -> bool
    def ignored(self) -> bool
    def is_directory(self) -> bool
class Watcher
    def add(self: &mut Watcher, path: &Path) -> Result[i32, WatchError]
    def remove(self: &mut Watcher, watch: i32) -> Result[(), WatchError]
    def poll(self: &mut Watcher) -> Result[i64, WatchError]
    def wait(self: &mut Watcher, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, WatchError]
    def count(self) -> i64
    def event(self, index: i64) -> Result[Event, WatchError]
    def register(self, selector: &mut Selector, key: u64) -> Result[(), WaitError]
    def unregister(self, selector: &mut Selector) -> Result[(), WaitError]
    def close(self: &mut Watcher) -> Result[(), WatchError]
def watcher(batch_bytes: i64 = 4096) -> Result[Watcher, WatchError]

std.graph

Directed and undirected graphs with node and edge data, stable handles, traversal, shortest paths, topological order, components and spanning trees. Errors: AllocError, GraphError. Reference.

type NodeId = i64
type EdgeId = i64
enum GraphError
    Cycle(list[NodeId]) | NegativeCycle(list[NodeId]) | InvalidWeight(EdgeId) | InvalidEstimate(NodeId) | Allocation(AllocError)
class Walk
class Paths
    def distance(self, node: NodeId) -> Option[f64]
    def edge_to(self, node: NodeId) -> Option[EdgeId]
    def path(self, node: NodeId) -> Result[list[NodeId], AllocError]
class DiGraph[N, E]
    def __init__(self) -> Result[(), AllocError]
    def node_count(self) -> i64
    def edge_count(self) -> i64
    def node_bound(self) -> i64
    def edge_bound(self) -> i64
    def reserve(self: &mut DiGraph[N, E], nodes: i64, edges: i64) -> Result[(), AllocError]
    def add_node(self: &mut DiGraph[N, E], data: N) -> Result[NodeId, AllocError]
    def add_edge(self: &mut DiGraph[N, E], source: NodeId, target: NodeId, data: E) -> Result[EdgeId, AllocError]
    def remove_node(self: &mut DiGraph[N, E], node: NodeId) -> Option[N]
    def remove_edge(self: &mut DiGraph[N, E], edge: EdgeId) -> Option[E]
    def contains_node(self, node: NodeId) -> bool
    def contains_edge(self, edge: EdgeId) -> bool
    def node(self, node: NodeId) -> &N
    def node_mut(self: &mut DiGraph[N, E], node: NodeId) -> &mut N
    def edge(self, edge: EdgeId) -> &E
    def edge_mut(self: &mut DiGraph[N, E], edge: EdgeId) -> &mut E
    def get_node_ref(self, node: NodeId) -> Option[&N]
    def get_node_mut(self: &mut DiGraph[N, E], node: NodeId) -> Option[&mut N]
    def get_edge_ref(self, edge: EdgeId) -> Option[&E]
    def get_edge_mut(self: &mut DiGraph[N, E], edge: EdgeId) -> Option[&mut E]
    def source(self, edge: EdgeId) -> NodeId
    def target(self, edge: EdgeId) -> NodeId
    def find_edge(self, source: NodeId, target: NodeId) -> Option[EdgeId]
    def nodes(self) -> Result[list[NodeId], AllocError]
    def edges(self) -> Result[list[EdgeId], AllocError]
    def successors(self, node: NodeId) -> Result[list[NodeId], AllocError]
    def predecessors(self, node: NodeId) -> Result[list[NodeId], AllocError]
    def outgoing(self, node: NodeId) -> Walk
    def incoming(self, node: NodeId) -> Walk
    def next_edge(self, walk: &mut Walk) -> Option[EdgeId]
    def bfs(self, start: NodeId) -> Result[list[NodeId], AllocError]
    def dfs(self, start: NodeId) -> Result[list[NodeId], AllocError]
    def toposort(self) -> Result[list[NodeId], GraphError]
    def strongly_connected_components(self) -> Result[list[list[NodeId]], AllocError]
    def dijkstra[F: Callable[[&E], f64]](self, start: NodeId, weight: &F) -> Result[Paths, GraphError]
    def astar[F: Callable[[&E], f64], H: Callable[[NodeId], f64]](self, start: NodeId, goal: NodeId, weight: &F, estimate: &H) -> Result[Option[(f64, list[NodeId])], GraphError]
    def bellman_ford[F: Callable[[&E], f64]](self, start: NodeId, weight: &F) -> Result[Paths, GraphError]
class UnGraph[N, E]
    def __init__(self) -> Result[(), AllocError]
    def node_count(self) -> i64
    def edge_count(self) -> i64
    def node_bound(self) -> i64
    def edge_bound(self) -> i64
    def reserve(self: &mut UnGraph[N, E], nodes: i64, edges: i64) -> Result[(), AllocError]
    def add_node(self: &mut UnGraph[N, E], data: N) -> Result[NodeId, AllocError]
    def add_edge(self: &mut UnGraph[N, E], a: NodeId, b: NodeId, data: E) -> Result[EdgeId, AllocError]
    def remove_node(self: &mut UnGraph[N, E], node: NodeId) -> Option[N]
    def remove_edge(self: &mut UnGraph[N, E], edge: EdgeId) -> Option[E]
    def contains_node(self, node: NodeId) -> bool
    def contains_edge(self, edge: EdgeId) -> bool
    def node(self, node: NodeId) -> &N
    def node_mut(self: &mut UnGraph[N, E], node: NodeId) -> &mut N
    def edge(self, edge: EdgeId) -> &E
    def edge_mut(self: &mut UnGraph[N, E], edge: EdgeId) -> &mut E
    def get_node_ref(self, node: NodeId) -> Option[&N]
    def get_node_mut(self: &mut UnGraph[N, E], node: NodeId) -> Option[&mut N]
    def get_edge_ref(self, edge: EdgeId) -> Option[&E]
    def get_edge_mut(self: &mut UnGraph[N, E], edge: EdgeId) -> Option[&mut E]
    def endpoints(self, edge: EdgeId) -> (NodeId, NodeId)
    def opposite(self, edge: EdgeId, node: NodeId) -> NodeId
    def find_edge(self, a: NodeId, b: NodeId) -> Option[EdgeId]
    def nodes(self) -> Result[list[NodeId], AllocError]
    def edges(self) -> Result[list[EdgeId], AllocError]
    def neighbors(self, node: NodeId) -> Result[list[NodeId], AllocError]
    def incident(self, node: NodeId) -> Walk
    def next_edge(self, walk: &mut Walk) -> Option[EdgeId]
    def bfs(self, start: NodeId) -> Result[list[NodeId], AllocError]
    def dfs(self, start: NodeId) -> Result[list[NodeId], AllocError]
    def connected_components(self) -> Result[list[list[NodeId]], AllocError]
    def dijkstra[F: Callable[[&E], f64]](self, start: NodeId, weight: &F) -> Result[Paths, GraphError]
    def astar[F: Callable[[&E], f64], H: Callable[[NodeId], f64]](self, start: NodeId, goal: NodeId, weight: &F, estimate: &H) -> Result[Option[(f64, list[NodeId])], GraphError]
    def bellman_ford[F: Callable[[&E], f64]](self, start: NodeId, weight: &F) -> Result[Paths, GraphError]
    def minimum_spanning_tree[F: Callable[[&E], f64]](self, weight: &F) -> Result[list[EdgeId], GraphError]

std.http

Bounded HTTP/1.1 message heads and streamed Content-Length, chunked, and close-delimited bodies over std.io streams. Errors: HttpError. Reference.

enum HttpError
    Stream(StreamError) | Allocation(AllocError) | InvalidLimit | Truncated | LineTooLong | HeadTooLarge | TooManyHeaders | BareLineFeed | InvalidRequestLine | InvalidStatusLine | UnsupportedVersion | InvalidHeader | InvalidContentLength | DuplicateFraming | ConflictingFraming | UnsupportedTransferEncoding | InvalidChunk | BodyTooLarge | LengthMismatch | Unfinished | Broken | InvalidTarget | MissingHost | DuplicateHost | InvalidHost
class Limits
    max_line: i64
    max_head: i64
    max_headers: NonNegative[i64]
    max_body: NonNegative[i64]
def limits() -> Limits
class Header
    name: str
    value: str
class RequestHead
    method: str
    target: str
    minor: i64
    headers: list[Header]
    def add(self: &mut RequestHead, name: str, value: str) -> Result[(), HttpError]
class ResponseHead
    minor: i64
    status: i64
    reason: str
    headers: list[Header]
    def add(self: &mut ResponseHead, name: str, value: str) -> Result[(), HttpError]
enum Framing
    Empty | Length(i64) | Chunked | UntilClose
def request(method: str, target: str) -> Result[RequestHead, HttpError]
def response(status: i64, reason: str) -> Result[ResponseHead, HttpError]
def find(headers: &list[Header], name: &str) -> Option[i64]
def same_name(left: &str, right: &str) -> bool
def parse_field(line: &[u8]) -> Result[Header, HttpError]
def parse_request_line(line: &[u8]) -> Result[RequestHead, HttpError]
def parse_status_line(line: &[u8]) -> Result[ResponseHead, HttpError]
def read_request[R: Reader](conn: &mut BufReader[R], limits: &Limits) -> Result[Option[RequestHead], HttpError]
def read_response[R: Reader](conn: &mut BufReader[R], limits: &Limits) -> Result[Option[ResponseHead], HttpError]
def request_framing(head: &RequestHead) -> Result[Framing, HttpError]
def response_framing(head: &ResponseHead, method: &str) -> Result[Framing, HttpError]
def request_keeps_alive(head: &RequestHead) -> bool
class RequestTarget
    authority: str
    path: str
    query: str
def request_target(head: &RequestHead) -> Result[RequestTarget, HttpError]
def response_keeps_alive(head: &ResponseHead, framing: &Framing) -> bool
def parse_chunk_size(line: &[u8]) -> Result[i64, HttpError]
class BodyReader[R]
    trailers: list[Header]
    def total(self) -> i64
    def is_done(self) -> bool
    def take_failure(self: &mut BodyReader[R]) -> Option[HttpError]
    def read_body(self: &mut BodyReader[R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, HttpError]
    def read(self: &mut BodyReader[R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
def body_reader[R: Reader](conn: BufReader[R], framing: &Framing, limits: &Limits) -> Result[BodyReader[R], HttpError]
def read_to_end[R: Reader](body: &mut BodyReader[R], out: &mut Bytes) -> Result[i64, HttpError]
def discard[R: Reader](body: &mut BodyReader[R]) -> Result[i64, HttpError]
def finish[R](body: &mut BodyReader[R]) -> Result[BufReader[R], HttpError]
def release[R](body: &mut BodyReader[R]) -> Option[BufReader[R]]
def write_request[W: Writer](writer: &mut W, head: &RequestHead) -> Result[(), HttpError]
def encode_request(head: &RequestHead) -> Result[Bytes, HttpError]
def write_response[W: Writer](writer: &mut W, head: &ResponseHead) -> Result[(), HttpError]
def encode_response(head: &ResponseHead) -> Result[Bytes, HttpError]
def write_chunk[W: Writer](writer: &mut W, source: &[u8]) -> Result[(), HttpError]
def encode_chunk_size(length: NonNegative[i64]) -> Result[Bytes, HttpError]
def write_last_chunk[W: Writer](writer: &mut W, trailers: &list[Header]) -> Result[(), HttpError]
def encode_last_chunk(trailers: &list[Header]) -> Result[Bytes, HttpError]
def write_body[W: Writer](writer: &mut W, framing: &Framing, source: &[u8]) -> Result[(), HttpError]

std.http.decoder

Resumable bounded HTTP/1.x request framing over caller-supplied bytes, without I/O. Errors: HttpError. Reference.

const feed_budget: i64 = 4096
enum Event
    Head(RequestHead, RequestTarget, Framing) | Body(Bytes) | Trailers(list[Header]) | End
class Decoder
    def is_started(self) -> bool
    def has_head(self) -> bool
    def is_done(self) -> bool
    def total(self) -> i64
    def reset(self: &mut Decoder) -> Result[(), HttpError]
    def finish(self: &mut Decoder) -> Result[(), HttpError]
    def feed(self: &mut Decoder, source: &[u8]) -> Result[(i64, Option[Event]), HttpError]
def decoder(limits: &Limits) -> Result[Decoder, HttpError]

std.http.body

Bounded request bodies for handlers: URL-encoded forms, JSON, and multipart uploads into unnamed temporary files. Errors: BodyError. Reference.

enum BodyError
    UnsupportedMediaType | TooLarge | TooManyFields | Malformed | InvalidUtf8 | Http(HttpError) | Json(JsonError) | Storage(StreamError) | Allocation(AllocError)
def status(error: &BodyError) -> i64
def reject[T: Transport](exchange: &mut Exchange[T], error: &BodyError) -> Result[(), HttpError]
class FormLimits
    max_bytes: NonNegative[i64]
    max_fields: NonNegative[i64]
def form_limits() -> FormLimits
def parse_form(source: &[u8], limits: &FormLimits) -> Result[list[Pair], BodyError]
def parse_form_text(text: &str, limits: &FormLimits) -> Result[list[Pair], BodyError]
def find(pairs: &list[Pair], key: &str) -> Option[i64]
def read_form[T: Transport](exchange: &mut Exchange[T], limits: &FormLimits) -> Result[list[Pair], BodyError]
def read_json[T: Transport](exchange: &mut Exchange[T], limits: &std.json.Limits) -> Result[Json, BodyError]
def send_json[T: Transport](exchange: &mut Exchange[T], status: i64, value: &Json, limits: &std.json.Limits) -> Result[(), BodyError]
class MultipartLimits
    max_parts: NonNegative[i64]
    max_head: NonNegative[i64]
    max_field: NonNegative[i64]
    max_file: NonNegative[i64]
    max_body: NonNegative[i64]
def multipart_limits() -> MultipartLimits
enum Content
    Text(str) | File(TempFile)
class Part
    name: str
    filename: Option[str]
    content_type: str
    size: i64
    content: Content
def read_multipart[T: Transport](exchange: &mut Exchange[T], limits: &MultipartLimits, storage: &Root) -> Result[list[Part], BodyError]

std.http.client

HTTP/1.1 client: pooled connections, deadlines and cancellation, bounded redirects, an explicit proxy, and replay of idempotent requests only. Errors: ClientError. Reference.

enum ClientError
    Net(NetError) | Http(HttpError) | Url(UrlError) | Allocation(AllocError) | InvalidConfig | InvalidUrl | UnsupportedScheme | InvalidRequest | InvalidRedirect | TooManyRedirects | UnexpectedInterim | Tls(TlsFailure) | TunnelRefused(i64) | Body(StreamError) | WrongBodyLength
enum TlsFailure
    UntrustedCertificate | ExpiredCertificate | WrongHost | InvalidCertificate | RevokedCertificate | Rejected | Protocol | InvalidName | InvalidConfiguration | NoTrustRoots | CertificateRequired | Incompatible
class Tunnel
    host: str
    port: u16
    authorization: Option[str]
    limits: Limits
class Endpoint
    scheme: str
    host: str
    port: u16
    tunnel: Option[Tunnel]
protocol Transport
    def read_before(self: &mut Transport, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, ClientError]
    def write_before(self: &mut Transport, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, ClientError]
protocol Connector[T]
    def open(self, endpoint: &Endpoint, deadline: &Deadline, cancel: &CancellationToken) -> Result[T, ClientError]
class Plain
    def read_before(self: &mut Plain, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, ClientError]
    def write_before(self: &mut Plain, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, ClientError]
class TcpConnector
    def open(self, endpoint: &Endpoint, deadline: &Deadline, cancel: &CancellationToken) -> Result[Plain, ClientError]
def dial(endpoint: &Endpoint, deadline: &Deadline, cancel: &CancellationToken) -> Result[TcpStream, ClientError]
class Dialled
    def read(self: &mut Dialled, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[ClientError]]
    def write(self: &mut Dialled, source: &[u8]) -> Result[i64, StepError[ClientError]]
class Proxy
    endpoint: Endpoint
    authorization: Option[str]
def proxy(url: &str) -> Result[Proxy, ClientError]
class Config
    limits: Limits
    connect_timeout: Duration
    write_timeout: Duration
    head_timeout: Duration
    read_timeout: Duration
    idle_timeout: Duration
    continue_timeout: Duration
    max_idle: i64
    max_idle_per_origin: i64
    redirects: i64
    retries: i64
    sensitive: list[str]
    proxy: Option[Proxy]
def config() -> Result[Config, ClientError]
class Upload
    length: Option[i64]
    expect_continue: bool
def sized(length: i64) -> Upload
def chunked() -> Upload
class Unstreamed
    def read(self: &mut Unstreamed, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
class Stats
    opened: u64
    reused: u64
    retried: u64
    redirected: u64
    discarded: u64
class Request
    method: str
    url: str
    headers: list[Header]
    body: Bytes
    def add(self: &mut Request, name: str, value: str) -> Result[(), ClientError]
def request(method: &str, url: &str) -> Result[Request, ClientError]
class Fetched
    status: i64
    head: ResponseHead
    url: str
    redirects: i64
    body: Bytes
class Wire[T]
    def read(self: &mut Wire[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[ClientError]]
    def write(self: &mut Wire[T], source: &[u8]) -> Result[i64, StepError[ClientError]]
class Response[T]
    status: i64
    head: ResponseHead
    url: str
    redirects: i64
    def is_done(self) -> bool
    def read_body(self: &mut Response[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, ClientError]
    def read_all(self: &mut Response[T], out: &mut Bytes) -> Result[i64, ClientError]
    def read_all_progress(self: &mut Response[T], out: &mut Bytes) -> Result[i64, Partial[ClientError]]
    def total(self) -> i64
    def trailers(self) -> &list[Header]
    def read_typed(self: &mut Response[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[ClientError]]
    def read(self: &mut Response[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def take_failure(self: &mut Response[T]) -> Option[ClientError]
class TypedResponse[T]
    def read(self: &mut TypedResponse[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[ClientError]]
def typed_response[T](response: Response[T]) -> TypedResponse[T]
def unwrap_response[T](response: TypedResponse[T]) -> Response[T]
class Client[T, C]
    def stats(self) -> Stats
    def idle(self) -> i64
    def close_idle(self) -> ()
    def send(self, request: Request, deadline: &Deadline, cancel: &CancellationToken) -> Result[Response[T], ClientError]
    def send_from[R: Reader](self, request: Request, body: &mut R, upload: &Upload, deadline: &Deadline, cancel: &CancellationToken) -> Result[Response[T], ClientError]
    def fetch(self, request: Request, deadline: &Deadline, cancel: &CancellationToken) -> Result[Fetched, ClientError]
    def get(self, url: &str, deadline: &Deadline, cancel: &CancellationToken) -> Result[Fetched, ClientError]
    def finish(self, response: Response[T]) -> ()
def client(config: Config) -> Result[Client[Plain, TcpConnector], ClientError]
def connector[T: Transport, C: Connector[T]](opener: C, config: Config) -> Result[Client[T, C], ClientError]

std.http.cookie

Cookie fields read leniently and Set-Cookie fields validated against injection, with secure defaults. Errors: CookieError. Reference.

enum CookieError
    InvalidName | InvalidValue | InvalidAttribute | TooManyCookies | InvalidKey | Http(HttpError) | Crypto(CryptoError) | Allocation(AllocError)
class Cookie
    name: str
    value: str
def cookies(headers: &list[Header], limit: i64) -> Result[list[Cookie], CookieError]
def find(cookies: &list[Cookie], name: &str) -> Option[i64]
enum SameSite
    Strict | Lax | Unrestricted
class SetCookie
    name: str
    value: str
    path: str
    domain: str
    max_age: Option[Duration]
    secure: bool
    http_only: bool
    same_site: SameSite
    def to_string(self) -> Result[str, CookieError]
def set_cookie(name: &str, value: &str) -> Result[SetCookie, CookieError]
def removal(name: &str) -> Result[SetCookie, CookieError]
def add(head: &mut ResponseHead, cookie: &SetCookie) -> Result[(), CookieError]
const min_key: i64 = 32
def sign(keys: &list[Bytes], name: &str, value: &str) -> Result[str, CookieError]
def verify(keys: &list[Bytes], name: &str, signed: &str) -> Result[Option[str], CookieError]
def find_signed(cookies: &list[Cookie], keys: &list[Bytes], name: &str) -> Result[Option[str], CookieError]
def signed_cookie(keys: &list[Bytes], name: &str, value: &str) -> Result[SetCookie, CookieError]

std.http.files

Static files below a Root, opened one segment at a time without following links, with media types and conditional requests. Errors: FilesError. Reference.

enum FilesError
    Io(IoError) | Stream(StreamError) | Http(HttpError) | Truncated | Allocation(AllocError)
const max_path: i64 = 4096
def open_file(root: &Root, path: &str) -> Result[Option[FileStream], FilesError]
def media_type(name: &str) -> str
def http_date(timestamp: &Timestamp) -> Result[Option[str], FilesError]
def parse_http_date(text: &str) -> Result[Option[Timestamp], FilesError]
def serve[T: Transport](exchange: &mut Exchange[T], root: &Root, path: &str) -> Result[i64, FilesError]

std.http.https

std.http.client for https URLs through std.tls, verified by default, with CONNECT tunnels through a proxy. Errors: ClientError. Reference.

class Connection
    def read_before(self: &mut Connection, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, ClientError]
    def write_before(self: &mut Connection, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, ClientError]
def secure_error(error: TlsError) -> ClientError
class HttpsConnector
    def open(self, endpoint: &Endpoint, deadline: &Deadline, cancel: &CancellationToken) -> Result[Connection, ClientError]
def connector(tls: ClientConfig) -> HttpsConnector
def client(config: Config, tls: ClientConfig) -> Result[Client[Connection, HttpsConnector], ClientError]
def system_client(config: Config) -> Result[Client[Connection, HttpsConnector], ClientError]

std.http.proxy

The client address and scheme behind explicitly trusted reverse proxies; deployment guidance. Errors: ProxyError. Reference.

enum ProxyError
    InvalidNetwork | UnknownPeer | InvalidForwarded | TooManyHops | Allocation(AllocError)
enum Forwarding
    # X-Forwarded-For, with the scheme from X-Forwarded-Proto. | XForwardedFor
class Proxies
    header: Forwarding
    max_hops: i64
    def trust(self: &mut Proxies, network: &str) -> Result[(), ProxyError]
    def trusts(self, ip: &IpAddress) -> bool
def proxies(header: Forwarding) -> Result[Proxies, ProxyError]
class Client
    address: IpAddress
    scheme: Option[str]
    proxied: bool
def client(peer: &SocketAddress, headers: &list[Header], proxies: &Proxies) -> Result[Client, ProxyError]
def client_of[T: Transport](exchange: &Exchange[T], proxies: &Proxies) -> Result[Client, ProxyError]

std.http.server

HTTP/1.1 server: routing, a bounded worker pool and admission queue, idle connections parked off the workers, per-phase deadlines, and graceful shutdown. Errors: ServerError. Reference.

enum ServerError
    InvalidConfig | InvalidPattern | DuplicateRoute | Allocation(AllocError) | Thread(SpawnError[()]) | Net(NetError)
protocol Transport
    def read_before(self: &mut Transport, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, NetError]
    def write_before(self: &mut Transport, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, NetError]
    def shutdown(self: &mut Transport, direction: Shutdown) -> Result[(), NetError]
protocol Handler[T, R, E]
    def handle(self, route: &R, exchange: &mut Exchange[T]) -> Result[(), E]
class Config
    workers: i64
    queue: i64
    limits: Limits
    idle_timeout: Duration
    head_timeout: Duration
    body_timeout: Duration
    write_timeout: Duration
    response_timeout: Duration
    drain_timeout: Duration
    max_requests: i64
    events: Option[ChannelSink]
    handshake_timeout: Duration
    idle_connections: i64
def config() -> Config
class Report
    connections: u64
    rejected: u64
    requests: u64
    handler_errors: u64
    protocol_errors: u64
    timeouts: u64
    cancelled: u64
    accept_errors: u64
    dropped_events: u64
enum Match
    Found(i64, list[str]) | NotFound | MethodNotAllowed(str)
class Router[R]
    def add(self: &mut Router[R], method: &str, pattern: &str, route: R) -> Result[(), ServerError]
    def find(self, method: &str, path: &str) -> Result[Match, ServerError]
    def route(self, index: i64) -> &R
def router[R]() -> Result[Router[R], ServerError]
class Conn[T]
    def read(self: &mut Conn[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def write(self: &mut Conn[T], source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut Conn[T]) -> Result[(), StreamError]
class Exchange[T]
    request: RequestHead
    authority: str
    path: str
    query: str
    params: list[str]
    peer: Option[SocketAddress]
    def stopping(self) -> bool
    def cancelled(self) -> bool
    def stop_token(self) -> CancellationToken
    def cancel_token(self) -> CancellationToken
    def status(self) -> i64
    def sent(self) -> i64
    def read_body(self: &mut Exchange[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, HttpError]
    def read_all(self: &mut Exchange[T], out: &mut Bytes) -> Result[i64, HttpError]
    def respond(self: &mut Exchange[T], head: ResponseHead, body: &[u8]) -> Result[(), HttpError]
    def send(self: &mut Exchange[T], status: i64, content_type: &str, body: &[u8]) -> Result[(), HttpError]
    def send_text(self: &mut Exchange[T], status: i64, text: &str) -> Result[(), HttpError]
    def start(self: &mut Exchange[T], head: ResponseHead) -> Result[(), HttpError]
    def write(self: &mut Exchange[T], source: &[u8]) -> Result[(), HttpError]
    def end(self: &mut Exchange[T]) -> Result[(), HttpError]
    def switch_protocols(self: &mut Exchange[T], head: ResponseHead) -> Result[(T, Bytes), HttpError]
    def detach(self: &mut Exchange[T], head: ResponseHead) -> Result[T, HttpError]
def reason(status: i64) -> str
def serve_connection[T: Transport, R, E, H: Handler[T, R, E]](stream: T, router: &Router[R], handler: &H, config: &Config, stop: &CancellationToken, cancel: &CancellationToken) -> Report
def serve_connection_from[T: Transport, R, E, H: Handler[T, R, E]](stream: T, peer: Option[SocketAddress], router: &Router[R], handler: &H, config: &Config, stop: &CancellationToken, cancel: &CancellationToken) -> Report
enum OpenError
    TimedOut | Cancelled | Failed | Gone
protocol Opener[T]
    def open(self, tcp: TcpStream) -> Result[T, OpenError]
    def advance(self, stream: &mut T, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), OpenError]
    def handshakes(self) -> bool
    def watch(self, stream: &T, selector: &mut Selector, key: u64) -> bool
    def unwatch(self, stream: &T, selector: &mut Selector) -> ()
def serve[R, E, H: Handler[TcpStream, R, E]](listener: TcpListener, router: &Router[R], handler: &H, config: &Config, stop: &CancellationToken) -> Result[Report, ServerError]
def serve_with[T: Transport, O: Opener[T], R, E, H: Handler[T, R, E]](listener: TcpListener, opener: &O, router: &Router[R], handler: &H, config: &Config, stop: &CancellationToken) -> Result[Report, ServerError]

std.http.sse

Server-Sent Events from a server exchange: event, id, multi-line data, comments and retry, flushed per event, with disconnect and shutdown detection. Errors: SseError. Reference.

enum SseError
    Net(NetError) | Allocation(AllocError) | Http(HttpError) | InvalidField | InvalidText | Disconnected | Closed | Stopping
class EventStream[T]
    last_event_id: Option[str]
    def is_open(self) -> bool
    def send(self: &mut EventStream[T], data: &str, deadline: &Deadline, cancel: &CancellationToken, event: str = "", id: Option[str] = Nothing) -> Result[(), SseError]
    def send_bytes(self: &mut EventStream[T], data: &[u8], deadline: &Deadline, cancel: &CancellationToken, event: str = "", id: Option[str] = Nothing) -> Result[(), SseError]
    def comment(self: &mut EventStream[T], text: &str, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), SseError]
    def retry(self: &mut EventStream[T], span: &Duration, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), SseError]
    def wait(self: &mut EventStream[T], deadline: &Deadline, cancel: &CancellationToken) -> Result[(), SseError]
    def close(self: &mut EventStream[T]) -> ()
def head() -> Result[ResponseHead, HttpError]
def accept[T: Transport](exchange: &mut Exchange[T]) -> Result[EventStream[T], SseError]
def accept_with[T: Transport](exchange: &mut Exchange[T], head: ResponseHead) -> Result[EventStream[T], SseError]

std.http.tls

std.http.server over std.tls, with handshake deadlines. Errors: ServerError. Reference.

class TlsTransport
    stream: TlsStream
    def read_before(self: &mut TlsTransport, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, NetError]
    def write_before(self: &mut TlsTransport, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, NetError]
    def shutdown(self: &mut TlsTransport, direction: Shutdown) -> Result[(), NetError]
class TlsOpener
    def open(self, tcp: TcpStream) -> Result[TlsTransport, OpenError]
    def advance(self, stream: &mut TlsTransport, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), OpenError]
    def handshakes(self) -> bool
    def watch(self, stream: &TlsTransport, selector: &mut Selector, key: u64) -> bool
    def unwatch(self, stream: &TlsTransport, selector: &mut Selector) -> ()
def serve[R, E, H: Handler[TlsTransport, R, E]](listener: TcpListener, tls: ServerConfig, router: &Router[R], handler: &H, config: &Config, stop: &CancellationToken) -> Result[Report, ServerError]

std.http.typed

Typed head parsing and writes, fixed/chunked/close-delimited bodies, and guarded connection recovery with concrete causes and progress. Errors: FramingError[E], Partial[E]. Reference.

enum FramingError[E]
    Transport(E) | Truncated | InvalidProgress | OutOfRange | Broken | NotReusable | Protocol(HttpError)
def read_request[E, R: Reader[E]](reader: &mut R, limits: &Limits) -> Result[Option[RequestHead], Partial[FramingError[E]]]
def read_response[E, R: Reader[E]](reader: &mut R, limits: &Limits) -> Result[Option[ResponseHead], Partial[FramingError[E]]]
def write_request[E, W: Writer[E]](writer: &mut W, head: &RequestHead) -> Result[(), Partial[FramingError[E]]]
def write_response[E, W: Writer[E]](writer: &mut W, head: &ResponseHead) -> Result[(), Partial[FramingError[E]]]
def write_last_chunk[E, W: Writer[E]](writer: &mut W, trailers: &list[Header]) -> Result[(), Partial[FramingError[E]]]
def write_chunk[E, W: Writer[E]](writer: &mut W, source: &[u8]) -> Result[(), Partial[FramingError[E]]]
def fixed_body[E, R: Reader[E]](inner: R, length: NonNegative[i64]) -> Result[FixedBody[E, R], FramingError[E]]
class FixedBody[E, R]
    def read(self: &mut FixedBody[E, R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[FramingError[E]]]
def chunked_body[E, R: Reader[E]](inner: R, limits: &Limits) -> Result[ChunkedBody[E, R], FramingError[E]]
class ChunkedBody[E, R]
    trailers: list[Header]
    def total(self) -> i64
    def is_done(self) -> bool
    def read(self: &mut ChunkedBody[E, R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[FramingError[E]]]
def close_body[E, R: Reader[E]](inner: R) -> CloseBody[E, R]
class CloseBody[E, R]
    def read(self: &mut CloseBody[E, R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[FramingError[E]]]
def request_body[E, R: Reader[E]](inner: R, head: &RequestHead, limits: &Limits) -> Result[Body[E, R], FramingError[E]]
def response_body[E, R: Reader[E]](inner: R, head: &ResponseHead, method: &str, request_keep_alive: bool, limits: &Limits) -> Result[Body[E, R], FramingError[E]]
class Body[E, R]
    def total(self) -> i64
    def is_done(self) -> bool
    def trailers(self) -> &list[Header]
    def read(self: &mut Body[E, R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[FramingError[E]]]
    def finish(self: &mut Body[E, R]) -> Result[R, FramingError[E]]

std.http.websocket

RFC 6455 WebSocket connections: the handshake as a server exchange or a ws client, bounded framed messages, pings and the closing handshake. Errors: WebSocketError. Reference.

enum WebSocketError
    Net(NetError) | Allocation(AllocError) | Http(HttpError) | Connect(ClientError) | Entropy(StreamError) | InvalidConfig | InvalidUrl | UnsupportedScheme | OutOfRange | Refused(i64) | Rejected(i64) | InvalidHandshake | Protocol | TooLarge | InvalidText | Closed | Stopping
class Config
    max_frame: Positive[i64]
    max_message: Positive[i64]
    subprotocol: Option[str]
def config() -> Config
enum Message
    Text | Binary | Close(i64)
enum Kind
    Text | Binary
class WebSocket[T]
    subprotocol: Option[str]
    def is_open(self) -> bool
    def receive(self: &mut WebSocket[T], out: &mut Bytes, deadline: &Deadline, cancel: &CancellationToken) -> Result[Message, WebSocketError]
    def send(self: &mut WebSocket[T], kind: Kind, data: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[(), WebSocketError]
    def send_text(self: &mut WebSocket[T], text: &str, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), WebSocketError]
    def ping(self: &mut WebSocket[T], data: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[(), WebSocketError]
    def close(self: &mut WebSocket[T], code: i64, reason: &str, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), WebSocketError]
def accept[T: Transport](exchange: &mut Exchange[T], config: &Config) -> Result[WebSocket[T], WebSocketError]
class Target
    secure: bool
    host: str
    port: u16
def target(url: &str) -> Result[Target, WebSocketError]
def dial(target: &Target, deadline: &Deadline, cancel: &CancellationToken) -> Result[TcpStream, WebSocketError]
class Wire[T]
    def read(self: &mut Wire[T], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
def handshake[T: Transport](stream: T, target: &Target, config: &Config, deadline: &Deadline, cancel: &CancellationToken) -> Result[WebSocket[T], WebSocketError]
def connect(url: &str, config: &Config, deadline: &Deadline, cancel: &CancellationToken) -> Result[WebSocket[TcpStream], WebSocketError]

std.http.wss

std.http.websocket clients for wss URLs through std.tls. Errors: WebSocketError. Reference.

def connect(url: &str, tls: &ClientConfig, config: &Config, deadline: &Deadline, cancel: &CancellationToken) -> Result[WebSocket[TlsTransport], WebSocketError]

std.image

Owned 8-bit pixel buffers, bounded PNG decoding and encoding, cropping, colour conversion and resizing. Errors: ImageError. Reference.

enum ImageError
    OutOfRange | Corrupt | Checksum | Truncated | Unsupported | LimitExceeded | Allocation(AllocError)
enum ColorType
    Gray | GrayAlpha | Rgb | Rgba
    def channels(self) -> i64
    def has_alpha(self) -> bool
enum Format
    Png | Jpeg | Gif | WebP
enum Filter
    Nearest | Bilinear
class Limits
    max_width: NonNegative[i64]
    max_height: NonNegative[i64]
    max_bytes: NonNegative[i64]
    def check(self, width: i64, height: i64, color: ColorType) -> Result[(), ImageError]
def limits() -> Limits
class Info
    format: Format
    width: i64
    height: i64
    color: ColorType
    depth: i64
    interlaced: bool
class Image
    def width(self) -> i64
    def height(self) -> i64
    def color(self) -> ColorType
    def pixels(self) -> &Bytes
    def into_pixels(self: Image) -> Bytes
    def copy(self) -> Result[Image, ImageError]
    def get(self, x: i64, y: i64, channel: i64) -> Result[u8, ImageError]
    def set(self: &mut Image, x: i64, y: i64, channel: i64, value: u8) -> Result[(), ImageError]
    def crop(self, x: i64, y: i64, width: i64, height: i64) -> Result[Image, ImageError]
    def convert(self, color: ColorType) -> Result[Image, ImageError]
    def resize(self, width: i64, height: i64, filter: Filter) -> Result[Image, ImageError]
def new(width: Positive[i64], height: Positive[i64], color: ColorType) -> Result[Image, ImageError]
def from_pixels(width: Positive[i64], height: Positive[i64], color: ColorType, pixels: Bytes) -> Result[Image, ImageError]
def detect(data: &[u8]) -> Option[Format]
def info(data: &[u8]) -> Result[Info, ImageError]
def decode(data: &[u8], limits: &Limits) -> Result[Image, ImageError]
def encode_png(image: &Image, level: i64 = 6) -> Result[Bytes, ImageError]

std.io

Partial-progress byte stream contracts, retry helpers, fixed-capacity buffering, file and process-stream adapters, and checked sequential binary fields in an owned memory cursor. Errors: StreamError, Partial, CopyError, CloseError, BinaryError. Reference.

enum StreamError
    Interrupted | UnexpectedEof | WriteZero | OutOfRange | InvalidProgress | Io(IoError) | Allocation(AllocError)
enum BinaryError
    Truncated(i64, i64, i64) | TrailingData(i64, i64) | OutOfRange | LimitExceeded | Allocation(AllocError)
class Partial
    completed: i64
    cause: StreamError
enum CopyError
    Read(i64, StreamError) | Write(i64, StreamError)
enum CloseError
    Flush(StreamError) | Close(StreamError) | FlushAndClose(StreamError, StreamError)
enum SeekFrom
    Start(i64) | Current(i64) | End(i64)
protocol Reader
    def read(self: &mut Reader, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
protocol Writer
    def write(self: &mut Writer, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut Writer) -> Result[(), StreamError]
protocol Seeker
    def seek(self: &mut Seeker, target: SeekFrom) -> Result[i64, StreamError]
protocol Closer
    def close(self: &mut Closer) -> Result[(), StreamError]
def classify(error: IoError) -> StreamError
def read_exact[R: Reader](reader: &mut R, buffer: &mut Bytes, start: i64, stop: i64) -> Result[(), Partial]
def write_all[W: Writer](writer: &mut W, source: &[u8]) -> Result[(), Partial]
def read_up_to[R: Reader](reader: &mut R, out: &mut Bytes, limit: NonNegative[i64]) -> Result[i64, Partial]
def copy_all[R: Reader, W: Writer](reader: &mut R, writer: &mut W, scratch: &mut Bytes) -> Result[i64, CopyError]
class BufReader[R]
    inner: R
    def capacity(self) -> i64
    def buffered(self) -> i64
    def read(self: &mut BufReader[R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def read_until(self: &mut BufReader[R], delimiter: u8, out: &mut Bytes, limit: Positive[i64]) -> Result[i64, StreamError]
def buffered_reader[R](inner: R, capacity: Positive[i64]) -> Result[BufReader[R], StreamError]
def seek_reader[R: Seeker](reader: &mut BufReader[R], target: SeekFrom) -> Result[i64, StreamError]
class BufWriter[W]
    inner: W
    def capacity(self) -> i64
    def pending(self) -> i64
    def write(self: &mut BufWriter[W], source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut BufWriter[W]) -> Result[(), StreamError]
def buffered_writer[W](inner: W, capacity: Positive[i64]) -> Result[BufWriter[W], StreamError]
def seek_writer[W: Seeker](writer: &mut BufWriter[W], target: SeekFrom) -> Result[i64, StreamError]
def close_buffered[W: Closer](writer: &mut BufWriter[W]) -> Result[(), CloseError]
class Cursor
    data: Bytes
    def position(self) -> i64
    def remaining(self) -> i64
    def require_end(self) -> Result[(), BinaryError]
    def read_bytes(self: &mut Cursor, count: i64, max_bytes: i64 = 1048576) -> Result[Bytes, BinaryError]
    def write_bytes(self: &mut Cursor, source: &[u8], max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_u8(self: &mut Cursor) -> Result[u8, BinaryError]
    def write_u8(self: &mut Cursor, value: u8, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_i8(self: &mut Cursor) -> Result[i8, BinaryError]
    def write_i8(self: &mut Cursor, value: i8, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_u16(self: &mut Cursor, order: Endian) -> Result[u16, BinaryError]
    def write_u16(self: &mut Cursor, value: u16, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_i16(self: &mut Cursor, order: Endian) -> Result[i16, BinaryError]
    def write_i16(self: &mut Cursor, value: i16, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_u32(self: &mut Cursor, order: Endian) -> Result[u32, BinaryError]
    def write_u32(self: &mut Cursor, value: u32, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_i32(self: &mut Cursor, order: Endian) -> Result[i32, BinaryError]
    def write_i32(self: &mut Cursor, value: i32, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_u64(self: &mut Cursor, order: Endian) -> Result[u64, BinaryError]
    def write_u64(self: &mut Cursor, value: u64, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_i64(self: &mut Cursor, order: Endian) -> Result[i64, BinaryError]
    def write_i64(self: &mut Cursor, value: i64, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_f32(self: &mut Cursor, order: Endian) -> Result[f32, BinaryError]
    def write_f32(self: &mut Cursor, value: f32, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read_f64(self: &mut Cursor, order: Endian) -> Result[f64, BinaryError]
    def write_f64(self: &mut Cursor, value: f64, order: Endian, max_bytes: i64 = 1048576) -> Result[(), BinaryError]
    def read(self: &mut Cursor, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def write(self: &mut Cursor, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut Cursor) -> Result[(), StreamError]
    def seek(self: &mut Cursor, target: SeekFrom) -> Result[i64, StreamError]
def cursor(data: Bytes) -> Cursor
class FileStream
    file: File
    def read(self: &mut FileStream, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def write(self: &mut FileStream, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut FileStream) -> Result[(), StreamError]
    def sync(self: &mut FileStream) -> Result[(), StreamError]
    def seek(self: &mut FileStream, target: SeekFrom) -> Result[i64, StreamError]
    def close(self: &mut FileStream) -> Result[(), StreamError]
def open_file(path: &str, mode: &str) -> Result[FileStream, StreamError]
def open_path(path: &Path, mode: &str) -> Result[FileStream, StreamError]
def from_file(file: File) -> FileStream
class Stdin
    def is_terminal(self) -> bool
    def read(self: &mut Stdin, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
class Stdout
    def is_terminal(self) -> bool
    def write(self: &mut Stdout, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut Stdout) -> Result[(), StreamError]
class Stderr
    def is_terminal(self) -> bool
    def write(self: &mut Stderr, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut Stderr) -> Result[(), StreamError]
def stdin() -> Stdin
def stdout() -> Stdout
def stderr() -> Stderr

std.io.typed

Byte stream protocols that carry a caller-chosen error type, buffering, adapters for std.io streams, and exact read, write, and copy helpers. Errors: StepError[E], Partial[E], CopyFailure[R, W]. Reference.

enum StepError[E]
    Interrupted | Source(E)
class LegacyReader[R]
    def read(self: &mut LegacyReader[R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[StreamError]]
def reader[R: std.io.Reader](inner: R) -> LegacyReader[R]
def unwrap_reader[R](reader: LegacyReader[R]) -> R
class LegacyWriter[W]
    def write(self: &mut LegacyWriter[W], buffer: &[u8]) -> Result[i64, StepError[StreamError]]
def writer[W: std.io.Writer](inner: W) -> LegacyWriter[W]
def unwrap_writer[W](writer: LegacyWriter[W]) -> W
protocol Reader[E]
    def read(self: &mut Reader[E], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[E]]
protocol Writer[E]
    def write(self: &mut Writer[E], buffer: &[u8]) -> Result[i64, StepError[E]]
enum ReadFailure[E]
    Source(E) | UnexpectedEof | InvalidProgress | OutOfRange
class BufReader[E, R]
    inner: R
    def capacity(self) -> i64
    def buffered(self) -> i64
    def read(self: &mut BufReader[E, R], buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StepError[ReadFailure[E]]]
def buffered_reader[E, R: Reader[E]](inner: R, capacity: Positive[i64]) -> Result[BufReader[E, R], StreamError]
enum WriteFailure[E]
    Source(E) | WriteZero | InvalidProgress
class Partial[E]
    completed: i64
    cause: E
enum CopyFailure[R, W]
    Read(i64, ReadFailure[R]) | Write(i64, WriteFailure[W])
def within(start: i64, stop: i64, size: i64) -> bool
def read_exact[E, R: Reader[E]](reader: &mut R, buffer: &mut Bytes, start: i64, stop: i64) -> Result[(), Partial[ReadFailure[E]]]
def write_all[E, W: Writer[E]](writer: &mut W, buffer: &[u8]) -> Result[(), Partial[WriteFailure[E]]]
def copy_all[E, G, R: Reader[E], W: Writer[G]](reader: &mut R, writer: &mut W, scratch: &mut Bytes) -> Result[i64, CopyFailure[E, G]]

std.json

Strict JSON under depth, input, and output limits: resumable event decoder, validating encoder, and a value tree. Errors: JsonError. Reference.

enum JsonFault
    UnexpectedByte | UnexpectedEnd | TrailingData | InvalidLiteral | InvalidNumber | NumberOutOfRange | InvalidEscape | InvalidSurrogate | ControlCharacter | InvalidUtf8 | DuplicateKey | DepthExceeded | InputTooLarge | OutputTooLarge | NonFiniteNumber | InvalidState | Stream(StreamError) | Allocation(AllocError)
class JsonError
    fault: JsonFault
    offset: i64
    line: i64
    column: i64
enum DuplicateKeys
    Reject | Keep
class Limits
    max_depth: NonNegative[i64]
    max_input: NonNegative[i64]
    max_output: NonNegative[i64]
    duplicate_keys: DuplicateKeys
enum Json
    Null | Bool(bool) | Int(i64) | Float(f64) | Text(str) | Array(list[Json]) | Object(list[Member])
class Member
    key: str
    value: Json
enum Event
    Pending | End | Null | Bool(bool) | Number(str) | Text(str) | Key(str) | StartArray | EndArray | StartObject | EndObject
def limits() -> Limits
class Decoder
    def offset(self) -> i64
    def depth(self) -> i64
    def reject(self, fault: JsonFault) -> JsonError
    def feed(self: &mut Decoder, source: &[u8]) -> Result[(), JsonError]
    def finish(self: &mut Decoder) -> ()
    def next(self: &mut Decoder) -> Result[Event, JsonError]
def decoder(bounds: &Limits) -> Result[Decoder, JsonError]
def read_event[R: Reader](source: &mut Decoder, reader: &mut R) -> Result[Event, JsonError]
def parse(source: &[u8], bounds: &Limits) -> Result[Json, JsonError]
def parse_text(text: &str, bounds: &Limits) -> Result[Json, JsonError]
def read_value[R: Reader](reader: &mut R, bounds: &Limits) -> Result[Json, JsonError]
def find(members: &list[Member], key: &str) -> Option[i64]
class Encoder
    def pending(self) -> i64
    def written(self) -> i64
    def is_complete(self) -> bool
    def null(self: &mut Encoder) -> Result[(), JsonError]
    def boolean(self: &mut Encoder, value: bool) -> Result[(), JsonError]
    def integer(self: &mut Encoder, value: i64) -> Result[(), JsonError]
    def unsigned(self: &mut Encoder, value: u64) -> Result[(), JsonError]
    def decimal(self: &mut Encoder, value: f64) -> Result[(), JsonError]
    def number(self: &mut Encoder, text: &str) -> Result[(), JsonError]
    def text(self: &mut Encoder, value: &str) -> Result[(), JsonError]
    def key(self: &mut Encoder, name: &str) -> Result[(), JsonError]
    def start_array(self: &mut Encoder) -> Result[(), JsonError]
    def end_array(self: &mut Encoder) -> Result[(), JsonError]
    def start_object(self: &mut Encoder) -> Result[(), JsonError]
    def end_object(self: &mut Encoder) -> Result[(), JsonError]
    def event(self: &mut Encoder, event: &Event) -> Result[(), JsonError]
    def value(self: &mut Encoder, value: &Json) -> Result[(), JsonError]
    def take(self: &mut Encoder) -> Result[Bytes, JsonError]
def encoder(bounds: &Limits) -> Result[Encoder, JsonError]
def write_pending[W: Writer](source: &mut Encoder, writer: &mut W) -> Result[(), JsonError]
def encode(value: &Json, bounds: &Limits) -> Result[Bytes, JsonError]
def encode_text(value: &Json, bounds: &Limits) -> Result[str, JsonError]
def write_value[W: Writer](writer: &mut W, value: &Json, bounds: &Limits) -> Result[(), JsonError]

std.jwt

JSON Web Tokens: compact JWS signing and verification with the algorithm fixed by the key, strict decoding, and explicit-clock claim checks. Errors: JwtError. Reference.

enum Algorithm
    Hs256 | Hs512 | Rs256 | Rs384 | Rs512 | Ps256 | Ps384 | Ps512 | Es256 | EdDsa
    def name(self) -> str
enum Claim
    Expiry | NotBefore | IssuedAt | Issuer | Audience
enum JwtError
    Malformed | NotObject | TooLarge | UnsupportedAlgorithm | AlgorithmMismatch | CriticalHeader | InvalidSignature | Expired | NotYetValid | MissingClaim(Claim) | InvalidClaim(Claim) | WrongIssuer | WrongAudience | InvalidKey | InvalidValidation | RandomFailure | Allocation(AllocError)
    def format[W](self, output: &mut Formatter[W]) -> Result[(), FormatError]
class SigningKey
    def algorithm(self) -> Algorithm
    def verifying_key(self) -> Result[VerifyingKey, JwtError]
class VerifyingKey
    def algorithm(self) -> Algorithm
def hmac_signing_key(algorithm: Algorithm, secret: &[u8]) -> Result[SigningKey, JwtError]
def hmac_verifying_key(algorithm: Algorithm, secret: &[u8]) -> Result[VerifyingKey, JwtError]
def rsa_signing_key(algorithm: Algorithm, key: RsaPrivateKey) -> Result[SigningKey, JwtError]
def rsa_verifying_key(algorithm: Algorithm, key: RsaPublicKey) -> Result[VerifyingKey, JwtError]
def es256_signing_key(key: P256PrivateKey) -> SigningKey
def es256_verifying_key(key: P256PublicKey) -> VerifyingKey
def ed25519_signing_key(seed: &[u8]) -> Result[SigningKey, JwtError]
def ed25519_verifying_key(public_key: &[u8]) -> Result[VerifyingKey, JwtError]
const default_max_size: i64 = 8192
const max_leeway: i64 = 86400
const max_token_size: i64 = 1048576
class Validation
    now: Timestamp
    leeway: Duration
    require_expiry: bool
    issuer: Option[str]
    audience: Option[str]
    max_size: Positive[i64]
def validation(now: &Timestamp) -> Validation
class Header
    algorithm: Algorithm
    key_id: Option[str]
    token_type: Option[str]
class Token
    header: Header
    claims: list[Member]
def decode_header(token: &str, max_size: Positive[i64] = 8192) -> Result[Header, JwtError]
def verify(token: &str, key: &VerifyingKey, rules: &Validation) -> Result[Token, JwtError]
def sign(key: &SigningKey, claims: &Json, key_id: Option[str] = Nothing) -> Result[str, JwtError]

std.log

Leveled events with typed fields, delivered to caller-chosen sinks: logfmt lines, bounded memory, or a nonblocking channel. Errors: LogError. Reference.

enum LogError
    InvalidSpec | InvalidKey | UnknownLevel | TooLarge | Full | Closed | Format(FormatError) | Output(StreamError) | Allocation(AllocError)
enum Level
    Trace | Debug | Info | Warn | Error
def level_name(level: &Level) -> str
def parse_level(name: &str) -> Result[Level, LogError]
enum Value
    Text(str) | Integer(i64) | Unsigned(u64) | Floating(f64) | Boolean(bool)
class Field
    key: str
    value: Value
def text(key: str, value: str) -> Field
def integer(key: str, value: i64) -> Field
def unsigned(key: str, value: u64) -> Field
def floating(key: str, value: f64) -> Field
def boolean(key: str, value: bool) -> Field
class Event
    level: Level
    message: str
    fields: list[Field]
    time: Option[Timestamp]
def event(level: Level, message: str, fields: list[Field]) -> Event
protocol Sink
    def emit(self: &mut Sink, event: Event) -> Result[(), LogError]
enum Clock
    Off | Wall | Fixed(Timestamp)
class Logger[S]
    sink: S
    def enabled(self, level: &Level) -> bool
    def emitted(self) -> u64
    def filtered(self) -> u64
    def failed(self) -> u64
    def emit(self: &mut Logger[S], event: Event) -> Result[(), LogError]
    def log(self: &mut Logger[S], level: Level, message: str, fields: list[Field]) -> Result[(), LogError]
    def debug(self: &mut Logger[S], message: str, fields: list[Field]) -> Result[(), LogError]
    def info(self: &mut Logger[S], message: str, fields: list[Field]) -> Result[(), LogError]
    def warn(self: &mut Logger[S], message: str, fields: list[Field]) -> Result[(), LogError]
    def error(self: &mut Logger[S], message: str, fields: list[Field]) -> Result[(), LogError]
def logger[S: Sink](sink: S, threshold: Level, clock: Clock) -> Logger[S]
class LineBuffer
    data: Bytes
    def write(self: &mut LineBuffer, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut LineBuffer) -> Result[(), StreamError]
class TextSink[W]
    writer: W
    def emit(self: &mut TextSink[W], event: Event) -> Result[(), LogError]
def text_sink[W: Writer](writer: W, max_line: Positive[i64]) -> Result[TextSink[W], LogError]
class MemorySink
    events: list[Event]
    def emit(self: &mut MemorySink, event: Event) -> Result[(), LogError]
def memory_sink(capacity: NonNegative[i64]) -> Result[MemorySink, LogError]
class Discard
    def emit(self: &mut Discard, event: Event) -> Result[(), LogError]
def discard() -> Discard
class ChannelSink
    def share(self) -> ChannelSink
    def emit(self: &mut ChannelSink, event: Event) -> Result[(), LogError]
def channel_sink(sender: Sender[Event]) -> ChannelSink
class Drained
    delivered: u64
    failed: u64
def drain[S: Sink](receiver: &Receiver[Event], sink: &mut S) -> Drained

std.markdown

CommonMark 0.31.2 parsing into events and HTML rendering, under input, depth, and output limits. Errors: MarkdownError. Reference.

enum MarkdownFault
    InvalidUtf8 | InputTooLarge | OutputTooLarge | DepthExceeded | InvalidState | Stream(StreamError) | Allocation(AllocError)
class MarkdownError
    fault: MarkdownFault
    offset: i64
    line: i64
class Limits
    max_input: NonNegative[i64]
    max_depth: NonNegative[i64]
    max_output: NonNegative[i64]
enum Tag
    Paragraph | Heading(i64) | BlockQuote | CodeBlock(str) | BulletList | OrderedList(i64) | Item | Emphasis | Strong | Link(str, str) | Image(str, str)
enum Event
    Start(Tag) | End(Tag) | Text(str) | Code(str) | Html(str) | InlineHtml(str) | SoftBreak | HardBreak | Rule | Done
def limits() -> Limits
class Parser
    def next(self: &mut Parser) -> Result[Event, MarkdownError]
def parser(source: &[u8], bounds: &Limits) -> Result[Parser, MarkdownError]
def parser_text(text: &str, bounds: &Limits) -> Result[Parser, MarkdownError]
class HtmlRenderer
    def pending(self) -> i64
    def written(self) -> i64
    def event(self: &mut HtmlRenderer, event: &Event) -> Result[(), MarkdownError]
    def take(self: &mut HtmlRenderer) -> Result[Bytes, MarkdownError]
def renderer(bounds: &Limits) -> Result[HtmlRenderer, MarkdownError]
def write_pending[W: Writer](source: &mut HtmlRenderer, writer: &mut W) -> Result[(), MarkdownError]
def write_html[W: Writer](source: &mut Parser, writer: &mut W, bounds: &Limits) -> Result[(), MarkdownError]
def render(source: &[u8], bounds: &Limits) -> Result[Bytes, MarkdownError]
def to_html(text: &str, bounds: &Limits) -> Result[str, MarkdownError]

std.template

Bounded Jinja-style text templates with explicit JSON values, HTML escaping, conditions, loops and named inheritance. Errors: TemplateError. Reference.

enum TemplateError
    LimitExceeded | Syntax(i64) | UnknownTemplate(str) | DuplicateTemplate(str) | MissingValue(str) | TypeMismatch | InheritanceCycle | Allocation(AllocError) | Bytes(BytesError)
enum HtmlContext
    Text | DoubleQuotedAttribute | SingleQuotedAttribute | TextAndAttributes
class Limits
    max_source: NonNegative[i64]
    max_tokens: NonNegative[i64]
    max_templates: NonNegative[i64]
    max_context_nodes: Positive[i64]
    max_context_bytes: NonNegative[i64]
    max_depth: Positive[i64]
    max_steps: NonNegative[i64]
    max_output: NonNegative[i64]
def limits() -> Limits
def escape(text: &str, context: HtmlContext, max_bytes: NonNegative[i64] = 16777216) -> Result[str, TemplateError]
class Engine
    def add(self: &mut Engine, name: &str, source: &str) -> Result[(), TemplateError]
    def render(self, name: &str, context: &Json, html: bool = True) -> Result[str, TemplateError]
def engine(bounds: &Limits) -> Result[Engine, TemplateError]

std.math

Floating-point functions, checked rounding, integer algorithms, integer and float helpers, and constants. Errors: MathError, OverflowError[T]. Reference.

enum MathError
    Domain | Overflow
const pi: f64 = f64.PI
const e: f64 = f64.E
const tau: f64 = f64.TAU
const inf: f64 = f64.INF
const nan: f64 = f64.NAN
def isnan(x: f64) -> bool
def isinf(x: f64) -> bool
def isfinite(x: f64) -> bool
def fabs(x: f64) -> f64
def copysign(x: f64, y: f64) -> f64
def isclose(a: f64, b: f64, rel_tol: f64, abs_tol: f64) -> Result[bool, MathError]
def degrees(x: f64) -> f64
def radians(x: f64) -> f64
def sqrt(x: f64) -> Result[f64, MathError]
def exp(x: f64) -> Result[f64, MathError]
def exp2(x: f64) -> Result[f64, MathError]
def expm1(x: f64) -> Result[f64, MathError]
def log(x: f64) -> Result[f64, MathError]
def log2(x: f64) -> Result[f64, MathError]
def log10(x: f64) -> Result[f64, MathError]
def log1p(x: f64) -> Result[f64, MathError]
def log_base(x: f64, base: f64) -> Result[f64, MathError]
def sin(x: f64) -> Result[f64, MathError]
def cos(x: f64) -> Result[f64, MathError]
def tan(x: f64) -> Result[f64, MathError]
def asin(x: f64) -> Result[f64, MathError]
def acos(x: f64) -> Result[f64, MathError]
def atan(x: f64) -> Result[f64, MathError]
def atan2(y: f64, x: f64) -> Result[f64, MathError]
def sinh(x: f64) -> Result[f64, MathError]
def cosh(x: f64) -> Result[f64, MathError]
def tanh(x: f64) -> Result[f64, MathError]
def asinh(x: f64) -> Result[f64, MathError]
def acosh(x: f64) -> Result[f64, MathError]
def atanh(x: f64) -> Result[f64, MathError]
def cbrt(x: f64) -> Result[f64, MathError]
def pow(x: f64, y: f64) -> Result[f64, MathError]
def fmod(x: f64, y: f64) -> Result[f64, MathError]
def floor(x: f64) -> Result[i64, MathError]
def ceil(x: f64) -> Result[i64, MathError]
def trunc(x: f64) -> Result[i64, MathError]
def round(x: f64) -> Result[i64, MathError]
def divmod[T: IntType](a: T, b: T) -> Result[(T, T), MathError]
def divmod_float(a: f64, b: f64) -> Result[(f64, f64), MathError]
def factorial(n: NonNegative[i64]) -> Result[u64, MathError]
def gcd(a: u64, b: u64) -> u64
def lcm(a: u64, b: u64) -> Result[u64, MathError]
def isqrt(n: u64) -> u64
def perm(n: u64, k: u64) -> Result[u64, MathError]
def comb(n: u64, k: u64) -> Result[u64, MathError]
def abs[T: IntType](x: T) -> Result[T, OverflowError[T]]
def abs_float[T: FloatType](x: T) -> T
def min[T](a: T, b: T) -> T
def max[T](a: T, b: T) -> T
def min_all[T](items: &list[T]) -> Option[T]
def max_all[T](items: &list[T]) -> Option[T]
def sum[T: IntType](items: &list[T], start: T) -> Result[T, OverflowError[T]]
def prod[T: IntType](items: &list[T], start: T) -> Result[T, OverflowError[T]]
def sum_iter[I, T: IntType](items: &I, start: T) -> Result[T, OverflowError[T]]
def prod_iter[I, T: IntType](items: &I, start: T) -> Result[T, OverflowError[T]]
def sum_float[T: FloatType](items: &list[T], start: T) -> T
def prod_float[T: FloatType](items: &list[T], start: T) -> T
def sum_iter_float[I, T: FloatType](items: &I, start: T) -> T
def prod_iter_float[I, T: FloatType](items: &I, start: T) -> T

std.mime

Media types: RFC 9110 parsing and formatting with parameters, media-range matching, and the file-extension table. Errors: ParseError, AllocError. Reference.

enum MimeError
    Invalid | Allocation(AllocError)
class Param
    name: str
    value: str
class MediaType
    def type_name(self) -> &str
    def subtype(self) -> &str
    def params(self) -> &list[Param]
    def param(self, name: &str) -> Option[str]
    def suffix(self) -> Result[Option[str], AllocError]
    def essence(self) -> Result[str, AllocError]
    def is_wildcard(self) -> bool
    def matches(self, pattern: &MediaType) -> bool
    def set_param(self: &mut MediaType, name: &str, value: &str) -> Result[(), MimeError]
    def remove_param(self: &mut MediaType, name: &str) -> bool
    def to_string(self) -> Result[str, AllocError]
def parse(text: &str) -> Result[MediaType, MimeError]
def new(type_name: &str, subtype: &str) -> Result[MediaType, MimeError]
def from_extension(extension: &str) -> Option[str]
def from_file_name(name: &str) -> str

std.net

TCP listeners and streams, UDP sockets, IP addresses and name lookup, with deadlines and cancellation. Errors: NetError. Reference.

enum NetError
    TimedOut | ConnectionTimedOut | WouldBlock | Cancelled | Refused | Reset | AddressInUse | AddressUnavailable | Unreachable | NameNotFound | TryAgain | InvalidAddress | HandleLimit | Stream(StreamError)
enum IpAddress
    V4(u32) | V6(u64, u64)
class SocketAddress
    ip: IpAddress
    port: u16
    scope: u32
    def to_string(self) -> Result[str, NetError]
def socket_address(ip: IpAddress, port: u16) -> SocketAddress
def ipv4(a: u8, b: u8, c: u8, d: u8) -> IpAddress
def loopback_v4(port: u16) -> SocketAddress
def loopback_v6(port: u16) -> SocketAddress
def any_v4(port: u16) -> SocketAddress
def any_v6(port: u16) -> SocketAddress
def format_ip(ip: IpAddress) -> Result[str, NetError]
def parse_ip(text: &str) -> Result[IpAddress, NetError]
def parse_address(text: &str) -> Result[SocketAddress, NetError]
def resolve(host: &str, port: u16, deadline: &Deadline, cancel: &CancellationToken) -> Result[list[SocketAddress], NetError]
class Lookup
    def descriptor(self) -> &File
    def watch(self, selector: &mut Selector, key: u64) -> Result[(), NetError]
    def unwatch(self, selector: &mut Selector) -> Result[(), NetError]
    def finish_now(self: &mut Lookup) -> Result[list[SocketAddress], NetError]
def start_lookup(host: &str, port: u16) -> Result[Lookup, NetError]
enum Shutdown
    Read | Write | Both
class TcpStream
    def read(self: &mut TcpStream, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def write(self: &mut TcpStream, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut TcpStream) -> Result[(), StreamError]
    def close(self: &mut TcpStream) -> Result[(), StreamError]
    def read_now(self: &mut TcpStream, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, NetError]
    def write_now(self: &mut TcpStream, source: &[u8]) -> Result[i64, NetError]
    def read_before(self: &mut TcpStream, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, NetError]
    def write_before(self: &mut TcpStream, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, NetError]
    def write_all_before(self: &mut TcpStream, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[(), NetError]
    def local_address(self) -> Result[SocketAddress, NetError]
    def peer_address(self) -> Result[SocketAddress, NetError]
    def shutdown(self: &mut TcpStream, direction: Shutdown) -> Result[(), NetError]
    def descriptor(self) -> &File
    def watch(self, selector: &mut Selector, key: u64, interest: Interest) -> Result[(), NetError]
    def unwatch(self, selector: &mut Selector) -> Result[(), NetError]
    def set_no_delay(self: &mut TcpStream, enabled: bool) -> Result[(), NetError]
    def acknowledge_now(self: &mut TcpStream) -> Result[(), NetError]
class TcpListener
    def local_address(self) -> Result[SocketAddress, NetError]
    def descriptor(self) -> &File
    def watch(self, selector: &mut Selector, key: u64) -> Result[(), NetError]
    def unwatch(self, selector: &mut Selector) -> Result[(), NetError]
    def accept_now(self) -> Result[TcpStream, NetError]
    def accept(self, deadline: &Deadline, cancel: &CancellationToken) -> Result[TcpStream, NetError]
    def close(self: &mut TcpListener) -> Result[(), NetError]
def listen(address: &SocketAddress, backlog: i64) -> Result[TcpListener, NetError]
def connect(address: &SocketAddress, deadline: &Deadline, cancel: &CancellationToken) -> Result[TcpStream, NetError]
class Connecting
    def descriptor(self) -> &File
    def watch(self, selector: &mut Selector, key: u64) -> Result[(), NetError]
    def unwatch(self, selector: &mut Selector) -> Result[(), NetError]
    def finish_now(self: &mut Connecting) -> Result[(), NetError]
    def stream(self: Connecting) -> TcpStream
def start_connect(address: &SocketAddress) -> Result[Connecting, NetError]
class Datagram
    size: i64
    stored: i64
    source: SocketAddress
    def truncated(self) -> bool
class UdpSocket
    def local_address(self) -> Result[SocketAddress, NetError]
    def descriptor(self) -> &File
    def watch(self, selector: &mut Selector, key: u64, interest: Interest) -> Result[(), NetError]
    def unwatch(self, selector: &mut Selector) -> Result[(), NetError]
    def set_broadcast(self: &mut UdpSocket, enabled: bool) -> Result[(), NetError]
    def send_to(self: &mut UdpSocket, source: &[u8], target: &SocketAddress, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, NetError]
    def receive_from(self: &mut UdpSocket, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[Datagram, NetError]
    def close(self: &mut UdpSocket) -> Result[(), NetError]
def bind_udp(address: &SocketAddress) -> Result[UdpSocket, NetError]

std.path

Lossless Linux paths, lexical operations, checked text conversion and escaped display. Errors: IoError, AllocError. Reference.

class Path
    def as_bytes(self) -> &list[u8]
    def to_text(self) -> Result[str, IoError]
    def to_string(self) -> Result[str, IoError]
    def copy(self) -> Result[Path, AllocError]
    def join(self, child: &Path) -> Result[Path, IoError]
    def is_absolute(self) -> bool
    def parent(self) -> Result[Option[Path], IoError]
    def file_name(self) -> Result[Option[Path], IoError]
    def components(self) -> Result[list[list[u8]], IoError]
def from_bytes(bytes: list[u8]) -> Path
def from_text(text: &str) -> Result[Path, IoError]

std.process

Children spawned from an argument vector with no implicit shell, piped streams, bounded output collection, signals, and explicit reaping. Errors: IoError, StreamError. Reference.

enum Stdio
    Inherit | Null | Piped
class ExitStatus
    def success(self) -> bool
    def code(self) -> Option[i32]
    def signal(self) -> Option[i32]
class Output
    status: ExitStatus
    stdout: Bytes
    stderr: Bytes
class Command
    def arg_bytes(self: &mut Command, value: &list[u8]) -> Result[(), IoError]
    def arg(self: &mut Command, value: &str) -> Result[(), IoError]
    def arg_path(self: &mut Command, value: &Path) -> Result[(), IoError]
    def env_bytes(self: &mut Command, name: &list[u8], value: &list[u8]) -> Result[(), IoError]
    def env(self: &mut Command, name: &str, value: &str) -> Result[(), IoError]
    def env_remove_bytes(self: &mut Command, name: &list[u8]) -> Result[(), IoError]
    def env_remove(self: &mut Command, name: &str) -> Result[(), IoError]
    def env_clear(self: &mut Command) -> ()
    def current_dir(self: &mut Command, path: &Path) -> Result[(), IoError]
    def stdin(self: &mut Command, mode: Stdio) -> ()
    def stdout(self: &mut Command, mode: Stdio) -> ()
    def stderr(self: &mut Command, mode: Stdio) -> ()
    def spawn(self) -> Result[Child, IoError]
def command_bytes(program: &list[u8]) -> Result[Command, IoError]
def command(program: &str) -> Result[Command, IoError]
def shell(script: &str) -> Result[Command, IoError]
class Child
    def id(self) -> i64
    def take_stdin(self: &mut Child) -> Option[File]
    def take_stdout(self: &mut Child) -> Option[File]
    def take_stderr(self: &mut Child) -> Option[File]
    def close_stdin(self: &mut Child) -> Result[(), IoError]
    def wait(self: &mut Child) -> Result[ExitStatus, IoError]
    def try_wait(self: &mut Child) -> Result[Option[ExitStatus], IoError]
    def wait_timeout(self: &mut Child, budget: &Duration, cancel: &CancellationToken) -> Result[Option[ExitStatus], WaitError]
    def wait_before(self: &mut Child, deadline: &Deadline, cancel: &CancellationToken) -> Result[Option[ExitStatus], WaitError]
    def signal(self, number: i32) -> Result[(), IoError]
    def terminate(self) -> Result[(), IoError]
    def kill(self) -> Result[(), IoError]
    def communicate(self: &mut Child, input: &[u8], limit: NonNegative[i64]) -> Result[Output, StreamError]
    def output(self: &mut Child, limit: NonNegative[i64]) -> Result[Output, StreamError]
enum WaitError
    Io(IoError) | Cancelled

std.random

Caller-owned seeded generators with unbiased ranges, shuffling, and index sampling; not for secrets. Errors: RandomError. Reference.

enum RandomError
    EmptyRange | ZeroState
class Rng
    def next_u64(self: &mut Rng) -> u64
    def next_u32(self: &mut Rng) -> u32
    def next_bool(self: &mut Rng) -> bool
    def next_f64(self: &mut Rng) -> f64
    def below(self: &mut Rng, bound: u64) -> Result[u64, RandomError]
    def between(self: &mut Rng, low: i64, high: i64) -> Result[i64, RandomError]
    def index(self: &mut Rng, count: i64) -> Result[i64, RandomError]
    def shuffle[T](self: &mut Rng, items: &mut list[T]) -> ()
    def sample_indices(self: &mut Rng, count: i64, amount: i64) -> Result[list[i64], AllocError]
    def fill(self: &mut Rng, target: &mut Bytes, start: i64, stop: i64) -> ()
    def state(self) -> (u64, u64, u64, u64)
def seeded(seed: u64) -> Rng
def from_state(a: u64, b: u64, c: u64, d: u64) -> Result[Rng, RandomError]

std.ready

Readiness waits on pipes and other handles, bounded by a deadline and a cancellation token. Errors: WaitError. Reference.

enum Interest
    Read | Write | ReadWrite
class Readiness
    readable: bool
    writable: bool
    hangup: bool
    error: bool
enum WaitError
    TimedOut | Cancelled | Stream(StreamError)
def wait_now(file: &File, interest: Interest) -> Result[Readiness, WaitError]
def wait_until(file: &File, interest: Interest, deadline: &Deadline, cancel: &CancellationToken) -> Result[Readiness, WaitError]
def wait(file: &File, interest: Interest, deadline: &Deadline, cancel: &CancellationToken) -> Result[Readiness, WaitError]
def read_before(stream: &mut FileStream, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, WaitError]
def write_before(stream: &mut FileStream, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, WaitError]
protocol Watchable
    def descriptor(self) -> &File
class Event
    key: u64
    readiness: Readiness
class Selector
    def watch(self: &mut Selector, file: &File, key: u64, interest: Interest) -> Result[(), WaitError]
    def unwatch(self: &mut Selector, file: &File) -> Result[(), WaitError]
    def wait(self: &mut Selector, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, WaitError]
    def event(self, index: i64) -> Result[Event, WaitError]
    def close(self: &mut Selector) -> Result[(), WaitError]
def selector(capacity: i64) -> Result[Selector, WaitError]

std.regex

Linear-time regular expressions over text and bytes: search, captures, iteration, split, and replacement under explicit pattern, memory, and work limits. Errors: RegexError. Reference.

enum Limit
    PatternBytes | Nesting | Repetition | Instructions | Memory | Work | Output | Matches
class SyntaxError
    offset: i64
    message: str
enum RegexError
    Syntax(SyntaxError) | LimitExceeded(Limit) | OutOfRange | Allocation(AllocError)
class Limits
    max_pattern_bytes: NonNegative[i64]
    max_nesting: NonNegative[i64]
    max_repeat: NonNegative[i64]
    max_instructions: NonNegative[i64]
    max_memory: NonNegative[i64]
    max_work: NonNegative[i64]
def limits() -> Limits
class Match
    start: i64
    end: i64
    def len(self) -> Result[i64, OverflowError[i64]]
    def is_empty(self) -> bool
    def text(self, haystack: &str) -> Result[str, RegexError]
    def bytes(self, data: &[u8]) -> Result[Bytes, RegexError]
class Captures
    def len(self) -> i64
    def get(self, index: i64) -> Option[Match]
    def name(self, name: &str) -> Option[Match]
class Cursor
class Regex
    def group_count(self) -> i64
    def group_index(self, name: &str) -> Option[i64]
    def instructions(self) -> i64
    def is_match(self, text: &str) -> Result[bool, RegexError]
    def is_match_bytes(self, data: &[u8]) -> Result[bool, RegexError]
    def find(self, text: &str) -> Result[Option[Match], RegexError]
    def find_at(self, text: &str, start: i64) -> Result[Option[Match], RegexError]
    def find_bytes(self, data: &[u8], start: i64) -> Result[Option[Match], RegexError]
    def captures(self, text: &str) -> Result[Option[Captures], RegexError]
    def captures_at(self, text: &str, start: i64) -> Result[Option[Captures], RegexError]
    def captures_bytes(self, data: &[u8], start: i64) -> Result[Option[Captures], RegexError]
    def cursor(self) -> Result[Cursor, RegexError]
    def next_match(self, text: &str, cursor: &mut Cursor) -> Result[Option[Match], RegexError]
    def next_match_bytes(self, data: &[u8], cursor: &mut Cursor) -> Result[Option[Match], RegexError]
    def find_all(self, text: &str, max_matches: i64) -> Result[list[Match], RegexError]
    def find_all_bytes(self, data: &[u8], max_matches: i64) -> Result[list[Match], RegexError]
    def split(self, text: &str, max_pieces: i64) -> Result[list[str], RegexError]
    def replace(self, text: &str, template: &str, max_bytes: i64) -> Result[str, RegexError]
    def replace_all(self, text: &str, template: &str, max_bytes: i64) -> Result[str, RegexError]
def compile(pattern: &str, bounds: &Limits) -> Result[Regex, RegexError]

std.report

Bounded human-readable report rendering with std.fmt. Errors: FormatError. Reference.

def render[T: Formattable, W](value: &T, output: &mut Formatter[W]) -> Result[(), FormatError]
def to_string[T: Formattable](value: &T, max_bytes: NonNegative[i64], max_depth: NonNegative[i64]) -> Result[str, FormatError]

std.secrets

Operating-system entropy: secret bytes, hex and base64url tokens, and unbiased integers, with no fallback source. Errors: SecretsError. Reference.

enum SecretsError
    OutOfRange | EmptyRange | Entropy(StreamError) | Allocation(AllocError)
class OsEntropy
    def read(self: &mut OsEntropy, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
def os_entropy() -> OsEntropy
class Source[R]
    inner: R
    def fill(self: &mut Source[R], target: &mut Bytes, start: i64, stop: i64) -> Result[(), SecretsError]
    def token_bytes(self: &mut Source[R], count: i64) -> Result[Bytes, SecretsError]
    def token_hex(self: &mut Source[R], count: i64) -> Result[str, SecretsError]
    def token_urlsafe(self: &mut Source[R], count: i64) -> Result[str, SecretsError]
    def next_u64(self: &mut Source[R]) -> Result[u64, SecretsError]
    def below(self: &mut Source[R], bound: u64) -> Result[u64, SecretsError]
def source_from[R: Reader](inner: R) -> Source[R]
def os() -> Source[OsEntropy]
def fill(target: &mut Bytes, start: i64, stop: i64) -> Result[(), SecretsError]
def token_bytes(count: i64) -> Result[Bytes, SecretsError]
def token_hex(count: i64) -> Result[str, SecretsError]
def token_urlsafe(count: i64) -> Result[str, SecretsError]
def random_u64() -> Result[u64, SecretsError]
def below(bound: u64) -> Result[u64, SecretsError]

std.shlex

Shell-style word splitting and POSIX argument quoting, without execution or expansion. Errors: ShlexError, AllocError. Reference.

enum ShlexError
    UnclosedQuote(i64) | TrailingEscape(i64) | Nul(i64) | Allocation(AllocError)
def split(text: &str, comments: bool = False) -> Result[list[str], ShlexError]
def quote(text: &str) -> Result[str, ShlexError]

std.sketch

Bounded distinct counts, sampled quantiles and frequent-item bounds with versioned checkpoints. Errors: SketchError, AllocError, BytesError. Reference.

enum SketchError
    InvalidArgument | InvalidData | Incompatible | Empty | Limit | ConstructionFailed | Allocation(AllocError)
def hash_u64(key: u64, seed: u64 = 0u64) -> u64
class HyperLogLog
    def precision(self) -> i64
    def add(self: &mut HyperLogLog, key: u64) -> ()
    def estimate(self) -> f64
    def relative_standard_error(self) -> f64
    def merge(self: &mut HyperLogLog, other: &HyperLogLog) -> Result[(), SketchError]
    def to_bytes(self) -> Result[Bytes, AllocError]
def hyperloglog(precision: i64 = 12, seed: u64 = 0u64) -> Result[HyperLogLog, SketchError]
def hyperloglog_from_bytes(data: &[u8], max_precision: i64 = 18) -> Result[HyperLogLog, SketchError]
class Quantiles
    def count(self) -> u64
    def retained(self) -> i64
    def add(self: &mut Quantiles, value: f64) -> Result[(), SketchError]
    def quantile(self, fraction: f64) -> Result[f64, SketchError]
    def to_bytes(self) -> Result[Bytes, AllocError]
def quantiles(capacity: Positive[i64] = 1024, seed: u64 = 0u64) -> Result[Quantiles, SketchError]
def quantiles_from_bytes(data: &[u8], max_capacity: Positive[i64] = 1048576) -> Result[Quantiles, SketchError]
class Frequency
    key: u64
    lower: u64
    upper: u64
class FrequentItems
    def count(self) -> u64
    def error_bound(self) -> u64
    def add(self: &mut FrequentItems, key: u64) -> Result[(), SketchError]
    def frequency(self, key: u64) -> Frequency
    def candidates(self) -> Result[list[Frequency], AllocError]
    def to_bytes(self) -> Result[Bytes, AllocError]
def frequent_items(capacity: Positive[i64] = 128) -> Result[FrequentItems, SketchError]
def frequent_items_from_bytes(data: &[u8], max_capacity: Positive[i64] = 65536) -> Result[FrequentItems, SketchError]

std.sketch.xor

Static approximate membership over numeric identities with bounded construction. Errors: SketchError, AllocError, BytesError. Reference.

class XorFilter
    def len(self) -> i64
    def contains(self, key: u64) -> bool
    def to_bytes(self) -> Result[Bytes, AllocError]
def build(keys: &list[u64], max_keys: NonNegative[i64], seed: u64 = 0u64) -> Result[XorFilter, SketchError]
def from_bytes(data: &[u8], max_keys: NonNegative[i64]) -> Result[XorFilter, SketchError]

std.sketch.cuckoo

Scalable approximate membership with bounded growth and receipt-directed deletion. Errors: SketchError, AllocError, BytesError. Reference.

class CuckooFilter
    def len(self) -> u64
    def layers(self) -> i64
    def buckets(self) -> i64
    def contains(self, key: u64) -> bool
    def insert(self: &mut CuckooFilter, key: u64) -> Result[i64, SketchError]
    def remove(self: &mut CuckooFilter, key: u64, layer_index: i64) -> Result[bool, SketchError]
    def to_bytes(self) -> Result[Bytes, AllocError]
def cuckoo(initial_buckets: i64 = 64, max_buckets: Positive[i64] = 1048576, seed: u64 = 0u64) -> Result[CuckooFilter, SketchError]
def from_bytes(data: &[u8], max_buckets: Positive[i64]) -> Result[CuckooFilter, SketchError]

std.signal

SIGTERM and SIGINT as an event to wait or select on, and a helper that cancels a token on one. Errors: SignalError, WaitError. Reference.

enum Signal
    Interrupt | Terminate
enum SignalError
    AlreadyListening | Stream(StreamError)
class Signals
    def wait(self: &mut Signals, deadline: &Deadline, cancel: &CancellationToken) -> Result[Signal, WaitError]
    def received(self: &mut Signals) -> Result[Option[Signal], WaitError]
    def watch(self, selector: &mut Selector, key: u64) -> Result[(), WaitError]
    def unwatch(self, selector: &mut Selector) -> Result[(), WaitError]
    def close(self: &mut Signals) -> Result[(), WaitError]
def listen() -> Result[Signals, SignalError]
def cancel_on(signals: Signals, stop: CancellationToken) -> Result[Option[Signal], WaitError]

std.simd

Portable fixed-lane values, masks, checked and wrapping arithmetic, selection, and bounded list loads/stores. Reference.

enum i32x4
    Lanes(i32, i32, i32, i32)
    def lane(self, index: i64) -> Option[i32]
    def to_tuple(self) -> (i32, i32, i32, i32)
    def add(self, other: &i32x4) -> Result[i32x4, OverflowError[i32]]
    def sub(self, other: &i32x4) -> Result[i32x4, OverflowError[i32]]
    def mul(self, other: &i32x4) -> Result[i32x4, OverflowError[i32]]
    def wrapping_add(self, other: &i32x4) -> i32x4
    def wrapping_sub(self, other: &i32x4) -> i32x4
    def wrapping_mul(self, other: &i32x4) -> i32x4
    def simd_eq(self, other: &i32x4) -> mask32x4
    def simd_ne(self, other: &i32x4) -> mask32x4
    def simd_lt(self, other: &i32x4) -> mask32x4
    def simd_le(self, other: &i32x4) -> mask32x4
    def simd_gt(self, other: &i32x4) -> mask32x4
    def simd_ge(self, other: &i32x4) -> mask32x4
    def wrapping_sum(self) -> i32
    def store(self, values: &mut list[i32], offset: i64) -> bool
def splat_i32x4(value: i32) -> i32x4
def load_i32x4(values: &list[i32], offset: i64 = 0) -> Option[i32x4]
enum u32x4
    Lanes(u32, u32, u32, u32)
    def lane(self, index: i64) -> Option[u32]
    def to_tuple(self) -> (u32, u32, u32, u32)
    def add(self, other: &u32x4) -> Result[u32x4, OverflowError[u32]]
    def sub(self, other: &u32x4) -> Result[u32x4, OverflowError[u32]]
    def mul(self, other: &u32x4) -> Result[u32x4, OverflowError[u32]]
    def wrapping_add(self, other: &u32x4) -> u32x4
    def wrapping_sub(self, other: &u32x4) -> u32x4
    def wrapping_mul(self, other: &u32x4) -> u32x4
    def simd_eq(self, other: &u32x4) -> mask32x4
    def simd_ne(self, other: &u32x4) -> mask32x4
    def simd_lt(self, other: &u32x4) -> mask32x4
    def simd_le(self, other: &u32x4) -> mask32x4
    def simd_gt(self, other: &u32x4) -> mask32x4
    def simd_ge(self, other: &u32x4) -> mask32x4
    def wrapping_sum(self) -> u32
    def store(self, values: &mut list[u32], offset: i64) -> bool
def splat_u32x4(value: u32) -> u32x4
def load_u32x4(values: &list[u32], offset: i64 = 0) -> Option[u32x4]
enum f32x4
    Lanes(f32, f32, f32, f32)
    def lane(self, index: i64) -> Option[f32]
    def to_tuple(self) -> (f32, f32, f32, f32)
    def add(self, other: &f32x4) -> f32x4
    def sub(self, other: &f32x4) -> f32x4
    def mul(self, other: &f32x4) -> f32x4
    def div(self, other: &f32x4) -> f32x4
    def simd_eq(self, other: &f32x4) -> mask32x4
    def simd_ne(self, other: &f32x4) -> mask32x4
    def simd_lt(self, other: &f32x4) -> mask32x4
    def simd_le(self, other: &f32x4) -> mask32x4
    def simd_gt(self, other: &f32x4) -> mask32x4
    def simd_ge(self, other: &f32x4) -> mask32x4
    def sum_ordered(self, initial: f32) -> f32
    def store(self, values: &mut list[f32], offset: i64) -> bool
def splat_f32x4(value: f32) -> f32x4
def load_f32x4(values: &list[f32], offset: i64 = 0) -> Option[f32x4]
enum f64x2
    Lanes(f64, f64)
    def lane(self, index: i64) -> Option[f64]
    def to_tuple(self) -> (f64, f64)
    def add(self, other: &f64x2) -> f64x2
    def sub(self, other: &f64x2) -> f64x2
    def mul(self, other: &f64x2) -> f64x2
    def div(self, other: &f64x2) -> f64x2
    def simd_eq(self, other: &f64x2) -> mask64x2
    def simd_ne(self, other: &f64x2) -> mask64x2
    def simd_lt(self, other: &f64x2) -> mask64x2
    def simd_le(self, other: &f64x2) -> mask64x2
    def simd_gt(self, other: &f64x2) -> mask64x2
    def simd_ge(self, other: &f64x2) -> mask64x2
    def sum_ordered(self, initial: f64) -> f64
    def store(self, values: &mut list[f64], offset: i64) -> bool
def splat_f64x2(value: f64) -> f64x2
def load_f64x2(values: &list[f64], offset: i64 = 0) -> Option[f64x2]
enum mask32x4
    Lanes(bool, bool, bool, bool)
    def any(self) -> bool
    def all(self) -> bool
    def count(self) -> i64
    def select[T](self, yes: &T, no: &T) -> T
    def invert(self) -> mask32x4
    def and_mask(self, other: &mask32x4) -> mask32x4
    def or_mask(self, other: &mask32x4) -> mask32x4
    def xor_mask(self, other: &mask32x4) -> mask32x4
enum mask64x2
    Lanes(bool, bool)
    def any(self) -> bool
    def all(self) -> bool
    def count(self) -> i64
    def select[T](self, yes: &T, no: &T) -> T
    def invert(self) -> mask64x2
    def and_mask(self, other: &mask64x2) -> mask64x2
    def or_mask(self, other: &mask64x2) -> mask64x2
    def xor_mask(self, other: &mask64x2) -> mask64x2

std.stat

Descriptive f64 statistics, inclusive quantiles, and normal, uniform and exponential distributions with explicit RNG sampling. Errors: StatError. Reference.

enum StatError
    Empty | InsufficientData | NonFinite | Domain | Overflow | Allocation(AllocError)
def mean(values: &list[f64]) -> Result[f64, StatError]
def pstdev(values: &list[f64]) -> Result[f64, StatError]
def stdev(values: &list[f64]) -> Result[f64, StatError]
def pvariance(values: &list[f64]) -> Result[f64, StatError]
def variance(values: &list[f64]) -> Result[f64, StatError]
def quantile(values: &list[f64], p: f64) -> Result[f64, StatError]
def median(values: &list[f64]) -> Result[f64, StatError]
def quantiles(values: &list[f64], n: Positive[i64] = 4) -> Result[list[f64], StatError]
class Uniform
    def pdf(self, x: f64) -> Result[f64, StatError]
    def cdf(self, x: f64) -> Result[f64, StatError]
    def inverse_cdf(self, p: f64) -> Result[f64, StatError]
    def sample(self, rng: &mut random.Rng) -> f64
def uniform(low: f64 = 0.0, high: f64 = 1.0) -> Result[Uniform, StatError]
class Exponential
    def pdf(self, x: f64) -> Result[f64, StatError]
    def cdf(self, x: f64) -> Result[f64, StatError]
    def inverse_cdf(self, p: f64) -> Result[f64, StatError]
    def sample(self, rng: &mut random.Rng) -> Result[f64, StatError]
def exponential(rate: f64 = 1.0) -> Result[Exponential, StatError]
class Normal
    def pdf(self, x: f64) -> Result[f64, StatError]
    def cdf(self, x: f64) -> Result[f64, StatError]
    def inverse_cdf(self, p: f64) -> Result[f64, StatError]
    def sample(self, rng: &mut random.Rng) -> Result[f64, StatError]
def normal(mean: f64 = 0.0, sigma: f64 = 1.0) -> Result[Normal, StatError]

std.plot

Layered charts from owned columns or record accessors, validated mappings, grouped statistics, and deterministic streaming SVG. Errors: PlotError. Reference.

enum PlotError
    Allocation(AllocError) | Write(i64, StreamError) | Io(StreamError) | UnknownColumn(str) | DuplicateColumn(str) | ShapeMismatch(str) | MissingAesthetic(str) | WrongKind(str) | Conflict(str) | InvalidSetting(str)
enum Column
    Num(list[f64]) | Int(list[i64]) | Text(list[str]) | Bool(list[bool]) | MaybeNum(list[Option[f64]]) | MaybeText(list[Option[str]])
class Table
    def share(self) -> Table
    def height(self) -> i64
    def names(self) -> Result[list[str], PlotError]
def table(values: list[(str, Column)]) -> Result[Table, PlotError]
def columns(values: &dict[str, list[f64]]) -> Result[Table, PlotError]
enum Field[T]
    Num(str, BoxedCallable[[&T], f64]) | Int(str, BoxedCallable[[&T], i64]) | Text(str, BoxedCallable[[&T], str]) | Bool(str, BoxedCallable[[&T], bool])
def num[T, F: Callable[[&T], f64]](name: str, read: F) -> Result[Field[T], PlotError]
def integer[T, F: Callable[[&T], i64]](name: str, read: F) -> Result[Field[T], PlotError]
def text[T, F: Callable[[&T], str]](name: str, read: F) -> Result[Field[T], PlotError]
def flag[T, F: Callable[[&T], bool]](name: str, read: F) -> Result[Field[T], PlotError]
def rows[T](values: &list[T], fields: list[Field[T]]) -> Result[Table, PlotError]
class Factor
def factor(name: str) -> Factor
class Mapping
def aes(x: str | Factor = "", y: str | Factor = "", colour: str | Factor = "", color: str | Factor = "", fill: str | Factor = "", group: str = "", ymin: str = "", ymax: str = "") -> Mapping
enum Position
    Identity | Stack | Dodge | Fill
def position_identity() -> Position
def position_stack() -> Position
def position_dodge() -> Position
def position_fill() -> Position
enum Units
    In | Cm | Mm | Px
enum Legend
    Right | Hidden
class Layer
class Labels
class Theme
enum Component
    Layer(Layer) | Labels(Labels) | Theme(Theme) | Cartesian(Option[(f64, f64)], Option[(f64, f64)]) | Flip | ColourScale(bool, ColourScale) | PositionScale(bool, PositionScale) | Facet(Facet)
enum Scales
    Fixed | Free | FreeX | FreeY
class Facet
def facet_wrap(facets: str, nrow: i64 = 0, ncol: i64 = 0, scales: Scales = Scales.Fixed) -> Component
def facet_grid(rows: str = "", cols: str = "", scales: Scales = Scales.Fixed) -> Component
enum ColourScale
    Default | Manual(dict[str, str]) | Gradient(str, str)
def scale_colour_manual(values: dict[str, str]) -> Component
def scale_color_manual(values: dict[str, str]) -> Component
def scale_fill_manual(values: dict[str, str]) -> Component
def scale_colour_gradient(low: str = "#132B43", high: str = "#56B1F7") -> Component
def scale_color_gradient(low: str = "#132B43", high: str = "#56B1F7") -> Component
def scale_fill_gradient(low: str = "#132B43", high: str = "#56B1F7") -> Component
enum Unset
    Unset
enum Transform
    Identity | Log10 | Sqrt | Reverse
class PositionScale
def scale_x_continuous(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset, transform: Transform = Transform.Identity) -> Component
def scale_y_continuous(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset, transform: Transform = Transform.Identity) -> Component
def scale_x_discrete(name: str = "", limits: Option[list[str]] = Nothing, labels: Option[list[str]] = Nothing) -> Component
def scale_y_discrete(name: str = "", limits: Option[list[str]] = Nothing, labels: Option[list[str]] = Nothing) -> Component
def scale_x_log10(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset) -> Component
def scale_y_log10(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset) -> Component
def scale_x_sqrt(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset) -> Component
def scale_x_reverse(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset) -> Component
def scale_y_sqrt(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset) -> Component
def scale_y_reverse(name: str = "", breaks: Option[list[f64]] = Nothing, labels: Option[list[str]] = Nothing, limits: (f64, f64) | Unset = Unset.Unset) -> Component
def geom_point(colour: str = "", color: str = "", size: f64 | i64 = 1.5, alpha: f64 | i64 = 1.0, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_line(colour: str = "", color: str = "", linewidth: f64 | i64 = 0.5, alpha: f64 | i64 = 1.0, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_path(colour: str = "", color: str = "", linewidth: f64 | i64 = 0.5, alpha: f64 | i64 = 1.0, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_col(colour: str = "", color: str = "", fill: str = "", width: f64 | i64 = 0.9, alpha: f64 | i64 = 1.0, position: Position = Position.Stack, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_bar(colour: str = "", color: str = "", fill: str = "", width: f64 | i64 = 0.9, alpha: f64 | i64 = 1.0, position: Position = Position.Stack, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_histogram(colour: str = "", color: str = "", fill: str = "", bins: i64 = 30, alpha: f64 | i64 = 1.0, position: Position = Position.Stack, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_errorbar(colour: str = "", color: str = "", linewidth: f64 | i64 = 0.5, width: f64 | i64 = 0.2, alpha: f64 | i64 = 1.0, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_linerange(colour: str = "", color: str = "", linewidth: f64 | i64 = 0.5, alpha: f64 | i64 = 1.0, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def geom_ribbon(colour: str = "", color: str = "", fill: str = "", linewidth: f64 | i64 = 0.5, alpha: f64 | i64 = 0.3, na_rm: bool = False, data: Table | Unset = Unset.Unset, mapping: Mapping | Unset = Unset.Unset, inherit_aes: bool = True) -> Component
def labs(title: str = "", x: str = "", y: str = "", colour: str = "", fill: str = "") -> Component
def theme_grey(base_size: f64 | i64 = 11, legend_position: Legend = Legend.Right) -> Component
def theme_minimal(base_size: f64 | i64 = 11, legend_position: Legend = Legend.Right) -> Component
def theme_classic(base_size: f64 | i64 = 11, legend_position: Legend = Legend.Right) -> Component
def coord_flip() -> Component
def coord_cartesian(xlim: (f64, f64) | Unset = Unset.Unset, ylim: (f64, f64) | Unset = Unset.Unset) -> Component
class Plot
    def plus(self, components: list[Component]) -> Result[Plot, PlotError]
    def write_svg[W: Writer](self, writer: &mut W, width: f64 = 6.0, height: f64 = 4.0, units: Units = Units.In, dpi: f64 = 300.0) -> Result[list[str], PlotError]
    def save(self, path: &str, width: f64 = 6.0, height: f64 = 4.0, units: Units = Units.In, dpi: f64 = 300.0) -> Result[list[str], PlotError]
def ggplot(data: Table, mapping: Mapping, components: list[Component]) -> Result[Plot, PlotError]

std.linalg

Dense f64 matrices, products, solves, LU, QR, Cholesky, SVD and eigen decompositions through an optional faer engine. Errors: AllocError, LinalgError. Reference.

enum LinalgError
    Shape | Bounds | NonFinite | Singular | NotSymmetric | NotPositiveDefinite | NoConvergence | Overflow | NativePanic | Allocation(AllocError)
class Matrix
    def rows(self) -> i64
    def cols(self) -> i64
    def get(self, row: i64, col: i64) -> Result[f64, LinalgError]
    def set(self: &mut Matrix, row: i64, col: i64, value: f64) -> Result[(), LinalgError]
    def to_list(self) -> Result[list[f64], AllocError]
    def transpose(self) -> Result[Matrix, AllocError]
    def add(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
    def subtract(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
    def scale(self, factor: f64) -> Result[Matrix, LinalgError]
    def negate(self) -> Result[Matrix, LinalgError]
    def __add__(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
    def __sub__(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
    def __neg__(self) -> Result[Matrix, LinalgError]
    def __mul__(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
    def __rmul__(self, factor: f64) -> Result[Matrix, LinalgError]
    def matmul(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
    def lu(self) -> Result[Lu, LinalgError]
    def solve(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
    def qr(self) -> Result[(Matrix, Matrix), LinalgError]
    def cholesky(self) -> Result[Matrix, LinalgError]
    def svd(self) -> Result[(Matrix, list[f64], Matrix), LinalgError]
    def eigh(self) -> Result[(list[f64], Matrix), LinalgError]
    def eig(self) -> Result[(list[f64], list[f64], Matrix, Matrix), LinalgError]
class Lu
    def lower(self) -> Result[Matrix, LinalgError]
    def upper(self) -> Result[Matrix, LinalgError]
    def permutation(self) -> Result[list[i64], AllocError]
    def solve(self, rhs: &Matrix) -> Result[Matrix, LinalgError]
def matrix(rows: i64, cols: i64, values: &list[f64]) -> Result[Matrix, LinalgError]
def vector(values: &list[f64]) -> Result[Matrix, LinalgError]
def zeros(rows: i64, cols: i64) -> Result[Matrix, LinalgError]
def identity(n: i64) -> Result[Matrix, LinalgError]
def diagonal(values: &list[f64]) -> Result[Matrix, LinalgError]

std.sync

Shared cooperative cancellation tokens. Errors: AllocError. Reference.

Compiler-provided: CancellationToken. Their signatures are on the reference page.

class Mutex[T]
    def __init__(self, value: T) -> ()
enum WaitError
    TimedOut | Cancelled | Disconnected
enum SendBeforeError[T]
    TimedOut(T) | Cancelled(T) | Disconnected(T)
def recv_before[T](receiver: &Receiver[T], deadline: &Deadline, cancel: &CancellationToken) -> Result[T, WaitError]
def send_before[T](sender: &Sender[T], value: T, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), SendBeforeError[T]]
def future_before[T](future: &Future[T], deadline: &Deadline, cancel: &CancellationToken) -> Result[(), WaitError]
def cancelled_before(token: &CancellationToken, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), WaitError]
def select_recv_before[A, B](first: &Receiver[A], second: &Receiver[B], deadline: &Deadline, cancel: &CancellationToken) -> Result[Selected[A, B], WaitError]

std.system

Bounded Linux procfs snapshots: CPUs, memory, load, uptime, block devices, disk I/O and process status. Errors: IoError, SystemError. Reference.

enum SystemError
    Io(IoError) | Stream(StreamError) | Allocation(AllocError) | Limit | Malformed(str)
class Memory
    total_bytes: u64
    free_bytes: u64
    available_bytes: Option[u64]
    swap_total_bytes: u64
    swap_free_bytes: u64
class LoadAverage
    one_minute: f64
    five_minutes: f64
    fifteen_minutes: f64
    runnable_tasks: u64
    total_tasks: u64
    last_pid: u32
class Uptime
    seconds: f64
    idle_cpu_seconds: f64
class BlockDevice
    major: u32
    minor: u32
    name: str
    size_bytes: u64
class DiskIo
    major: u32
    minor: u32
    name: str
    reads_completed: u64
    bytes_read: u64
    writes_completed: u64
    bytes_written: u64
    in_flight: u64
    busy_milliseconds: u64
class Process
    pid: u32
    parent_pid: u32
    name: str
    state: str
    real_uid: u32
    threads: u64
    virtual_bytes: Option[u64]
    resident_bytes: Option[u64]
class Procfs
    def cpu_count(self, max_bytes: Positive[i64] = 1048576) -> Result[i64, SystemError]
    def memory(self, max_bytes: Positive[i64] = 65536) -> Result[Memory, SystemError]
    def load_average(self, max_bytes: Positive[i64] = 4096) -> Result[LoadAverage, SystemError]
    def uptime(self, max_bytes: Positive[i64] = 4096) -> Result[Uptime, SystemError]
    def block_devices(self, max_bytes: Positive[i64] = 1048576, max_devices: NonNegative[i64] = 4096) -> Result[list[BlockDevice], SystemError]
    def disk_io(self, max_bytes: Positive[i64] = 1048576, max_devices: NonNegative[i64] = 4096) -> Result[list[DiskIo], SystemError]
    def process_ids(self, max_entries: NonNegative[i64] = 65536) -> Result[list[u32], SystemError]
    def process(self, pid: u32, max_bytes: Positive[i64] = 65536) -> Result[Process, SystemError]
def open_procfs(path: &Path) -> Result[Procfs, IoError]
def local() -> Result[Procfs, IoError]

std.tempfile

Unnamed and named temporary files, recursively cleaned directories, context managers and explicit ownership transfer. Errors: IoError, FsError, StreamError, AllocError. Reference.

def default_dir() -> Result[Path, IoError]
class TemporaryFile
    def stream(self: &mut TemporaryFile) -> &mut FileStream
    def close(self: &mut TemporaryFile) -> Result[(), StreamError]
    def __enter__(self: &mut TemporaryFile) -> &mut FileStream
    def __exit__(self: &mut TemporaryFile) -> ()
def file(parent: &Path = default_dir()?) -> Result[TemporaryFile, IoError]
class NamedTemporaryFile
    def path(self) -> &Path
    def read(self: &mut NamedTemporaryFile, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def write(self: &mut NamedTemporaryFile, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut NamedTemporaryFile) -> Result[(), StreamError]
    def sync(self: &mut NamedTemporaryFile) -> Result[(), StreamError]
    def seek(self: &mut NamedTemporaryFile, target: SeekFrom) -> Result[i64, StreamError]
    def close(self: &mut NamedTemporaryFile) -> Result[(), FsError]
    def keep(self: &mut NamedTemporaryFile) -> Result[Path, AllocError]
    def __enter__(self: &mut NamedTemporaryFile) -> &mut NamedTemporaryFile
    def __exit__(self: &mut NamedTemporaryFile) -> ()
def named_file(parent: &Path = io_error(default_dir())?, prefix: &str = "plenty-", suffix: &str = "") -> Result[NamedTemporaryFile, FsError]
class TemporaryDirectory
    def path(self) -> &Path
    def root(self) -> &Root
    def cleanup(self: &mut TemporaryDirectory) -> Result[(), FsError]
    def keep(self: &mut TemporaryDirectory) -> Result[Path, AllocError]
    def __enter__(self: &mut TemporaryDirectory) -> &mut TemporaryDirectory
    def __exit__(self: &mut TemporaryDirectory) -> ()
def directory(parent: &Path = io_error(default_dir())?, prefix: &str = "plenty-", max_entries: Positive[i64] = 100000, max_depth: Positive[i64] = 64) -> Result[TemporaryDirectory, FsError]

std.test

Assertions that explain their failure on standard error, self-removing scratch directories, the seeded generator for plenty test, and fake clocks and streams. Errors: TestError. Reference.

enum TestError
    Assertion | Fixture(FsError) | Allocation(AllocError) | InvalidSeed | Unavailable
def fail(message: &str) -> Result[(), TestError]
def check(condition: bool, message: &str) -> Result[(), TestError]
def equal[T](left: &T, right: &T) -> Result[(), TestError]
def not_equal[T](left: &T, right: &T) -> Result[(), TestError]
def less[T](left: &T, right: &T) -> Result[(), TestError]
def close(left: f64, right: f64, tolerance: f64) -> Result[(), TestError]
def is_ok[T, E](result: &Result[T, E]) -> Result[(), TestError]
def is_err[T, E](result: &Result[T, E]) -> Result[(), TestError]
def fail_allocations_after(count: u32) -> Result[(), TestError]
def restore_allocations() -> Result[(), TestError]
def fail_files_after(count: u32, code: i32) -> Result[(), TestError]
def restore_files() -> Result[(), TestError]
class Scratch
    def path(self) -> &Path
    def root(self) -> &Root
    def file(self, name: &str) -> Result[str, TestError]
    def cleanup(self: &mut Scratch) -> Result[(), TestError]
def scratch() -> Result[Scratch, TestError]
def seed() -> Result[u64, TestError]
def rng() -> Result[Rng, TestError]
class FakeClock
    def now(self) -> Instant
    def advance(self: &mut FakeClock, span: &Duration) -> Result[(), RangeError]
    def set(self: &mut FakeClock, nanoseconds_after_origin: u64) -> ()
def fake_clock(nanoseconds_after_origin: u64) -> FakeClock
class FakeStream
    input: Bytes
    output: Bytes
    def calls(self) -> i64
    def limit(self: &mut FakeStream, bytes: i64) -> ()
    def fail_after(self: &mut FakeStream, after: i64, error: StreamError) -> Result[(), OverflowError[i64]]
    def read(self: &mut FakeStream, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def write(self: &mut FakeStream, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut FakeStream) -> Result[(), StreamError]
def fake_stream(input: Bytes) -> Result[FakeStream, AllocError]

std.text

Bounded builders, joining, scalar/word wrapping, shortening, and indentation. Errors: TextError. Reference.

def find_in(text: &str, set: &[u8]) -> Option[i64]
def find_not_in(text: &str, set: &[u8]) -> Option[i64]
enum TextError
    InvalidLimit | LimitExceeded | Allocation(AllocError) | Bytes(BytesError)
class Builder
    def byte_len(self) -> i64
    def limit(self) -> i64
    def append(self: &mut Builder, text: &str) -> Result[(), TextError]
    def clear(self: &mut Builder) -> ()
    def to_text(self) -> Result[str, TextError]
    def finish(self: Builder) -> Result[str, TextError]
def builder(max_bytes: NonNegative[i64]) -> Result[Builder, TextError]
def join(pieces: &list[str], separator: &str, max_bytes: NonNegative[i64]) -> Result[str, TextError]
def hard_wrap(text: &str, width: Positive[i64], max_bytes: NonNegative[i64]) -> Result[str, TextError]
class TextWrapper
    width: Positive[i64]
    initial_indent: str
    subsequent_indent: str
    expand_tabs: bool
    replace_whitespace: bool
    fix_sentence_endings: bool
    break_long_words: bool
    drop_whitespace: bool
    break_on_hyphens: bool
    tabsize: NonNegative[i64]
    max_lines: Option[Positive[i64]]
    placeholder: str
    max_bytes: NonNegative[i64]
    max_input_bytes: NonNegative[i64]
    def wrap(self, text: &str) -> Result[list[str], TextError]
    def fill(self, text: &str) -> Result[str, TextError]
def text_wrapper(width: Positive[i64] = 70, max_bytes: NonNegative[i64] = 1048576, max_input_bytes: NonNegative[i64] = 1048576) -> TextWrapper
def wrap(text: &str, width: Positive[i64] = 70, max_bytes: NonNegative[i64] = 1048576, max_input_bytes: NonNegative[i64] = 1048576) -> Result[list[str], TextError]
def fill(text: &str, width: Positive[i64] = 70, max_bytes: NonNegative[i64] = 1048576, max_input_bytes: NonNegative[i64] = 1048576) -> Result[str, TextError]
def shorten(text: &str, width: Positive[i64], placeholder: &str = " [...]", max_bytes: NonNegative[i64] = 1048576, max_input_bytes: NonNegative[i64] = 1048576, fix_sentence_endings: bool = False, break_long_words: bool = True, break_on_hyphens: bool = True) -> Result[str, TextError]
def dedent(text: &str, max_bytes: NonNegative[i64] = 1048576, max_input_bytes: NonNegative[i64] = 1048576) -> Result[str, TextError]
def indent(text: &str, prefix: &str, max_bytes: NonNegative[i64] = 1048576, max_input_bytes: NonNegative[i64] = 1048576) -> Result[str, TextError]
def indent_with[F: Callable[[&str], bool]](text: &str, prefix: &str, predicate: F, max_bytes: NonNegative[i64] = 1048576, max_input_bytes: NonNegative[i64] = 1048576) -> Result[str, TextError]

std.thread

Explicit scoped thread and owned-job imports. Errors: ThreadError, SpawnError[F]. Reference.

Compiler-provided: spawn, ThreadError, SpawnError. Their signatures are on the reference page.

std.time

Checked durations, monotonic instants and deadlines, wall timestamps, and sleep. Errors: RangeError. Reference.

class Duration
    def as_nanoseconds(self) -> u64
    def as_microseconds(self) -> u64
    def as_milliseconds(self) -> u64
    def as_seconds(self) -> u64
    def as_timeout_ms(self) -> u64
    def is_zero(self) -> bool
    def checked_add(self, other: &Duration) -> Result[Duration, RangeError]
    def checked_sub(self, other: &Duration) -> Result[Duration, RangeError]
    def saturating_sub(self, other: &Duration) -> Duration
    def checked_mul(self, factor: u64) -> Result[Duration, RangeError]
def nanoseconds(count: u64) -> Duration
def microseconds(count: u32) -> Duration
def milliseconds(count: u32) -> Duration
def seconds(count: u32) -> Duration
class Instant
    def checked_add(self, span: &Duration) -> Result[Instant, RangeError]
    def duration_since(self, earlier: &Instant) -> Result[Duration, RangeError]
    def saturating_duration_since(self, earlier: &Instant) -> Duration
def monotonic_now() -> Instant
def instant_at(nanoseconds_after_origin: u64) -> Instant
protocol Clock
    def now(self) -> Instant
class MonotonicClock
    def now(self) -> Instant
def monotonic_clock() -> MonotonicClock
class Deadline
    def expired(self, now: &Instant) -> bool
    def remaining(self, now: &Instant) -> Duration
def deadline_at(at: &Instant) -> Deadline
def deadline_after(start: &Instant, budget: &Duration) -> Result[Deadline, RangeError]
class Timestamp
    seconds: i64
    nanoseconds: u32
    def duration_since(self, earlier: &Timestamp) -> Result[Duration, RangeError]
    def checked_add(self, span: &Duration) -> Result[Timestamp, RangeError]
def wall_now() -> Timestamp
def sleep(span: &Duration) -> ()
def sleep_until(deadline: &Deadline) -> ()

std.tls

TLS 1.2 and 1.3 client and server streams over std.net TCP, with verified certificates, client certificates, ALPN, deadlines, and cancellation. Errors: TlsError. Reference.

enum TlsError
    Net(NetError) | UntrustedCertificate | ExpiredCertificate | WrongHost | InvalidCertificate | Rejected | Protocol | Truncated | InvalidName | InvalidConfiguration | NoTrustRoots | Closed | Allocation(AllocError) | RevokedCertificate | CertificateRequired | Incompatible
enum TlsVersion
    Tls12 | Tls13
enum CipherSuite
    Tls13Aes256GcmSha384 | Tls13Aes128GcmSha256 | Tls13Chacha20Poly1305Sha256 | EcdheEcdsaAes256GcmSha384 | EcdheEcdsaAes128GcmSha256 | EcdheEcdsaChacha20Poly1305Sha256 | EcdheRsaAes256GcmSha384 | EcdheRsaAes128GcmSha256 | EcdheRsaChacha20Poly1305Sha256
enum ClientCertificates
    Required | Optional
class TrustRoots
    def len(self) -> i64
def roots_from_pem(pem: &str) -> Result[TrustRoots, TlsError]
def system_roots() -> Result[TrustRoots, TlsError]
class ClientConfig
class ServerConfig
class ClientBuilder
    def certificate(self: &mut ClientBuilder, chain_pem: &str, key_pem: &str) -> Result[(), TlsError]
    def application_protocol(self: &mut ClientBuilder, name: &str) -> Result[(), TlsError]
    def minimum_version(self: &mut ClientBuilder, version: TlsVersion) -> ()
    def cipher_suite(self: &mut ClientBuilder, suite: CipherSuite) -> ()
    def revocation_list(self: &mut ClientBuilder, crl_pem: &str) -> Result[(), TlsError]
    def build(self) -> Result[ClientConfig, TlsError]
def client_builder(roots: &TrustRoots) -> Result[ClientBuilder, TlsError]
def client_config(roots: &TrustRoots) -> Result[ClientConfig, TlsError]
class ServerBuilder
    def certificate(self: &mut ServerBuilder, chain_pem: &str, key_pem: &str) -> Result[(), TlsError]
    def verify_clients(self: &mut ServerBuilder, roots: &TrustRoots, certificates: ClientCertificates) -> ()
    def application_protocol(self: &mut ServerBuilder, name: &str) -> Result[(), TlsError]
    def minimum_version(self: &mut ServerBuilder, version: TlsVersion) -> ()
    def cipher_suite(self: &mut ServerBuilder, suite: CipherSuite) -> ()
    def revocation_list(self: &mut ServerBuilder, crl_pem: &str) -> Result[(), TlsError]
    def build(self) -> Result[ServerConfig, TlsError]
def server_builder(chain_pem: &str, key_pem: &str) -> Result[ServerBuilder, TlsError]
def server_config(chain_pem: &str, key_pem: &str) -> Result[ServerConfig, TlsError]
class TlsStream
    def handshake_before(self: &mut TlsStream, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), TlsError]
    def try_handshake(self: &mut TlsStream) -> Result[bool, TlsError]
    def try_flush(self: &mut TlsStream) -> Result[bool, TlsError]
    def try_read(self: &mut TlsStream, buffer: &mut Bytes, start: i64, stop: i64) -> Result[Option[i64], TlsError]
    def try_write(self: &mut TlsStream, source: &[u8]) -> Result[Option[i64], TlsError]
    def interest(self) -> Interest
    def watch(self, selector: &mut Selector, key: u64, interest: Interest) -> Result[(), TlsError]
    def unwatch(self, selector: &mut Selector) -> Result[(), TlsError]
    def read_before(self: &mut TlsStream, buffer: &mut Bytes, start: i64, stop: i64, deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, TlsError]
    def write_before(self: &mut TlsStream, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[i64, TlsError]
    def write_all_before(self: &mut TlsStream, source: &[u8], deadline: &Deadline, cancel: &CancellationToken) -> Result[(), TlsError]
    def close_before(self: &mut TlsStream, deadline: &Deadline, cancel: &CancellationToken) -> Result[(), TlsError]
    def shutdown(self: &mut TlsStream, direction: Shutdown) -> Result[(), TlsError]
    def read(self: &mut TlsStream, buffer: &mut Bytes, start: i64, stop: i64) -> Result[i64, StreamError]
    def write(self: &mut TlsStream, source: &[u8]) -> Result[i64, StreamError]
    def flush(self: &mut TlsStream) -> Result[(), StreamError]
    def close(self: &mut TlsStream) -> Result[(), StreamError]
    def application_protocol(self) -> Result[Option[str], TlsError]
    def server_name(self) -> Result[Option[str], TlsError]
    def peer_certificate(self) -> Result[Option[Bytes], TlsError]
    def version(self) -> Option[TlsVersion]
    def cipher_suite(self) -> Option[CipherSuite]
def start_connect(tcp: TcpStream, config: &ClientConfig, server_name: &str) -> Result[TlsStream, TlsError]
def start_accept(tcp: TcpStream, config: &ServerConfig) -> Result[TlsStream, TlsError]
def connect(tcp: TcpStream, config: &ClientConfig, server_name: &str, deadline: &Deadline, cancel: &CancellationToken) -> Result[TlsStream, TlsError]
def accept(tcp: TcpStream, config: &ServerConfig, deadline: &Deadline, cancel: &CancellationToken) -> Result[TlsStream, TlsError]
class Session
    def feed(self: &mut Session, source: &[u8]) -> Result[i64, TlsError]
    def feed_end(self: &mut Session) -> Result[(), TlsError]
    def take(self: &mut Session, target: &mut Bytes, start: i64, stop: i64) -> Result[i64, TlsError]
    def read(self: &mut Session, target: &mut Bytes, start: i64, stop: i64) -> Result[Option[i64], TlsError]
    def write(self: &mut Session, source: &[u8]) -> Result[i64, TlsError]
    def close(self: &mut Session) -> ()
    def handshaking(self) -> bool
    def wants_write(self) -> bool
    def wants_read(self) -> bool
    def application_protocol(self) -> Result[Option[str], TlsError]
    def server_name(self) -> Result[Option[str], TlsError]
    def peer_certificate(self) -> Result[Option[Bytes], TlsError]
    def version(self) -> Option[TlsVersion]
    def cipher_suite(self) -> Option[CipherSuite]
def client_session(config: &ClientConfig, server_name: &str) -> Result[Session, TlsError]
def server_session(config: &ServerConfig) -> Result[Session, TlsError]

std.toml

Strict TOML 1.0 parsing, value-tree writing and format-preserving document edits, under depth, input, and output limits. Errors: TomlError. Reference.

enum TomlFault
    UnexpectedByte | UnexpectedEnd | InvalidUtf8 | ControlCharacter | InvalidEscape | InvalidNumber | NumberOutOfRange | InvalidDateTime | DuplicateKey | DuplicateTable | KeyConflict | DepthExceeded | InputTooLarge | OutputTooLarge | NotATable | Stream(StreamError) | Allocation(AllocError)
class TomlError
    fault: TomlFault
    offset: i64
    line: i64
    column: i64
class Limits
    max_depth: NonNegative[i64]
    max_input: NonNegative[i64]
    max_output: NonNegative[i64]
enum DateTimeKind
    OffsetDateTime | LocalDateTime | LocalDate | LocalTime
class DateTime
    kind: DateTimeKind
    year: i64
    month: i64
    day: i64
    hour: i64
    minute: i64
    second: i64
    nanosecond: i64
    offset_minutes: i64
enum Toml
    Bool(bool) | Int(i64) | Float(f64) | Text(str) | DateTime(DateTime) | Array(list[Toml]) | Table(list[Entry])
class Entry
    key: str
    value: Toml
def limits() -> Limits
def parse(source: &[u8], bounds: &Limits) -> Result[Toml, TomlError]
def parse_text(text: &str, bounds: &Limits) -> Result[Toml, TomlError]
def read_value[R: Reader](reader: &mut R, bounds: &Limits) -> Result[Toml, TomlError]
def find(entries: &list[Entry], key: &str) -> Option[i64]
def encode(value: &Toml, bounds: &Limits) -> Result[Bytes, TomlError]
def encode_text(value: &Toml, bounds: &Limits) -> Result[str, TomlError]
def write_value[W: Writer](writer: &mut W, value: &Toml, bounds: &Limits) -> Result[(), TomlError]
class Document
    def text(self) -> Result[str, TomlError]
    def get(self, path: &list[str]) -> Result[Option[Toml], TomlError]
    def set(self: &mut Document, path: &list[str], value: &Toml) -> Result[(), TomlError]
    def insert(self: &mut Document, path: &list[str], value: &Toml) -> Result[(), TomlError]
    def remove(self: &mut Document, path: &list[str]) -> Result[bool, TomlError]
def document(source: &[u8], bounds: &Limits) -> Result[Document, TomlError]
def document_text(text: &str, bounds: &Limits) -> Result[Document, TomlError]

std.unicode

Unicode 17 normalization, combining classes, and Mark classification. Errors: TextError. Reference.

def version() -> str
def combining_class(scalar: &str) -> Option[u32]
def is_mark(scalar: &str) -> Option[bool]
def nfd(text: &str, max_scalars: NonNegative[i64]) -> Result[str, TextError]
def nfc(text: &str, max_scalars: NonNegative[i64]) -> Result[str, TextError]
def nfkd(text: &str, max_scalars: NonNegative[i64]) -> Result[str, TextError]
def nfkc(text: &str, max_scalars: NonNegative[i64]) -> Result[str, TextError]

std.units

SI dimensions, prefixed and common units, physical constants, and dimension-aware square roots, sums and trigonometry over Quantity. Errors: MathError, RangeError. Reference.

dimension Mass("kg")
dimension Length("m")
dimension Time("s")
dimension Current("A")
dimension Temperature("K")
dimension Amount("mol")
dimension Luminosity("cd")
dimension Area = Pow[Length, 2]
dimension Volume = Pow[Length, 3]
dimension Wavenumber = One / Length
dimension Velocity = Length / Time
dimension Acceleration = Length / Pow[Time, 2]
dimension Frequency = One / Time
dimension Force = Mass * Acceleration
dimension Pressure = Force / Area
dimension Energy = Force * Length
dimension Power = Energy / Time
dimension Momentum = Mass * Velocity
dimension Action = Energy * Time
dimension Density = Mass / Volume
dimension MassFlowRate = Mass / Time
dimension VolumeFlowRate = Volume / Time
dimension DynamicViscosity = Pressure * Time
dimension KinematicViscosity = Area / Time
dimension SurfaceTension = Force / Length
dimension HeatFlux = Power / Area
dimension SpecificEnergy = Energy / Mass
dimension Entropy = Energy / Temperature
dimension SpecificHeatCapacity = SpecificEnergy / Temperature
dimension ThermalConductivity = Power / (Length * Temperature)
dimension MolarMass = Mass / Amount
dimension MolarEnergy = Energy / Amount
dimension MolarHeatCapacity = Entropy / Amount
dimension Concentration = Amount / Volume
dimension PerAmount = One / Amount
dimension CatalyticActivity = Amount / Time
dimension Charge = Current * Time
dimension Voltage = Power / Current
dimension ElectricField = Voltage / Length
dimension Capacitance = Charge / Voltage
dimension Permittivity = Capacitance / Length
dimension Resistance = Voltage / Current
dimension Conductance = Current / Voltage
dimension MagneticFlux = Voltage * Time
dimension MagneticFluxDensity = MagneticFlux / Area
dimension Inductance = MagneticFlux / Current
dimension Permeability = Inductance / Length
dimension Illuminance = Luminosity / Area
dimension LuminousEfficacy = Luminosity / Power
dimension StefanBoltzmann = HeatFlux / Pow[Temperature, 4]
dimension Gravitation = Volume / (Mass * Pow[Time, 2])
const kg: Quantity[f64, Mass] = Quantity[f64, Mass](1.0)
const m: Quantity[f64, Length] = Quantity[f64, Length](1.0)
const s: Quantity[f64, Time] = Quantity[f64, Time](1.0)
const A: Quantity[f64, Current] = Quantity[f64, Current](1.0)
const K: Quantity[f64, Temperature] = Quantity[f64, Temperature](1.0)
const mol: Quantity[f64, Amount] = Quantity[f64, Amount](1.0)
const cd: Quantity[f64, Luminosity] = Quantity[f64, Luminosity](1.0)
const rad: Quantity[f64, One] = Quantity[f64, One](1.0)
const sr: Quantity[f64, One] = Quantity[f64, One](1.0)
const degree: Quantity[f64, One] = (f64.PI / 180.0) * rad
const arcminute: Quantity[f64, One] = degree / 60.0
const arcsecond: Quantity[f64, One] = degree / 3600.0
const Hz: Quantity[f64, Frequency] = 1.0 / s
const N: Quantity[f64, Force] = kg * m / (s * s)
const Pa: Quantity[f64, Pressure] = N / (m * m)
const J: Quantity[f64, Energy] = N * m
const W: Quantity[f64, Power] = J / s
const C: Quantity[f64, Charge] = A * s
const V: Quantity[f64, Voltage] = W / A
const F: Quantity[f64, Capacitance] = C / V
const ohm: Quantity[f64, Resistance] = V / A
const S: Quantity[f64, Conductance] = A / V
const Wb: Quantity[f64, MagneticFlux] = V * s
const T: Quantity[f64, MagneticFluxDensity] = Wb / (m * m)
const H: Quantity[f64, Inductance] = Wb / A
const lm: Quantity[f64, Luminosity] = cd * sr
const lx: Quantity[f64, Illuminance] = lm / (m * m)
const Bq: Quantity[f64, Frequency] = 1.0 / s
const Gy: Quantity[f64, SpecificEnergy] = J / kg
const Sv: Quantity[f64, SpecificEnergy] = J / kg
const kat: Quantity[f64, CatalyticActivity] = mol / s
const ug: Quantity[f64, Mass] = 1e-9 * kg
const mg: Quantity[f64, Mass] = 1e-6 * kg
const g: Quantity[f64, Mass] = 1e-3 * kg
const pm: Quantity[f64, Length] = 1e-12 * m
const nm: Quantity[f64, Length] = 1e-9 * m
const um: Quantity[f64, Length] = 1e-6 * m
const mm: Quantity[f64, Length] = 1e-3 * m
const cm: Quantity[f64, Length] = 1e-2 * m
const km: Quantity[f64, Length] = 1e3 * m
const ps: Quantity[f64, Time] = 1e-12 * s
const ns: Quantity[f64, Time] = 1e-9 * s
const us: Quantity[f64, Time] = 1e-6 * s
const ms: Quantity[f64, Time] = 1e-3 * s
const uA: Quantity[f64, Current] = 1e-6 * A
const mA: Quantity[f64, Current] = 1e-3 * A
const kA: Quantity[f64, Current] = 1e3 * A
const mK: Quantity[f64, Temperature] = 1e-3 * K
const umol: Quantity[f64, Amount] = 1e-6 * mol
const mmol: Quantity[f64, Amount] = 1e-3 * mol
const kmol: Quantity[f64, Amount] = 1e3 * mol
const kHz: Quantity[f64, Frequency] = 1e3 * Hz
const MHz: Quantity[f64, Frequency] = 1e6 * Hz
const GHz: Quantity[f64, Frequency] = 1e9 * Hz
const mN: Quantity[f64, Force] = 1e-3 * N
const kN: Quantity[f64, Force] = 1e3 * N
const MN: Quantity[f64, Force] = 1e6 * N
const hPa: Quantity[f64, Pressure] = 1e2 * Pa
const kPa: Quantity[f64, Pressure] = 1e3 * Pa
const MPa: Quantity[f64, Pressure] = 1e6 * Pa
const GPa: Quantity[f64, Pressure] = 1e9 * Pa
const mJ: Quantity[f64, Energy] = 1e-3 * J
const kJ: Quantity[f64, Energy] = 1e3 * J
const MJ: Quantity[f64, Energy] = 1e6 * J
const GJ: Quantity[f64, Energy] = 1e9 * J
const uW: Quantity[f64, Power] = 1e-6 * W
const mW: Quantity[f64, Power] = 1e-3 * W
const kW: Quantity[f64, Power] = 1e3 * W
const MW: Quantity[f64, Power] = 1e6 * W
const GW: Quantity[f64, Power] = 1e9 * W
const Wh: Quantity[f64, Energy] = 3600.0 * J
const kWh: Quantity[f64, Energy] = 3.6e6 * J
const MWh: Quantity[f64, Energy] = 3.6e9 * J
const GWh: Quantity[f64, Energy] = 3.6e12 * J
const nC: Quantity[f64, Charge] = 1e-9 * C
const uC: Quantity[f64, Charge] = 1e-6 * C
const mC: Quantity[f64, Charge] = 1e-3 * C
const uV: Quantity[f64, Voltage] = 1e-6 * V
const mV: Quantity[f64, Voltage] = 1e-3 * V
const kV: Quantity[f64, Voltage] = 1e3 * V
const MV: Quantity[f64, Voltage] = 1e6 * V
const pF: Quantity[f64, Capacitance] = 1e-12 * F
const nF: Quantity[f64, Capacitance] = 1e-9 * F
const uF: Quantity[f64, Capacitance] = 1e-6 * F
const mF: Quantity[f64, Capacitance] = 1e-3 * F
const kohm: Quantity[f64, Resistance] = 1e3 * ohm
const Mohm: Quantity[f64, Resistance] = 1e6 * ohm
const uS: Quantity[f64, Conductance] = 1e-6 * S
const mS: Quantity[f64, Conductance] = 1e-3 * S
const uT: Quantity[f64, MagneticFluxDensity] = 1e-6 * T
const mT: Quantity[f64, MagneticFluxDensity] = 1e-3 * T
const nH: Quantity[f64, Inductance] = 1e-9 * H
const uH: Quantity[f64, Inductance] = 1e-6 * H
const mH: Quantity[f64, Inductance] = 1e-3 * H
const delta_nu_Cs: Quantity[f64, Frequency] = 9192631770.0 * Hz
const c: Quantity[f64, Velocity] = 299792458.0 * (m / s)
const h: Quantity[f64, Action] = 6.62607015e-34 * (J * s)
const e: Quantity[f64, Charge] = 1.602176634e-19 * C
const k_B: Quantity[f64, Entropy] = 1.380649e-23 * (J / K)
const N_A: Quantity[f64, PerAmount] = 6.02214076e23 / mol
const K_cd: Quantity[f64, LuminousEfficacy] = 683.0 * (lm / W)
const hbar: Quantity[f64, Action] = h / f64.TAU
const R: Quantity[f64, MolarHeatCapacity] = N_A * k_B
const sigma: Quantity[f64, StefanBoltzmann] = 5.670374419e-8 * (W / (m * m * K * K * K * K))
const g_n: Quantity[f64, Acceleration] = 9.80665 * (m / (s * s))
const atm: Quantity[f64, Pressure] = 101325.0 * Pa
const G: Quantity[f64, Gravitation] = 6.67430e-11 * (m * m * m / (kg * s * s))
const m_e: Quantity[f64, Mass] = 9.1093837139e-31 * kg
const m_p: Quantity[f64, Mass] = 1.67262192595e-27 * kg
const m_u: Quantity[f64, Mass] = 1.66053906892e-27 * kg
const epsilon_0: Quantity[f64, Permittivity] = 8.8541878188e-12 * (F / m)
const mu_0: Quantity[f64, Permeability] = 1.25663706127e-6 * (H / m)
const minute: Quantity[f64, Time] = 60.0 * s
const hour: Quantity[f64, Time] = 3600.0 * s
const day: Quantity[f64, Time] = 86400.0 * s
const hectare: Quantity[f64, Area] = 1e4 * (m * m)
const litre: Quantity[f64, Volume] = 1e-3 * (m * m * m)
const millilitre: Quantity[f64, Volume] = 1e-6 * (m * m * m)
const cubic_metre: Quantity[f64, Volume] = m * m * m
const tonne: Quantity[f64, Mass] = 1e3 * kg
const dalton: Quantity[f64, Mass] = m_u
const eV: Quantity[f64, Energy] = e * V
const keV: Quantity[f64, Energy] = 1e3 * eV
const MeV: Quantity[f64, Energy] = 1e6 * eV
const GeV: Quantity[f64, Energy] = 1e9 * eV
const au: Quantity[f64, Length] = 149597870700.0 * m
const bar: Quantity[f64, Pressure] = 1e5 * Pa
const mbar: Quantity[f64, Pressure] = 1e2 * Pa
const rankine: Quantity[f64, Temperature] = K * 5.0 / 9.0
const inch: Quantity[f64, Length] = 0.0254 * m
const foot: Quantity[f64, Length] = 0.3048 * m
const yard: Quantity[f64, Length] = 0.9144 * m
const mile: Quantity[f64, Length] = 1609.344 * m
const nautical_mile: Quantity[f64, Length] = 1852.0 * m
const angstrom: Quantity[f64, Length] = 1e-10 * m
const light_year: Quantity[f64, Length] = 9460730472580800.0 * m
const parsec: Quantity[f64, Length] = (648000.0 / f64.PI) * au
const acre: Quantity[f64, Area] = 4046.8564224 * (m * m)
const gallon: Quantity[f64, Volume] = 3.785411784e-3 * (m * m * m)
const pound: Quantity[f64, Mass] = 0.45359237 * kg
const ounce: Quantity[f64, Mass] = pound / 16.0
const pound_force: Quantity[f64, Force] = 0.45359237 * 9.80665 * N
const knot: Quantity[f64, Velocity] = nautical_mile / hour
const km_per_hour: Quantity[f64, Velocity] = km / hour
const mph: Quantity[f64, Velocity] = mile / hour
const psi: Quantity[f64, Pressure] = pound_force / (inch * inch)
const torr: Quantity[f64, Pressure] = atm / 760.0
const mmHg: Quantity[f64, Pressure] = 133.322387415 * Pa
const calorie: Quantity[f64, Energy] = 4.184 * J
const kilocalorie: Quantity[f64, Energy] = 4184.0 * J
const btu: Quantity[f64, Energy] = 1055.05585262 * J
const horsepower: Quantity[f64, Power] = 550.0 * foot * pound_force / s
const week: Quantity[f64, Time] = 7.0 * day
const year: Quantity[f64, Time] = 365.0 * day
def abs[T: IntType, D: Dimension](x: Quantity[T, D]) -> Result[Quantity[T, D], OverflowError[T]]
def abs_float[T: FloatType, D: Dimension](x: Quantity[T, D]) -> Quantity[T, D]
def clamp[Num, D: Dimension](x: Quantity[Num, D], low: Quantity[Num, D], high: Quantity[Num, D]) -> Quantity[Num, D]
def sum[D: Dimension](items: &list[Quantity[f64, D]]) -> Quantity[f64, D]
def mean[D: Dimension](items: &list[Quantity[f64, D]]) -> Option[Quantity[f64, D]]
def wrap_list[D: Dimension](values: list[f64]) -> list[Quantity[f64, D]]
def strip_list[D: Dimension](items: list[Quantity[f64, D]]) -> list[f64]
def sqrt[D: Dimension](x: Quantity[f64, D]) -> Result[Quantity[f64, Root[D, 2]], MathError]
def cbrt[D: Dimension](x: Quantity[f64, D]) -> Result[Quantity[f64, Root[D, 3]], MathError]
def hypot[D: Dimension](a: Quantity[f64, D], b: Quantity[f64, D]) -> Quantity[f64, D]
def exp(x: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def log(x: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def log2(x: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def log10(x: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def sin(angle: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def cos(angle: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def tan(angle: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def asin(x: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def acos(x: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def atan(x: Quantity[f64, One]) -> Result[Quantity[f64, One], MathError]
def atan2[D: Dimension](y: Quantity[f64, D], x: Quantity[f64, D]) -> Result[Quantity[f64, One], MathError]
def from_celsius(degrees: f64) -> Quantity[f64, Temperature]
def to_celsius(t: Quantity[f64, Temperature]) -> f64
def from_fahrenheit(degrees: f64) -> Quantity[f64, Temperature]
def to_fahrenheit(t: Quantity[f64, Temperature]) -> f64
def from_duration(span: &Duration) -> Quantity[f64, Time]
def to_duration(t: Quantity[f64, Time]) -> Result[Duration, RangeError]

std.units.catalogue

Every SI prefix on every SI unit and the other named units of NIST SP 811. Reference.

dimension LinearDensity = u.Mass / u.Length
dimension ElectricDipoleMoment = u.Charge * u.Length
dimension MagneticFieldStrength = u.Current / u.Length
dimension Exposure = u.Charge / u.Mass
dimension Luminance = u.Luminosity / u.Area
const qg: Quantity[f64, u.Mass] = 1e-33 * u.kg
const rg: Quantity[f64, u.Mass] = 1e-30 * u.kg
const yg: Quantity[f64, u.Mass] = 1e-27 * u.kg
const zg: Quantity[f64, u.Mass] = 1e-24 * u.kg
const ag: Quantity[f64, u.Mass] = 1e-21 * u.kg
const fg: Quantity[f64, u.Mass] = 1e-18 * u.kg
const pg: Quantity[f64, u.Mass] = 1e-15 * u.kg
const ng: Quantity[f64, u.Mass] = 1e-12 * u.kg
const ug: Quantity[f64, u.Mass] = 1e-9 * u.kg
const mg: Quantity[f64, u.Mass] = 1e-6 * u.kg
const cg: Quantity[f64, u.Mass] = 1e-5 * u.kg
const dg: Quantity[f64, u.Mass] = 1e-4 * u.kg
const dag: Quantity[f64, u.Mass] = 1e-2 * u.kg
const hg: Quantity[f64, u.Mass] = 1e-1 * u.kg
const kg: Quantity[f64, u.Mass] = 1e0 * u.kg
const Mg: Quantity[f64, u.Mass] = 1e3 * u.kg
const Gg: Quantity[f64, u.Mass] = 1e6 * u.kg
const Tg: Quantity[f64, u.Mass] = 1e9 * u.kg
const Pg: Quantity[f64, u.Mass] = 1e12 * u.kg
const Eg: Quantity[f64, u.Mass] = 1e15 * u.kg
const Zg: Quantity[f64, u.Mass] = 1e18 * u.kg
const Yg: Quantity[f64, u.Mass] = 1e21 * u.kg
const Rg: Quantity[f64, u.Mass] = 1e24 * u.kg
const Qg: Quantity[f64, u.Mass] = 1e27 * u.kg
const qm: Quantity[f64, u.Length] = 1e-30 * u.m
const rm: Quantity[f64, u.Length] = 1e-27 * u.m
const ym: Quantity[f64, u.Length] = 1e-24 * u.m
const zm: Quantity[f64, u.Length] = 1e-21 * u.m
const am: Quantity[f64, u.Length] = 1e-18 * u.m
const fm: Quantity[f64, u.Length] = 1e-15 * u.m
const pm: Quantity[f64, u.Length] = 1e-12 * u.m
const nm: Quantity[f64, u.Length] = 1e-9 * u.m
const um: Quantity[f64, u.Length] = 1e-6 * u.m
const mm: Quantity[f64, u.Length] = 1e-3 * u.m
const cm: Quantity[f64, u.Length] = 1e-2 * u.m
const dm: Quantity[f64, u.Length] = 1e-1 * u.m
const dam: Quantity[f64, u.Length] = 1e1 * u.m
const hm: Quantity[f64, u.Length] = 1e2 * u.m
const km: Quantity[f64, u.Length] = 1e3 * u.m
const Mm: Quantity[f64, u.Length] = 1e6 * u.m
const Gm: Quantity[f64, u.Length] = 1e9 * u.m
const Tm: Quantity[f64, u.Length] = 1e12 * u.m
const Pm: Quantity[f64, u.Length] = 1e15 * u.m
const Em: Quantity[f64, u.Length] = 1e18 * u.m
const Zm: Quantity[f64, u.Length] = 1e21 * u.m
const Ym: Quantity[f64, u.Length] = 1e24 * u.m
const Rm: Quantity[f64, u.Length] = 1e27 * u.m
const Qm: Quantity[f64, u.Length] = 1e30 * u.m
const qs: Quantity[f64, u.Time] = 1e-30 * u.s
const rs: Quantity[f64, u.Time] = 1e-27 * u.s
const ys: Quantity[f64, u.Time] = 1e-24 * u.s
const zs: Quantity[f64, u.Time] = 1e-21 * u.s
const attosecond: Quantity[f64, u.Time] = 1e-18 * u.s
const fs: Quantity[f64, u.Time] = 1e-15 * u.s
const ps: Quantity[f64, u.Time] = 1e-12 * u.s
const ns: Quantity[f64, u.Time] = 1e-9 * u.s
const us: Quantity[f64, u.Time] = 1e-6 * u.s
const ms: Quantity[f64, u.Time] = 1e-3 * u.s
const cs: Quantity[f64, u.Time] = 1e-2 * u.s
const ds: Quantity[f64, u.Time] = 1e-1 * u.s
const das: Quantity[f64, u.Time] = 1e1 * u.s
const hs: Quantity[f64, u.Time] = 1e2 * u.s
const ks: Quantity[f64, u.Time] = 1e3 * u.s
const Ms: Quantity[f64, u.Time] = 1e6 * u.s
const Gs: Quantity[f64, u.Time] = 1e9 * u.s
const Ts: Quantity[f64, u.Time] = 1e12 * u.s
const Ps: Quantity[f64, u.Time] = 1e15 * u.s
const Es: Quantity[f64, u.Time] = 1e18 * u.s
const Zs: Quantity[f64, u.Time] = 1e21 * u.s
const Ys: Quantity[f64, u.Time] = 1e24 * u.s
const Rs: Quantity[f64, u.Time] = 1e27 * u.s
const Qs: Quantity[f64, u.Time] = 1e30 * u.s
const qA: Quantity[f64, u.Current] = 1e-30 * u.A
const rA: Quantity[f64, u.Current] = 1e-27 * u.A
const yA: Quantity[f64, u.Current] = 1e-24 * u.A
const zA: Quantity[f64, u.Current] = 1e-21 * u.A
const aA: Quantity[f64, u.Current] = 1e-18 * u.A
const fA: Quantity[f64, u.Current] = 1e-15 * u.A
const pA: Quantity[f64, u.Current] = 1e-12 * u.A
const nA: Quantity[f64, u.Current] = 1e-9 * u.A
const uA: Quantity[f64, u.Current] = 1e-6 * u.A
const mA: Quantity[f64, u.Current] = 1e-3 * u.A
const cA: Quantity[f64, u.Current] = 1e-2 * u.A
const dA: Quantity[f64, u.Current] = 1e-1 * u.A
const daA: Quantity[f64, u.Current] = 1e1 * u.A
const hA: Quantity[f64, u.Current] = 1e2 * u.A
const kA: Quantity[f64, u.Current] = 1e3 * u.A
const MA: Quantity[f64, u.Current] = 1e6 * u.A
const GA: Quantity[f64, u.Current] = 1e9 * u.A
const TA: Quantity[f64, u.Current] = 1e12 * u.A
const PA: Quantity[f64, u.Current] = 1e15 * u.A
const EA: Quantity[f64, u.Current] = 1e18 * u.A
const ZA: Quantity[f64, u.Current] = 1e21 * u.A
const YA: Quantity[f64, u.Current] = 1e24 * u.A
const RA: Quantity[f64, u.Current] = 1e27 * u.A
const QA: Quantity[f64, u.Current] = 1e30 * u.A
const qK: Quantity[f64, u.Temperature] = 1e-30 * u.K
const rK: Quantity[f64, u.Temperature] = 1e-27 * u.K
const yK: Quantity[f64, u.Temperature] = 1e-24 * u.K
const zK: Quantity[f64, u.Temperature] = 1e-21 * u.K
const aK: Quantity[f64, u.Temperature] = 1e-18 * u.K
const fK: Quantity[f64, u.Temperature] = 1e-15 * u.K
const pK: Quantity[f64, u.Temperature] = 1e-12 * u.K
const nK: Quantity[f64, u.Temperature] = 1e-9 * u.K
const uK: Quantity[f64, u.Temperature] = 1e-6 * u.K
const mK: Quantity[f64, u.Temperature] = 1e-3 * u.K
const cK: Quantity[f64, u.Temperature] = 1e-2 * u.K
const dK: Quantity[f64, u.Temperature] = 1e-1 * u.K
const daK: Quantity[f64, u.Temperature] = 1e1 * u.K
const hK: Quantity[f64, u.Temperature] = 1e2 * u.K
const kK: Quantity[f64, u.Temperature] = 1e3 * u.K
const MK: Quantity[f64, u.Temperature] = 1e6 * u.K
const GK: Quantity[f64, u.Temperature] = 1e9 * u.K
const TK: Quantity[f64, u.Temperature] = 1e12 * u.K
const PK: Quantity[f64, u.Temperature] = 1e15 * u.K
const EK: Quantity[f64, u.Temperature] = 1e18 * u.K
const ZK: Quantity[f64, u.Temperature] = 1e21 * u.K
const YK: Quantity[f64, u.Temperature] = 1e24 * u.K
const RK: Quantity[f64, u.Temperature] = 1e27 * u.K
const QK: Quantity[f64, u.Temperature] = 1e30 * u.K
const qmol: Quantity[f64, u.Amount] = 1e-30 * u.mol
const rmol: Quantity[f64, u.Amount] = 1e-27 * u.mol
const ymol: Quantity[f64, u.Amount] = 1e-24 * u.mol
const zmol: Quantity[f64, u.Amount] = 1e-21 * u.mol
const amol: Quantity[f64, u.Amount] = 1e-18 * u.mol
const fmol: Quantity[f64, u.Amount] = 1e-15 * u.mol
const pmol: Quantity[f64, u.Amount] = 1e-12 * u.mol
const nmol: Quantity[f64, u.Amount] = 1e-9 * u.mol
const umol: Quantity[f64, u.Amount] = 1e-6 * u.mol
const mmol: Quantity[f64, u.Amount] = 1e-3 * u.mol
const cmol: Quantity[f64, u.Amount] = 1e-2 * u.mol
const dmol: Quantity[f64, u.Amount] = 1e-1 * u.mol
const damol: Quantity[f64, u.Amount] = 1e1 * u.mol
const hmol: Quantity[f64, u.Amount] = 1e2 * u.mol
const kmol: Quantity[f64, u.Amount] = 1e3 * u.mol
const Mmol: Quantity[f64, u.Amount] = 1e6 * u.mol
const Gmol: Quantity[f64, u.Amount] = 1e9 * u.mol
const Tmol: Quantity[f64, u.Amount] = 1e12 * u.mol
const Pmol: Quantity[f64, u.Amount] = 1e15 * u.mol
const Emol: Quantity[f64, u.Amount] = 1e18 * u.mol
const Zmol: Quantity[f64, u.Amount] = 1e21 * u.mol
const Ymol: Quantity[f64, u.Amount] = 1e24 * u.mol
const Rmol: Quantity[f64, u.Amount] = 1e27 * u.mol
const Qmol: Quantity[f64, u.Amount] = 1e30 * u.mol
const qcd: Quantity[f64, u.Luminosity] = 1e-30 * u.cd
const rcd: Quantity[f64, u.Luminosity] = 1e-27 * u.cd
const ycd: Quantity[f64, u.Luminosity] = 1e-24 * u.cd
const zcd: Quantity[f64, u.Luminosity] = 1e-21 * u.cd
const acd: Quantity[f64, u.Luminosity] = 1e-18 * u.cd
const fcd: Quantity[f64, u.Luminosity] = 1e-15 * u.cd
const pcd: Quantity[f64, u.Luminosity] = 1e-12 * u.cd
const ncd: Quantity[f64, u.Luminosity] = 1e-9 * u.cd
const ucd: Quantity[f64, u.Luminosity] = 1e-6 * u.cd
const mcd: Quantity[f64, u.Luminosity] = 1e-3 * u.cd
const ccd: Quantity[f64, u.Luminosity] = 1e-2 * u.cd
const dcd: Quantity[f64, u.Luminosity] = 1e-1 * u.cd
const dacd: Quantity[f64, u.Luminosity] = 1e1 * u.cd
const hcd: Quantity[f64, u.Luminosity] = 1e2 * u.cd
const kcd: Quantity[f64, u.Luminosity] = 1e3 * u.cd
const Mcd: Quantity[f64, u.Luminosity] = 1e6 * u.cd
const Gcd: Quantity[f64, u.Luminosity] = 1e9 * u.cd
const Tcd: Quantity[f64, u.Luminosity] = 1e12 * u.cd
const Pcd: Quantity[f64, u.Luminosity] = 1e15 * u.cd
const Ecd: Quantity[f64, u.Luminosity] = 1e18 * u.cd
const Zcd: Quantity[f64, u.Luminosity] = 1e21 * u.cd
const Ycd: Quantity[f64, u.Luminosity] = 1e24 * u.cd
const Rcd: Quantity[f64, u.Luminosity] = 1e27 * u.cd
const Qcd: Quantity[f64, u.Luminosity] = 1e30 * u.cd
const qrad: Quantity[f64, One] = 1e-30 * u.rad
const rrad: Quantity[f64, One] = 1e-27 * u.rad
const yrad: Quantity[f64, One] = 1e-24 * u.rad
const zrad: Quantity[f64, One] = 1e-21 * u.rad
const arad: Quantity[f64, One] = 1e-18 * u.rad
const frad: Quantity[f64, One] = 1e-15 * u.rad
const prad: Quantity[f64, One] = 1e-12 * u.rad
const nrad: Quantity[f64, One] = 1e-9 * u.rad
const urad: Quantity[f64, One] = 1e-6 * u.rad
const mrad: Quantity[f64, One] = 1e-3 * u.rad
const crad: Quantity[f64, One] = 1e-2 * u.rad
const drad: Quantity[f64, One] = 1e-1 * u.rad
const darad: Quantity[f64, One] = 1e1 * u.rad
const hrad: Quantity[f64, One] = 1e2 * u.rad
const krad: Quantity[f64, One] = 1e3 * u.rad
const Mrad: Quantity[f64, One] = 1e6 * u.rad
const Grad: Quantity[f64, One] = 1e9 * u.rad
const Trad: Quantity[f64, One] = 1e12 * u.rad
const Prad: Quantity[f64, One] = 1e15 * u.rad
const Erad: Quantity[f64, One] = 1e18 * u.rad
const Zrad: Quantity[f64, One] = 1e21 * u.rad
const Yrad: Quantity[f64, One] = 1e24 * u.rad
const Rrad: Quantity[f64, One] = 1e27 * u.rad
const Qrad: Quantity[f64, One] = 1e30 * u.rad
const qHz: Quantity[f64, u.Frequency] = 1e-30 * u.Hz
const rHz: Quantity[f64, u.Frequency] = 1e-27 * u.Hz
const yHz: Quantity[f64, u.Frequency] = 1e-24 * u.Hz
const zHz: Quantity[f64, u.Frequency] = 1e-21 * u.Hz
const aHz: Quantity[f64, u.Frequency] = 1e-18 * u.Hz
const fHz: Quantity[f64, u.Frequency] = 1e-15 * u.Hz
const pHz: Quantity[f64, u.Frequency] = 1e-12 * u.Hz
const nHz: Quantity[f64, u.Frequency] = 1e-9 * u.Hz
const uHz: Quantity[f64, u.Frequency] = 1e-6 * u.Hz
const mHz: Quantity[f64, u.Frequency] = 1e-3 * u.Hz
const cHz: Quantity[f64, u.Frequency] = 1e-2 * u.Hz
const dHz: Quantity[f64, u.Frequency] = 1e-1 * u.Hz
const daHz: Quantity[f64, u.Frequency] = 1e1 * u.Hz
const hHz: Quantity[f64, u.Frequency] = 1e2 * u.Hz
const kHz: Quantity[f64, u.Frequency] = 1e3 * u.Hz
const MHz: Quantity[f64, u.Frequency] = 1e6 * u.Hz
const GHz: Quantity[f64, u.Frequency] = 1e9 * u.Hz
const THz: Quantity[f64, u.Frequency] = 1e12 * u.Hz
const PHz: Quantity[f64, u.Frequency] = 1e15 * u.Hz
const EHz: Quantity[f64, u.Frequency] = 1e18 * u.Hz
const ZHz: Quantity[f64, u.Frequency] = 1e21 * u.Hz
const YHz: Quantity[f64, u.Frequency] = 1e24 * u.Hz
const RHz: Quantity[f64, u.Frequency] = 1e27 * u.Hz
const QHz: Quantity[f64, u.Frequency] = 1e30 * u.Hz
const qN: Quantity[f64, u.Force] = 1e-30 * u.N
const rN: Quantity[f64, u.Force] = 1e-27 * u.N
const yN: Quantity[f64, u.Force] = 1e-24 * u.N
const zN: Quantity[f64, u.Force] = 1e-21 * u.N
const aN: Quantity[f64, u.Force] = 1e-18 * u.N
const fN: Quantity[f64, u.Force] = 1e-15 * u.N
const pN: Quantity[f64, u.Force] = 1e-12 * u.N
const nN: Quantity[f64, u.Force] = 1e-9 * u.N
const uN: Quantity[f64, u.Force] = 1e-6 * u.N
const mN: Quantity[f64, u.Force] = 1e-3 * u.N
const cN: Quantity[f64, u.Force] = 1e-2 * u.N
const dN: Quantity[f64, u.Force] = 1e-1 * u.N
const daN: Quantity[f64, u.Force] = 1e1 * u.N
const hN: Quantity[f64, u.Force] = 1e2 * u.N
const kN: Quantity[f64, u.Force] = 1e3 * u.N
const MN: Quantity[f64, u.Force] = 1e6 * u.N
const GN: Quantity[f64, u.Force] = 1e9 * u.N
const TN: Quantity[f64, u.Force] = 1e12 * u.N
const PN: Quantity[f64, u.Force] = 1e15 * u.N
const EN: Quantity[f64, u.Force] = 1e18 * u.N
const ZN: Quantity[f64, u.Force] = 1e21 * u.N
const YN: Quantity[f64, u.Force] = 1e24 * u.N
const RN: Quantity[f64, u.Force] = 1e27 * u.N
const QN: Quantity[f64, u.Force] = 1e30 * u.N
const qPa: Quantity[f64, u.Pressure] = 1e-30 * u.Pa
const rPa: Quantity[f64, u.Pressure] = 1e-27 * u.Pa
const yPa: Quantity[f64, u.Pressure] = 1e-24 * u.Pa
const zPa: Quantity[f64, u.Pressure] = 1e-21 * u.Pa
const aPa: Quantity[f64, u.Pressure] = 1e-18 * u.Pa
const fPa: Quantity[f64, u.Pressure] = 1e-15 * u.Pa
const pPa: Quantity[f64, u.Pressure] = 1e-12 * u.Pa
const nPa: Quantity[f64, u.Pressure] = 1e-9 * u.Pa
const uPa: Quantity[f64, u.Pressure] = 1e-6 * u.Pa
const mPa: Quantity[f64, u.Pressure] = 1e-3 * u.Pa
const cPa: Quantity[f64, u.Pressure] = 1e-2 * u.Pa
const dPa: Quantity[f64, u.Pressure] = 1e-1 * u.Pa
const daPa: Quantity[f64, u.Pressure] = 1e1 * u.Pa
const hPa: Quantity[f64, u.Pressure] = 1e2 * u.Pa
const kPa: Quantity[f64, u.Pressure] = 1e3 * u.Pa
const MPa: Quantity[f64, u.Pressure] = 1e6 * u.Pa
const GPa: Quantity[f64, u.Pressure] = 1e9 * u.Pa
const TPa: Quantity[f64, u.Pressure] = 1e12 * u.Pa
const PPa: Quantity[f64, u.Pressure] = 1e15 * u.Pa
const EPa: Quantity[f64, u.Pressure] = 1e18 * u.Pa
const ZPa: Quantity[f64, u.Pressure] = 1e21 * u.Pa
const YPa: Quantity[f64, u.Pressure] = 1e24 * u.Pa
const RPa: Quantity[f64, u.Pressure] = 1e27 * u.Pa
const QPa: Quantity[f64, u.Pressure] = 1e30 * u.Pa
const qJ: Quantity[f64, u.Energy] = 1e-30 * u.J
const rJ: Quantity[f64, u.Energy] = 1e-27 * u.J
const yJ: Quantity[f64, u.Energy] = 1e-24 * u.J
const zJ: Quantity[f64, u.Energy] = 1e-21 * u.J
const aJ: Quantity[f64, u.Energy] = 1e-18 * u.J
const fJ: Quantity[f64, u.Energy] = 1e-15 * u.J
const pJ: Quantity[f64, u.Energy] = 1e-12 * u.J
const nJ: Quantity[f64, u.Energy] = 1e-9 * u.J
const uJ: Quantity[f64, u.Energy] = 1e-6 * u.J
const mJ: Quantity[f64, u.Energy] = 1e-3 * u.J
const cJ: Quantity[f64, u.Energy] = 1e-2 * u.J
const dJ: Quantity[f64, u.Energy] = 1e-1 * u.J
const daJ: Quantity[f64, u.Energy] = 1e1 * u.J
const hJ: Quantity[f64, u.Energy] = 1e2 * u.J
const kJ: Quantity[f64, u.Energy] = 1e3 * u.J
const MJ: Quantity[f64, u.Energy] = 1e6 * u.J
const GJ: Quantity[f64, u.Energy] = 1e9 * u.J
const TJ: Quantity[f64, u.Energy] = 1e12 * u.J
const PJ: Quantity[f64, u.Energy] = 1e15 * u.J
const EJ: Quantity[f64, u.Energy] = 1e18 * u.J
const ZJ: Quantity[f64, u.Energy] = 1e21 * u.J
const YJ: Quantity[f64, u.Energy] = 1e24 * u.J
const RJ: Quantity[f64, u.Energy] = 1e27 * u.J
const QJ: Quantity[f64, u.Energy] = 1e30 * u.J
const qW: Quantity[f64, u.Power] = 1e-30 * u.W
const rW: Quantity[f64, u.Power] = 1e-27 * u.W
const yW: Quantity[f64, u.Power] = 1e-24 * u.W
const zW: Quantity[f64, u.Power] = 1e-21 * u.W
const aW: Quantity[f64, u.Power] = 1e-18 * u.W
const fW: Quantity[f64, u.Power] = 1e-15 * u.W
const pW: Quantity[f64, u.Power] = 1e-12 * u.W
const nW: Quantity[f64, u.Power] = 1e-9 * u.W
const uW: Quantity[f64, u.Power] = 1e-6 * u.W
const mW: Quantity[f64, u.Power] = 1e-3 * u.W
const cW: Quantity[f64, u.Power] = 1e-2 * u.W
const dW: Quantity[f64, u.Power] = 1e-1 * u.W
const daW: Quantity[f64, u.Power] = 1e1 * u.W
const hW: Quantity[f64, u.Power] = 1e2 * u.W
const kW: Quantity[f64, u.Power] = 1e3 * u.W
const MW: Quantity[f64, u.Power] = 1e6 * u.W
const GW: Quantity[f64, u.Power] = 1e9 * u.W
const TW: Quantity[f64, u.Power] = 1e12 * u.W
const PW: Quantity[f64, u.Power] = 1e15 * u.W
const EW: Quantity[f64, u.Power] = 1e18 * u.W
const ZW: Quantity[f64, u.Power] = 1e21 * u.W
const YW: Quantity[f64, u.Power] = 1e24 * u.W
const RW: Quantity[f64, u.Power] = 1e27 * u.W
const QW: Quantity[f64, u.Power] = 1e30 * u.W
const qC: Quantity[f64, u.Charge] = 1e-30 * u.C
const rC: Quantity[f64, u.Charge] = 1e-27 * u.C
const yC: Quantity[f64, u.Charge] = 1e-24 * u.C
const zC: Quantity[f64, u.Charge] = 1e-21 * u.C
const aC: Quantity[f64, u.Charge] = 1e-18 * u.C
const fC: Quantity[f64, u.Charge] = 1e-15 * u.C
const pC: Quantity[f64, u.Charge] = 1e-12 * u.C
const nC: Quantity[f64, u.Charge] = 1e-9 * u.C
const uC: Quantity[f64, u.Charge] = 1e-6 * u.C
const mC: Quantity[f64, u.Charge] = 1e-3 * u.C
const cC: Quantity[f64, u.Charge] = 1e-2 * u.C
const dC: Quantity[f64, u.Charge] = 1e-1 * u.C
const daC: Quantity[f64, u.Charge] = 1e1 * u.C
const hC: Quantity[f64, u.Charge] = 1e2 * u.C
const kC: Quantity[f64, u.Charge] = 1e3 * u.C
const MC: Quantity[f64, u.Charge] = 1e6 * u.C
const GC: Quantity[f64, u.Charge] = 1e9 * u.C
const TC: Quantity[f64, u.Charge] = 1e12 * u.C
const PC: Quantity[f64, u.Charge] = 1e15 * u.C
const EC: Quantity[f64, u.Charge] = 1e18 * u.C
const ZC: Quantity[f64, u.Charge] = 1e21 * u.C
const YC: Quantity[f64, u.Charge] = 1e24 * u.C
const RC: Quantity[f64, u.Charge] = 1e27 * u.C
const QC: Quantity[f64, u.Charge] = 1e30 * u.C
const qV: Quantity[f64, u.Voltage] = 1e-30 * u.V
const rV: Quantity[f64, u.Voltage] = 1e-27 * u.V
const yV: Quantity[f64, u.Voltage] = 1e-24 * u.V
const zV: Quantity[f64, u.Voltage] = 1e-21 * u.V
const aV: Quantity[f64, u.Voltage] = 1e-18 * u.V
const fV: Quantity[f64, u.Voltage] = 1e-15 * u.V
const pV: Quantity[f64, u.Voltage] = 1e-12 * u.V
const nV: Quantity[f64, u.Voltage] = 1e-9 * u.V
const uV: Quantity[f64, u.Voltage] = 1e-6 * u.V
const mV: Quantity[f64, u.Voltage] = 1e-3 * u.V
const cV: Quantity[f64, u.Voltage] = 1e-2 * u.V
const dV: Quantity[f64, u.Voltage] = 1e-1 * u.V
const daV: Quantity[f64, u.Voltage] = 1e1 * u.V
const hV: Quantity[f64, u.Voltage] = 1e2 * u.V
const kV: Quantity[f64, u.Voltage] = 1e3 * u.V
const MV: Quantity[f64, u.Voltage] = 1e6 * u.V
const GV: Quantity[f64, u.Voltage] = 1e9 * u.V
const TV: Quantity[f64, u.Voltage] = 1e12 * u.V
const PV: Quantity[f64, u.Voltage] = 1e15 * u.V
const EV: Quantity[f64, u.Voltage] = 1e18 * u.V
const ZV: Quantity[f64, u.Voltage] = 1e21 * u.V
const YV: Quantity[f64, u.Voltage] = 1e24 * u.V
const RV: Quantity[f64, u.Voltage] = 1e27 * u.V
const QV: Quantity[f64, u.Voltage] = 1e30 * u.V
const qF: Quantity[f64, u.Capacitance] = 1e-30 * u.F
const rF: Quantity[f64, u.Capacitance] = 1e-27 * u.F
const yF: Quantity[f64, u.Capacitance] = 1e-24 * u.F
const zF: Quantity[f64, u.Capacitance] = 1e-21 * u.F
const aF: Quantity[f64, u.Capacitance] = 1e-18 * u.F
const fF: Quantity[f64, u.Capacitance] = 1e-15 * u.F
const pF: Quantity[f64, u.Capacitance] = 1e-12 * u.F
const nF: Quantity[f64, u.Capacitance] = 1e-9 * u.F
const uF: Quantity[f64, u.Capacitance] = 1e-6 * u.F
const mF: Quantity[f64, u.Capacitance] = 1e-3 * u.F
const cF: Quantity[f64, u.Capacitance] = 1e-2 * u.F
const dF: Quantity[f64, u.Capacitance] = 1e-1 * u.F
const daF: Quantity[f64, u.Capacitance] = 1e1 * u.F
const hF: Quantity[f64, u.Capacitance] = 1e2 * u.F
const kF: Quantity[f64, u.Capacitance] = 1e3 * u.F
const MF: Quantity[f64, u.Capacitance] = 1e6 * u.F
const GF: Quantity[f64, u.Capacitance] = 1e9 * u.F
const TF: Quantity[f64, u.Capacitance] = 1e12 * u.F
const PF: Quantity[f64, u.Capacitance] = 1e15 * u.F
const EF: Quantity[f64, u.Capacitance] = 1e18 * u.F
const ZF: Quantity[f64, u.Capacitance] = 1e21 * u.F
const YF: Quantity[f64, u.Capacitance] = 1e24 * u.F
const RF: Quantity[f64, u.Capacitance] = 1e27 * u.F
const QF: Quantity[f64, u.Capacitance] = 1e30 * u.F
const qohm: Quantity[f64, u.Resistance] = 1e-30 * u.ohm
const rohm: Quantity[f64, u.Resistance] = 1e-27 * u.ohm
const yohm: Quantity[f64, u.Resistance] = 1e-24 * u.ohm
const zohm: Quantity[f64, u.Resistance] = 1e-21 * u.ohm
const aohm: Quantity[f64, u.Resistance] = 1e-18 * u.ohm
const fohm: Quantity[f64, u.Resistance] = 1e-15 * u.ohm
const pohm: Quantity[f64, u.Resistance] = 1e-12 * u.ohm
const nohm: Quantity[f64, u.Resistance] = 1e-9 * u.ohm
const uohm: Quantity[f64, u.Resistance] = 1e-6 * u.ohm
const milliohm: Quantity[f64, u.Resistance] = 1e-3 * u.ohm
const cohm: Quantity[f64, u.Resistance] = 1e-2 * u.ohm
const dohm: Quantity[f64, u.Resistance] = 1e-1 * u.ohm
const daohm: Quantity[f64, u.Resistance] = 1e1 * u.ohm
const hohm: Quantity[f64, u.Resistance] = 1e2 * u.ohm
const kohm: Quantity[f64, u.Resistance] = 1e3 * u.ohm
const Mohm: Quantity[f64, u.Resistance] = 1e6 * u.ohm
const Gohm: Quantity[f64, u.Resistance] = 1e9 * u.ohm
const Tohm: Quantity[f64, u.Resistance] = 1e12 * u.ohm
const Pohm: Quantity[f64, u.Resistance] = 1e15 * u.ohm
const Eohm: Quantity[f64, u.Resistance] = 1e18 * u.ohm
const Zohm: Quantity[f64, u.Resistance] = 1e21 * u.ohm
const Yohm: Quantity[f64, u.Resistance] = 1e24 * u.ohm
const Rohm: Quantity[f64, u.Resistance] = 1e27 * u.ohm
const Qohm: Quantity[f64, u.Resistance] = 1e30 * u.ohm
const qS: Quantity[f64, u.Conductance] = 1e-30 * u.S
const rS: Quantity[f64, u.Conductance] = 1e-27 * u.S
const yS: Quantity[f64, u.Conductance] = 1e-24 * u.S
const zS: Quantity[f64, u.Conductance] = 1e-21 * u.S
const aS: Quantity[f64, u.Conductance] = 1e-18 * u.S
const fS: Quantity[f64, u.Conductance] = 1e-15 * u.S
const pS: Quantity[f64, u.Conductance] = 1e-12 * u.S
const nS: Quantity[f64, u.Conductance] = 1e-9 * u.S
const uS: Quantity[f64, u.Conductance] = 1e-6 * u.S
const mS: Quantity[f64, u.Conductance] = 1e-3 * u.S
const cS: Quantity[f64, u.Conductance] = 1e-2 * u.S
const dS: Quantity[f64, u.Conductance] = 1e-1 * u.S
const daS: Quantity[f64, u.Conductance] = 1e1 * u.S
const hS: Quantity[f64, u.Conductance] = 1e2 * u.S
const kS: Quantity[f64, u.Conductance] = 1e3 * u.S
const MS: Quantity[f64, u.Conductance] = 1e6 * u.S
const GS: Quantity[f64, u.Conductance] = 1e9 * u.S
const TS: Quantity[f64, u.Conductance] = 1e12 * u.S
const PS: Quantity[f64, u.Conductance] = 1e15 * u.S
const ES: Quantity[f64, u.Conductance] = 1e18 * u.S
const ZS: Quantity[f64, u.Conductance] = 1e21 * u.S
const YS: Quantity[f64, u.Conductance] = 1e24 * u.S
const RS: Quantity[f64, u.Conductance] = 1e27 * u.S
const QS: Quantity[f64, u.Conductance] = 1e30 * u.S
const qWb: Quantity[f64, u.MagneticFlux] = 1e-30 * u.Wb
const rWb: Quantity[f64, u.MagneticFlux] = 1e-27 * u.Wb
const yWb: Quantity[f64, u.MagneticFlux] = 1e-24 * u.Wb
const zWb: Quantity[f64, u.MagneticFlux] = 1e-21 * u.Wb
const aWb: Quantity[f64, u.MagneticFlux] = 1e-18 * u.Wb
const fWb: Quantity[f64, u.MagneticFlux] = 1e-15 * u.Wb
const pWb: Quantity[f64, u.MagneticFlux] = 1e-12 * u.Wb
const nWb: Quantity[f64, u.MagneticFlux] = 1e-9 * u.Wb
const uWb: Quantity[f64, u.MagneticFlux] = 1e-6 * u.Wb
const mWb: Quantity[f64, u.MagneticFlux] = 1e-3 * u.Wb
const cWb: Quantity[f64, u.MagneticFlux] = 1e-2 * u.Wb
const dWb: Quantity[f64, u.MagneticFlux] = 1e-1 * u.Wb
const daWb: Quantity[f64, u.MagneticFlux] = 1e1 * u.Wb
const hWb: Quantity[f64, u.MagneticFlux] = 1e2 * u.Wb
const kWb: Quantity[f64, u.MagneticFlux] = 1e3 * u.Wb
const MWb: Quantity[f64, u.MagneticFlux] = 1e6 * u.Wb
const GWb: Quantity[f64, u.MagneticFlux] = 1e9 * u.Wb
const TWb: Quantity[f64, u.MagneticFlux] = 1e12 * u.Wb
const PWb: Quantity[f64, u.MagneticFlux] = 1e15 * u.Wb
const EWb: Quantity[f64, u.MagneticFlux] = 1e18 * u.Wb
const ZWb: Quantity[f64, u.MagneticFlux] = 1e21 * u.Wb
const YWb: Quantity[f64, u.MagneticFlux] = 1e24 * u.Wb
const RWb: Quantity[f64, u.MagneticFlux] = 1e27 * u.Wb
const QWb: Quantity[f64, u.MagneticFlux] = 1e30 * u.Wb
const qT: Quantity[f64, u.MagneticFluxDensity] = 1e-30 * u.T
const rT: Quantity[f64, u.MagneticFluxDensity] = 1e-27 * u.T
const yT: Quantity[f64, u.MagneticFluxDensity] = 1e-24 * u.T
const zT: Quantity[f64, u.MagneticFluxDensity] = 1e-21 * u.T
const aT: Quantity[f64, u.MagneticFluxDensity] = 1e-18 * u.T
const fT: Quantity[f64, u.MagneticFluxDensity] = 1e-15 * u.T
const pT: Quantity[f64, u.MagneticFluxDensity] = 1e-12 * u.T
const nT: Quantity[f64, u.MagneticFluxDensity] = 1e-9 * u.T
const uT: Quantity[f64, u.MagneticFluxDensity] = 1e-6 * u.T
const mT: Quantity[f64, u.MagneticFluxDensity] = 1e-3 * u.T
const cT: Quantity[f64, u.MagneticFluxDensity] = 1e-2 * u.T
const dT: Quantity[f64, u.MagneticFluxDensity] = 1e-1 * u.T
const daT: Quantity[f64, u.MagneticFluxDensity] = 1e1 * u.T
const hT: Quantity[f64, u.MagneticFluxDensity] = 1e2 * u.T
const kT: Quantity[f64, u.MagneticFluxDensity] = 1e3 * u.T
const MT: Quantity[f64, u.MagneticFluxDensity] = 1e6 * u.T
const GT: Quantity[f64, u.MagneticFluxDensity] = 1e9 * u.T
const TT: Quantity[f64, u.MagneticFluxDensity] = 1e12 * u.T
const PT: Quantity[f64, u.MagneticFluxDensity] = 1e15 * u.T
const ET: Quantity[f64, u.MagneticFluxDensity] = 1e18 * u.T
const ZT: Quantity[f64, u.MagneticFluxDensity] = 1e21 * u.T
const YT: Quantity[f64, u.MagneticFluxDensity] = 1e24 * u.T
const RT: Quantity[f64, u.MagneticFluxDensity] = 1e27 * u.T
const QT: Quantity[f64, u.MagneticFluxDensity] = 1e30 * u.T
const qH: Quantity[f64, u.Inductance] = 1e-30 * u.H
const rH: Quantity[f64, u.Inductance] = 1e-27 * u.H
const yH: Quantity[f64, u.Inductance] = 1e-24 * u.H
const zH: Quantity[f64, u.Inductance] = 1e-21 * u.H
const aH: Quantity[f64, u.Inductance] = 1e-18 * u.H
const fH: Quantity[f64, u.Inductance] = 1e-15 * u.H
const pH: Quantity[f64, u.Inductance] = 1e-12 * u.H
const nH: Quantity[f64, u.Inductance] = 1e-9 * u.H
const uH: Quantity[f64, u.Inductance] = 1e-6 * u.H
const mH: Quantity[f64, u.Inductance] = 1e-3 * u.H
const cH: Quantity[f64, u.Inductance] = 1e-2 * u.H
const dH: Quantity[f64, u.Inductance] = 1e-1 * u.H
const daH: Quantity[f64, u.Inductance] = 1e1 * u.H
const hH: Quantity[f64, u.Inductance] = 1e2 * u.H
const kH: Quantity[f64, u.Inductance] = 1e3 * u.H
const MH: Quantity[f64, u.Inductance] = 1e6 * u.H
const GH: Quantity[f64, u.Inductance] = 1e9 * u.H
const TH: Quantity[f64, u.Inductance] = 1e12 * u.H
const PH: Quantity[f64, u.Inductance] = 1e15 * u.H
const EH: Quantity[f64, u.Inductance] = 1e18 * u.H
const ZH: Quantity[f64, u.Inductance] = 1e21 * u.H
const YH: Quantity[f64, u.Inductance] = 1e24 * u.H
const RH: Quantity[f64, u.Inductance] = 1e27 * u.H
const QH: Quantity[f64, u.Inductance] = 1e30 * u.H
const qlm: Quantity[f64, u.Luminosity] = 1e-30 * u.lm
const rlm: Quantity[f64, u.Luminosity] = 1e-27 * u.lm
const ylm: Quantity[f64, u.Luminosity] = 1e-24 * u.lm
const zlm: Quantity[f64, u.Luminosity] = 1e-21 * u.lm
const alm: Quantity[f64, u.Luminosity] = 1e-18 * u.lm
const flm: Quantity[f64, u.Luminosity] = 1e-15 * u.lm
const plm: Quantity[f64, u.Luminosity] = 1e-12 * u.lm
const nlm: Quantity[f64, u.Luminosity] = 1e-9 * u.lm
const ulm: Quantity[f64, u.Luminosity] = 1e-6 * u.lm
const mlm: Quantity[f64, u.Luminosity] = 1e-3 * u.lm
const clm: Quantity[f64, u.Luminosity] = 1e-2 * u.lm
const dlm: Quantity[f64, u.Luminosity] = 1e-1 * u.lm
const dalm: Quantity[f64, u.Luminosity] = 1e1 * u.lm
const hlm: Quantity[f64, u.Luminosity] = 1e2 * u.lm
const klm: Quantity[f64, u.Luminosity] = 1e3 * u.lm
const Mlm: Quantity[f64, u.Luminosity] = 1e6 * u.lm
const Glm: Quantity[f64, u.Luminosity] = 1e9 * u.lm
const Tlm: Quantity[f64, u.Luminosity] = 1e12 * u.lm
const Plm: Quantity[f64, u.Luminosity] = 1e15 * u.lm
const Elm: Quantity[f64, u.Luminosity] = 1e18 * u.lm
const Zlm: Quantity[f64, u.Luminosity] = 1e21 * u.lm
const Ylm: Quantity[f64, u.Luminosity] = 1e24 * u.lm
const Rlm: Quantity[f64, u.Luminosity] = 1e27 * u.lm
const Qlm: Quantity[f64, u.Luminosity] = 1e30 * u.lm
const qlx: Quantity[f64, u.Illuminance] = 1e-30 * u.lx
const rlx: Quantity[f64, u.Illuminance] = 1e-27 * u.lx
const ylx: Quantity[f64, u.Illuminance] = 1e-24 * u.lx
const zlx: Quantity[f64, u.Illuminance] = 1e-21 * u.lx
const alx: Quantity[f64, u.Illuminance] = 1e-18 * u.lx
const flx: Quantity[f64, u.Illuminance] = 1e-15 * u.lx
const plx: Quantity[f64, u.Illuminance] = 1e-12 * u.lx
const nlx: Quantity[f64, u.Illuminance] = 1e-9 * u.lx
const ulx: Quantity[f64, u.Illuminance] = 1e-6 * u.lx
const mlx: Quantity[f64, u.Illuminance] = 1e-3 * u.lx
const clx: Quantity[f64, u.Illuminance] = 1e-2 * u.lx
const dlx: Quantity[f64, u.Illuminance] = 1e-1 * u.lx
const dalx: Quantity[f64, u.Illuminance] = 1e1 * u.lx
const hlx: Quantity[f64, u.Illuminance] = 1e2 * u.lx
const klx: Quantity[f64, u.Illuminance] = 1e3 * u.lx
const Mlx: Quantity[f64, u.Illuminance] = 1e6 * u.lx
const Glx: Quantity[f64, u.Illuminance] = 1e9 * u.lx
const Tlx: Quantity[f64, u.Illuminance] = 1e12 * u.lx
const Plx: Quantity[f64, u.Illuminance] = 1e15 * u.lx
const Elx: Quantity[f64, u.Illuminance] = 1e18 * u.lx
const Zlx: Quantity[f64, u.Illuminance] = 1e21 * u.lx
const Ylx: Quantity[f64, u.Illuminance] = 1e24 * u.lx
const Rlx: Quantity[f64, u.Illuminance] = 1e27 * u.lx
const Qlx: Quantity[f64, u.Illuminance] = 1e30 * u.lx
const qBq: Quantity[f64, u.Frequency] = 1e-30 * u.Bq
const rBq: Quantity[f64, u.Frequency] = 1e-27 * u.Bq
const yBq: Quantity[f64, u.Frequency] = 1e-24 * u.Bq
const zBq: Quantity[f64, u.Frequency] = 1e-21 * u.Bq
const aBq: Quantity[f64, u.Frequency] = 1e-18 * u.Bq
const fBq: Quantity[f64, u.Frequency] = 1e-15 * u.Bq
const pBq: Quantity[f64, u.Frequency] = 1e-12 * u.Bq
const nBq: Quantity[f64, u.Frequency] = 1e-9 * u.Bq
const uBq: Quantity[f64, u.Frequency] = 1e-6 * u.Bq
const mBq: Quantity[f64, u.Frequency] = 1e-3 * u.Bq
const cBq: Quantity[f64, u.Frequency] = 1e-2 * u.Bq
const dBq: Quantity[f64, u.Frequency] = 1e-1 * u.Bq
const daBq: Quantity[f64, u.Frequency] = 1e1 * u.Bq
const hBq: Quantity[f64, u.Frequency] = 1e2 * u.Bq
const kBq: Quantity[f64, u.Frequency] = 1e3 * u.Bq
const MBq: Quantity[f64, u.Frequency] = 1e6 * u.Bq
const GBq: Quantity[f64, u.Frequency] = 1e9 * u.Bq
const TBq: Quantity[f64, u.Frequency] = 1e12 * u.Bq
const PBq: Quantity[f64, u.Frequency] = 1e15 * u.Bq
const EBq: Quantity[f64, u.Frequency] = 1e18 * u.Bq
const ZBq: Quantity[f64, u.Frequency] = 1e21 * u.Bq
const YBq: Quantity[f64, u.Frequency] = 1e24 * u.Bq
const RBq: Quantity[f64, u.Frequency] = 1e27 * u.Bq
const QBq: Quantity[f64, u.Frequency] = 1e30 * u.Bq
const qGy: Quantity[f64, u.SpecificEnergy] = 1e-30 * u.Gy
const rGy: Quantity[f64, u.SpecificEnergy] = 1e-27 * u.Gy
const yGy: Quantity[f64, u.SpecificEnergy] = 1e-24 * u.Gy
const zGy: Quantity[f64, u.SpecificEnergy] = 1e-21 * u.Gy
const aGy: Quantity[f64, u.SpecificEnergy] = 1e-18 * u.Gy
const fGy: Quantity[f64, u.SpecificEnergy] = 1e-15 * u.Gy
const pGy: Quantity[f64, u.SpecificEnergy] = 1e-12 * u.Gy
const nGy: Quantity[f64, u.SpecificEnergy] = 1e-9 * u.Gy
const uGy: Quantity[f64, u.SpecificEnergy] = 1e-6 * u.Gy
const mGy: Quantity[f64, u.SpecificEnergy] = 1e-3 * u.Gy
const cGy: Quantity[f64, u.SpecificEnergy] = 1e-2 * u.Gy
const dGy: Quantity[f64, u.SpecificEnergy] = 1e-1 * u.Gy
const daGy: Quantity[f64, u.SpecificEnergy] = 1e1 * u.Gy
const hGy: Quantity[f64, u.SpecificEnergy] = 1e2 * u.Gy
const kGy: Quantity[f64, u.SpecificEnergy] = 1e3 * u.Gy
const MGy: Quantity[f64, u.SpecificEnergy] = 1e6 * u.Gy
const GGy: Quantity[f64, u.SpecificEnergy] = 1e9 * u.Gy
const TGy: Quantity[f64, u.SpecificEnergy] = 1e12 * u.Gy
const PGy: Quantity[f64, u.SpecificEnergy] = 1e15 * u.Gy
const EGy: Quantity[f64, u.SpecificEnergy] = 1e18 * u.Gy
const ZGy: Quantity[f64, u.SpecificEnergy] = 1e21 * u.Gy
const YGy: Quantity[f64, u.SpecificEnergy] = 1e24 * u.Gy
const RGy: Quantity[f64, u.SpecificEnergy] = 1e27 * u.Gy
const QGy: Quantity[f64, u.SpecificEnergy] = 1e30 * u.Gy
const qSv: Quantity[f64, u.SpecificEnergy] = 1e-30 * u.Sv
const rSv: Quantity[f64, u.SpecificEnergy] = 1e-27 * u.Sv
const ySv: Quantity[f64, u.SpecificEnergy] = 1e-24 * u.Sv
const zSv: Quantity[f64, u.SpecificEnergy] = 1e-21 * u.Sv
const aSv: Quantity[f64, u.SpecificEnergy] = 1e-18 * u.Sv
const fSv: Quantity[f64, u.SpecificEnergy] = 1e-15 * u.Sv
const pSv: Quantity[f64, u.SpecificEnergy] = 1e-12 * u.Sv
const nSv: Quantity[f64, u.SpecificEnergy] = 1e-9 * u.Sv
const uSv: Quantity[f64, u.SpecificEnergy] = 1e-6 * u.Sv
const mSv: Quantity[f64, u.SpecificEnergy] = 1e-3 * u.Sv
const cSv: Quantity[f64, u.SpecificEnergy] = 1e-2 * u.Sv
const dSv: Quantity[f64, u.SpecificEnergy] = 1e-1 * u.Sv
const daSv: Quantity[f64, u.SpecificEnergy] = 1e1 * u.Sv
const hSv: Quantity[f64, u.SpecificEnergy] = 1e2 * u.Sv
const kSv: Quantity[f64, u.SpecificEnergy] = 1e3 * u.Sv
const MSv: Quantity[f64, u.SpecificEnergy] = 1e6 * u.Sv
const GSv: Quantity[f64, u.SpecificEnergy] = 1e9 * u.Sv
const TSv: Quantity[f64, u.SpecificEnergy] = 1e12 * u.Sv
const PSv: Quantity[f64, u.SpecificEnergy] = 1e15 * u.Sv
const ESv: Quantity[f64, u.SpecificEnergy] = 1e18 * u.Sv
const ZSv: Quantity[f64, u.SpecificEnergy] = 1e21 * u.Sv
const YSv: Quantity[f64, u.SpecificEnergy] = 1e24 * u.Sv
const RSv: Quantity[f64, u.SpecificEnergy] = 1e27 * u.Sv
const QSv: Quantity[f64, u.SpecificEnergy] = 1e30 * u.Sv
const qkat: Quantity[f64, u.CatalyticActivity] = 1e-30 * u.kat
const rkat: Quantity[f64, u.CatalyticActivity] = 1e-27 * u.kat
const ykat: Quantity[f64, u.CatalyticActivity] = 1e-24 * u.kat
const zkat: Quantity[f64, u.CatalyticActivity] = 1e-21 * u.kat
const akat: Quantity[f64, u.CatalyticActivity] = 1e-18 * u.kat
const fkat: Quantity[f64, u.CatalyticActivity] = 1e-15 * u.kat
const pkat: Quantity[f64, u.CatalyticActivity] = 1e-12 * u.kat
const nkat: Quantity[f64, u.CatalyticActivity] = 1e-9 * u.kat
const ukat: Quantity[f64, u.CatalyticActivity] = 1e-6 * u.kat
const mkat: Quantity[f64, u.CatalyticActivity] = 1e-3 * u.kat
const ckat: Quantity[f64, u.CatalyticActivity] = 1e-2 * u.kat
const dkat: Quantity[f64, u.CatalyticActivity] = 1e-1 * u.kat
const dakat: Quantity[f64, u.CatalyticActivity] = 1e1 * u.kat
const hkat: Quantity[f64, u.CatalyticActivity] = 1e2 * u.kat
const kkat: Quantity[f64, u.CatalyticActivity] = 1e3 * u.kat
const Mkat: Quantity[f64, u.CatalyticActivity] = 1e6 * u.kat
const Gkat: Quantity[f64, u.CatalyticActivity] = 1e9 * u.kat
const Tkat: Quantity[f64, u.CatalyticActivity] = 1e12 * u.kat
const Pkat: Quantity[f64, u.CatalyticActivity] = 1e15 * u.kat
const Ekat: Quantity[f64, u.CatalyticActivity] = 1e18 * u.kat
const Zkat: Quantity[f64, u.CatalyticActivity] = 1e21 * u.kat
const Ykat: Quantity[f64, u.CatalyticActivity] = 1e24 * u.kat
const Rkat: Quantity[f64, u.CatalyticActivity] = 1e27 * u.kat
const Qkat: Quantity[f64, u.CatalyticActivity] = 1e30 * u.kat
const microlitre: Quantity[f64, u.Volume] = 1e-9 * (u.m * u.m * u.m)
const centilitre: Quantity[f64, u.Volume] = 1e-5 * (u.m * u.m * u.m)
const decilitre: Quantity[f64, u.Volume] = 1e-4 * (u.m * u.m * u.m)
const hectolitre: Quantity[f64, u.Volume] = 1e-1 * (u.m * u.m * u.m)
const kilolitre: Quantity[f64, u.Volume] = u.m * u.m * u.m
const megalitre: Quantity[f64, u.Volume] = 1e3 * (u.m * u.m * u.m)
const meV: Quantity[f64, u.Energy] = 1e-3 * u.eV
const TeV: Quantity[f64, u.Energy] = 1e12 * u.eV
const TWh: Quantity[f64, u.Energy] = 1e12 * u.Wh
const fermi: Quantity[f64, u.Length] = 1e-15 * u.m
const micron: Quantity[f64, u.Length] = 1e-6 * u.m
const mil: Quantity[f64, u.Length] = 1e-3 * u.inch
const microinch: Quantity[f64, u.Length] = 1e-6 * u.inch
const point: Quantity[f64, u.Length] = u.inch / 72.0
const pica: Quantity[f64, u.Length] = u.inch / 6.0
const printers_point: Quantity[f64, u.Length] = 0.013837 * u.inch
const printers_pica: Quantity[f64, u.Length] = 12.0 * printers_point
const survey_foot: Quantity[f64, u.Length] = (1200.0 / 3937.0) * u.m
const survey_mile: Quantity[f64, u.Length] = 5280.0 * survey_foot
const chain: Quantity[f64, u.Length] = 66.0 * survey_foot
const rod: Quantity[f64, u.Length] = 16.5 * survey_foot
const fathom: Quantity[f64, u.Length] = 6.0 * survey_foot
const are: Quantity[f64, u.Area] = 1e2 * (u.m * u.m)
const barn: Quantity[f64, u.Area] = 1e-28 * (u.m * u.m)
const circular_mil: Quantity[f64, u.Area] = (f64.PI / 4.0) * (mil * mil)
const survey_acre: Quantity[f64, u.Area] = 43560.0 * (survey_foot * survey_foot)
const darcy: Quantity[f64, u.Area] = u.cm * (1e-3 * u.Pa * u.s) * (u.cm * u.cm * u.cm / u.s) / (u.cm * u.cm * u.atm)
const stere: Quantity[f64, u.Volume] = u.m * u.m * u.m
const acre_foot: Quantity[f64, u.Volume] = survey_acre * survey_foot
const barrel: Quantity[f64, u.Volume] = 42.0 * u.gallon
const quart: Quantity[f64, u.Volume] = u.gallon / 4.0
const pint: Quantity[f64, u.Volume] = u.gallon / 8.0
const cup: Quantity[f64, u.Volume] = u.gallon / 16.0
const gill: Quantity[f64, u.Volume] = u.gallon / 32.0
const fluid_ounce: Quantity[f64, u.Volume] = u.gallon / 128.0
const tablespoon: Quantity[f64, u.Volume] = fluid_ounce / 2.0
const teaspoon: Quantity[f64, u.Volume] = fluid_ounce / 6.0
const bushel: Quantity[f64, u.Volume] = 2150.42 * (u.inch * u.inch * u.inch)
const peck: Quantity[f64, u.Volume] = bushel / 4.0
const dry_quart: Quantity[f64, u.Volume] = bushel / 32.0
const dry_pint: Quantity[f64, u.Volume] = bushel / 64.0
const imperial_gallon: Quantity[f64, u.Volume] = 4.54609e-3 * (u.m * u.m * u.m)
const imperial_gill: Quantity[f64, u.Volume] = imperial_gallon / 32.0
const imperial_fluid_ounce: Quantity[f64, u.Volume] = imperial_gallon / 160.0
const cord: Quantity[f64, u.Volume] = 128.0 * (u.foot * u.foot * u.foot)
const register_ton: Quantity[f64, u.Volume] = 100.0 * (u.foot * u.foot * u.foot)
const carat: Quantity[f64, u.Mass] = 200.0 * u.mg
const grain: Quantity[f64, u.Mass] = 64.79891 * u.mg
const pennyweight: Quantity[f64, u.Mass] = 24.0 * grain
const troy_ounce: Quantity[f64, u.Mass] = 480.0 * grain
const troy_pound: Quantity[f64, u.Mass] = 5760.0 * grain
const short_hundredweight: Quantity[f64, u.Mass] = 100.0 * u.pound
const long_hundredweight: Quantity[f64, u.Mass] = 112.0 * u.pound
const short_ton: Quantity[f64, u.Mass] = 2000.0 * u.pound
const long_ton: Quantity[f64, u.Mass] = 2240.0 * u.pound
const assay_ton: Quantity[f64, u.Mass] = (short_ton / troy_ounce) * u.mg
const slug: Quantity[f64, u.Mass] = u.pound_force * u.s * u.s / u.foot
const shake: Quantity[f64, u.Time] = 1e-8 * u.s
const sidereal_day: Quantity[f64, u.Time] = 86164.0905 * u.s
const sidereal_hour: Quantity[f64, u.Time] = sidereal_day / 24.0
const sidereal_minute: Quantity[f64, u.Time] = sidereal_hour / 60.0
const sidereal_second: Quantity[f64, u.Time] = sidereal_minute / 60.0
const sidereal_year: Quantity[f64, u.Time] = 365.256363004 * u.day
const tropical_year: Quantity[f64, u.Time] = 365.24219 * u.day
const dyne: Quantity[f64, u.Force] = 1e-5 * u.N
const kilogram_force: Quantity[f64, u.Force] = u.kg * u.g_n
const ounce_force: Quantity[f64, u.Force] = u.pound_force / 16.0
const poundal: Quantity[f64, u.Force] = u.pound * u.foot / (u.s * u.s)
const kip: Quantity[f64, u.Force] = 1e3 * u.pound_force
const ton_force: Quantity[f64, u.Force] = 2000.0 * u.pound_force
const technical_atmosphere: Quantity[f64, u.Pressure] = kilogram_force / (u.cm * u.cm)
const ksi: Quantity[f64, u.Pressure] = 1e3 * u.psi
const cmHg: Quantity[f64, u.Pressure] = 10.0 * u.mmHg
const inHg: Quantity[f64, u.Pressure] = 25.4 * u.mmHg
const ftHg: Quantity[f64, u.Pressure] = 304.8 * u.mmHg
const mmH2O: Quantity[f64, u.Pressure] = water_density * u.g_n * u.mm
const cmH2O: Quantity[f64, u.Pressure] = water_density * u.g_n * u.cm
const inH2O: Quantity[f64, u.Pressure] = water_density * u.g_n * u.inch
const ftH2O: Quantity[f64, u.Pressure] = water_density * u.g_n * u.foot
const erg: Quantity[f64, u.Energy] = 1e-7 * u.J
const calorie_IT: Quantity[f64, u.Energy] = 4.1868 * u.J
const kilocalorie_IT: Quantity[f64, u.Energy] = 4186.8 * u.J
const btu_th: Quantity[f64, u.Energy] = u.calorie / (u.g * u.K) * u.pound * u.rankine
const therm_EC: Quantity[f64, u.Energy] = 1.05506e8 * u.J
const therm_US: Quantity[f64, u.Energy] = 1.054804e8 * u.J
const quad: Quantity[f64, u.Energy] = 1e15 * u.btu
const ton_of_tnt: Quantity[f64, u.Energy] = 4.184e9 * u.J
const horsepower_electric: Quantity[f64, u.Power] = 746.0 * u.W
const horsepower_metric: Quantity[f64, u.Power] = 75.0 * kilogram_force * u.m / u.s
const ton_of_refrigeration: Quantity[f64, u.Power] = 12000.0 * u.btu / u.hour
const poise: Quantity[f64, u.DynamicViscosity] = 0.1 * u.Pa * u.s
const centipoise: Quantity[f64, u.DynamicViscosity] = 1e-3 * u.Pa * u.s
const rhe: Quantity[f64, One / u.DynamicViscosity] = 1.0 / poise
const stokes: Quantity[f64, u.KinematicViscosity] = 1e-4 * (u.m * u.m) / u.s
const centistokes: Quantity[f64, u.KinematicViscosity] = 1e-6 * (u.m * u.m) / u.s
const ampere_hour: Quantity[f64, u.Charge] = u.A * u.hour
const milliampere_hour: Quantity[f64, u.Charge] = u.mA * u.hour
const faraday: Quantity[f64, u.Charge] = u.e * u.N_A * u.mol
const mho: Quantity[f64, u.Conductance] = u.S
const debye: Quantity[f64, ElectricDipoleMoment] = 1e-21 * u.C * u.m * u.m / (u.c * u.s)
const gauss: Quantity[f64, u.MagneticFluxDensity] = 1e-4 * u.T
const gamma: Quantity[f64, u.MagneticFluxDensity] = 1e-9 * u.T
const maxwell: Quantity[f64, u.MagneticFlux] = 1e-8 * u.Wb
const oersted: Quantity[f64, MagneticFieldStrength] = (1e3 / (4.0 * f64.PI)) * u.A / u.m
const curie: Quantity[f64, u.Frequency] = 3.7e10 * u.Bq
const rad_dose: Quantity[f64, u.SpecificEnergy] = 1e-2 * u.Gy
const rem: Quantity[f64, u.SpecificEnergy] = 1e-2 * u.Sv
const roentgen: Quantity[f64, Exposure] = 2.58e-4 * u.C / u.kg
const footcandle: Quantity[f64, u.Illuminance] = u.lm / (u.foot * u.foot)
const phot: Quantity[f64, u.Illuminance] = u.lm / (u.cm * u.cm)
const stilb: Quantity[f64, Luminance] = u.cd / (u.cm * u.cm)
const lambert: Quantity[f64, Luminance] = u.cd / (f64.PI * u.cm * u.cm)
const footlambert: Quantity[f64, Luminance] = u.cd / (f64.PI * u.foot * u.foot)
const revolution: Quantity[f64, One] = 2.0 * f64.PI * u.rad
const gon: Quantity[f64, One] = (f64.PI / 200.0) * u.rad
const angular_mil: Quantity[f64, One] = (2.0 * f64.PI / 6400.0) * u.rad
const gal: Quantity[f64, u.Acceleration] = 1e-2 * u.m / (u.s * u.s)
const kayser: Quantity[f64, u.Wavenumber] = 1e2 / u.m
const tex: Quantity[f64, LinearDensity] = u.g / u.km
const denier: Quantity[f64, LinearDensity] = u.g / (9000.0 * u.m)

std.url

Strict RFC 3986 absolute URL parsing and formatting without normalization, component-aware percent encoding, and query pairs. Errors: UrlError. Reference.

enum UrlError
    LimitExceeded | MissingScheme | MissingHost | InvalidByte(i64) | InvalidEscape(i64) | InvalidHost(i64) | InvalidPort(i64) | InvalidUtf8 | Allocation(AllocError)
enum Component
    Userinfo | Segment | Path | Query | QueryPart | Fragment
class Url
    scheme: str
    userinfo: Option[str]
    host: Option[str]
    port: Option[i64]
    path: str
    query: Option[str]
    fragment: Option[str]
    def to_string(self) -> Result[str, UrlError]
class Pair
    key: str
    value: str
def parse(text: &str, max_bytes: NonNegative[i64]) -> Result[Url, UrlError]
def encode_bytes(source: &[u8], component: Component) -> Result[Bytes, UrlError]
def decode_bytes(source: &[u8]) -> Result[Bytes, UrlError]
def encode(text: &str, component: Component) -> Result[str, UrlError]
def decode(text: &str) -> Result[str, UrlError]
def query_pairs(query: &str) -> Result[list[Pair], UrlError]
def query_text(pairs: &list[Pair]) -> Result[str, UrlError]

std.uuid

UUID values, canonical text and network bytes, random v4 and timestamp-prefixed v7 generation. Errors: ParseError, BytesError, SecretsError, RangeError. Reference.

class Uuid
    def as_u64_pair(self) -> (u64, u64)
    def compare(self, other: &Uuid) -> i64
    def is_nil(self) -> bool
    def is_rfc_variant(self) -> bool
    def version(self) -> Option[u8]
    def unix_milliseconds(self) -> Option[u64]
    def write_bytes(self, target: &mut Bytes, offset: i64) -> ()
    def to_bytes(self) -> Result[Bytes, BytesError]
    def to_string(self) -> Result[str, BytesError]
def nil() -> Uuid
def from_u64_pair(high: u64, low: u64) -> Uuid
def parse(text: &str) -> Result[Uuid, ParseError]
def from_bytes(source: &[u8]) -> Result[Uuid, ParseError]
def v4_from[R: Reader](source: &mut Source[R]) -> Result[Uuid, SecretsError]
def v4() -> Result[Uuid, SecretsError]
def v7_from[R: Reader](at: &Timestamp, source: &mut Source[R]) -> Result[Uuid, RangeError | SecretsError]
def v7() -> Result[Uuid, RangeError | SecretsError]

std.xml

Bounded UTF-8 XML event readers and validating stream writers, without DTDs or external entities. Errors: XmlError. Reference.

enum Fault
    Syntax | UnexpectedEnd | InvalidName | InvalidCharacter | InvalidUtf8 | InvalidReference | UnknownEntity | DuplicateAttribute | MismatchedEnd | DoctypeForbidden | UnsupportedDeclaration | DepthExceeded | InputTooLarge | OutputTooLarge | TokenTooLarge | TooManyAttributes | InvalidState | Stopped | Allocation(AllocError) | Stream(StreamError)
class XmlError
    fault: Fault
    offset: i64
class Limits
    max_depth: NonNegative[i64]
    max_input: NonNegative[i64]
    max_output: NonNegative[i64]
    max_token: Positive[i64]
    max_attributes: NonNegative[i64]
def limits() -> Limits
class Attribute
    name: str
    value: str
enum Event
    Declaration(Option[bool]) | Start(str, list[Attribute]) | Empty(str, list[Attribute]) | End(str) | Text(str) | CData(str) | Comment(str) | ProcessingInstruction(str, str) | Eof
class Reader[R]
    inner: R
    def offset(self) -> i64
    def next(self: &mut Reader[R]) -> Result[Event, XmlError]
def reader[R](inner: R, bounds: &Limits) -> Result[Reader[R], XmlError]
class Writer[W]
    inner: W
    def offset(self) -> i64
    def write(self: &mut Writer[W], event: &Event) -> Result[(), XmlError]
    def finish(self: &mut Writer[W]) -> Result[(), XmlError]
def writer[W](inner: W, bounds: &Limits) -> Result[Writer[W], XmlError]