std — API Documentation v0.2.32

Memory allocation abstractions and global allocator interface.

Runtime assertion and panic functions.

Declarative build API for Yo projects.

Process environment: command-line arguments, environment variables,

Standard error handling types and traits for Yo.

Garbage collection interface for cycle collection.

Glob pattern matching for file paths.

Hashing — the Hasher implementations behind the prelude's Hash trait

Structured logging — level-filtered, optionally timestamped and

Floating-point mathematics — the Yo-level surface over libc/math.

Cross-platform filesystem path manipulation.

Prelude — automatically imported into every Yo source file.

Non-cryptographic pseudo-random numbers — seedable, reproducible, fast

High-level signal handling.

Terminal facade: TTY detection, terminal size, color-support detection and

OS threads and a thread pool, each thread with its own Io event loop and

Async (event-loop) channel — deliver values BETWEEN TASKS on one thread's

Async task utilities — cooperative yield and JoinHandle combinators

Async (event-loop) mutex — a critical section that may SPAN AWAITS

Async iteration — the Stream trait: "a value, later, repeatedly"

Waker and park — the "resume THIS task" primitive.

Command-line argument parsing.

Dynamic array (vector) with amortized O(1) push and O(1) indexed access.

Sorted map backed by a sorted array with O(log n) lookup via binary

Double-ended queue (ring buffer) with O(1) push/pop at both ends.

The key/value entry shared by every map in the standard library.

Hash map with a SwissTable-style control-byte layout.

Hash set — a thin set-shaped view over HashMap(T, unit) (D16).

Doubly-linked list with O(1) push/pop at both ends.

Insertion-ordered map.

Binary MAX-heap priority queue — Rust's BinaryHeap (D11).

CRC-32 (IEEE 802.3, reflected, polynomial 0xEDB88320) — the checksum

The streaming Digest trait — one interface over Sha256 / Sha512 /

HMAC (RFC 2104) — generic over any Digest implementor

MD5 hash function (RFC 1321), pure Yo implementation.

Cryptographically secure random number generation.

SHA-1 (FIPS 180-4) — streaming hasher + one-shot helpers

SHA-256 hash function (FIPS 180-4), pure Yo implementation.

SHA-512 (FIPS 180-4) — streaming hasher + one-shot helpers

