Standard Library Reference

libc

distinct Errno = inline CInt;

struct DivResult

struct LongDivResult

struct TimeSpec

struct Timespec

struct Tm

fn TimeSpec Duration.to_timespec(self) @inline

fn TimeSpec NanoDuration.to_timespec(self) @inline

fn Errno errno()

fn void errno_set(Errno e)

libc @if(!env::LIBC)

fn void* calloc(usz count, usz size) @weak @extern("calloc") @nostrip

fn CFile fclose(CFile) @weak @extern("fclose") @nostrip

fn int feof(CFile stream) @weak @extern("feof") @nostrip

fn int fflush(CFile stream) @weak @extern("fflush") @nostrip

fn int fgetc(CFile stream) @weak @extern("fgetc") @nostrip

fn char* fgets(ZString str, int n, CFile stream) @weak @extern("fgets") @nostrip

fn CFile fopen(ZString filename, ZString mode) @weak @extern("fopen") @nostrip

fn int fputc(int c, CFile stream) @weak @extern("fputc") @nostrip

fn usz fread(void* ptr, usz size, usz nmemb, CFile stream) @weak @extern("fread") @nostrip

fn void* free(void*) @weak @extern("free")

fn CFile freopen(ZString filename, ZString mode, CFile stream) @weak @extern("fopen") @nostrip

fn int fseek(CFile stream, SeekIndex offset, int whence) @weak @extern("fseek") @nostrip

fn usz fwrite(void* ptr, usz size, usz nmemb, CFile stream) @weak @extern("fwrite") @nostrip

fn void longjmp(JmpBuf* buffer, CInt value) @weak @extern("longjmp") @nostrip

fn void* malloc(usz size) @weak @extern("malloc") @nostrip

fn void* memcpy(void* dest, void* src, usz n) @weak @extern("memcpy") @nostrip

fn void* memmove(void* dest, void* src, usz n) @weak @extern("memmove") @nostrip

fn void* memset(void* dest, CInt value, usz n) @weak @extern("memset") @nostrip

fn int putc(int c, CFile stream) @weak @extern("putc") @nostrip

fn int putchar(int c) @weak @extern("putchar") @nostrip

fn int puts(ZString str) @weak @extern("puts") @nostrip

fn void* realloc(void* ptr, usz size) @weak @extern("realloc") @nostrip

fn CInt setjmp(JmpBuf* buffer) @weak @extern("setjmp") @nostrip

libc @if(env::DARWIN)

struct Stat

macro CFile stderr()

macro CFile stdin()

macro CFile stdout()

libc @if(env::LIBC && !env::WIN32 && !env::LINUX && !env::DARWIN)

macro CFile stderr() { return (CFile*)(uptr)STDERR_FD; }

macro CFile stdin() { return (CFile*)(uptr)STDIN_FD; }

macro CFile stdout() { return (CFile*)(uptr)STDOUT_FD; }

libc @if(env::LINUX)

struct Stat @if(!env::X86_64)

struct Stat @if(env::X86_64)

macro usz malloc_size(void* ptr)

macro CFile stderr()

macro CFile stdin()

macro CFile stdout()

libc @if(env::POSIX)

struct Sigaction

struct Stack_t

libc @if(env::WIN32)

struct SystemInfo

macro Tm* gmtime_r(Time_t* timer, Tm* buf)

macro Tm* localtime_r(Time_t* timer, Tm* buf)

macro usz malloc_size(void* ptr)

macro isz read(Fd fd, void* buffer, usz buffer_size)

macro CInt setjmp(JmpBuf* buffer)

macro CFile stderr()

macro CFile stdin()

macro CFile stdout()

macro isz write(Fd fd, void* buffer, usz count)

libc::os

fn int errno() @if(ERRNO_DEFAULT)

macro int errno() @if(env::DARWIN)

macro int errno() @if(env::LINUX)

macro int errno() @if(env::WIN32)

fn void errno_set(int err) @if(ERRNO_DEFAULT)

macro void errno_set(int err) @if(env::DARWIN)

macro void errno_set(int err) @if(env::LINUX)

macro void errno_set(int err) @if(env::WIN32)

std::ascii

fn char char.from_hex(char c)

fn bool char.in_range(char c, char start, char len)

fn bool char.is_alnum(char c)

fn bool char.is_alpha(char c)

fn bool char.is_bdigit(char c)

fn bool char.is_blank(char c)

fn bool char.is_cntrl(char c)

fn bool char.is_digit(char c)

fn bool char.is_graph(char c)

fn bool char.is_lower(char c)

fn bool char.is_odigit(char c)

fn bool char.is_print(char c)

fn bool char.is_punct(char c)

fn bool char.is_space(char c)

fn bool char.is_upper(char c)

fn bool char.is_xdigit(char c)

fn char char.to_lower(char c)

fn char char.to_upper(char c)

fn bool in_range(char c, char start, char len)

macro bool in_range_m(c, start, len)

fn bool is_alnum(char c)

macro bool is_alnum_m(c)

fn bool is_alpha(char c)

macro bool is_alpha_m(c)

fn bool is_bdigit(char c)

macro bool is_bdigit_m(c)

fn bool is_blank(char c)

macro bool is_blank_m(c)

fn bool is_cntrl(char c)

macro bool is_cntrl_m(c)

fn bool is_digit(char c)

macro bool is_digit_m(c)

fn bool is_graph(char c)

macro bool is_graph_m(c)

fn bool is_lower(char c)

macro bool is_lower_m(c)

fn bool is_odigit(char c)

macro bool is_odigit_m(c)

fn bool is_print(char c)

macro bool is_print_m(c)

fn bool is_punct(char c)

macro bool is_punct_m(c)

fn bool is_space(char c)

macro bool is_space_m(c)

fn bool is_upper(char c)

macro bool is_upper_m(c)

fn bool is_xdigit(char c)

macro bool is_xdigit_m(c)

fn char to_lower(char c)

macro to_lower_m(c)

fn char to_upper(char c)

macro to_upper_m(c)

fn bool uint.in_range(uint c, uint start, uint len)

fn bool uint.is_alnum(uint c)

fn bool uint.is_alpha(uint c)

fn bool uint.is_bdigit(uint c)

fn bool uint.is_blank(uint c)

fn bool uint.is_cntrl(uint c)

fn bool uint.is_digit(uint c)

fn bool uint.is_graph(uint c)

fn bool uint.is_lower(uint c)

fn bool uint.is_odigit(uint c)

fn bool uint.is_print(uint c)

fn bool uint.is_punct(uint c)

fn bool uint.is_space(uint c)

fn bool uint.is_upper(uint c)

fn bool uint.is_xdigit(uint c)

fn uint uint.to_lower(uint c)

fn uint uint.to_upper(uint c)

std::atomic

macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $success, failure, $alignment)

macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, success, failure, $alignment)

fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired, CInt success, CInt failure) @extern("__atomic_compare_exchange") @export

macro fetch_add(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)

macro fetch_and(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)

macro fetch_div(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)

macro fetch_max(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)

macro fetch_min(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)

macro fetch_mul(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)

macro fetch_or(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)

macro fetch_shift_left(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)

macro fetch_shift_right(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)

macro fetch_sub(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)

macro fetch_xor(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)

macro flag_clear(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)

macro flag_set(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)

std::atomic::types(<Type>)

struct Atomic

macro Type Atomic.add(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)

macro Type Atomic.and(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))

macro Type Atomic.div(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)

macro Type Atomic.load(&self, AtomicOrdering ordering = SEQ_CONSISTENT)

macro Type Atomic.max(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)

macro Type Atomic.min(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)

macro Type Atomic.mul(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)

macro Type Atomic.or(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))

macro Type Atomic.shift_left(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))

macro Type Atomic.shift_right(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))

macro void Atomic.store(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)

macro Type Atomic.sub(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)

fn Type Atomic.xor(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))

std::bits

macro bswap(i) @builtin

macro char.clz(self)

macro char.ctz(self)

macro char char.fshl(hi, char lo, char shift)

