`core:*` Standard Library & Diagnostics Reference

Automatically generated from the live cfire compiler metadata catalog and verified by cfire doc --check.

import "core:fs" — Filesystem & Zero-Copy Byte I/O

Provides RAII file and directory utilities backed by `std::filesystem` and `std::vector`.
Auto-linked flags: (header-only)

import "core:cli" — Struct-Tag Command-Line Parser

Generates zero-boilerplate command-line flag parsers from struct field tags (`cli:"--flag,help"`).
Auto-linked flags: (header-only)

import "core:compress/zstd" — Native Zstandard Frame Compression

Hardware-accelerated Zstandard frame compression and decompression backed by native `libzstd`.
Auto-linked flags: -lzstd

import "core:json" — Compile-Time SIMD JSON Reflection & Dynamic DOM

Uses `json:"..."` struct tags to emit specialized `simdjson::ondemand` parsers and fast `std::format` serializers with zero runtime reflection overhead, along with a zero-dependency dynamic DOM `json.Value`.
Auto-linked flags: -lsimdjson (or header-only)

import "core:db/sqlite" — Embedded SQLite3 with WAL & Row Mapping

RAII SQLite3 wrapper enabling `PRAGMA journal_mode=WAL`, parameterized queries, atomic transactions, and compile-time `sql:"..."` struct row mapping.
Auto-linked flags: -lsqlite3

import "core:crypto/sha256" — Standard FIPS 180-4 SHA-256 Digest

Computes NIST FIPS 180-4 SHA-256 digests over byte slices or strings.
Auto-linked flags: (CommonCrypto / built-in)

import "core:crypto/hmac" — RFC 2104 HMAC-SHA256 Message Authentication

Computes RFC 2104 keyed HMAC-SHA256 authentication digests.
Auto-linked flags: (CommonCrypto / built-in)

import "core:crypto/aes" — NIST FIPS 197 AES-256 Symmetric Encryption & GCM AEAD

Constant-time AES-256 block cipher implementation with Counter Mode (CTR) and Galois/Counter Mode (GCM) Authenticated Encryption with Associated Data (AEAD).
Auto-linked flags: (Header-only pure C++23)

import "core:crypto/blake3" — Cryptographic 256-Bit Digest (Alias)

Computes fast 256-bit cryptographic hex digests over byte slices (backward-compatible alias for `core:crypto/sha256`).
Auto-linked flags: (CommonCrypto / built-in)

import "core:net" — POSIX BSD TCP Sockets & Loopback Networking

RAII TCP client and listener sockets backed by BSD `AF_INET` sockets with non-blocking `poll` timeouts and automatic `AF_UNIX` `socketpair` loopback fallback inside sandboxes.
Auto-linked flags: (POSIX sockets)

import "core:net/url" — RFC 3986 URL Parsing & URL Encoding

RFC 3986 URL parsing with component extraction (scheme, host, port, path, query, fragment), form-urlencoded query parameter maps, and percent encoding/decoding.
Auto-linked flags: (header-only)

import "core:net/http" — HTTP/1.1 Client & Lightweight Dispatch Server

High-level HTTP/1.1 client (`get`, `post`, `request`) and lightweight synchronous/threaded HTTP server dispatcher (`make_server`).
Auto-linked flags: (POSIX sockets)

import "core:net/websocket" — RFC 6455 High-Level WebSockets Client & Server

RFC 6455 full-duplex WebSocket client (`connect`) and server upgrade handler (`upgrade`) with automated framing, client masking, and Ping/Pong management.
Auto-linked flags: (POSIX sockets)

import "core:time" — Time, Calendar Dates, Durations & RFC 3339 Formatting

High-resolution monotonic timing, duration arithmetic, and RFC 3339 / ISO 8601 formatting backed by `std::chrono`.
Auto-linked flags: (header-only)

import "core:os" — Environment, Working Directory & Subprocesses

Process environment inspection, working directory queries, and subprocess output capture.
Auto-linked flags: (header-only)

import "core:sync" — Thread-Safe Typed Channels

Go-style typed MPSC/MPMC channels (`Channel[T]`) synchronized with `std::mutex` and `std::condition_variable`.
Auto-linked flags: (header-only)

import "core:sync/context" — Cancellation Tokens & Deadline Contexts

Structured concurrency cancellation token and deadline propagation hierarchy (`core:sync/context`).
Auto-linked flags: (header-only)

import "core:str" — UTF-8 String Manipulation

Zero-surprise string splitting, joining, trimming, searching, replacement, and ASCII case conversion.
Auto-linked flags: (header-only)

import "core:math" — Numeric & Floating-Point Utilities