TLS client streams over OpenSSL — plans/archive/D6_TLS_PLAN.md (the O2

Base64 encoding and decoding (RFC 4648) with standard and URL-safe variants.

CSV (RFC 4180) reader and writer.

Shared error type for the std/encoding codecs.

Hexadecimal encoding and decoding.

HTML entity decoding — named, decimal, and hexadecimal character references.

HTML character utility functions.

HTML5 named character references data.

JSON parsing and serialization (RFC 8259).

Percent-encoding (RFC 3986) — the URI component codec

TOML v1.0.0 parsing and serialization.

UTF-8 to UTF-16 conversion and vice versa.

UTF-8 primitives — the single decoder/encoder the rest of std is built on.

The Format protocol — value.format(spec) (STD_API_AUDIT D3.10).

Formatted output to stdout and stderr.

Format specifications — the ${value:spec} vocabulary (STD_API_AUDIT D3.10).

ToString and Debug — the two rendering channels, and their impls for

Async directory operations — create, remove, read, link, rename.

Async file I/O operations with Exception-based error handling.

File metadata via statx with ergonomic accessors.

RAII-managed temporary files and directories.

File system types for open modes, permissions, and seek positions.

Recursive directory traversal.

File-system change notifications (fs.watch, plans/archive/STD_API_AUDIT.md §7 P1).

Async HTTP client — fetch and fetch_with, shaped like JavaScript's

HTTP core types — HttpMethod, StatusCode, HeaderMap, HttpRequest,

HTTP/1.1 — the module you import.

Minimal HTTP/1.1 server on TcpListener (plans/archive/STD_API_AUDIT.md §7 P1).

HTTP/1.1 wire framing shared by std/http's client and server — header

Persistent immutable singly-linked list with O(1) prepend, head, and tail.

Persistent immutable hash map using a Hash Array Mapped Trie (HAMT).

Persistent immutable hash set using a Hash Array Mapped Trie (HAMT).

Persistent immutable sorted map using a left-leaning red-black tree.

Persistent immutable sorted set using a left-leaning red-black tree.

Immutable, thread-safe UTF-8 string type.

Immutable vector with O(1) indexed access — a flat copy-on-write array,

Buffered wrappers over ANY async Reader/Writer — the D5 generic

Async I/O traits — the D5 redesign (plans/archive/STD_API_AUDIT.md §D5).

Typed standard-stream handles — stdin() / stdout() / stderr()

C11 <assert.h> — assertion debugging facility.

C11 <ctype.h> — character classification and conversion functions.

Darwin-only C interface pieces (audit env row: vars()).

C11 <dirent.h> — directory entry operations.

macOS <mach-o/dyld.h> — dynamic linker interface.

C11 <errno.h> — error handling constants and errno variable.

POSIX <fcntl.h> — file control options.

C11 <float.h> — floating-point implementation limits.

C11 <limits.h> — implementation-defined limits for integer types.

C11 <math.h> — mathematical functions and constants.

C11 <signal.h> — signal handling functions and constants.

C11 <stdatomic.h> — atomic operations and types.

C11 <stdint.h> — fixed-width integer types and limits.

C11 <stdio.h> — standard I/O functions.

C11 <stdlib.h> — general utility functions.

C11 <string.h> — string and memory functions.

C11 <time.h> — date and time functions.

POSIX <unistd.h> — standard symbolic constants and types.

C11 <wctype.h> — wide character classification and conversion functions.

Windows-specific C API bindings.

POSIX <sys/stat.h> — file status and mode operations.

Network address types — IpAddr (v4 / v6) and SocketAddr (an address

Name resolution — getaddrinfo behind typed lookup functions.

The network error type — NetError, the payload every throw in

Async TCP networking — typed TcpListener and TcpStream objects over

Async UDP networking — a typed UdpSocket over std/sys/udp for

Unix domain sockets — UnixListener / UnixStream

High-level child-process spawning with builder-style configuration.

Process information: platform/arch detection, child-process spawning, and exit.

NFA compiler — compiles a RegexNode AST into a flat list of NFA instructions

Typed error for std/regex pattern and flag compilation.

Regex flags parsing and representation.

Regular expression engine with an NFA-based virtual machine.

Match result type — represents the result of a regex match,

Regex AST node types.

Regex pattern parser — parses a regex pattern string into an AST

Unicode property ranges for `\p{...

NFA virtual machine (Thompson simulation).

EXPERIMENTAL — not covered by the std stability promise (audit spec/

EXPERIMENTAL — not covered by the std stability promise (audit spec/

String and Unicode types.

Unicode code point type (rune) for representing individual characters.

Growable UTF-8 strings: String, its four iterators, and the Pattern

Mutable UTF-8 string builder for efficient incremental construction.

Unicode case conversion — locale-independent, table-driven.

High-level Atomic* wrappers for thread-safe shared mutable values.

Reusable N-party barrier — the generation model, the same one Rust's

Bounded multi-producer multi-consumer (MPMC) channel.

Condition variable for thread synchronization.

Mutual exclusion lock primitives.

One-time initialization primitives.

Reader-writer lock allowing multiple concurrent readers or one exclusive

Counting semaphore — Dijkstra's P/V, the same model Java's

Wait for a group of tasks to complete, similar to Go's sync.WaitGroup.

Kernel access-pattern hints (posix_fadvise/madvise) — the raw syscall

High-resolution clock reads (clock_gettime) — the raw syscall boundary.

File-system constants — the numeric flag values std/fs passes to the

File copy and zero-copy transfer — the raw syscall boundary.

Directory operations.

DNS resolution operations.

IoError type — comprehensive I/O error type with errno-to-error mapping.

Event-loop handles — TTY modes, fd polling and filesystem watches.

Extern C runtime function declarations.

File space pre-allocation (fallocate) — the raw syscall boundary.

Descriptor flags (fcntl F_GETFL/F_SETFL/F_GETFD/F_SETFD) — the raw

Async and sync file operations.

IoFuture — the opaque handle every async I/O extern hands back.

Scatter/gather I/O (readv/writev) — the raw syscall boundary.

Advisory file locking (flock) — the raw syscall boundary.

Memory-mapped I/O (mmap/munmap/mprotect/msync) — the raw syscall

Path canonicalization (realpath) — the raw syscall boundary.

File permissions, ownership and access checks — the raw syscall boundary.

Pipes and descriptor duplication — the raw syscall boundary.

Child process spawning and reaping — the raw syscall boundary.

File position control (lseek) — the raw syscall boundary.

Signal registration and delivery — the raw syscall boundary.

POSIX signal numbers, as plain integers for std/sys/signal's

Socket constants and sockaddr sizes — the numbers std/net passes to

Connected socket pair (socketpair) — the raw syscall boundary.

Socket address and option queries — the raw syscall boundary.

Filesystem statistics (statvfs) — the raw syscall boundary.

Statx — a typed view over the platform's stat buffer.

System identification (uname/gethostname) — the raw syscall boundary.

Async TCP sockets — the raw syscall boundary.

Temporary file and directory creation — the raw syscall boundary.

File timestamp updates (utime/futime/lutime) — the raw syscall

Async sleep (sleep) — the raw timer boundary.

Terminal control (termios / Win32 Console) — the raw syscall boundary.

Async UDP sockets — the raw syscall boundary.

Process file-creation mask (umask) — the raw syscall boundary.

Async Unix-domain sockets — the raw syscall boundary.

Micro-benchmarking utilities.

Wall-clock date and time, either in UTC or at a FIXED offset from it.

Duration type representing a span of time with nanosecond precision.

The two clocks: Instant (monotonic, for measuring elapsed time) and

Sleeping — one async form and one blocking form, both taking a Duration.

URL parsing and formatting per RFC 3986 (simplified).