macro char char.fshr(hi, char lo, char shift)

macro char.popcount(self)

macro char char.rotl(self, char shift)

macro char char.rotr(self, char shift)

macro char[<*>].clz(self)

macro char[<*>].ctz(self)

macro char[<*>] char[<*>].fshl(hi, char[<*>] lo, char[<*>] shift)

macro char[<*>] char[<*>].fshr(hi, char[<*>] lo, char[<*>] shift)

macro char[<*>].popcount(self)

macro char[<*>] char[<*>].rotl(self, char[<*>] shift)

macro char[<*>] char[<*>].rotr(self, char[<*>] shift)

macro ichar.clz(self)

macro ichar.ctz(self)

macro ichar ichar.fshl(hi, ichar lo, ichar shift)

macro ichar ichar.fshr(hi, ichar lo, ichar shift)

macro ichar.popcount(self)

macro ichar ichar.rotl(self, ichar shift)

macro ichar ichar.rotr(self, ichar shift)

macro ichar[<*>].clz(self)

macro ichar[<*>].ctz(self)

macro ichar[<*>] ichar[<*>].fshl(hi, ichar[<*>] lo, ichar[<*>] shift)

macro ichar[<*>] ichar[<*>].fshr(hi, ichar[<*>] lo, ichar[<*>] shift)

macro ichar[<*>].popcount(self)

macro ichar[<*>] ichar[<*>].rotl(self, ichar[<*>] shift)

macro ichar[<*>] ichar[<*>].rotr(self, ichar[<*>] shift)

macro int.clz(self)

macro int.ctz(self)

macro int int.fshl(hi, int lo, int shift)

macro int int.fshr(hi, int lo, int shift)

macro int.popcount(self)

macro int int.rotl(self, int shift)

macro int int.rotr(self, int shift)

macro int128.clz(self)

macro int128.ctz(self)

macro int128 int128.fshl(hi, int128 lo, int128 shift)

macro int128 int128.fshr(hi, int128 lo, int128 shift)

macro int128.popcount(self)

macro int128 int128.rotl(self, int128 shift)

macro int128 int128.rotr(self, int128 shift)

macro int128[<*>].clz(self)

macro int128[<*>].ctz(self)

macro int128[<*>] int128[<*>].fshl(hi, int128[<*>] lo, int128[<*>] shift)

macro int128[<*>] int128[<*>].fshr(hi, int128[<*>] lo, int128[<*>] shift)

macro int128[<*>].popcount(self)

macro int128[<*>] int128[<*>].rotl(self, int128[<*>] shift)

macro int128[<*>] int128[<*>].rotr(self, int128[<*>] shift)

macro int[<*>].clz(self)

macro int[<*>].ctz(self)

macro int[<*>] int[<*>].fshl(hi, int[<*>] lo, int[<*>] shift)

macro int[<*>] int[<*>].fshr(hi, int[<*>] lo, int[<*>] shift)

macro int[<*>].popcount(self)

macro int[<*>] int[<*>].rotl(self, int[<*>] shift)

macro int[<*>] int[<*>].rotr(self, int[<*>] shift)

macro long.clz(self)

macro long.ctz(self)

macro long long.fshl(hi, long lo, long shift)

macro long long.fshr(hi, long lo, long shift)

macro long.popcount(self)

macro long long.rotl(self, long shift)

macro long long.rotr(self, long shift)

macro long[<*>].clz(self)

macro long[<*>].ctz(self)

macro long[<*>] long[<*>].fshl(hi, long[<*>] lo, long[<*>] shift)

macro long[<*>] long[<*>].fshr(hi, long[<*>] lo, long[<*>] shift)

macro long[<*>].popcount(self)

macro long[<*>] long[<*>].rotl(self, long[<*>] shift)

macro long[<*>] long[<*>].rotr(self, long[<*>] shift)

macro reverse(i)

macro short.clz(self)

macro short.ctz(self)

macro short short.fshl(hi, short lo, short shift)

macro short short.fshr(hi, short lo, short shift)

macro short.popcount(self)

macro short short.rotl(self, short shift)

macro short short.rotr(self, short shift)

macro short[<*>].clz(self)

macro short[<*>].ctz(self)

macro short[<*>] short[<*>].fshl(hi, short[<*>] lo, short[<*>] shift)

macro short[<*>] short[<*>].fshr(hi, short[<*>] lo, short[<*>] shift)

macro short[<*>].popcount(self)

macro short[<*>] short[<*>].rotl(self, short[<*>] shift)

macro short[<*>] short[<*>].rotr(self, short[<*>] shift)

macro uint.clz(self)

macro uint.ctz(self)

macro uint uint.fshl(hi, uint lo, uint shift)

macro uint uint.fshr(hi, uint lo, uint shift)

macro uint.popcount(self)

macro uint uint.rotl(self, uint shift)

macro uint uint.rotr(self, uint shift)

macro uint128.clz(self)

macro uint128.ctz(self)

macro uint128 uint128.fshl(hi, uint128 lo, uint128 shift)

macro uint128 uint128.fshr(hi, uint128 lo, uint128 shift)

macro uint128.popcount(self)

macro uint128 uint128.rotl(self, uint128 shift)

macro uint128 uint128.rotr(self, uint128 shift)

macro uint128[<*>].clz(self)

macro uint128[<*>].ctz(self)

macro uint128[<*>] uint128[<*>].fshl(hi, uint128[<*>] lo, uint128[<*>] shift)

macro uint128[<*>] uint128[<*>].fshr(hi, uint128[<*>] lo, uint128[<*>] shift)

macro uint128[<*>].popcount(self)

macro uint128[<*>] uint128[<*>].rotl(self, uint128[<*>] shift)

macro uint128[<*>] uint128[<*>].rotr(self, uint128[<*>] shift)

macro uint[<*>].clz(self)

macro uint[<*>].ctz(self)

macro uint[<*>] uint[<*>].fshl(hi, uint[<*>] lo, uint[<*>] shift)

macro uint[<*>] uint[<*>].fshr(hi, uint[<*>] lo, uint[<*>] shift)

macro uint[<*>].popcount(self)

macro uint[<*>] uint[<*>].rotl(self, uint[<*>] shift)

macro uint[<*>] uint[<*>].rotr(self, uint[<*>] shift)

macro ulong.clz(self)

macro ulong.ctz(self)

macro ulong ulong.fshl(hi, ulong lo, ulong shift)

macro ulong ulong.fshr(hi, ulong lo, ulong shift)

macro ulong.popcount(self)

macro ulong ulong.rotl(self, ulong shift)

macro ulong ulong.rotr(self, ulong shift)

macro ulong[<*>].clz(self)

macro ulong[<*>].ctz(self)

macro ulong[<*>] ulong[<*>].fshl(hi, ulong[<*>] lo, ulong[<*>] shift)

macro ulong[<*>] ulong[<*>].fshr(hi, ulong[<*>] lo, ulong[<*>] shift)

macro ulong[<*>].popcount(self)

macro ulong[<*>] ulong[<*>].rotl(self, ulong[<*>] shift)

macro ulong[<*>] ulong[<*>].rotr(self, ulong[<*>] shift)

macro ushort.clz(self)

macro ushort.ctz(self)

macro ushort ushort.fshl(hi, ushort lo, ushort shift)

macro ushort ushort.fshr(hi, ushort lo, ushort shift)

macro ushort.popcount(self)

macro ushort ushort.rotl(self, ushort shift)

macro ushort ushort.rotr(self, ushort shift)

macro ushort[<*>].clz(self)

macro ushort[<*>].ctz(self)

macro ushort[<*>] ushort[<*>].fshl(hi, ushort[<*>] lo, ushort[<*>] shift)

macro ushort[<*>] ushort[<*>].fshr(hi, ushort[<*>] lo, ushort[<*>] shift)

macro ushort[<*>].popcount(self)

macro ushort[<*>] ushort[<*>].rotl(self, ushort[<*>] shift)

macro ushort[<*>] ushort[<*>].rotr(self, ushort[<*>] shift)

