std — API Documentation v0.2.15

Memory allocation abstractions and global allocator interface.

Runtime assertion and panic functions.

Async utilities for cooperative task scheduling.

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.

Structured logging with configurable level and output destination.

Cross-platform filesystem path manipulation.

Prelude — automatically imported into every Yo source file.

OS thread creation and management with per-thread Io event loops.

Thread pool with per-core thread affinity and round-robin task distribution.

FNV-1a (Fowler-Noll-Vo) hash function.

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

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

Hash map using SwissTable algorithm with SIMD-accelerated lookup.

Hash set using SwissTable algorithm with set-theoretic operations.

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

ListView — a SAFE window over an ArrayList(T).

Insertion-ordered map.

Binary min-heap priority queue.

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

Cryptographically secure random number generation.

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

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

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.

Punycode encoding/decoding (RFC 3492) for internationalized domain names.

Basic TOML parser for configuration files.

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

Display trait for streaming formatted output to a Writer.

Formatted output to stdout and stderr.

ToString trait and implementations for all primitive types.

Chainable string builder for composing formatted output.

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.

Async HTTP client with high-level fetch API.

HTTP core types — methods, headers, requests, and responses.

HTTP client library — types, request building, and async fetching.

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.

Persistent immutable vector with efficient indexed access and append.

Reader trait for byte-level input.

Writer trait for byte-level output.

C11 <assert.h> — assertion debugging facility.

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

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 — IP addresses and socket addresses.

Async DNS resolution.

Network error types.

Async TCP networking — listeners and streams with Exception-based error handling.

Async UDP networking — connectionless datagram sockets.

Environment directory utilities.

High-level signal handling.

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

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

No description

No description

String and Unicode types.

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

Immutable UTF-8 string type with comprehensive operations.

Mutable UTF-8 string builder for efficient incremental construction.

Unicode-aware case conversion using full case folding rules.

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

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

Condition variable for thread synchronization.

Mutual exclusion lock primitives.

One-time initialization primitive.

Reader-writer lock allowing multiple concurrent readers or one exclusive writer.

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

Kernel advisory hints.

High-resolution clock queries.

File system constants.

File copy operations.

Directory operations.

DNS resolution operations.

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

TTY, Poll, and FS Event constants.

Extern C runtime function declarations.

File space pre-allocation.

File descriptor control operations.

Async and sync file operations.

IoFuture type — opaque handle to a C async I/O future struct.

Scatter/gather I/O.

Advisory file locking.

Memory-mapped I/O operations.

Path resolution.

File permission and access operations.

Pipe and file descriptor duplication operations.

Child process management.

File position control.

Signal handling functions.

POSIX signal constants.

Socket constants.

Connected socket pair.

Socket address and option query helpers.

Filesystem statistics.

Statx file status type.

Runtime system identification.

Async TCP socket operations.

Temporary file/directory operations.

File timestamp operations.

Async timer operations.

TTY operations.

Async UDP socket operations.

Process file creation mask.

Unix domain socket operations.

Buffered reader for file descriptors.

Buffered writer for file descriptors.

Micro-benchmarking utilities.

Wall-clock date and time in UTC.

Duration type representing a span of time with nanosecond precision.

Monotonic clock instant for measuring elapsed time.

Synchronous sleep — blocks the current thread.

URL parsing and formatting per RFC 3986 (simplified).