Standard mathematical constants (`PI`, `E`) and numeric clamping/transcendental functions.
Auto-linked flags: (header-only)

import "core:rand" — Thread-Local MT19937_64 & CSPRNG Generator

Fast, thread-safe pseudo-random and OS-entropy CSPRNG random generation.
Auto-linked flags: (header-only)

import "core:encoding/base64" — RFC 4648 Base64 & URL-Safe Encoding/Decoding

High-performance, zero-allocation Base64 and URL-safe Base64 encoder and decoder.
Auto-linked flags: (header-only)

import "core:encoding/hex" — Hexadecimal Encoding & Decoding

Encodes binary bytes to lowercase hexadecimal strings and decodes hex strings to byte buffers.
Auto-linked flags: (header-only)

import "core:encoding/csv" — RFC 4180 CSV Parsing & Stringification

RFC 4180 compliant CSV parser and serializer supporting multi-line quoted fields and comma escaping.
Auto-linked flags: (header-only)

import "core:regex" — ECMAScript Regular Expressions

Pattern matching, group extraction, and text substitution backed by C++23 ``.
Auto-linked flags: (header-only)

import "core:collections" — Generic Containers (Set, PriorityQueue, Deque)

Standard generic containers backed by STL unordered_set, priority_queue, and deque.
Auto-linked flags: (header-only)

import "core:sort" — Slice Sorting & Binary Search

In-place sorting algorithms and binary search on slices.
Auto-linked flags: (header-only)

import "core:log" — Structured Leveled Logging

Leveled logging (`debug`, `info`, `warn`, `error`) with structured key-value attributes and Text / JSON formatters.
Auto-linked flags: (header-only)

import "core:unicode" — UTF-8 Decoding, Rune Counting & Unicode Manipulation

RFC 3629 compliant branchless UTF-8 decoding, codepoint extraction, rune validation, and Unicode case transformation.
Auto-linked flags: (header-only)

Compiler Semantic Diagnostics

fn bump(mut x: i32) { x += 1 }
fn main() {
    mut a := 10
    bump(a) // ERROR [cfire/MUT-CALLSITE]
}

fn bump(mut x: i32) { x += 1 }
fn main() {
    mut a := 10
    bump(mut a) // OK
}

fn write_sum(out total: i32) { total = 42 }
fn main() {
    mut s: i32 = 0
    write_sum(s) // ERROR [cfire/OUT-CALLSITE]
}

fn write_sum(out total: i32) { total = 42 }
fn main() {
    mut s: i32 = 0
    write_sum(out s) // OK
}

fn reset(mut v: i32) { v = 0 }
fn main() {
    val := 5
    reset(mut val) // ERROR [cfire/IMMUTABLE-MUT-ARG]
}

fn reset(mut v: i32) { v = 0 }
fn main() {
    mut val := 5
    reset(mut val) // OK
}

c := Counter{Value: 0}
c.inc() // ERROR [cfire/MUT-RECEIVER]

mut c := Counter{Value: 0}
c.inc() // OK

fn transfer(mut from: i32, mut to: i32) { ... }
fn main() {
    mut acc := 100
    transfer(mut acc, mut acc) // ERROR [cfire/MUT-ALIAS]
}

fn transfer(mut from: i32, mut to: i32) { ... }
fn main() {
    mut a := 100
    mut b := 50
    transfer(mut a, mut b) // OK: distinct bindings
}

consume(move buf)
println("{}", buf.len()) // ERROR [cfire/USE-AFTER-MOVE]

println("{}", buf.len())
consume(move buf) // OK: moved on last use

match shape {
    Circle(r) => { ... }
    // ERROR [cfire/NON-EXHAUSTIVE-MATCH]: missing Rect
}

match shape {
    Circle(r) => { ... }
    Rect(w, h) => { ... }
}

fn compute() -> i32 {
    // ERROR [cfire/NON-DIVERGING-OR-BLOCK]: handler does not diverge
    x := parse_num() or err {
        println("error: {}", err.message())
    }
    return x
}

fn compute() -> i32 {
    x := parse_num() or err {
        println("error: {}", err.message())
        return 0
    }
    return x
}

fn parse_coords(s: str, out x: f64, out y: f64) { ... } // WARNING [cfire/DEPRECATED-OUT-PARAM]

fn parse_coords(s: str) -> (f64, f64)! { return (1.0, 2.0) }
(x, y) := try parse_coords("1,2") // OK

var x = 42 // WARNING [cfire/DEPRECATED-VAR]
var mut name: str = "hello" // WARNING [cfire/DEPRECATED-VAR]

x := 42 // OK
mut name: str = "hello" // OK