std::collections::anylist

struct AnyList (Printable)

macro any AnyList.@item_at(&self, usz index) @operator([])

fn void AnyList.add_all(&self, AnyList* other_list)

fn any[] AnyList.array_view(&self)

fn void AnyList.clear(&self)

macro AnyList.first(&self, $Type)

fn any! AnyList.first_any(&self) @inline

fn void AnyList.free(&self)

fn void AnyList.free_element(&self, any element) @inline

macro AnyList.get(&self, usz index, $Type)

fn any AnyList.get_any(&self, usz index) @inline

fn bool AnyList.is_empty(&self) @inline

macro AnyList.last(&self, $Type)

fn any! AnyList.last_any(&self) @inline

fn usz AnyList.len(&self) @operator(len) @inline

fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap())

fn any! AnyList.new_pop(&self, Allocator allocator = allocator::heap())

fn any! AnyList.new_pop_first(&self, Allocator allocator = allocator::heap())

macro AnyList.pop(&self, $Type)

macro AnyList.pop_first(&self, $Type)

fn any! AnyList.pop_first_retained(&self)

fn any! AnyList.pop_retained(&self)

macro void AnyList.push(&self, element)

macro void AnyList.push_front(&self, type)

fn void AnyList.remove_at(&self, usz index)

fn void AnyList.remove_first(&self)

fn usz AnyList.remove_if(&self, AnyPredicate filter)

fn void AnyList.remove_last(&self)

fn usz AnyList.remove_using_test(&self, AnyTest filter, any context)

fn void AnyList.reserve(&self, usz min_capacity)

fn usz AnyList.retain_if(&self, AnyPredicate selection)

fn usz AnyList.retain_using_test(&self, AnyTest filter, any context)

fn void AnyList.reverse(&self)

macro void AnyList.set(&self, usz index, value)

fn void AnyList.swap(&self, usz i, usz j)

fn AnyList* AnyList.temp_init(&self, usz initial_capacity = 16)

fn any! AnyList.temp_pop(&self)

fn any! AnyList.temp_pop_first(&self)

fn usz! AnyList.to_format(&self, Formatter* formatter) @dynamic

fn String AnyList.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic

fn String AnyList.to_tstring(&self)

std::collections::bitset(<SIZE>)

struct BitSet

fn usz BitSet.cardinality(&self)

fn bool BitSet.get(&self, usz i) @operator([]) @inline

fn usz BitSet.len(&self) @operator(len) @inline

fn void BitSet.set(&self, usz i)

fn void BitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline

fn void BitSet.unset(&self, usz i)

std::collections::enummap(<Enum, ValueType>)

struct EnumMap (Printable)

fn ValueType EnumMap.get(&self, Enum key) @operator([]) @inline

fn ValueType* EnumMap.get_ref(&self, Enum key) @operator(&[]) @inline

fn void EnumMap.init(&self, ValueType init_value)

fn usz EnumMap.len(&self) @operator(len) @inline

fn void EnumMap.set(&self, Enum key, ValueType value) @operator([]=) @inline

fn usz! EnumMap.to_format(&self, Formatter* formatter) @dynamic

fn String EnumMap.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic

fn String EnumMap.to_tstring(&self) @dynamic

std::collections::enumset(<Enum>)

distinct EnumSet (Printable) = EnumSetType;

fn void EnumSet.add(&self, Enum v)

fn void EnumSet.add_all(&self, EnumSet s)

fn EnumSet EnumSet.and_of(&self, EnumSet s)

fn void EnumSet.clear(&self)

fn EnumSet EnumSet.diff_of(&self, EnumSet s)

fn bool EnumSet.has(&self, Enum v)

fn EnumSet EnumSet.or_of(&self, EnumSet s)

fn bool EnumSet.remove(&self, Enum v)

fn void EnumSet.remove_all(&self, EnumSet s)

fn void EnumSet.retain_all(&self, EnumSet s)

fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic

fn String EnumSet.to_new_string(&set, Allocator allocator = allocator::heap()) @dynamic

fn String EnumSet.to_tstring(&set) @dynamic

fn EnumSet EnumSet.xor_of(&self, EnumSet s)

std::collections::enumset::private

macro typeid type_for_enum_elements(usz $elements)

std::collections::growablebitset(<Type>)

struct GrowableBitSet

fn usz GrowableBitSet.cardinality(&self)

fn void GrowableBitSet.free(&self)

fn bool GrowableBitSet.get(&self, usz i) @operator([]) @inline

fn usz GrowableBitSet.len(&self) @operator(len)

fn GrowableBitSet* GrowableBitSet.new_init(&self, usz initial_capacity = 1, Allocator allocator = allocator::heap())

fn void GrowableBitSet.set(&self, usz i)

fn void GrowableBitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline

fn GrowableBitSet* GrowableBitSet.temp_init(&self, usz initial_capacity = 1)

fn void GrowableBitSet.unset(&self, usz i)

std::collections::linkedlist(<Type>)

struct LinkedList

fn void LinkedList.clear(&self)

fn Type! LinkedList.first(&self)

fn void LinkedList.free(&self)

fn Type LinkedList.get(&self, usz index)

fn void LinkedList.insert_at(&self, usz index, Type element)

fn Type! LinkedList.last(&self)

fn usz LinkedList.len(&self) @inline

fn LinkedList* LinkedList.new_init(&self, Allocator allocator = allocator::heap())

macro Node* LinkedList.node_at_index(&self, usz index)

fn Type! LinkedList.peek(&self)

fn Type! LinkedList.peek_last(&self)

fn Type! LinkedList.pop(&self)

fn Type! LinkedList.pop_front(&self)

fn void LinkedList.push(&self, Type value)

fn void LinkedList.push_front(&self, Type value)

fn usz LinkedList.remove(&self, Type t) @if(ELEMENT_IS_EQUATABLE)

fn void LinkedList.remove_at(&self, usz index)

fn void! LinkedList.remove_first(&self) @maydiscard

fn bool LinkedList.remove_first_match(&self, Type t) @if(ELEMENT_IS_EQUATABLE)

fn void! LinkedList.remove_last(&self) @maydiscard

fn bool LinkedList.remove_last_match(&self, Type t)  @if(ELEMENT_IS_EQUATABLE)

fn void LinkedList.set(&self, usz index, Type element)

fn LinkedList* LinkedList.temp_init(&self)

std::collections::list(<Type>)

struct List (Printable)

macro Type List.@item_at(&self, usz index) @operator([])

fn void List.add_all(&self, List* other_list)

fn void List.add_array(&self, Type[] array)

fn Type[] List.array_view(&self)

fn usz List.byte_size(&self) @inline

fn void List.clear(&self)

fn usz List.compact(&self) @if(ELEMENT_IS_POINTER)

fn usz List.compact_count(&self) @if(ELEMENT_IS_POINTER)

fn bool List.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)

fn bool List.equals(&self, List other_list) @if(ELEMENT_IS_EQUATABLE)

fn Type! List.first(&self)

fn void List.free(&self)

fn Type List.get(&self, usz index) @inline

fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline

fn usz! List.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)

fn void List.init_wrapping_array(&self, Type[] types, Allocator allocator = allocator::heap())

fn void List.insert_at(&self, usz index, Type type)

fn bool List.is_empty(&self) @inline

fn Type! List.last(&self)

fn usz List.len(&self) @operator(len) @inline

fn List* List.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap())

fn Type! List.pop(&self)

fn Type! List.pop_first(&self)

fn void List.push(&self, Type element) @inline

fn void List.push_front(&self, Type type) @inline

fn void List.remove_all_from(&self, List* other_list) @if(ELEMENT_IS_EQUATABLE)

fn usz List.remove_all_matches(&self, Type value) @if(ELEMENT_IS_EQUATABLE)

fn void List.remove_at(&self, usz index)

fn void! List.remove_first(&self) @maydiscard

fn bool List.remove_first_match(&self, Type value) @if(ELEMENT_IS_EQUATABLE)

fn usz List.remove_if(&self, ElementPredicate filter)

fn void! List.remove_last(&self) @maydiscard

fn bool List.remove_last_match(&self, Type value) @if(ELEMENT_IS_EQUATABLE)

fn usz List.remove_using_test(&self, ElementTest filter, any context)

fn void List.reserve(&self, usz min_capacity)

fn usz List.retain_if(&self, ElementPredicate selection)

fn usz List.retain_using_test(&self, ElementTest filter, any context)

fn void List.reverse(&self)

fn usz! List.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)

fn void List.set(&self, usz index, Type value) @operator([]=)

fn void List.set_at(&self, usz index, Type type)

fn void List.swap(&self, usz i, usz j)

fn List* List.temp_init(&self, usz initial_capacity = 16)

fn usz! List.to_format(&self, Formatter* formatter) @dynamic

fn Type[] List.to_new_array(&self, Allocator allocator = allocator::heap())

fn String List.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic

fn Type[] List.to_tarray(&self)

fn String List.to_tstring(&self)

std::collections::map(<Key, Value>)

struct Entry

struct HashMap

macro HashMap.@each(map; @body(key, value))

macro HashMap.@each_entry(map; @body(entry))

macro Value HashMap.@get_or_set(&map, Key key, Value #expr)

fn void HashMap.clear(&map)

fn void HashMap.free(&map)

fn Value! HashMap.get(&map, Key key) @operator([])

fn Entry*! HashMap.get_entry(&map, Key key)

fn Value*! HashMap.get_ref(&map, Key key)

fn bool HashMap.has_key(&map, Key key)

fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)

fn bool HashMap.is_empty(&map) @inline

fn bool HashMap.is_initialized(&map)

fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())

fn Key[] HashMap.key_tlist(&map)

fn usz HashMap.len(&map) @inline

fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())

fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map, Allocator allocator = allocator::heap())

fn void! HashMap.remove(&map, Key key) @maydiscard

fn bool HashMap.set(&map, Key key, Value value) @operator([]=)

fn HashMap* HashMap.temp_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)

fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map)

fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())

fn Value[] HashMap.value_tlist(&map)

std::collections::maybe(<Type>)

struct Maybe

macro Type! Maybe.get(self)

fn Maybe value(Type val)

std::collections::object

struct Object (Printable)

fn void Object.free(&self)

fn Object*! Object.get(&self, String key)

fn Object* Object.get_at(&self, usz index)

fn bool! Object.get_bool(&self, String key)

fn bool! Object.get_bool_at(&self, usz index)

fn char! Object.get_char(&self, String key)

fn char! Object.get_char_at(&self, usz index)

macro String! Object.get_enum(&self, $EnumType, String key)

macro String! Object.get_enum_at(&self, $EnumType, usz index)

fn double! Object.get_float(&self, String key)

fn double! Object.get_float_at(&self, usz index)

fn ichar! Object.get_ichar(&self, String key)

fn ichar! Object.get_ichar_at(&self, usz index)

fn int! Object.get_int(&self, String key)

fn int128! Object.get_int128(&self, String key)

fn int128! Object.get_int128_at(&self, usz index)

fn int! Object.get_int_at(&self, usz index)

fn usz Object.get_len(&self)

fn long! Object.get_long(&self, String key)

fn long! Object.get_long_at(&self, usz index)

fn Object* Object.get_or_create_obj(&self, String key)

fn short! Object.get_short(&self, String key)

fn short! Object.get_short_at(&self, usz index)

fn String! Object.get_string(&self, String key)

fn String! Object.get_string_at(&self, usz index)

fn uint! Object.get_uint(&self, String key)

fn uint128! Object.get_uint128(&self, String key)

fn uint128! Object.get_uint128_at(&self, usz index)

fn uint! Object.get_uint_at(&self, usz index)

fn ulong! Object.get_ulong(&self, String key)

fn ulong! Object.get_ulong_at(&self, usz index)

fn short! Object.get_ushort(&self, String key)

fn ushort! Object.get_ushort_at(&self, usz index)

fn bool Object.has_key(&self, String key)

fn bool Object.is_array(&self) @inline

fn bool Object.is_bool(&self) @inline

fn bool Object.is_empty(&self) @inline

fn bool Object.is_float(&self) @inline

fn bool Object.is_indexable(&self)

fn bool Object.is_int(&self) @inline

fn bool Object.is_keyable(&self)

fn bool Object.is_map(&self) @inline

fn bool Object.is_null(&self) @inline

fn bool Object.is_string(&self) @inline

macro Object* Object.push(&self, value)

fn void Object.push_object(&self, Object* to_append)

macro Object* Object.set(&self, String key, value)

macro Object* Object.set_at(&self, usz index, String key, value)

fn void Object.set_object_at(&self, usz index, Object* to_set)

fn usz! Object.to_format(&self, Formatter* formatter) @dynamic

macro get_integer_value(Object* value, $Type)

fn Object* new_bool(bool b)

macro Object* new_enum(e, Allocator allocator)

fn Object* new_float(double f, Allocator allocator)

fn Object* new_int(int128 i, Allocator allocator)

fn Object* new_null()

fn Object* new_obj(Allocator allocator)

fn Object* new_string(String s, Allocator allocator)

std::collections::priorityqueue(<Type>)

distinct PriorityQueue = inline PrivatePriorityQueue(<Type, false>);

distinct PriorityQueueMax = inline PrivatePriorityQueue(<Type, true>);

std::collections::priorityqueue::private(<Type, MAX>)

struct PrivatePriorityQueue (Printable)

fn Type! PrivatePriorityQueue.first(&self)

fn void PrivatePriorityQueue.free(&self)

fn Type PrivatePriorityQueue.get(&self, usz index) @operator([])

fn bool PrivatePriorityQueue.is_empty(&self)

fn usz PrivatePriorityQueue.len(&self) @operator(len)

fn void PrivatePriorityQueue.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap()) @inline

fn Type! PrivatePriorityQueue.pop(&self)

fn void PrivatePriorityQueue.push(&self, Type element)

fn void PrivatePriorityQueue.temp_init(&self, usz initial_capacity = 16) @inline

fn usz! PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic

fn String PrivatePriorityQueue.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic

std::collections::range(<Type>)

struct ExclusiveRange (Printable)

struct Range (Printable)

fn bool ExclusiveRange.contains(&self, Type value) @inline

fn Type ExclusiveRange.get(&self, usz index) @operator([])

fn usz ExclusiveRange.len(&self) @operator(len)

fn usz! ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic

fn String ExclusiveRange.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic

fn String ExclusiveRange.to_tstring(&self)

fn bool Range.contains(&self, Type value) @inline

fn Type Range.get(&self, usz index) @operator([])

fn usz Range.len(&self) @operator(len)

fn usz! Range.to_format(&self, Formatter* formatter) @dynamic

fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic

fn String Range.to_tstring(&self)

std::collections::ringbuffer(<Type, SIZE>)

struct RingBuffer

fn Type RingBuffer.get(&self, usz index) @operator([])

fn void RingBuffer.init(&self) @inline

fn Type! RingBuffer.pop(&self)

fn void RingBuffer.push(&self, Type c)

fn usz RingBuffer.read(&self, usz index, Type[] buffer)

fn void RingBuffer.write(&self, Type[] buffer)

std::collections::triple(<Type1, Type2, Type3>)

struct Triple

std::collections::tuple(<Type1, Type2>)

struct Tuple

std::core::array

macro concat_new(arr1, arr2, Allocator allocator = allocator::heap())

macro index_of(array, element)

macro rindex_of(array, element)

macro slice2d(array, x = 0, xlen = 0, y = 0, ylen = 0)

macro tconcat(arr1, arr2)

std::core::array::slice(<Type>)

struct Slice2d

macro void Slice2d.@each(&self; @body(usz[<2>], Type))

macro void Slice2d.@each_ref(&self; @body(usz[<2>], Type*))

fn usz Slice2d.count(&self)

macro Type[] Slice2d.get(self, usz idy) @operator([])

fn usz Slice2d.len(&self) @operator(len)

fn Slice2d Slice2d.slice(&self, isz x = 0, isz xlen = 0, isz y = 0, isz ylen = 0)

std::core::bitorder

macro bool is_array_or_slice_of_char(bytes)

macro bool is_arrayptr_or_slice_of_char(bytes)

macro is_bitorder($Type)

macro read(bytes, $Type)

macro write(x, bytes, $Type)

std::core::builtin

enum PrefetchLocality

fault CastResult

fault IteratorResult

fault SearchResult

macro char[] @as_char_view(&value) @builtin

macro anyfault @catch(#expr) @builtin

macro @expect(#value, expected, $probability = 1.0) @builtin

macro bool @likely(bool #value, $probability = 1.0) @builtin

macro bool @ok(#expr) @builtin

macro @prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write = false) @builtin

macro void @scope(&variable; @body) @builtin

macro void @swap(&a, &b) @builtin

macro bool @unlikely(bool #value, $probability = 1.0) @builtin

macro uint String.hash(String c)

macro any.as_inner(&self)

macro any.retype_to(&self, typeid type)

macro any_make(void* ptr, typeid type) @builtin

macro anycast(any v, $Type) @builtin

macro bitcast(expr, $Type) @builtin

macro uint bool.hash(bool b)

macro uint char.hash(char c)

macro uint char[].hash(char[] c)

macro int compare_to(a, b) @builtin

fn void default_panic(String message, String file, String function, uint line) @if(!env::NATIVE_STACKTRACE)

fn void default_panic(String message, String file, String function, uint line) @if(env::NATIVE_STACKTRACE)

macro enum_by_name($Type, String enum_name) @builtin

macro bool equals(a, b) @builtin

macro void* get_frameaddress(int n)

macro void* get_returnaddress(int n)

macro greater(a, b) @builtin

macro greater_eq(a, b) @builtin

macro uint ichar.hash(ichar c)

macro uint int.hash(int i)

macro uint int128.hash(int128 i)

macro less(a, b) @builtin

macro less_eq(a, b) @builtin

macro uint long.hash(long i)

macro max(x, ...) @builtin

macro min(x, ...) @builtin

fn void panicf(String fmt, String file, String function, uint line, args...)

fn bool print_backtrace(String message, int backtraces_to_ignore) @if(env::NATIVE_STACKTRACE)

macro uint short.hash(short s)

macro swizzle(v, ...) @builtin

macro swizzle2(v, v2, ...) @builtin

macro uint typeid.hash(typeid t)

macro uint uint.hash(uint i)

macro uint uint128.hash(uint128 i)

macro uint ulong.hash(ulong i)

macro void unreachable(String string = "Unreachable statement reached.", ...) @builtin @noreturn

macro void unsupported(String string = "Unsupported function invoked") @builtin @noreturn

macro uint ushort.hash(ushort s)

macro uint void*.hash(void* ptr)

std::core::builtin @if((env::LINUX || env::DARWIN) && env::COMPILER_SAFE_MODE && env::DEBUG_SYMBOLS)

fn void sig_bus_error(CInt i)

fn void sig_panic(String message)

fn void sig_segmentation_fault(CInt i)

std::core::dstring

distinct DString (OutStream) = void*;

macro void DString.append(&self, value)

fn void DString.append_char(&self, char c)

fn void DString.append_char32(&self, Char32 c)

fn void DString.append_chars(&self, String str)

fn void DString.append_repeat(&self, char c, usz times)

fn void DString.append_string(&self, DString str)

fn void DString.append_utf32(&self, Char32[] chars)

fn usz! DString.appendf(&self, String format, args...) @maydiscard

fn usz! DString.appendfn(&self, String format, args...) @maydiscard

fn usz DString.capacity(self)

fn void DString.chop(self, usz new_size)

fn void DString.clear(self)

fn DString DString.copy(self, Allocator allocator = null)

fn String DString.copy_str(self, Allocator allocator = allocator::heap())

fn Char32[] DString.copy_utf32(&self, Allocator allocator = allocator::heap())

fn ZString DString.copy_zstr(self, Allocator allocator = allocator::heap())

fn void DString.delete(&self, usz start, usz len = 1)

fn void DString.delete_range(&self, usz start, usz end)

fn bool DString.equals(self, DString other_string)

fn void DString.free(&self)

fn void DString.insert_at(&self, usz index, String s)

fn usz DString.len(&self) @dynamic

fn bool DString.less(self, DString other_string)

fn DString DString.new_concat(self, DString b, Allocator allocator = allocator::heap())

fn DString DString.new_init(&self, usz capacity = MIN_CAPACITY, Allocator allocator = allocator::heap())

fn usz! DString.read_from_stream(&self, InStream reader)

fn void DString.reserve(&self, usz addition)

fn void DString.set(self, usz index, char c)

fn String DString.str_view(self)

fn DString DString.tcopy(&self)

fn String DString.tcopy_str(self)

fn DString DString.temp_concat(self, DString b)

fn DString DString.temp_init(&self, usz capacity = MIN_CAPACITY)

fn usz! DString.write(&self, char[] buffer) @dynamic

fn void! DString.write_byte(&self, char c) @dynamic

fn ZString DString.zstr_view(&self)

fn DString new(String c = "", Allocator allocator = allocator::heap())

fn DString new_join(String[] s, String joiner, Allocator allocator = allocator::heap())

fn DString new_with_capacity(usz capacity, Allocator allocator = allocator::heap())

fn DString temp_new(String s = "")

fn DString temp_with_capacity(usz capacity)

std::core::env

enum ArchType

enum CompilerOptLevel

enum MemoryEnvironment

enum OsType

macro bool os_is_darwin()

macro bool os_is_posix()

std::core::mem

enum AtomicOrdering : int

struct TempState

macro @atomic_load(&x, AtomicOrdering $ordering = SEQ_CONSISTENT, $volatile = false) @builtin

macro void @atomic_store(&x, value, AtomicOrdering $ordering = SEQ_CONSISTENT, $volatile = false) @builtin

macro @clone(value) @builtin @nodiscard

macro @gather_aligned(ptrvec, bool[<*>] mask, passthru, usz $alignment)

macro @masked_load_aligned(ptr, bool[<*>] mask, passthru, usz $alignment)

macro @masked_store_aligned(ptr, value, bool[<*>] mask, usz $alignment)

macro void @pool(TempAllocator* #other_temp = null; @body) @builtin

macro void @report_heap_allocs_in_scope(;@body())

macro @scatter_aligned(ptrvec, value, bool[<*>] mask, usz $alignment)

macro void @scoped(Allocator allocator; @body())

macro void @stack_mem(usz $size; @body(Allocator mem)) @builtin

macro void @stack_pool(usz $size; @body) @builtin

macro @tclone(value) @builtin @nodiscard

macro @volatile_load(&x) @builtin

macro @volatile_store(&x, y) @builtin

fn usz aligned_offset(usz offset, usz alignment)

macro void* aligned_pointer(void* ptr, usz alignment)

macro alloc($Type) @nodiscard

macro alloc_aligned($Type) @nodiscard

macro alloc_array($Type, usz elements) @nodiscard

macro alloc_array_aligned($Type, usz elements) @nodiscard

fn void* calloc(usz size) @builtin @inline @nodiscard

fn void* calloc_aligned(usz size, usz alignment) @builtin @inline @nodiscard

macro void clear(void* dst, usz len, usz $dst_align = 0, bool $is_volatile = false, bool $inlined = false)

macro void clear_inline(void* dst, usz $len, usz $dst_align = 0, bool $is_volatile = false)

macro compare_exchange(ptr, compare, value, AtomicOrdering $success = SEQ_CONSISTENT, AtomicOrdering $failure = SEQ_CONSISTENT, bool $volatile = true, bool $weak = false, usz $alignment = 0)

macro compare_exchange_volatile(ptr, compare, value, AtomicOrdering $success = SEQ_CONSISTENT, AtomicOrdering $failure = SEQ_CONSISTENT)

macro void copy(void* dst, void* src, usz len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false, bool $inlined = false)

macro void copy_inline(void* dst, void* src, usz $len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false)

macro bool equals(a, b, isz len = -1, usz $align = 0)

fn void free(void* ptr) @builtin @inline

fn void free_aligned(void* ptr) @builtin @inline

macro gather(ptrvec, bool[<*>] mask, passthru)

macro TrackingEnv* get_tracking_env()

fn void* malloc(usz size) @builtin @inline @nodiscard

macro masked_load(ptr, bool[<*>] mask, passthru)

macro masked_store(ptr, value, bool[<*>] mask)

macro void move(void* dst, void* src, usz len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false)

macro new($Type, ...) @nodiscard

macro new_aligned($Type, ...) @nodiscard

macro new_array($Type, usz elements) @nodiscard

macro new_array_aligned($Type, usz elements) @nodiscard

fn bool ptr_is_aligned(void* ptr, usz alignment) @inline

fn void* realloc(void *ptr, usz new_size) @builtin @inline @nodiscard

fn void* realloc_aligned(void *ptr, usz new_size, usz alignment) @builtin @inline @nodiscard

macro scatter(ptrvec, value, bool[<*>] mask)

macro void set(void* dst, char val, usz len, usz $dst_align = 0, bool $is_volatile = false)

macro void set_inline(void* dst, char val, usz $len, usz $dst_align = 0, bool $is_volatile = false)

fn void* tcalloc(usz size, usz alignment = 0) @builtin @inline @nodiscard

macro temp_alloc($Type) @nodiscard

macro temp_alloc_array($Type, usz elements) @nodiscard

macro temp_new($Type, ...) @nodiscard

macro temp_new_array($Type, usz elements) @nodiscard

fn void temp_pop(TempState old_state)

fn TempState temp_push(TempAllocator* other = null)

fn void* tmalloc(usz size, usz alignment = 0) @builtin @inline @nodiscard

fn void* trealloc(void* ptr, usz size, usz alignment = mem::DEFAULT_MEM_ALIGNMENT) @builtin @inline @nodiscard

macro type_alloc_must_be_aligned($Type)

std::core::mem::allocator

distinct LibcAllocator (Allocator) = uptr;

enum AllocInitType

fault AllocationFailure

interface Allocator

struct AlignedBlock

struct Allocation

struct ArenaAllocator (Allocator)

struct DynamicArenaAllocator (Allocator)

struct OnStackAllocator (Allocator)

struct OnStackAllocatorHeader

struct SimpleHeapAllocator (Allocator)

struct TempAllocator (Allocator)

struct TempAllocatorPage

struct TrackingAllocator (Allocator)

struct TrackingEnv

struct WasmMemory

macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment)

macro void! @aligned_free(#free_fn, void* old_pointer)

macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)

fn void*! ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic

fn void ArenaAllocator.clear(&self)

fn void ArenaAllocator.init(&self, char[] data)

fn usz ArenaAllocator.mark(&self) @dynamic

fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic

fn void ArenaAllocator.reset(&self, usz mark) @dynamic

fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic

fn void*! DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic

fn void DynamicArenaAllocator.free(&self)

fn void DynamicArenaAllocator.init(&self, usz page_size, Allocator allocator)

fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic

fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic

fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic

fn void*! OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic

fn void OnStackAllocator.free(&self)

fn void OnStackAllocator.init(&self, char[] data, Allocator allocator)

fn void OnStackAllocator.release(&self, void* old_pointer, bool aligned) @dynamic

fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic

fn void*! SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic

fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)

fn void SimpleHeapAllocator.release(&self, void* old_pointer, bool aligned) @dynamic

fn void*! SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic

fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic

fn usz TempAllocator.mark(&self) @dynamic

fn void! TempAllocator.print_pages(&self, File* f)

fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic

fn void TempAllocator.reset(&self, usz mark) @dynamic

fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic

macro bool TempAllocatorPage.is_aligned(&self)

macro usz TempAllocatorPage.pagesize(&self)

fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic

fn usz TrackingAllocator.allocated(&self)

fn usz TrackingAllocator.allocation_count(&self)

fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)

fn void TrackingAllocator.clear(&self)

fn void! TrackingAllocator.fprint_report(&self, OutStream out)

fn void TrackingAllocator.free(&self)

fn void TrackingAllocator.init(&self, Allocator allocator)

fn void TrackingAllocator.print_report(&self)

fn void TrackingAllocator.release(&self, void* old_pointer, bool is_aligned) @dynamic

fn void*! TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic

fn usz TrackingAllocator.total_allocated(&self)

fn usz TrackingAllocator.total_allocation_count(&self)

fn char[]! WasmMemory.allocate_block(&self, usz bytes)

macro alloc(Allocator allocator, $Type) @nodiscard

macro alloc_array(Allocator allocator, $Type, usz elements) @nodiscard

macro alloc_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard

macro alloc_array_try(Allocator allocator, $Type, usz elements) @nodiscard

macro alloc_try(Allocator allocator, $Type) @nodiscard

macro alloc_with_padding(Allocator allocator, $Type, usz padding) @nodiscard

macro void* calloc(Allocator allocator, usz size) @nodiscard

macro void*! calloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard

macro void*! calloc_try(Allocator allocator, usz size) @nodiscard

macro clone(Allocator allocator, value) @nodiscard

fn any clone_any(Allocator allocator, any value) @nodiscard

macro void free(Allocator allocator, void* ptr)

macro void free_aligned(Allocator allocator, void* ptr)

macro Allocator heap()

macro void* malloc(Allocator allocator, usz size) @nodiscard

macro void*! malloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard

macro void*! malloc_try(Allocator allocator, usz size) @nodiscard

macro new(Allocator allocator, $Type, ...) @nodiscard

macro new_array(Allocator allocator, $Type, usz elements) @nodiscard

macro new_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard

macro new_array_try(Allocator allocator, $Type, usz elements) @nodiscard

fn TempAllocator*! new_temp_allocator(usz size, Allocator allocator)

macro new_try(Allocator allocator, $Type, ...) @nodiscard

macro new_with_padding(Allocator allocator, $Type, usz padding) @nodiscard

macro void* realloc(Allocator allocator, void* ptr, usz new_size) @nodiscard

macro void*! realloc_aligned(Allocator allocator, void* ptr, usz new_size, usz alignment) @nodiscard

macro void*! realloc_try(Allocator allocator, void* ptr, usz new_size) @nodiscard

macro TempAllocator* temp()

std::core::mem::allocator @if(!env::WIN32 && !env::POSIX)

fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic

fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic

fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic

std::core::mem::allocator @if(env::POSIX)

fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic

fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic

fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic

std::core::mem::allocator @if(env::WIN32)

fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic

fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic

fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic

std::core::runtime

struct AnyRaw

struct BenchmarkUnit

struct SliceRaw

struct TestContext

struct TestUnit

fn BenchmarkUnit[] benchmark_collection_create(Allocator allocator = allocator::heap())

fn int cmp_test_unit(TestUnit a, TestUnit b)

fn bool default_benchmark_runner()

fn bool default_test_runner()

fn bool run_benchmarks(BenchmarkUnit[] benchmarks)

fn bool run_tests(TestUnit[] tests)

fn void set_benchmark_max_iterations(uint value) @builtin

fn void set_benchmark_warmup_iterations(uint value) @builtin

fn TestUnit[] test_collection_create(Allocator allocator = allocator::heap())

fn void test_panic(String message, String file, String function, uint line)

std::core::runtime @if(WASM_NOLIBC)

fn void wasm_initialize() @extern("_initialize") @wasm

std::core::string

distinct WString = inline Char16*;

distinct ZString = inline char*;

fault NumberConversion

fault UnicodeResult

struct Splitter

fn String! Splitter.next(&self)

fn void Splitter.reset(&self)

fn String String.concat(s1, String s2, Allocator allocator = allocator::heap())

fn bool String.contains(s, String needle)

fn void String.convert_ascii_to_lower(s)

fn void String.convert_ascii_to_upper(s)

fn String String.copy(s, Allocator allocator = allocator::heap())

fn bool String.ends_with(string, String needle)

fn void String.free(&s, Allocator allocator = allocator::heap())

fn usz! String.index_of(s, String needle)

fn usz! String.index_of_char(s, char needle)

fn StringIterator String.iterator(s)

fn String String.new_ascii_to_lower(s, Allocator allocator = allocator::heap())

fn String String.new_ascii_to_upper(s, Allocator allocator = allocator::heap())

fn usz! String.rindex_of(s, String needle)

fn usz! String.rindex_of_char(s, char needle)

fn String[] String.split(s, String needle, usz max = 0, Allocator allocator = allocator::heap())

fn Splitter String.splitter(self, String split)

fn bool String.starts_with(string, String needle)

fn String String.strip(string, String needle)

fn String String.strip_end(string, String needle)

fn String String.tconcat(s1, String s2)

fn String String.tcopy(s)

fn String String.temp_ascii_to_lower(s, Allocator allocator = allocator::heap())

fn String String.temp_ascii_to_upper(s)

fn double! String.to_double(s)

fn float! String.to_float(s)

fn ichar! String.to_ichar(s, int base = 10)

fn int! String.to_int(s, int base = 10)

fn int128! String.to_int128(s, int base = 10)

macro String.to_integer(string, $Type, int base = 10)

fn long! String.to_long(s, int base = 10)

fn Char16[]! String.to_new_utf16(s, Allocator allocator = allocator::heap())

fn Char32[]! String.to_new_utf32(s, Allocator allocator = allocator::heap())

fn WString! String.to_new_wstring(s, Allocator allocator = allocator::heap())

fn short! String.to_short(s, int base = 10)

fn Char16[]! String.to_temp_utf16(s)

fn Char32[]! String.to_temp_utf32(s)

fn WString! String.to_temp_wstring(s)

fn char! String.to_uchar(s, int base = 10)

fn uint! String.to_uint(s, int base = 10)

fn uint128! String.to_uint128(s, int base = 10)

fn ulong! String.to_ulong(s, int base = 10)

fn ushort! String.to_ushort(s, int base = 10)

fn String String.trim(string, String to_trim = "\t\n\r ")

fn String[] String.tsplit(s, String needle, usz max = 0)

fn usz String.utf8_codepoints(s)

fn ZString String.zstr_copy(s, Allocator allocator = allocator::heap())

fn ZString String.zstr_tcopy(s)

fn usz ZString.char_len(str)

fn String ZString.copy(z, Allocator allocator = allocator::temp())

fn usz ZString.len(str)

fn String ZString.str_view(str)

fn String ZString.tcopy(z)

macro bool char_in_set(char c, String set)

macro double! decfloat(char[] chars, int $bits, int $emin, int sign)

macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)

fn String join_new(String[] s, String joiner, Allocator allocator = allocator::heap())

macro String new_format(String fmt, ..., Allocator allocator = allocator::heap())

fn String! new_from_utf16(Char16[] utf16, Allocator allocator = allocator::heap())

fn String! new_from_utf32(Char32[] utf32, Allocator allocator = allocator::heap())

fn String! new_from_wstring(WString wstring, Allocator allocator = allocator::heap())

fn String! temp_from_utf16(Char16[] utf16)

fn String! temp_from_wstring(WString wstring)

macro String tformat(String fmt, ...)

std::core::string::conv

fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)

fn void char32_to_utf16_unsafe(Char32 c, Char16** output)

fn usz! char32_to_utf8(Char32 c, char[] output)

fn usz char32_to_utf8_unsafe(Char32 c, char** output)

fn usz utf16len_for_utf32(Char32[] utf32)

fn usz utf16len_for_utf8(String utf8)

fn void! utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)

fn usz! utf32to8(Char32[] utf32, char[] utf8_buffer)

fn void utf32to8_unsafe(Char32[] utf32, char* utf8_buffer)

fn usz utf8_codepoints(String utf8)

fn Char32! utf8_to_char32(char* ptr, usz* size)

fn usz utf8len_for_utf16(Char16[] utf16)

fn usz utf8len_for_utf32(Char32[] utf32)

fn void! utf8to16_unsafe(String utf8, Char16* utf16_buffer)

fn usz! utf8to32(String utf8, Char32[] utf32_buffer)

fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)

std::core::string::iterator

struct StringIterator

fn Char32! StringIterator.next(&self)

fn void StringIterator.reset(&self)

std::core::types

enum TypeKind : char

fault ConversionResult

struct TypeEnum

macro bool @has_same(#a, #b, ...)

fn bool TypeKind.is_int(kind) @inline

macro any_to_int(any v, $Type)

macro bool implements_copy($Type)

macro TypeKind inner_kind($Type)

macro bool is_bool($Type)

macro bool is_comparable_value(value)

macro bool is_equatable_type($Type)

macro bool is_equatable_value(value)

macro bool is_float($Type)

macro bool is_floatlike($Type)

macro bool is_int($Type)

macro bool is_intlike($Type)

macro bool is_numerical($Type)

macro bool is_promotable_to_float($Type)

macro bool is_promotable_to_floatlike($Type)

macro bool is_same($TypeA, $TypeB)

macro bool is_same_vector_type($Type1, $Type2)

macro bool is_slice_convertable($Type)

macro bool is_subtype_of($Type, $OtherType)

macro bool is_underlying_int($Type)

macro bool is_vector($Type)

macro lower_to_atomic_compatible_type($Type)

macro bool may_load_atomic($Type)

fn bool typeid.is_subtype_of(self, typeid other)

std::core::values

macro bool @assign_to(#value1, #value2)

macro TypeKind @inner_kind(#value)

macro bool @is_bool(#value)

macro bool @is_float(#value)

macro bool @is_floatlike(#value)

macro bool @is_int(#value)

macro bool @is_promotable_to_float(#value)

macro bool @is_promotable_to_floatlike(#value)

macro bool @is_same_type(#value1, #value2)

macro bool @is_same_vector_type(#value1, #value2)

macro bool @is_vector(#value)

macro typeid @typeid(#value) @builtin

macro bool @typeis(#value, $Type) @builtin

macro TypeKind @typekind(#value) @builtin

macro promote_int(x)

std::crypto::rc4

struct Rc4

fn void Rc4.crypt(&self, char[] in, char[] out)

fn void Rc4.destroy(&self)

fn void Rc4.init(&self, char[] key)

std::encoding::base64

fault Base64Error

struct Base64Decoder

struct Base64Encoder

fn usz! Base64Decoder.decode(&self, char[] src, char[] dst)

fn usz! Base64Decoder.decode_len(&self, usz n)

fn void! Base64Decoder.init(&self, String alphabet, int padding = '=')

fn usz! Base64Encoder.encode(&self, char[] src, char[] dst)

fn usz Base64Encoder.encode_len(&self, usz n)

fn void! Base64Encoder.init(&self, String alphabet, int padding = '=')

std::encoding::csv

struct CsvReader

macro CsvReader.@each_row(self, int rows = int.max; @body(String[] row))

fn void CsvReader.init(&self, InStream stream, String separator = ",")

fn String[]! CsvReader.read_new_row(self, Allocator allocator = allocator::heap())

fn String[]! CsvReader.read_new_row_with_allocator(self, Allocator allocator = allocator::heap())

fn String[]! CsvReader.read_temp_row(self)

fn void! CsvReader.skip_row(self) @maydiscard

std::encoding::json

fault JsonParsingError

fn JsonTokenType! lex_string(JsonContext* context)

fn Object*! parse(InStream s, Allocator allocator = allocator::heap())

std::hash::adler32

struct Adler32

fn uint Adler32.final(&self)

fn void Adler32.init(&self)

fn void Adler32.update(&self, char[] data)

fn void Adler32.updatec(&self, char c)

fn uint encode(char[] data)

std::hash::crc32

struct Crc32

fn uint Crc32.final(&self)

fn void Crc32.init(&self, uint seed = 0)

fn void Crc32.update(&self, char[] data)

fn void Crc32.updatec(&self, char c)

fn uint encode(char[] data)

std::hash::crc64

struct Crc64

fn ulong Crc64.final(&self)

fn void Crc64.init(&self, uint seed = 0)

fn void Crc64.update(&self, char[] data)

fn void Crc64.updatec(&self, char c)

fn ulong encode(char[] data)

std::hash::fnv32a

distinct Fnv32a = uint;

fn void Fnv32a.init(&self)

fn void Fnv32a.update(&self, char[] data)

macro void Fnv32a.update_char(&self, char c)

fn uint encode(char[] data)

std::hash::fnv64a

distinct Fnv64a = ulong;

fn void Fnv64a.init(&self)

fn void Fnv64a.update(&self, char[] data)

macro void Fnv64a.update_char(&self, char c)

fn ulong encode(char[] data)

std::hash::sha1

struct Sha1

fn char[20] Sha1.final(&self)

fn void Sha1.init(&self)

fn void Sha1.update(&self, char[] data)

std::io

enum Seek

fault FormattingFault

fault IoError

fault PrintFault

interface InStream

interface OutStream

interface Printable

struct BitReader

struct BitWriter

struct ByteBuffer (InStream, OutStream)

struct ByteReader (InStream)

struct ByteWriter (OutStream)

struct File (InStream, OutStream)

struct Formatter

struct LimitReader (InStream)

struct ReadBuffer (InStream)

struct Scanner (InStream)

struct WriteBuffer (OutStream)

macro bool @is_instream(#expr)

macro bool @is_outstream(#expr)

macro void! @pushback_using_seek(&s)

macro char! @read_byte_using_read(&s)

macro usz! @read_using_read_byte(&s, char[] buffer)

macro void! @write_byte_using_write(&s, char c)

macro usz! @write_using_write_byte(&s, char[] bytes)

fn void BitReader.clear(&self) @inline

fn void BitReader.init(&self, InStream byte_reader)

fn char! BitReader.read_bits(&self, uint nbits)

fn void! BitWriter.flush(&self)

fn void BitWriter.init(&self, OutStream byte_writer)

fn void! BitWriter.write_bits(&self, uint bits, uint nbits)

fn usz! ByteBuffer.available(&self) @inline @dynamic

fn void ByteBuffer.free(&self)

fn void! ByteBuffer.grow(&self, usz n)

fn ByteBuffer*! ByteBuffer.init_with_buffer(&self, char[] buf)

fn ByteBuffer*! ByteBuffer.new_init(&self, usz max_read, usz initial_capacity = 16, Allocator allocator = allocator::heap())

fn void! ByteBuffer.pushback_byte(&self) @dynamic

fn usz! ByteBuffer.read(&self, char[] bytes) @dynamic

fn char! ByteBuffer.read_byte(&self) @dynamic

fn usz! ByteBuffer.seek(&self, isz offset, Seek seek) @dynamic

macro ByteBuffer.shrink(&self)

fn ByteBuffer*! ByteBuffer.temp_init(&self, usz max_read, usz initial_capacity = 16)

fn usz! ByteBuffer.write(&self, char[] bytes) @dynamic

fn void! ByteBuffer.write_byte(&self, char c) @dynamic

fn usz! ByteReader.available(&self) @inline @dynamic

fn ByteReader* ByteReader.init(&self, char[] bytes)

fn usz ByteReader.len(&self) @dynamic

fn void! ByteReader.pushback_byte(&self) @dynamic

fn usz! ByteReader.read(&self, char[] bytes) @dynamic

fn char! ByteReader.read_byte(&self) @dynamic

fn usz! ByteReader.seek(&self, isz offset, Seek seek) @dynamic

fn usz! ByteReader.write_to(&self, OutStream writer) @dynamic

fn void! ByteWriter.destroy(&self) @dynamic

fn void! ByteWriter.ensure_capacity(&self, usz len) @inline

fn ByteWriter* ByteWriter.init_with_buffer(&self, char[] data)

fn ByteWriter* ByteWriter.new_init(&self, Allocator allocator = allocator::heap())

fn usz! ByteWriter.read_from(&self, InStream reader) @dynamic

fn String ByteWriter.str_view(&self) @inline

fn ByteWriter* ByteWriter.temp_init(&self)

fn usz! ByteWriter.write(&self, char[] bytes) @dynamic

fn void! ByteWriter.write_byte(&self, char c) @dynamic

fn void Formatter.init(&self, OutputFn out_fn, void* data = null)

fn usz! Formatter.print(&self, String str)

fn usz! Formatter.print_with_function(&self, Printable arg)

fn usz! Formatter.printf(&self, String format, args...)

fn usz! Formatter.vprintf(&self, String format, any[] anys)

fn usz! LimitReader.available(&self) @inline @dynamic

fn void! LimitReader.close(&self) @dynamic

fn LimitReader* LimitReader.init(&self, InStream wrapped_stream, usz limit)

fn usz! LimitReader.read(&self, char[] bytes) @dynamic

fn char! LimitReader.read_byte(&self) @dynamic

fn void! ReadBuffer.close(&self) @dynamic

fn ReadBuffer* ReadBuffer.init(&self, InStream wrapped_stream, char[] bytes)

fn usz! ReadBuffer.read(&self, char[] bytes) @dynamic

fn char! ReadBuffer.read_byte(&self) @dynamic

fn String ReadBuffer.str_view(&self) @inline

fn void! Scanner.close(&self) @dynamic

fn char[] Scanner.flush(&self) @dynamic

fn void Scanner.init(&self, InStream stream, char[] buffer)

fn usz! Scanner.read(&self, char[] bytes) @dynamic

fn char! Scanner.read_byte(&self) @dynamic

fn char[]! Scanner.scan(&self, String pattern = "\n")

fn void! WriteBuffer.close(&self) @dynamic

fn void! WriteBuffer.flush(&self) @dynamic

fn WriteBuffer* WriteBuffer.init(&self, OutStream wrapped_stream, char[] bytes)

fn String WriteBuffer.str_view(&self) @inline

fn usz! WriteBuffer.write(&self, char[] bytes) @dynamic

fn void! WriteBuffer.write_byte(&self, char c) @dynamic

fn usz! available(InStream s)

fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard

fn usz! copy_to(InStream in, OutStream dst, char[] buffer = {})

macro void eprint(x)

fn usz! eprintf(String format, args...) @maydiscard

fn usz! eprintfn(String format, args...) @maydiscard

macro void eprintn(x)

macro usz! fprint(out, x)

fn usz! fprintf(OutStream out, String format, args...)

fn usz! fprintfn(OutStream out, String format, args...) @maydiscard

macro usz! fprintn(out, x = "")

macro void print(x)

fn usz! printf(String format, args...) @maydiscard

fn usz! printfn(String format, args...) @maydiscard

macro void printn(x = "")

macro usz! read_all(stream, char[] buffer)

macro usz! read_any(stream, any ref)

macro usz! read_varint(stream, x_ptr)

macro String! readline(stream = io::stdin(), Allocator allocator = allocator::heap())

macro String! treadline(stream = io::stdin())

macro usz! write_all(stream, char[] buffer)

macro usz! write_any(stream, any ref)

macro usz! write_varint(stream, x)

std::io @if (env::LIBC)

fn void putchar(char c) @inline

fn File* stderr()

fn File* stdin()

fn File* stdout()

std::io @if(!env::LIBC)

fn void putchar(char c) @inline

fn File* stderr()

fn File* stdin()

fn File* stdout()

std::io::file

fn void! File.close(&self) @inline @dynamic

fn bool File.eof(&self) @inline

fn void! File.flush(&self) @dynamic

fn void! File.memopen(File* file, char[] data, String mode)

fn usz! File.read(&self, char[] buffer) @dynamic

fn char! File.read_byte(&self) @dynamic

fn void! File.reopen(&self, String filename, String mode)

fn usz! File.seek(&self, isz offset, Seek seek_mode = Seek