Fix deprecation warnings not silenced.

* vendor-fetch lists available libraries

from `github.com/c3lang/vendor` when no library is specified.

* add release notes

.clang-format

@@ -0,0 +1,15 @@
+IndentWidth: 4
+UseCRLF: false
+IndentCaseLabels: true
+UseTab: ForIndentation
+TabWidth: 4
+BreakBeforeBraces: Allman
+AllowShortBlocksOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: WithoutElse
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeParens: ControlStatementsExceptControlMacros
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false

.clang-tidy

@@ -1,21 +1,7 @@
 ---
 # Configure clang-tidy for this project.
 
-IndentWidth: 4
-UseCRLF: false
-IndentCaseLabels: true
-UseTab: UT_ForIndentation
-TabWidth: 4
-BreakBeforeBraces: Allman
-AllowShortBlocksOnASingleLine: SBS_Empty
-AllowShortIfStatementsOnASingleLine: SIS_WithoutElse
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCaseColon: false
-SpaceBeforeParens: SBPO_ControlStatementsExceptControlMacros
-SpacesInCStyleCastParentheses: false
-SpacesInConditionalStatement: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
+
 
 # Disabled:
 #  -google-readability-namespace-comments the *_CLIENT_NS is a macro, and
@@ -40,17 +26,19 @@ Checks: >
 
 # Turn all the warnings from the checks above into errors.
 WarningsAsErrors: "*"
-
 CheckOptions:
-  - { key: readability-function-cognitive-complexity.Threshold,    value: 100 }
-  - { key: readability-identifier-naming.StructCase,             value: CamelCase  }
-  - { key: readability-identifier-naming.FunctionCase,           value: lower_case  }
-  - { key: readability-identifier-naming.VariableCase,           value: lower_case }
-  - { key: readability-identifier-naming.MacroDefinitionCase,    value: UPPER_CASE }
-  - { key: readability-identifier-naming.EnumConstantCase,         value: UPPER_CASE }
-  - { key: readability-identifier-naming.ConstexprVariableCase,    value: CamelCase }
-  - { key: readability-identifier-naming.ConstexprVariablePrefix,  value: k         }
-  - { key: readability-identifier-naming.GlobalConstantCase,       value: CamelCase }
-  - { key: readability-identifier-naming.GlobalConstantPrefix,     value: k         }
-  - { key: readability-identifier-naming.StaticConstantCase,       value: CamelCase }
-  - { key: readability-identifier-naming.StaticConstantPrefix,     value: k         }
+  - { key: readability-function-cognitive-complexity.Threshold,        value: 100 }
+  - { key: readability-identifier-naming.StructCase,                   value: CamelCase  }
+  - { key: readability-identifier-naming.FunctionCase,                 value: lower_case  }
+  - { key: readability-identifier-naming.VariableCase,                 value: lower_case }
+  - { key: readability-identifier-naming.MacroDefinitionCase,          value: UPPER_CASE }
+  - { key: readability-identifier-naming.EnumConstantCase,             value: UPPER_CASE }
+  - { key: readability-identifier-naming.ConstexprVariableCase,        value: CamelCase }
+  - { key: readability-identifier-naming.ConstexprVariablePrefix,      value: k         }
+  - { key: readability-identifier-naming.GlobalConstantCase,           value: CamelCase }
+  - { key: readability-identifier-naming.GlobalConstantPrefix,         value: k         }
+  - { key: readability-identifier-naming.StaticConstantCase,           value: CamelCase }
+  - { key: readability-identifier-naming.StaticConstantPrefix,         value: k         }
+  - { key: readability-identifier-naming.MinimumParameterNameLength,   value: 0 }
+
+MinimumParameterNameLength: 0

.gitignore

@@ -1,5 +1,7 @@
 # Prerequisites
 *.d
+testrun
+benchmarkrun
 
 # Object files
 *.o
@@ -7,6 +9,8 @@
 *.obj
 *.elf
 *.ll
+*.wasm
+*.s
 
 # Linker output
 *.ilk
@@ -19,6 +23,7 @@
 
 # Libraries
 *.lib
+*.tlb
 *.a
 *.la
 *.lo
@@ -68,10 +73,34 @@ out/
 /cmake-build-debug/
 /cmake-build-release/
 
-# Emacs files
+CMakeFiles/cmake.check_cache
+CMakeCache.txt
+
+# etags(Emacs), ctags, gtags
 TAGS
+GPATH
+GRTAGS
+GTAGS
+tags
 
 # Clangd LSP files
 /.cache/
 /compile_commands.json
 
+# Nix
+result
+/.envrc
+/.direnv/
+
+# macOS
+.DS_Store
+
+# tests
+/test/tmp/*
+testrun
+test_suite_runner
+
+# patches, originals and rejects
+*.patch
+*.rej
+*.orig

CMakeLists.txt

@@ -1,5 +1,13 @@
 cmake_minimum_required(VERSION 3.20)
 
+set(C3_LLVM_MIN_VERSION 17)
+set(C3_LLVM_MAX_VERSION 22)
+set(C3_LLVM_DEFAULT_VERSION 21)
+
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
+    message(FATAL_ERROR "In-tree build detected, please build in a separate directory")
+endif()
+
 # Grab the version
 file(READ "src/version.h" ver)
 if (NOT ${ver} MATCHES "COMPILER_VERSION \"([0-9]+.[0-9]+.[0-9]+)\"")
@@ -7,8 +15,20 @@ if (NOT ${ver} MATCHES "COMPILER_VERSION \"([0-9]+.[0-9]+.[0-9]+)\"")
 endif()
 
 # Set the project and version
-project(c3c VERSION ${CMAKE_MATCH_1})
-message("C3C version: ${CMAKE_PROJECT_VERSION}")
+project(c3c VERSION ${CMAKE_MATCH_1} LANGUAGES C CXX)
+message("Configuring C3C ${CMAKE_PROJECT_VERSION} for ${CMAKE_SYSTEM_NAME}")
+
+# Helper functions
+function(c3_print_variables)
+    set(msg "")
+    foreach(var ${ARGN})
+        if(msg)
+            string(APPEND msg " ; ")
+        endif()
+        string(APPEND msg "${c3_print_prefix}${var}=\"${${var}}\"")
+    endforeach()
+    message(STATUS "${msg}")
+endfunction()
 
 # Avoid warning for FetchContent
 if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
@@ -16,7 +36,7 @@ if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.24.0")
 endif()
 
 if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
-    if (MSVC)
+    if (WIN32)
         set(CMAKE_INSTALL_LIBDIR "c:\\c3c\\lib")
         set(CMAKE_INSTALL_BINDIR "c:\\c3c")
     else ()
@@ -38,33 +58,63 @@ set(CMAKE_CXX_STANDARD 17)
 
 if(MSVC)
     message(STATUS "MSVC version ${MSVC_VERSION}")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /EHsc")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /O2 /EHsc")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /EHa")
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Od /Zi /EHa")
-else()
-    if (true)
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -fno-exceptions")
-        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-3 -fno-exceptions")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fno-exceptions")
-        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -fno-exceptions")
-    else()
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-3 -O1 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -O1 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined,address -fno-exceptions")
+    add_compile_options(/utf-8)
+
+    if(C3_WITH_LLVM)
+        FetchContent_GetProperties(LLVM_Windows)
+        if(NOT LLVM_Windows_URL MATCHES "msvcrt")
+            set(MSVC_CRT_SUFFIX "")
+            message(STATUS "Detected STATIC LLVM (libcmt)")
+        else()
+            set(MSVC_CRT_SUFFIX "DLL")
+            message(STATUS "Detected DYNAMIC LLVM (msvcrt)")
+        endif()
     endif()
+
+    # Force the Runtime to Release (/MT or /MD) even in Debug
+    # This is required to match our RelWithDebInfo LLVM builds
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+    set_property(GLOBAL PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+
+    add_compile_definitions(_ITERATOR_DEBUG_LEVEL=0)
+
+    # Suppresses the LNK4098 mismatch warning in Debug builds
+    set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /NODEFAULTLIB:libcmtd /NODEFAULTLIB:msvcrtd")
+else()
+    add_compile_options(-gdwarf-3 -fno-exceptions)
+
+    #add_compile_options(-fsanitize=address,undefined)
+    #add_link_options(-fsanitize=address,undefined)
 endif()
 
-option(C3_LINK_DYNAMIC "link dynamically with LLVM/LLD libs")
+# Options
+set(C3_LINK_DYNAMIC         OFF                         CACHE BOOL   "Link dynamically with LLVM/LLD libs")
+set(C3_WITH_LLVM            ON                          CACHE BOOL   "Build with LLVM")
+set(C3_LLVM_VERSION         "auto"                      CACHE STRING "Use LLVM version [default: auto]")
+set(C3_USE_MIMALLOC         OFF                         CACHE BOOL   "Use built-in mimalloc")
+set(C3_MIMALLOC_TAG         "v1.7.3"                    CACHE STRING "Used version of mimalloc")
+set(C3_USE_TB               OFF                         CACHE BOOL   "Use TB")
+set(C3_LLD_DIR              ""                          CACHE STRING "Use custom LLD directory")
+set(C3_LLD_INCLUDE_DIR      ""                          CACHE STRING "Use custom LLD include directory")
+set(C3_ENABLE_CLANGD_LSP    OFF                         CACHE BOOL   "Enable/Disable output of compile commands during generation")
+set(C3_FETCH_LLVM           OFF                         CACHE BOOL   "Automatically download LLVM artifacts")
+set(C3_LLVM_TAG             "llvm_21.x"                 CACHE STRING "Tag/Branch to download LLVM from")
+set(LLVM_CRT_LIBRARY_DIR    ""                          CACHE STRING "Use custom llvm's compiler-rt directory")
+set(TCC_LIB_PATH            "/usr/lib/tcc/libtcc1.a"    CACHE STRING "Use custom libtcc1.a path")
 
-set(C3_LLVM_VERSION "auto" CACHE STRING "Use LLVM version [default: auto]")
-option(C3_USE_MIMALLOC "Use built-in mimalloc" OFF)
-option(C3_USE_TB "Use TB" OFF)
-set(C3_MIMALLOC_TAG "v1.7.3" CACHE STRING "Used version of mimalloc")
-option(C3_WITH_LLVM "Build with LLVM" ON)
-option(C3_LLD_DIR "Use custom LLD directory" "")
+set(C3_OPTIONS
+        C3_LINK_DYNAMIC
+        C3_WITH_LLVM
+        C3_FETCH_LLVM
+        C3_LLVM_TAG
+        C3_LLVM_VERSION
+        C3_USE_MIMALLOC
+        C3_MIMALLOC_TAG
+        C3_USE_TB
+        C3_LLD_DIR
+        C3_ENABLE_CLANGD_LSP
+        LLVM_CRT_LIBRARY_DIR
+)
 
 set(C3_USE_MIMALLOC OFF)
 if(C3_USE_MIMALLOC)
@@ -73,22 +123,12 @@ if(C3_USE_MIMALLOC)
     option(MI_PADDING OFF)
     option(MI_DEBUG_FULL OFF)
     FetchContent_Declare(
-    mimalloc
-    GIT_REPOSITORY https://github.com/microsoft/mimalloc.git
-    GIT_TAG ${C3_MIMALLOC_TAG}
+            mimalloc
+            GIT_REPOSITORY https://github.com/microsoft/mimalloc.git
+            GIT_TAG ${C3_MIMALLOC_TAG}
     )
     FetchContent_MakeAvailable(mimalloc)
 endif()
-if (NOT WIN32)
-    find_package(CURL)
-endif()
-if(C3_WITH_LLVM)
-    if (NOT C3_LLVM_VERSION STREQUAL "auto")
-        if (${C3_LLVM_VERSION} VERSION_LESS 17 OR ${C3_LLVM_VERSION} VERSION_GREATER 20)
-            message(FATAL_ERROR "LLVM ${C3_LLVM_VERSION} is not supported!")
-        endif()
-    endif()
-endif()
 
 find_package(Git QUIET)
 if(C3_USE_TB AND GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
@@ -106,56 +146,112 @@ if(C3_USE_TB AND GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
 endif()
 
 # Clangd LSP support
-option(C3_ENABLE_CLANGD_LSP "Enable/Disable output of compile commands during generation." OFF)
 if(C3_ENABLE_CLANGD_LSP)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
     execute_process(
-        COMMAND ${CMAKE_COMMAND} -E create_symlink
+            COMMAND ${CMAKE_COMMAND} -E create_symlink
             ${CMAKE_BINARY_DIR}/compile_commands.json
             ${CMAKE_SOURCE_DIR}/compile_commands.json
     )
 endif(C3_ENABLE_CLANGD_LSP)
 
 if(C3_WITH_LLVM)
-    if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-        if (C3_LLVM_VERSION STREQUAL "auto")
-            set(C3_LLVM_VERSION "18")
+    if(C3_FETCH_LLVM)
+        # 1. Determine local platform ID
+        if (WIN32)
+            set(C3_LLVM_PLATFORM "windows-amd64")
+        elseif (APPLE)
+            if (CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64" OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "arm64")
+                set(C3_LLVM_PLATFORM "darwin-aarch64")
+            else()
+                set(C3_LLVM_PLATFORM "darwin-amd64")
+            endif()
+        else() # Linux
+            if (CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "aarch64")
+                set(C3_LLVM_PLATFORM "linux-aarch64")
+            elseif (CMAKE_SYSTEM_PROCESSOR STREQUAL "riscv64" OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "riscv64")
+                set(C3_LLVM_PLATFORM "linux-riscv64")
+            else()
+                set(C3_LLVM_PLATFORM "linux-amd64")
+            endif()
         endif()
-        FetchContent_Declare(
-                LLVM_Windows
-                URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt.7z
-        )
-        FetchContent_Declare(
-                LLVM_Windows_debug
-                URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt-dbg.7z
-        )
-        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-            message("Loading Windows LLVM debug libraries, this may take a while...")
-            FetchContent_MakeAvailable(LLVM_Windows_debug)
-            set(llvm_dir ${llvm_windows_debug_SOURCE_DIR})
-        else()
-            message("Loading Windows LLVM libraries, this may take a while...")
-            FetchContent_MakeAvailable(LLVM_Windows)
-            set(llvm_dir ${llvm_windows_SOURCE_DIR})
-        endif()
-        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_dir} ${CMAKE_SYSTEM_PREFIX_PATH})
 
-        find_package(LLVM REQUIRED CONFIG)
-        find_package(LLD REQUIRED CONFIG)
+        # 2. Determine if we want Debug or Release
+        set(C3_LLVM_SUFFIX "")
+        set(C3_LLVM_TYPE "Release")
+        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+            set(C3_LLVM_SUFFIX "-dbg")
+            set(C3_LLVM_TYPE "Debug")
+        endif()
+
+        # 3. Construct URL
+        set(C3_LLVM_ARTIFACT_NAME "llvm-${C3_LLVM_PLATFORM}${C3_LLVM_SUFFIX}")
+        #set(C3_LLVM_URL "https://github.com/c3lang/c3-llvm/releases/download/${C3_LLVM_TAG}/${C3_LLVM_ARTIFACT_NAME}.tar.gz")
+        #set(C3_LLVM_URL "https://github.com//ManuLinares/llvm-custom-builds/releases/download/${C3_LLVM_TAG}/${C3_LLVM_ARTIFACT_NAME}.tar.gz")
+
+        # We could also just set "latest" here to always fetch the latest release
+        set(C3_LLVM_URL "https://github.com/c3lang/llvm-for-c3/releases/latest/download/${C3_LLVM_ARTIFACT_NAME}.tar.gz")
+
+        message(STATUS "Fetching ${C3_LLVM_TYPE} LLVM artifact for ${C3_LLVM_PLATFORM}...")
+        message(STATUS "URL: ${C3_LLVM_URL}")
+
+        FetchContent_Declare(
+                LLVM_Artifact
+                URL ${C3_LLVM_URL}
+        )
+        FetchContent_MakeAvailable(LLVM_Artifact)
+
+        # 4. Point CMake to the fetched location
+        set(llvm_dir ${llvm_artifact_SOURCE_DIR})
+        set(CMAKE_PREFIX_PATH ${llvm_dir} ${CMAKE_PREFIX_PATH})
+        set(LLVM_DIR "${llvm_dir}/lib/cmake/llvm")
+        set(LLD_DIR "${llvm_dir}/lib/cmake/lld")
+
+        # TEST: For Windows, we might need to add the bin dir to prefix path for find_package to work well
+        if (WIN32)
+            set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_dir} ${CMAKE_SYSTEM_PREFIX_PATH})
+        endif()
+
+        find_package(LLVM REQUIRED CONFIG NO_DEFAULT_PATH)
+        find_package(LLD REQUIRED CONFIG NO_DEFAULT_PATH)
     else()
-        if (NOT C3_LLVM_VERSION STREQUAL "auto")
-            find_package(LLVM ${C3_LLVM_VERSION} REQUIRED CONFIG)
-        else()
+        if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
+            # Legacy MSVC path if someone explicitly disabled fetching but is on MSVC
             find_package(LLVM REQUIRED CONFIG)
+            find_package(LLD REQUIRED CONFIG)
+        else()
+            # Default system search
+            file (GLOB LLVM_CMAKE_PATHS "/usr/lib/llvm/*/lib/cmake/llvm/")
+            list (APPEND CMAKE_PREFIX_PATH ${LLVM_CMAKE_PATHS} "/usr/lib/")
+
+            if (NOT C3_LLVM_VERSION STREQUAL "auto")
+                find_package(LLVM ${C3_LLVM_VERSION} REQUIRED CONFIG)
+            else()
+                find_package(LLVM REQUIRED CONFIG)
+            endif()
         endif()
     endif()
 
+    if (NOT C3_FETCH_LLVM AND EXISTS /opt/homebrew/lib)
+        list(APPEND LLVM_LIBRARY_DIRS /opt/homebrew/lib)
+    endif()
+
+    if (EXISTS /usr/lib)
+        # Some systems (such as Alpine Linux) seem to put some of the relevant
+        # LLVM files in /usr/lib, but this doesn't seem to be included in the
+        # value of LLVM_LIBRARY_DIRS.
+        list(APPEND LLVM_LIBRARY_DIRS /usr/lib)
+    endif()
+
+    list(REMOVE_DUPLICATES LLVM_LIBRARY_DIRS)
+
     message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
     message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
-    message(STATUS "Libraries located in: ${LLVM_LIBRARY_DIRS}")
+    message(STATUS "LLVM libraries located in: ${LLVM_LIBRARY_DIRS}")
 
-    if (NOT LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL 15.0)
-        message(FATAL_ERROR "LLVM version 15.0 or later is required.")
+    if (${LLVM_PACKAGE_VERSION} VERSION_LESS C3_LLVM_MIN_VERSION OR
+        ${LLVM_PACKAGE_VERSION} VERSION_GREATER C3_LLVM_MAX_VERSION)
+        message(FATAL_ERROR "LLVM ${LLVM_PACKAGE_VERSION} is not supported! LLVM version between ${C3_LLVM_MIN_VERSION} and ${C3_LLVM_MAX_VERSION} is required.")
     endif()
 
     if(LLVM_ENABLE_RTTI)
@@ -173,102 +269,125 @@ if(C3_WITH_LLVM)
 
     if(NOT C3_LINK_DYNAMIC)
         set(LLVM_LINK_COMPONENTS
-            AllTargetsAsmParsers
-            AllTargetsCodeGens
-            AllTargetsDescs
-            AllTargetsDisassemblers
-            AllTargetsInfos
-            Analysis
-            AsmPrinter
-            BitReader
-            Core
-            DebugInfoPDB
-            InstCombine
-            IrReader
-            LibDriver
-            Linker
-            LTO
-            MC
-            MCDisassembler
-            native
-            nativecodegen
-            Object
-            Option
-            ScalarOpts
-            Support
-            Target
-            TransformUtils
-            WindowsManifest
-            WindowsDriver
+                AllTargetsAsmParsers
+                AllTargetsCodeGens
+                AllTargetsDescs
+                AllTargetsDisassemblers
+                AllTargetsInfos
+                Analysis
+                AsmPrinter
+                BitReader
+                Core
+                DebugInfoPDB
+                InstCombine
+                IrReader
+                LibDriver
+                Linker
+                LTO
+                MC
+                MCDisassembler
+                native
+                nativecodegen
+                Object
+                Option
+                ScalarOpts
+                Support
+                Target
+                TransformUtils
+                WindowsManifest
+                WindowsDriver
         )
 
         llvm_map_components_to_libnames(llvm_libs ${LLVM_LINK_COMPONENTS})
 
-        if(NOT ${C3_LLD_DIR} EQUAL "" AND EXISTS ${C3_LLD_DIR}) 
-            message("C3_LLD_DIR: " ${C3_LLD_DIR})
-            set(LLVM_LIBRARY_DIRS
-            "${LLVM_LIBRARY_DIRS}"
-            "${C3_LLD_DIR}"
-            )
+        if(NOT ${C3_LLD_DIR} EQUAL "" AND EXISTS ${C3_LLD_DIR})
+            list(APPEND LLVM_LIBRARY_DIRS ${C3_LLD_DIR})
             list(REMOVE_DUPLICATES LLVM_LIBRARY_DIRS)
         endif()
 
+        message(STATUS "Looking for static lld libraries in ${LLVM_LIBRARY_DIRS}")
+
         # These don't seem to be reliable on windows.
-        message(STATUS "using find_library")
-        find_library(LLD_COFF NAMES liblldCOFF.dylib lldCOFF.lib lldCOFF.a liblldCOFF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_COMMON NAMES liblldCommon.dylib lldCommon.lib lldCommon.a liblldCommon.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_ELF NAMES liblldELF.dylib lldELF.lib lldELF.a liblldELF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MACHO NAMES liblldMachO.dylib lldMachO.lib lldMachO.a liblldMachO.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MINGW NAMES liblldMinGW.dylib lldMinGW.lib lldMinGW.a liblldMinGW.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_WASM NAMES liblldWasm.dylib lldWasm.lib lldWasm.a liblldWasm.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_COFF NAMES lldCOFF.a liblldCOFF.a liblldCOFF.dylib lldCOFF.lib liblldCOFF.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_COMMON NAMES lldCommon.a liblldCommon.a liblldCommon.dylib lldCommon.lib liblldCommon.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_ELF NAMES lldELF.a liblldELF.a liblldELF.dylib lldELF.lib liblldELF.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
+            find_library(LLD_MACHO NAMES lldMachO.a liblldMachO.a liblldMachO.dylib lldMachO.lib liblldMachO.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        else()
+            set(LLD_MACHO "")
+        endif()
+        find_library(LLD_MINGW NAMES lldMinGW.a liblldMinGW.a liblldMinGW.dylib lldMinGW.lib liblldMinGW.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_WASM NAMES lldWasm.a liblldWasm.a liblldWasm.dylib lldWasm.lib liblldWasm.dll.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
     else()
-        find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        message(STATUS "Looking for shared lld libraries in ${LLVM_LIBRARY_DIRS}")
+
+        #find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        if(UNIX AND NOT WIN32)
+            find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} REQUIRED)
+        else()
+            find_library(LLVM NAMES libLLVM.a LLVM.lib PATHS ${LLVM_LIBRARY_DIRS} REQUIRED)
+        endif()
         set(llvm_libs ${LLVM})
 
         # These don't seem to be reliable on windows.
-        message(STATUS "using find_library")
-        find_library(LLD_COFF NAMES liblldCOFF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_COMMON NAMES liblldCommon.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_ELF NAMES liblldELF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MACHO NAMES liblldMachO.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_MINGW NAMES liblldMinGW.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-        find_library(LLD_WASM NAMES liblldWasm.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_COFF NAMES liblldCOFF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_COMMON NAMES liblldCommon.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_ELF NAMES liblldELF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
+            find_library(LLD_MACHO NAMES liblldMachO.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        else()
+            set(LLD_MACHO "")
+        endif()
+        find_library(LLD_MINGW NAMES liblldMinGW.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
+        find_library(LLD_WASM NAMES liblldWasm.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH REQUIRED)
     endif()
-endif()
 
-if (NOT(${CMAKE_BINARY_DIR} EQUAL ${CMAKE_SOURCE_DIR}))
-    file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/lib)
-    file(COPY ${CMAKE_SOURCE_DIR}/lib DESTINATION ${CMAKE_BINARY_DIR})
-endif()
-
-if(C3_WITH_LLVM)
-    find_library(LLD_LOONG NAMES libLLVMLoongArchCodeGen.lib libLLVMLoongArchAsmParser.lib libLLVMLoongArchCodeGen.a libLLVMLoongArchAsmParser.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+    # find_library(LLD_LOONG NAMES libLLVMLoongArchCodeGen.lib libLLVMLoongArchAsmParser.lib libLLVMLoongArchCodeGen.a libLLVMLoongArchAsmParser.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
     set(lld_libs
-        ${LLD_COFF}
-        ${LLD_COMMON}
-        ${LLD_WASM}
-        ${LLD_MINGW}
-        ${LLD_ELF}
-        ${LLD_MACHO}
-        )
+            ${LLD_COFF}
+            ${LLD_WASM}
+            ${LLD_MINGW}
+            ${LLD_ELF}
+            ${LLD_MACHO}
+            ${LLD_COMMON}
+    )
 
     if (APPLE)
         set(lld_libs ${lld_libs} xar)
-        find_file(RT_ASAN_DYNAMIC NAMES libclang_rt.asan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIR}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
-        find_file(RT_TSAN_DYNAMIC NAMES libclang_rt.tsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIR}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
-        find_file(RT_UBSAN_DYNAMIC NAMES libclang_rt.ubsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIR}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
-        find_file(RT_LSAN_DYNAMIC NAMES libclang_rt.lsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIR}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
-        set(sanitizer_runtime_libraries
-                ${RT_ASAN_DYNAMIC}
-                ${RT_TSAN_DYNAMIC}
-                # Unused
-                # ${RT_UBSAN_DYNAMIC}
-                # ${RT_LSAN_DYNAMIC}
+        if (llvm_dir)
+            file(GLOB_RECURSE RT_ASAN_DYNAMIC "${llvm_dir}/*libclang_rt.asan_osx_dynamic.dylib")
+            file(GLOB_RECURSE RT_TSAN_DYNAMIC "${llvm_dir}/*libclang_rt.tsan_osx_dynamic.dylib")
+        endif()
+
+        if (NOT RT_ASAN_DYNAMIC OR NOT RT_TSAN_DYNAMIC)
+            # Fallback to searching in LLVM_LIBRARY_DIRS (for non-fetched LLVM)
+            find_file(RT_ASAN_DYNAMIC_PATH NAMES libclang_rt.asan_osx_dynamic.dylib PATHS ${LLVM_LIBRARY_DIRS} PATH_SUFFIXES "clang/${LLVM_MAJOR_VERSION}/lib/darwin" "clang/${LLVM_PACKAGE_VERSION}/lib/darwin")
+            find_file(RT_TSAN_DYNAMIC_PATH NAMES libclang_rt.tsan_osx_dynamic.dylib PATHS ${LLVM_LIBRARY_DIRS} PATH_SUFFIXES "clang/${LLVM_MAJOR_VERSION}/lib/darwin" "clang/${LLVM_PACKAGE_VERSION}/lib/darwin")
+            if (RT_ASAN_DYNAMIC_PATH)
+                set(RT_ASAN_DYNAMIC ${RT_ASAN_DYNAMIC_PATH})
+            endif()
+            if (RT_TSAN_DYNAMIC_PATH)
+                set(RT_TSAN_DYNAMIC ${RT_TSAN_DYNAMIC_PATH})
+            endif()
+        endif()
+
+        if (RT_ASAN_DYNAMIC)
+            list(GET RT_ASAN_DYNAMIC 0 RT_ASAN_DYNAMIC)
+        endif()
+        if (RT_TSAN_DYNAMIC)
+            list(GET RT_TSAN_DYNAMIC 0 RT_TSAN_DYNAMIC)
+        endif()
+
+        if (RT_ASAN_DYNAMIC AND RT_TSAN_DYNAMIC)
+            set(sanitizer_runtime_libraries
+                    ${RT_ASAN_DYNAMIC}
+                    ${RT_TSAN_DYNAMIC}
             )
+        endif()
     endif()
 
-    message(STATUS "linking to llvm libs ${lld_libs}")
-    message(STATUS "Found lld libs ${lld_libs}")
+    message(STATUS "Linking to llvm libs ${llvm_libs}")
+    message(STATUS "Linking to lld libs ${lld_libs}")
 endif()
 
 add_library(miniz STATIC dependencies/miniz/miniz.c)
@@ -342,11 +461,15 @@ add_executable(c3c
         src/utils/whereami.c
         src/utils/cpus.c
         src/utils/unzipper.c
+        src/utils/msi.c
+        src/compiler/c_codegen.c
         src/compiler/decltable.c
-        src/compiler/mac_support.c 
+        src/compiler/methodtable.c
+        src/compiler/mac_support.c
+        src/utils/fetch_msvc.c
         src/compiler/windows_support.c
         src/compiler/codegen_asm.c
-        src/compiler/asm_target.c 
+        src/compiler/asm_target.c
         src/compiler/expr.c
         src/utils/time.c
         src/utils/http.c
@@ -354,7 +477,7 @@ add_executable(c3c
         src/build/common_build.c
         src/compiler/sema_const.c
         ${CMAKE_BINARY_DIR}/git_hash.h
-        )
+)
 
 if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
     # We are inside of a git repository so rebuilding the hash every time something changes.
@@ -370,24 +493,38 @@ else()
 endif()
 
 if(C3_WITH_LLVM)
-    target_sources(c3c PRIVATE 
-        src/compiler/llvm_codegen.c
-        src/compiler/llvm_codegen_debug_info.c
-        src/compiler/llvm_codegen_expr.c
-        src/compiler/llvm_codegen_function.c
-        src/compiler/llvm_codegen_instr.c
-        src/compiler/llvm_codegen_module.c
-        src/compiler/llvm_codegen_stmt.c
-        src/compiler/llvm_codegen_type.c
-        src/compiler/llvm_codegen_value.c
-        src/compiler/llvm_codegen_storeload.c
-        src/compiler/llvm_codegen_builtins.c)
+    target_sources(c3c PRIVATE
+            src/compiler/llvm_codegen.c
+            src/compiler/llvm_codegen_debug_info.c
+            src/compiler/llvm_codegen_expr.c
+            src/compiler/llvm_codegen_function.c
+            src/compiler/llvm_codegen_instr.c
+            src/compiler/llvm_codegen_module.c
+            src/compiler/llvm_codegen_stmt.c
+            src/compiler/llvm_codegen_type.c
+            src/compiler/llvm_codegen_value.c
+            src/compiler/llvm_codegen_storeload.c
+            src/compiler/llvm_codegen_builtins.c)
 
     target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=1)
     add_library(c3c_wrappers STATIC wrapper/src/wrapper.cpp)
+    if (MSVC)
+        # Use the same detected CRT for the wrapper
+        set_target_properties(c3c_wrappers PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+        set_target_properties(miniz PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded${MSVC_CRT_SUFFIX}")
+
+        target_compile_options(c3c PRIVATE
+                "$<$<CONFIG:Debug>:/EHa>"
+                "$<$<CONFIG:Release>:/EHsc>")
+    endif()
+
+    if(C3_LLD_INCLUDE_DIR)
+        target_include_directories(c3c_wrappers PRIVATE ${C3_LLD_INCLUDE_DIR})
+    endif()
 else()
     target_sources(c3c PRIVATE src/utils/hostinfo.c)
     target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=0)
+    target_link_libraries(c3c m)
 endif()
 
 target_include_directories(c3c PRIVATE
@@ -409,7 +546,7 @@ if (C3_USE_TB)
             tilde-backend/src/tb/x64/*.c
             tilde-backend/src/tb/wasm/*.c
             tilde-backend/src/tb/aarch64/*.c
-            )
+    )
     target_sources(c3c PRIVATE
             src/compiler/tilde_codegen.c
             src/compiler/tilde_codegen_instr.c
@@ -437,7 +574,7 @@ else()
 endif()
 
 if(C3_WITH_LLVM)
-    target_link_libraries(c3c ${llvm_libs} miniz c3c_wrappers ${lld_libs})
+    target_link_libraries(c3c miniz c3c_wrappers)
 
     target_include_directories(c3c PRIVATE
             "${CMAKE_SOURCE_DIR}/wrapper/include/")
@@ -445,11 +582,11 @@ if(C3_WITH_LLVM)
     target_include_directories(c3c_wrappers PRIVATE
             "${CMAKE_SOURCE_DIR}/wrapper/include/")
 
-    target_link_libraries(c3c_wrappers ${llvm_libs} ${lld_libs})
+    target_link_libraries(c3c_wrappers PUBLIC ${lld_libs} ${llvm_libs})
 
-else() 
+else()
 
-    target_link_libraries(c3c ${llvm_libs} miniz ${lld_libs})
+    target_link_libraries(c3c miniz ${lld_libs} ${llvm_libs})
 
 endif()
 
@@ -466,60 +603,79 @@ if(MINGW)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,8388608")
 endif ()
 
-if (CURL_FOUND)
-    target_link_libraries(c3c ${CURL_LIBRARIES})
-    target_include_directories(c3c PRIVATE ${CURL_INCLUDES})
-    target_compile_definitions(c3c PUBLIC CURL_FOUND=1)
-else()
-    target_compile_definitions(c3c PUBLIC CURL_FOUND=0)
+if (NOT WIN32)
+    # For dlopen support
+    if (CMAKE_DL_LIBS)
+        target_link_libraries(c3c ${CMAKE_DL_LIBS})
+    endif()
 endif()
 
 
 if(MSVC)
-    message("Adding MSVC options")
-    target_compile_options(c3c PRIVATE /wd4068 /wd4090 /WX /Wv:18)
+    target_compile_options(c3c PRIVATE
+        /wd4068
+        /wd4090
+        /WX
+        /Wv:18
+    )
+
     if(C3_WITH_LLVM)
-        target_compile_options(c3c_wrappers PUBLIC /wd4624 /wd4267 /wd4244 /WX /Wv:18)
+        target_compile_options(c3c_wrappers PUBLIC
+            /wd4624
+            /wd4267
+            /wd4244
+            /WX
+            /Wv:18
+        )
         if(NOT LLVM_ENABLE_RTTI)
             target_compile_options(c3c_wrappers PUBLIC /GR-)
         endif()
         target_link_options(c3c_wrappers PUBLIC /ignore:4099)
     endif()
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        target_compile_options(c3c PUBLIC /MTd)
-        if (C3_WITH_LLVM)
-            target_compile_options(c3c_wrappers PUBLIC /MTd)
-        endif()
-        target_compile_options(miniz PUBLIC /MTd)
-        if (C3_USE_TB)
-            target_compile_options(tilde-backend PUBLIC /MTd)
-        endif()
-    else()
-        target_compile_options(c3c PUBLIC /MT)
-        if (C3_WITH_LLVM)
-            target_compile_options(c3c_wrappers PUBLIC /MT)
-        endif()
-        target_compile_options(miniz PUBLIC /MT)
-        if (C3_USE_TB)
-            target_compile_options(tilde-backend PUBLIC /MT)
-        endif()
-    endif()
+
     if(C3_WITH_LLVM)
-        set(clang_lib_dir ${llvm_dir}/lib/clang/${C3_LLVM_VERSION}/lib/windows)
-        set(sanitizer_runtime_libraries
-            ${clang_lib_dir}/clang_rt.asan-x86_64.lib
-            ${clang_lib_dir}/clang_rt.asan_dynamic-x86_64.lib
-            ${clang_lib_dir}/clang_rt.asan_dynamic-x86_64.dll
-            ${clang_lib_dir}/clang_rt.asan_dynamic_runtime_thunk-x86_64.lib)
+        # The the sanitizer libs are in the folder "lib/clang/21/lib/windows/" but use the find anyway
+        file(GLOB_RECURSE FOUND_ASAN_LIB "${llvm_dir}/*clang_rt.asan_dynamic-x86_64.lib")
+        if(FOUND_ASAN_LIB)
+            list(GET FOUND_ASAN_LIB 0 _asan_path)
+            get_filename_component(_asan_dir "${_asan_path}" DIRECTORY)
+            set(sanitizer_runtime_libraries
+                    ${_asan_dir}/clang_rt.asan_dynamic-x86_64.lib
+                    ${_asan_dir}/clang_rt.asan_dynamic-x86_64.dll
+                    ${_asan_dir}/clang_rt.asan_dynamic_runtime_thunk-x86_64.lib)
+            message(STATUS "Found Sanitizer binaries at: ${_asan_dir}")
+        else()
+            message(WARNING "Could not find sanitizer runtime libraries in ${llvm_dir}")
+        endif()
     endif()
+
 else()
-    message(STATUS "using gcc/clang warning switches")
-    target_link_options(c3c PRIVATE -pthread)
     if (C3_WITH_LLVM AND NOT LLVM_ENABLE_RTTI)
         target_compile_options(c3c_wrappers PRIVATE -fno-rtti)
     endif()
-    target_compile_options(c3c PRIVATE -pthread -Wall -Werror -Wno-unknown-pragmas -Wno-unused-result
-            -Wno-unused-function -Wno-unused-variable -Wno-unused-parameter)
+    target_compile_options(c3c PRIVATE
+        -pthread
+        -Wall
+        -Werror
+        -Wno-unknown-pragmas
+        -Wno-unused-result
+        -Wno-unused-function
+        -Wno-unused-variable
+        -Wno-unused-parameter
+        -Wno-char-subscripts
+    )
+    target_link_options(c3c PRIVATE -pthread)
+endif()
+
+if(CMAKE_C_COMPILER_ID STREQUAL "TinyCC")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,--no-eh-frame-hdr -z noexecstack")
+
+    # Link the static tcc runtime archive if it exists
+    if(EXISTS "${TCC_LIB_PATH}")
+        target_link_libraries(c3c "${TCC_LIB_PATH}")
+    else()
+        message(FATAL_ERROR "TCC runtime not found at ${TCC_LIB_PATH}; Ensure the path is correct.")
+    endif()
 endif()
 
 install(TARGETS c3c DESTINATION bin)
@@ -530,22 +686,62 @@ if (NOT WIN32)
     install(FILES c3c.1 DESTINATION "share/man/man1")
 endif()
 
+# Copy stdlib
+if (NOT ${CMAKE_BINARY_DIR} EQUAL ${CMAKE_SOURCE_DIR})
+    file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/lib)
+    file(COPY ${CMAKE_SOURCE_DIR}/lib DESTINATION ${CMAKE_BINARY_DIR})
+endif()
+
 if (C3_WITH_LLVM AND DEFINED sanitizer_runtime_libraries)
     add_custom_command(TARGET c3c POST_BUILD
-        COMMAND "${CMAKE_COMMAND}" -E rm -rf -- $<TARGET_FILE_DIR:c3c>/c3c_rt
-        COMMAND "${CMAKE_COMMAND}" -E make_directory $<TARGET_FILE_DIR:c3c>/c3c_rt
-        COMMAND "${CMAKE_COMMAND}" -E copy ${sanitizer_runtime_libraries} $<TARGET_FILE_DIR:c3c>/c3c_rt
-        VERBATIM
-        COMMENT "Copying sanitizer runtime libraries to output directory")
+            COMMAND "${CMAKE_COMMAND}" -E rm -rf -- $<TARGET_FILE_DIR:c3c>/c3c_rt
+            COMMAND "${CMAKE_COMMAND}" -E make_directory $<TARGET_FILE_DIR:c3c>/c3c_rt
+            COMMAND "${CMAKE_COMMAND}" -E copy ${sanitizer_runtime_libraries} $<TARGET_FILE_DIR:c3c>/c3c_rt
+            VERBATIM
+            COMMENT "Copying sanitizer runtime libraries to output directory")
 
     if (APPLE)
         # Change LC_ID_DYLIB to be rpath-based instead of having an absolute path
+        # We set DYLD_LIBRARY_PATH so the tools (which might be dynamic) can find libLLVM.dylib in the artifact
+        string(REPLACE ";" ":" _dyld_path "${LLVM_LIBRARY_DIRS}")
         add_custom_command(TARGET c3c POST_BUILD
-            COMMAND find $<TARGET_FILE_DIR:c3c>/c3c_rt -type f -name "*.dylib" -execdir ${LLVM_TOOLS_BINARY_DIR}/llvm-install-name-tool -id @rpath/{} {} $<SEMICOLON>
-            VERBATIM)
+                COMMAND ${CMAKE_COMMAND} -E env "DYLD_LIBRARY_PATH=${_dyld_path}:$ENV{DYLD_LIBRARY_PATH}" find $<TARGET_FILE_DIR:c3c>/c3c_rt -type f -name "*.dylib" -execdir ${LLVM_TOOLS_BINARY_DIR}/llvm-install-name-tool -id @rpath/{} {} $<SEMICOLON>
+                VERBATIM)
     endif()
 
     install(DIRECTORY $<TARGET_FILE_DIR:c3c>/c3c_rt/ DESTINATION bin/c3c_rt)
 endif()
 
 feature_summary(WHAT ALL)
+
+message(STATUS "Building ${CMAKE_PROJECT_NAME} with the following configuration:")
+
+set(c3_print_prefix "  ")
+
+foreach(option IN LISTS C3_OPTIONS)
+    if (DEFINED ${option})
+        c3_print_variables(${option})
+    endif()
+endforeach()
+
+foreach(flag_var
+        CMAKE_BUILD_TYPE
+        CMAKE_C_COMPILER
+        CMAKE_CXX_COMPILER
+        CMAKE_LINKER
+        CMAKE_OBJCOPY
+        CMAKE_STRIP
+        CMAKE_DLLTOOL)
+    c3_print_variables(${flag_var})
+endforeach()
+
+message(STATUS "Build flags:")
+foreach(flag_var
+        CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+        CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+    c3_print_variables(${flag_var})
+endforeach()
+
+message(STATUS "Output to: \"${CMAKE_BINARY_DIR}\"")

CMakePresets.json

@@ -0,0 +1,57 @@
+{
+    "version": 3,
+    "configurePresets": [
+        {
+            "name": "windows-base",
+            "hidden": true,
+            "architecture": {
+                "value": "x64"
+            },
+            "toolset": {
+                "value": "host=x64"
+            }
+        },
+        {
+            "name": "windows-vs-2022-release",
+            "generator": "Visual Studio 17 2022",
+            "displayName": "Windows x64 Visual Studio 17 2022",
+            "inherits": "windows-base",
+            "binaryDir": "build",
+            "cacheVariables": {
+                "CMAKE_CONFIGURATION_TYPES": "Release;RelWithDebInfo",
+                "CMAKE_BUILD_TYPE": "Release"
+            }
+        },
+        {
+            "name": "windows-vs-2022-debug",
+            "generator": "Visual Studio 17 2022",
+            "displayName": "Windows x64 Visual Studio 17 2022 (Debug)",
+            "inherits": "windows-base",
+            "binaryDir": "build-debug",
+            "cacheVariables": {
+                "CMAKE_CONFIGURATION_TYPES": "Debug",
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        }
+    ],
+    "buildPresets": [
+        {
+            "name": "windows-vs-2022-debug",
+            "displayName": "Debug",
+            "configurePreset": "windows-vs-2022-debug",
+            "configuration": "Debug"
+        },
+        {
+            "name": "windows-vs-2022-release",
+            "displayName": "Release",
+            "configurePreset": "windows-vs-2022-release",
+            "configuration": "Release"
+        },
+        {
+            "name": "windows-vs-2022-release-with-debug-info",
+            "displayName": "RelWithDebInfo",
+            "configurePreset": "windows-vs-2022-release",
+            "configuration": "RelWithDebInfo"
+        }
+    ]
+}

CODESTYLE.md

@@ -74,7 +74,7 @@ No space inside parenthesis:
 
 ### Tab vs spaces
 
-Recommendation: tabs, 4 spaces wide. No CRLF in the source.
+Use tabs for indentation, no CRLF in the source.
 
 ### If, braces and new lines
 
@@ -147,4 +147,114 @@ Iterating over the elements are done using `VECEACH`.
 ### Scratch buffer for strings.
 
 There is a scratch buffer for strings in the `global_context` prefer using that
-one with related functions when working on temporary strings.
+one with related functions when working on temporary strings.
+
+# C3 Standard library style guide.
+
+When contributing to the standard library please try your best to adhere to the
+following style requirements to ensure a consistent style in the stdlib and to
+facilitate accepting PRs more quickly.
+
+### Braces are placed on the next line
+
+**NO:**
+```c
+fn void foo(String bar) {
+  @pool() {
+    ...
+  };
+} 
+```
+
+**YES:**
+```c
+fn void foo(String bar)
+{
+  @pool() 
+  {
+    ...
+  };
+}
+```
+
+### Indentation with tabs
+
+Use tab for indentation, not spaces, no CRLF in the sources 
+
+### Type names
+
+Use `PascalCase` not `Ada_Case` for type names.
+
+**YES:**
+```c
+enum MyEnum
+{
+  ABC,
+  DEF
+}  
+```
+
+**NO:**
+```c
+enum My_Enum
+{
+  ABC,
+  DEF
+}  
+```
+
+### Type names when binding to OS libraries
+
+When doing bindings (for instance, adding declarations referring to Win32 APIs),
+try to retain the original name when possible. If it isn't possible use (consistently)
+one of two options:
+
+1. Prefix: `HANDLE` -> `Win32_HANDLE`
+2. Change the first letter to upper case: `mode_t` -> `Mode_t`
+
+### Variables, function, methods and globals
+
+Use `snake_case`, not `camelCase`.
+
+**YES:**
+```c
+int some_global = 1;
+
+fn void open_file(String special_file)
+{
+  ...
+}
+```
+
+**NO:**
+```c
+int someGlobal = 1;
+
+fn void openFile(String specialFile)
+{
+  ...
+}
+```
+
+### Variables, function, methods and globals when binding to OS libraries
+
+When doing bindings (for instance, adding declarations referring to Win32 APIs),
+try to retain the original name when possible. If it isn't possible use (consistently)
+one of two options:
+
+1. Prefix: `win32_GetWindowLongPtrW`. However, this is usually only recommended if it is builtin.
+2. Change first character to lower case: `GetWindowLongPtrW` -> `getWindowLongPtrW`
+
+### Use `self` as the first method argument
+
+Unless there is a strong reason not to, use `self` for the first parameter in a method.
+
+### The allocator argument
+
+Prefer always calling the allocator parameter `allocator`, and make it the first regular
+argument.
+
+## Add tests to your changes
+
+If you add or fix things, then there should always be tests in `test/unit/stdlib` to verify
+the functionality.

CODE_OF_CONDUCT.md

@@ -59,7 +59,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at . All
+reported by contacting the project team at info@c3-lang.org. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.

CONTRIBUTING.md

@@ -0,0 +1,70 @@
+# How to contribute to C3
+
+The C3 project consists of
+
+1. The C3 language itself.
+2. The C3 compiler, called c3c.
+3. The C3 standard library
+4. Various tools, such as the editor plugins
+
+## 1. How to contribute to the C3 language
+
+The C3 language is essentially the language specification. You can contribute to the language by:
+
+1. Filing enhancement requests for changes to the language.
+2. Offering feedback on existing features, on Discord or by filing issues.
+3. Help working on the language specification.
+4. Help working on the grammar.
+
+## 2. How to contribute to the C3 compiler
+
+The C3 compiler consists for the compiler itself + test suites for testing the compiler. 
+You can contribute by:
+
+1. File bugs (by far the most important thing).
+2. Suggest improved diagnostics / error messages.
+3. Refactoring existing code (needs deep understanding of the compiler).
+4. Add support for more architectures.
+5. Add support for more backends.
+
+## 3. How to contribute to the standard library
+
+The standard library is the library itself + test suites for testing the standard library.
+You can contribute by:
+
+1. Filing bugs on the standard library.
+2. Write additional unit tests.
+3. Suggest new functionality by filing an issue.
+4. Work on stdlib additions.
+5. Fix bugs in the stdlib
+6. Maintain a section of the standard library
+
+### How to work on small stdlib additions
+
+If there is just a matter of adding a function or two to an existing module, a pull request
+is sufficient. However, please make sure that:
+
+1. It follows the guidelines for the code to ensure a uniform experience (naming standard, indentation, braces etc).
+2. Add a line in the release notes about the change.
+3. Make sure it has unit tests.
+
+### How to work on non-trivial additions to the stdlib
+
+Regardless whether an addition is approved for inclusion or not, it needs to incubate:
+
+1. First implement it standalone, showing that it’s working well and has a solid design. This has the advantage of people being able to contribute or even create competing implementations
+2. Once it is considered finished it can be proposed for inclusion.
+
+This will greatly help improving the quality of additions.
+
+Note that any new addition needs a full set of unit tests before being included into the standard library.
+
+### Maintain a part of the standard library
+
+A single maintainer is insufficient for a standard library, instead we need one or more maintainer
+for each module. The maintainer(s) will review pull requests and actively work on making the module
+pristine with the highest possible quality.
+
+## 4. How to contribute to various tools
+
+In general, file a pull request. Depending on who maintains it, rules may differ.

LICENSE

@@ -1,165 +1,20 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+Copyright (c) 2022-2025 Christoffer Lernö and contributors
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE_SRC

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

LICENSE_STDLIB

@@ -1,20 +0,0 @@
-Copyright (c) 2022 Christoffer Lernö and contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -8,16 +8,19 @@ for programmers who like C.
 
 Precompiled binaries for the following operating systems are available:
  
-- Windows x64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-windows.zip), [install instructions](#installing-on-windows-with-precompiled-binaries).
-- Debian x64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-linux.tar.gz), [install instructions](#installing-on-debian-with-precompiled-binaries).
-- Ubuntu x86 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz), [install instructions](#installing-on-ubuntu-with-precompiled-binaries).
-- MacOS Arm64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip), [install instructions](#installing-on-mac-with-precompiled-binaries).
+- Windows x64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows.zip), [install instructions](#installing-on-windows-with-precompiled-binaries).
+- Debian x64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux.tar.gz), [install instructions](#installing-on-debian-with-precompiled-binaries).
+- Ubuntu x86 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20.tar.gz), [install instructions](#installing-on-ubuntu-with-precompiled-binaries).
+- MacOS Arm64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos.zip), [install instructions](#installing-on-macos-with-precompiled-binaries).
+- OpenBSD x64 [download](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd.tar.gz), [install instructions](#installing-on-openbsd-with-precompiled-binaries).
 
 The manual for C3 can be found at [www.c3-lang.org](http://www.c3-lang.org).
 
 ![vkQuake](https://github.com/c3lang/c3c/blob/master/resources/images/vkQuake.png?raw=true)
 
-Thanks to full ABI compatibility with C, it's possible to mix C and C3 in the same project with no effort. As a demonstration, vkQuake was compiled with a small portion of the code converted to C3 and compiled with the c3c compiler. (The fork can be found at https://github.com/c3lang/vkQuake)
+Thanks to full ABI compatibility with C, it's possible to mix C and C3 in the same project with no effort. As a demonstration, vkQuake was compiled with a small portion of the code converted to C3 and compiled with the c3c compiler. (The aging fork can be found at https://github.com/c3lang/vkQuake)
+
+A non-curated list of user written projects and other resources can be found [here](https://github.com/c3lang/c3-showcase).
 
 ### Design Principles
 - Procedural "get things done"-type of language.
@@ -33,10 +36,10 @@ whole new language.
 
 ### Example code
 
-The following code shows [generic modules](https://c3-lang.org/references/docs/generics/) (more examples can be found at https://c3-lang.org/references/docs/examples/). 
+The following code shows [generics](https://c3-lang.org/generic-programming/generics/) (more examples can be found at https://c3-lang.org/language-overview/examples/). 
 
-```cpp
-module stack (<Type>);
+```c3
+module stack <Type>;
 // Above: the parameterized type is applied to the entire module.
 
 struct Stack
@@ -55,7 +58,7 @@ fn void Stack.push(Stack* this, Type element)
     if (this.capacity == this.size)
     {
         this.capacity *= 2;
-		if (this.capacity < 16) this.capacity = 16;
+        if (this.capacity < 16) this.capacity = 16;
         this.elems = realloc(this.elems, Type.sizeof * this.capacity);
     }
     this.elems[this.size++] = element;
@@ -75,18 +78,18 @@ fn bool Stack.empty(Stack* this)
 
 Testing it out:
 
-```cpp
+```c3
 import stack;
 
 // Define our new types, the first will implicitly create 
 // a complete copy of the entire Stack module with "Type" set to "int"
-def IntStack = Stack(<int>);
+alias IntStack = Stack {int};
 // The second creates another copy with "Type" set to "double"
-def DoubleStack = Stack(<double>);
+alias DoubleStack = Stack {double};
 
-// If we had added "define IntStack2 = Stack(<int>)"
+// If we had added "alias IntStack2 = Stack {int}"
 // no additional copy would have been made (since we already
-// have an parameterization of Stack(<int>)) so it would
+// have an parameterization of Stack {int} so it would
 // be same as declaring IntStack2 an alias of IntStack
 
 // Importing an external C function is straightforward
@@ -124,6 +127,7 @@ fn void main()
 - New semantic macro system
 - Module based name spacing
 - Slices
+- Operator overloading
 - Compile time reflection
 - Enhanced compile time execution
 - Generics based on generic modules
@@ -138,15 +142,16 @@ fn void main()
 
 ### Current status
 
-The current stable version of the compiler is **version 0.6.3**.
+The current stable version of the compiler is **version 0.7.10**.
 
-The upcoming 0.6.x releases will focus on expanding the standard library.
+The upcoming 0.7.x releases will focus on expanding the standard library,
+fixing bugs and improving compile time analysis. 
 Follow the issues [here](https://github.com/c3lang/c3c/issues).
 
 If you have suggestions on how to improve the language, either [file an issue](https://github.com/c3lang/c3c/issues) 
 or discuss C3 on its dedicated Discord: [https://discord.gg/qN76R87](https://discord.gg/qN76R87).
 
-The compiler is currently verified to compile on Linux, Windows and MacOS.
+The compiler is currently verified to compile on Linux, OpenBSD, Windows and MacOS.
 
 **Support matrix**
 
@@ -157,6 +162,8 @@ The compiler is currently verified to compile on Linux, Windows and MacOS.
 | MacOS x64                | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
 | MacOS Aarch64            | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
 | iOS Aarch64              | No                            | Untested                | Untested    | Yes      | Yes      | Yes*       |
+| Android Aarch64          | No                            | Untested                | Untested    | Untested | Untested | Yes*       |
+| Android x64              | No                            | Untested                | Untested    | Untested | Untested | Yes*       |
 | Linux x86                | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
 | Linux x64                | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
 | Linux Aarch64            | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
@@ -167,17 +174,21 @@ The compiler is currently verified to compile on Linux, Windows and MacOS.
 | ELF freestanding Aarch64 | No                            | Untested                | No          | No       | No       | Yes*       |
 | ELF freestanding Riscv64 | No                            | Untested                | No          | No       | No       | Untested   |
 | ELF freestanding Riscv32 | No                            | Untested                | No          | No       | No       | Untested   |
+| ELF freestanding Xtensa* | No                            | Untested                | No          | No       | No       | Untested   |
 | FreeBSD x86              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
 | FreeBSD x64              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
 | NetBSD x86               | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
 | NetBSD x64               | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
 | OpenBSD x86              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
-| OpenBSD x64              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
+| OpenBSD x64              | Yes*                          | Yes                     | Yes*        | Yes      | Untested | Yes*       |
 | MCU x86                  | No                            | Untested                | No          | No       | No       | Yes*       |
 | Wasm32                   | No                            | Yes                     | No          | No       | No       | No         |
 | Wasm64                   | No                            | Untested                | No          | No       | No       | No         |
 
-*\* Inline asm is still a work in progress*
+*\* Inline asm is still a work in progress*<br>
+*\* OpenBSD 7.7 is the only tested version*<br>
+*\* OpenBSD has limited stacktrace, needs to be tested further*<br>
+*\* Xtensa support is enabled by compiling with `-DXTENSA_ENABLE`. The [espressif llvm fork](https://github.com/espressif/llvm-project) is recommended for best compatibility*
 
 More platforms will be supported in the future.
 
@@ -186,41 +197,82 @@ More platforms will be supported in the future.
 - If you wish to contribute with ideas, please file issues or discuss on Discord.
 - Interested in contributing to the stdlib? Please get in touch on Discord.
 - Compilation instructions for other Linux and Unix variants are appreciated.
-- Would you like to contribute bindings to some library? It would be nice to have support for SDL, Raylib and more.
+- Would you like to contribute bindings to some library? It would be nice to have support for SDL3 and more. If you have created some bindings, please submit them to https://github.com/c3lang/vendor.  
 - Build something with C3 and show it off and give feedback. The language is still open for significant tweaks.
 - Start work on the C -> C3 converter which takes C code and does a "best effort" to translate it to C3. The first version only needs to work on C headers.
 - Do you have some specific area you have deep knowledge of and could help make C3 even better at doing? File or comment on issues.
 
 ### Installing
 
+This installs the latest prerelease build, as opposed to the latest released version.
+
 #### Installing on Windows with precompiled binaries
-1. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest/c3-windows.zip](https://github.com/c3lang/c3c/releases/download/latest/c3-windows.zip) 
-(debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-windows-debug.zip))
+1. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows.zip](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows.zip)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-windows-debug.zip))
 2. Unzip exe and standard lib.
 3. If you don't have Visual Studio 17 installed you can either do so, or run the `msvc_build_libraries.py` Python script which will download the necessary files to compile on Windows. 
 4. Run `c3c.exe`.
 
+#### Installing on Windows with the install script
+
+Open a PowerShell terminal (you may need to run it as an administrator) and run the following command:
+```bash
+iwr -useb https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.ps1 | iex
+```
+The script will inform you once the installation is successful and add the `~/.c3` directory to your PATH, which will allow you to run the c3c command from any location.
+
+You can choose another version with option `C3_VERSION`.
+For example, you can force the installation of the 0.7.4 version:
+```bash
+$env:C3_VERSION='0.7.4'; powershell -ExecutionPolicy Bypass -Command "iwr -useb https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.ps1 | iex"
+```
+
+If you don't have Visual Studio 17 installed you can either do so, or run the `msvc_build_libraries.py` Python script which will download the necessary files to compile on Windows.
+
+
 #### Installing on Debian with precompiled binaries
-1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest/c3-linux.tar.gz](https://github.com/c3lang/c3c/releases/download/latest/c3-linux.tar.gz)
-   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-linux-debug.tar.gz))
+1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux.tar.gz](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux.tar.gz)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-linux-debug.tar.gz))
 2. Unpack executable and standard lib.
 3. Run `./c3c`.
 
+#### Installing on Debian with the install script
+
+Open a terminal and run the following command:
+```bash
+curl -fsSL https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.sh | bash
+```
+The C3 compiler will be installed, and the script will also update your ~/.bashrc to include `~/.c3` in your PATH, allowing you to invoke the c3c command from anywhere. You might need to restart your terminal or source your shell for the changes to take effect.
+
+You can choose another version with option `C3_VERSION`.
+For example, you can force the installation of the 0.7.4 version:
+```bash
+curl -fsSL https://raw.githubusercontent.com/c3lang/c3c/refs/heads/master/install/install.sh | C3_VERSION=0.7.4 bash
+```
+
 #### Installing on Ubuntu with precompiled binaries
-1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz)
-   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20-debug.tar.gz))
+1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20.tar.gz](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20.tar.gz)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-ubuntu-20-debug.tar.gz))
 2. Unpack executable and standard lib.
 3. Run `./c3c`.
 
 #### Installing on MacOS with precompiled binaries
 1. Make sure you have XCode with command line tools installed.
-2. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip](https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip)
-   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-macos-debug.zip))
+2. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos.zip](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos.zip)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-macos-debug.zip))
 3. Unzip executable and standard lib.
 4. Run `./c3c`.
 
 (*Note that there is a known issue with debug symbol generation on MacOS 13, see [issue #1086](https://github.com/c3lang/c3c/issues/1086))
 
+#### Installing on OpenBSD with precompiled binaries
+1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd.tar.gz](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd.tar.gz)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest-prerelease-tag/c3-openbsd-debug.tar.gz))
+2. Unpack executable and standard lib.
+3. Run `./c3c`.
+
+(*Note that this is specifically for OpenBSD 7.7, running it on any other version is prone to ABI breaks)
+
 #### Installing on Arch Linux
 Arch includes c3c in the official 'extra' repo. It can be easily installed the usual way:
 
@@ -247,38 +299,94 @@ cd c3c-git
 makepkg -si
 ```
 
+#### Installing via Nix
+
+You can access `c3c` via [flake.nix](./flake.nix), which will contain the latest commit of the compiler. To add `c3c` to your `flake.nix`, do the following:
+```nix
+{
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixpkgs-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+    c3c.url = "github:c3lang/c3c";
+    # Those are desired if you don't want to copy extra nixpkgs
+    c3c.inputs = {
+      nixpkgs.follows = "nixpkgs";
+      flake-utils.follows = "flake-utils";
+    };
+  };
+
+  outputs = { self, ... } @ inputs: inputs.flake-utils.lib.eachDefaultSystem (system: 
+    let 
+      pkgs = import inputs.nixpkgs { inherit system; };
+      c3c = inputs.c3c.packages.${system}.c3c;
+    in 
+    {
+      devShells.default = pkgs.mkShell {
+        buildInputs = [
+          pkgs.c3c
+        ];
+      };
+    }
+  );
+}
+```
+
+### Installing on Gentoo
+
+`c3c` is available in the [Gentoo GURU overlay](https://wiki.gentoo.org/wiki/Project:GURU).
+
+Enable and sync the GURU repository (if not already done):
+
+```sh
+sudo eselect repository enable guru
+sudo emaint sync -r guru
+```
+
+Install `c3c` with:
+
+```sh
+sudo emerge -av dev-lang/c3c
+```
+
+* The compiler binary is installed to `/usr/bin/c3c`.
+* The standard library is installed to `/usr/lib/c3`.
+
+For Gentoo-specific issues, please use the [Gentoo Bugzilla](https://bugs.gentoo.org/) (Product: *GURU*).
+
 #### Building via Docker
 
-You can build `c3c` using either an Ubuntu 18.04 or 20.04 container:
+You can build `c3c` using an Ubuntu container. By default, the script will build through Ubuntu 22.04. You can specify the version by passing the `UBUNTU_VERSION` environment variable.
 
 ```
-./build-with-docker.sh 18
+UBUNTU_VERSION=20.04 ./build-with-docker.sh
 ```
 
-Replace `18` with `20` to build through Ubuntu 20.04.
-
-For a release build specify:
-```
-./build-with-docker.sh 20 Release
-```
-
-A `c3c` executable will be found under `bin/`.
+See the `build-with-docker.sh` script for more information on other configurable environment variables.
 
 #### Installing on OS X using Homebrew
 
-2. Install CMake: `brew install cmake`
-3. Install LLVM 17+: `brew install llvm`
-4. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
-5. Enter the C3C directory `cd c3c`.
-6. Create a build directory `mkdir build`
-7. Change directory to the build directory `cd build`
-8. Set up CMake build for debug: `cmake ..`
-9. Build: `cmake --build .`
+1. Install [Homebrew](https://brew.sh/)
+2. Install LLVM 17+: `brew install llvm`
+3. Install lld: `brew install lld`
+4. Install CMake: `brew install cmake`
+5. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
+6. Enter the C3C directory `cd c3c`.
+7. Set up CMake build for debug: `cmake -B build -S .`
+8. Build: `cmake --build build`
+9. Change directory to the build directory `cd build`
+
+#### Installing on Windows using Scoop
+
+c3c is included in 'Main' bucket.
+
+```sh
+scoop install c3
+```
 
 #### Getting started with a "hello world"
 
 Create a `main.c3` file with:
-```c++
+```c3
 module hello_world;
 import std::io;
 
@@ -303,31 +411,38 @@ called `hello_world` or `hello_world.exe`depending on platform.
 
 #### Compiling on Windows
 
-1. Make sure you have Visual Studio 17 2022 installed or alternatively install the "Buildtools for Visual Studio" (https://aka.ms/vs/17/release/vs_BuildTools.exe) and then select "Desktop development with C++" (there is also `c3c/resources/install_win_reqs.bat` to automate this)
+1. Make sure you have Visual Studio 17 2022 installed or alternatively install the "Buildtools for Visual Studio" (https://aka.ms/vs/17/release/vs_BuildTools.exe) and then select "Desktop development with C++"
 2. Install CMake
 3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
-4. Enter the C3C directory `cd c3c`.
-5. Set up the CMake build `cmake -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release`
-6. Build: `cmake --build build --config Release`
-7. You should now have the c3c.exe
+4. Enter the C3C directory: `cd c3c`.
+5. Set up the CMake build: `cmake --preset windows-vs-2022-release`
+6. Build: `cmake --build --preset windows-vs-2022-release`
 
-You should now have a `c3c` executable.
+You should now have a `c3c` executable in `build\Release`.
 
-You can try it out by running some sample code: `c3c.exe compile ../resources/examples/hash.c3`
+You can try it out by running some sample code: `c3c.exe compile ../../resources/examples/hash.c3`
+
+Building `c3c` using Visual Studio Code is also supported when using the `CMake Tools` extension. Simply select the `Windows x64 Visual Studio 17 2022` configure preset and build.
 
 *Note that if you run into linking issues when building, make sure that you are using the latest version of VS17.*
 
+#### Compiling on Windows (Debug)
+
+Debug build requires a different set of LLVM libraries to be loaded for which a separate CMake configuration is used to avoid conflicts.
+1. Configure: `cmake --preset windows-vs-2022-debug`
+2. Build: `cmake --build --preset windows-vs-2022-debug`
+
+You should now have a `c3c` executable in `build-debug\Debug`.
 
 #### Compiling on Ubuntu 24.04 LTS
 
 1. Make sure you have a C compiler that handles C11 and a C++ compiler, such as GCC or Clang. Git also needs to be installed.
-2. Install LLVM 18 `sudo apt-get install cmake git clang zlib1g zlib1g-dev libllvm18 llvm llvm-dev llvm-runtime liblld-dev liblld-18 libpolly-18-dev`
+2. Install LLVM 18 `sudo apt-get install cmake git clang zlib1g zlib1g-dev libllvm18 llvm llvm-dev llvm-runtime liblld-dev liblld-18 libpolly-18-dev`. If you're using Ubuntu 25.04, also install `libpolly-20-dev`.
 3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
 4. Enter the C3C directory `cd c3c`.
-5. Create a build directory `mkdir build`
-6. Change directory to the build directory `cd build`
-7. Set up CMake build: `cmake ..`
-8. Build: `cmake --build .`
+5. Set up CMake build: `cmake -B build -S .`
+6. Build: `cmake --build build`
+7. Change directory to the build directory `cd build`
 
 You should now have a `c3c` executable.
 
@@ -340,35 +455,77 @@ You can try it out by running some sample code: `./c3c compile ../resources/exam
 2. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
     - If you only need the latest commit, you may want to make a shallow clone instead: `git clone https://github.com/c3lang/c3c.git --depth=1`
 3. Enter the directory: `cd c3c`
-4. Create a build directory: `mkdir build`
-5. Enter the build directory: `cd build`
-6. Create the CMake build cache: `cmake ..`
-7. Build: `cmake --build .`
+4. Create the CMake build cache: `cmake -B build -S .`
+5. Build: `cmake --build build`
+6. Enter the build directory: `cd build`
 
 Your c3c executable should have compiled properly. You may want to test it: `./c3c compile ../resources/examples/hash.c3`  
-For a sytem-wide installation, run the following as root: `cmake --install .`
+For a system-wide installation, run the following as root: `cmake --install .`
 
 
+#### Compiling on Fedora
+
+1. Install required project dependencies: `dnf install cmake clang git llvm llvm-devel lld lld-devel ncurses-devel`
+2. Optionally, install additional dependencies: `dnf install libcurl-devel zlib-devel libzstd-devel libxml2-devel libffi-devel`
+3. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
+    - If you only need the latest commit, you may want to make a shallow clone: `git clone https://github.com/c3lang/c3c.git --depth=1`
+4. Enter the C3C directory: `cd c3c`
+5. Create the CMake build cache. The Fedora repositories provide `.so` libraries for lld, so you need to set the C3_LINK_DYNAMIC flag: `cmake -B build -S . -DC3_LINK_DYNAMIC=1`
+6. Build the project: `cmake --build build`
+7. Enter the build directory: `cd build`
+
+The c3c binary should be created in the build directory. You can try it out by running some sample code: `./c3c compile ../resources/examples/hash.c3`
+
+#### Compiling on Arch Linux
+
+1. Install required project dependencies: `sudo pacman -S curl lld llvm-libs clang cmake git libedit llvm libxml2`
+2. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
+    - If you only need the latest commit, you may want to make a shallow clone: `git clone https://github.com/c3lang/c3c.git --depth=1`
+3. Enter the C3C directory: `cd c3c`
+4. Create the CMake build cache:
+```bash
+cmake -B build \
+    -D C3_LINK_DYNAMIC=ON \
+    -D CMAKE_BUILD_TYPE=Release
+```
+5. Build the project: `cmake --build build`.
+
+After compilation, the `c3c` binary will be located in the `build` directory. You can test it by compiling an example: `./build/c3c compile resources/examples/ls.c3`.
+
+6. To install the compiler globally: `sudo cmake --install build`
+
+#### Compiling on NixOS
+
+1. Enter nix shell, by typing `nix develop` in root directory
+2. Configure cmake via `cmake . -Bbuild $=C3_CMAKE_FLAGS`. Note: passing `C3_CMAKE_FLAGS` is needed in due to generate `compile_commands.json` and find missing libs.
+4. Build it `cmake --build build`
+5. Test it out: `./build/c3c -V`
+6. If you use `clangd` lsp server for your editor, it is recommended to make a symbolic link to `compile_command.json` in the root: `ln -s ./build/compile_commands.json compile_commands.json`
+
 #### Compiling on other Linux / Unix variants
 
 1. Install CMake.
 2. Install or compile LLVM and LLD *libraries* (version 17+ or higher)
 3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
 4. Enter the C3C directory `cd c3c`.
-5. Create a build directory `mkdir build`
-6. Change directory to the build directory `cd build`
-7. Set up CMake build for debug: `cmake ..`. At this point you may need to manually 
-provide the link path to the LLVM CMake directories, e.g. `cmake -DLLVM_DIR=/usr/local/opt/llvm/lib/cmake/llvm/ ..`
-8. Build: `cmake --build .`
+5. Set up CMake build for debug: `cmake -B build -S .`. At this point you may need to manually 
+provide the link path to the LLVM CMake directories, e.g. `cmake -B build -S . -DLLVM_DIR=/usr/local/opt/llvm/lib/cmake/llvm/`
+6. Build: `cmake --build build`
+7. Change directory to the build directory `cd build`
 
 *A note on compiling for Linux/Unix/MacOS: to be able to fetch vendor libraries
 libcurl is needed. The CMake script should detect it if it is available. Note that
-this functionality is non-essential and it is perfectly fine to user the compiler without it.*
+this functionality is non-essential and it is perfectly fine to use the compiler without it.*
 
 #### Licensing
 
-The C3 compiler is licensed under LGPL 3.0, the standard library itself is
-MIT licensed.
+Unless specified otherwise, the code in this repository is MIT licensed.
+The exception is the compiler source code (the source code under `src`),
+which is licensed under LGPL 3.0. 
+
+This means you are free to use all parts of standard library, 
+tests, benchmarks, grammar, examples and so on under the MIT license, including 
+using those libraries and tests if you build your own C3 compiler.
 
 #### Editor plugins
 
@@ -387,4 +544,13 @@ Editor plugins can be found at https://github.com/c3lang/editor-plugins.
 
 A huge **THANK YOU** goes out to all contributors and sponsors.
 
-A special thank you to sponsors [Caleb-o](https://github.com/Caleb-o) and [devdad](https://github.com/devdad) for going the extra mile.
+A special thank you to sponsors [Zack Puhl](https://github.com/NotsoanoNimus) and [konimarti](https://github.com/konimarti) for going the extra mile.
+
+And honorable mention goes to past sponsors:
+[Ygor Pontelo](https://github.com/ygorpontelo), [Simone Raimondi](https://github.com/SRaimondi),
+[Jan Válek](https://github.com/jan-valek), [Pierre Curto](https://github.com/pierrec), 
+[Caleb-o](https://github.com/Caleb-o) and [devdad](https://github.com/devdad)
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=c3lang/c3c&type=Date)](https://www.star-history.com/#c3lang/c3c&Date)

benchmarks/stdlib/collections/hashmap.c3

@@ -0,0 +1,219 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+//
+// Some benchmark test ideas are sourced from this article on C++ hashmap benchmarking:
+//   https://martin.ankerl.com/2022/08/27/hashmap-bench-01/
+//
+module hashmap_benchmarks;
+
+import std::collections::map;
+import std::math::random;
+
+
+const DEFAULT_ITERATIONS = 16384;
+
+Lcg64Random rand;
+
+HashMap { int, int } modifying_numbers_random;
+
+fn void bench_setup() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(DEFAULT_ITERATIONS);
+
+	// TODO: Cannot take the address of a @benchmark function. If we could, we could pass &insert_erase as a fn ptr and use the $qnameof CT eval internally.
+	set_benchmark_func_iterations($qnameof(insert_erase), 32);
+	set_benchmark_func_iterations($qnameof(random_access), 1024);
+
+    random::seed(&rand, 0x4528_21e6_38d0_1377);
+
+    for (usz i = 0; i < 1_000; ++i) modifying_numbers_random.set(rand.next_int(), rand.next_int());
+}
+
+
+// ==============================================================================================
+module hashmap_benchmarks @benchmark;
+
+import std::collections::map;
+
+import std::math::random;
+import std::encoding::base64;
+
+
+fn void generic_hash_speeds()
+{
+	(char){}.hash();
+	(char[<100>]){}.hash();
+	(char[100]){}.hash();
+	(ichar){}.hash();
+	(ichar[<100>]){}.hash();
+	(ichar[100]){}.hash();
+	(short){}.hash();
+	(short[<100>]){}.hash();
+	(short[100]){}.hash();
+	(ushort){}.hash();
+	(ushort[<100>]){}.hash();
+	(ushort[100]){}.hash();
+	(int){}.hash();
+	(int[<100>]){}.hash();
+	(int[100]){}.hash();
+	(uint){}.hash();
+	(uint[<100>]){}.hash();
+	(uint[100]){}.hash();
+	(long){}.hash();
+	(long[<20>]){}.hash();
+	(long[100]){}.hash();
+	(ulong){}.hash();
+	(ulong[<20>]){}.hash();
+	(ulong[100]){}.hash();
+	(int128){}.hash();
+	(int128[<20>]){}.hash();
+	(int128[100]){}.hash();
+	(uint128){}.hash();
+	(uint128[<20>]){}.hash();
+	(uint128[100]){}.hash();
+	(bool){}.hash();
+	(bool[<100>]){}.hash();
+	(bool[100]){}.hash();
+	String x = "abc";
+	char[] y = "abc";
+	assert(x.hash() == y.hash());
+	String z1 = "This is a much longer string than the above value because longer values lead to longer hashing times.";
+	char[] z2 = "This is a much longer string than the above value because longer values lead to longer hashing times.";
+	assert(z1.hash() == z2.hash());
+	assert(int.typeid.hash());
+}
+
+
+fn void hash_speeds_of_many_random_values() => @pool()
+{
+	var $arrsz = 10_000;
+	uint fake_checksum;
+
+	char[] chars = allocator::new_array(tmem, char, $arrsz)[:$arrsz];
+	foreach (&v : chars) *v = (char)random::next(&rand, uint.max);
+
+	ushort[] shorts = allocator::new_array(tmem, ushort, $arrsz)[:$arrsz];
+	foreach (&v : shorts) *v = (ushort)random::next(&rand, uint.max);
+
+	uint[] ints = allocator::new_array(tmem, uint, $arrsz)[:$arrsz];
+	foreach (&v : ints) *v = random::next(&rand, uint.max);
+
+	ulong[] longs = allocator::new_array(tmem, ulong, $arrsz)[:$arrsz];
+	foreach (&v : longs) *v = (ulong)random::next(&rand, uint.max);
+
+	uint128[] vwideints = allocator::new_array(tmem, uint128, $arrsz)[:$arrsz];
+	foreach (&v : vwideints) *v = (uint128)random::next(&rand, uint.max);
+
+	char[48][] zstrs = allocator::new_array(tmem, char[48], $arrsz)[:$arrsz];
+
+	String[] strs = mem::temp_array(String, $arrsz);
+	foreach (x, &v : zstrs)
+	{
+		foreach (&c : (*v)[:random::next(&rand, 48)]) *c = (char)random::next(&rand, char.max);
+		strs[x] = ((ZString)&v[0]).str_view();
+	}
+
+	runtime::@start_benchmark();
+	foreach (v : chars) fake_checksum += v.hash();
+	foreach (v : shorts) fake_checksum += v.hash();
+	foreach (v : ints) fake_checksum += v.hash();
+	foreach (v : longs) fake_checksum += v.hash();
+	foreach (v : vwideints) fake_checksum += v.hash();
+	foreach (v : strs) fake_checksum += v.hash();
+	runtime::@end_benchmark();
+}
+
+
+fn void modifying_numbers_init_from_map() => @pool()
+{
+	HashMap { int, int } v;
+	v.tinit_from_map(&modifying_numbers_random);
+	v.free();
+}
+
+
+fn void insert_erase() => @pool()
+{
+	uint iters = 1_000_000;
+	HashMap { int, int } v;
+	v.tinit();
+
+	runtime::@start_benchmark();
+	for (int i = 0; i < iters; ++i) v[i] = i;
+	for (int i = 0; i < iters; ++i) v.remove(i);
+
+	runtime::@end_benchmark();
+
+	v.free();
+}
+
+
+fn void random_access() => @pool()
+{
+	HashMap { int, int } v;
+	v.tinit();
+
+	uint bound = 10_000;
+	usz pseudo_checksum = 0;
+
+	for (uint i = 0; i < bound; ++i) v[i] = i;
+
+	runtime::@start_benchmark();
+	for (uint i = 0; i < 1_000_000; ++i) pseudo_checksum += (v[i.hash() % bound] ?? 0);
+	runtime::@end_benchmark();
+
+	v.free();
+}
+
+
+fn void random_access_erase() => @pool()
+{
+	HashMap { int, int } v;
+	v.tinit();
+
+	uint bound = 10_000;
+
+	for (uint i = 0; i < bound; ++i) v[i] = i;
+
+	runtime::@start_benchmark();
+	for (uint i = 0; i < bound; ++i)
+	{
+		v[i.hash() % bound] = i;   // supplant an entry
+
+		v.remove(random::next(&rand, bound));   // remove a random entry
+	}
+	runtime::@end_benchmark();
+
+	v.free();
+}
+
+
+fn void random_access_string_keys() => @pool()
+{
+	HashMap { String, ulong } v;
+	v.tinit();
+
+	usz pseudo_checksum = 0;
+	String[] saved = mem::temp_array(String, 5_000);
+
+	for (usz i = 0; i < saved.len; ++i)
+	{
+		ulong hash = i.hash();
+		String b64key = base64::tencode(@as_char_view(hash));
+
+		v[b64key] = hash;
+
+		if (i < saved.len) saved[i] = b64key;
+	}
+
+	runtime::@start_benchmark();
+	for (usz i = 0; i < saved.len; ++i)
+	{
+		pseudo_checksum += v[ saved[random::next(&rand, saved.len)] ]!! % 512;
+	}
+	runtime::@end_benchmark();
+
+	v.free();
+}

benchmarks/stdlib/collections/linkedlist.c3

@@ -0,0 +1,38 @@
+module linkedlist_benchmarks;
+
+import std::collections::linkedlist;
+
+
+LinkedList{int} long_list;
+const HAY = 2;
+const NEEDLE = 1000;
+
+fn void bench_setup() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(4096);
+
+    int[*] haystack = { [0..999] = HAY };
+    long_list = linkedlist::@new{int}(mem, haystack[..]);
+    long_list.push(NEEDLE);
+    long_list.push_all(haystack[..]);
+}
+
+
+// ==============================================================================================
+module linkedlist_benchmarks @benchmark;
+
+String die_str = "Failed to find the value `1`. Is something broken?";
+
+
+fn void foreach_iterator()
+{
+    foreach (v : long_list.array_view()) if (v == NEEDLE) return;
+    runtime::@kill_benchmark(die_str);
+}
+
+fn void foreach_r_iterator()
+{
+    foreach_r (v : long_list.array_view()) if (v == NEEDLE) return;
+    runtime::@kill_benchmark(die_str);
+}

benchmarks/stdlib/compression/deflate.c3

@@ -0,0 +1,51 @@
+module deflate_benchmarks;
+import std::compression::deflate;
+
+const uint SMALL_ITERATIONS = 50000;
+const uint LARGE_ITERATIONS = 100;
+
+// Data to compress
+const char[] SMALL_DATA = { [0..1023] = 'A' };
+const char[] LARGE_DATA = { [0..1048575] = 'B' };
+
+char[] small_compressed;
+char[] large_compressed;
+
+fn void initialize_bench() @init
+{
+	small_compressed = deflate::compress(mem, SMALL_DATA)!!;
+	large_compressed = deflate::compress(mem, LARGE_DATA)!!;
+	set_benchmark_warmup_iterations(2);
+	set_benchmark_max_iterations(10);
+
+	set_benchmark_func_iterations($qnameof(deflate_compress_small), SMALL_ITERATIONS);
+	set_benchmark_func_iterations($qnameof(deflate_decompress_small), SMALL_ITERATIONS);
+	set_benchmark_func_iterations($qnameof(deflate_compress_large), LARGE_ITERATIONS);
+	set_benchmark_func_iterations($qnameof(deflate_decompress_large), LARGE_ITERATIONS);
+}
+
+// =======================================================================================
+module deflate_benchmarks @benchmark;
+
+import std::compression::deflate;
+import std::core::mem;
+
+fn void deflate_compress_small() => @pool()
+{
+	char[]? compressed = deflate::compress(tmem, SMALL_DATA);
+}
+
+fn void deflate_decompress_small() => @pool()
+{
+	char[]? decompressed = deflate::decompress(tmem, small_compressed);
+}
+
+fn void deflate_compress_large() => @pool()
+{
+	char[]? compressed = deflate::compress(tmem, LARGE_DATA);
+}
+
+fn void deflate_decompress_large() => @pool()
+{
+	char[]? decompressed = deflate::decompress(tmem, large_compressed);
+}

benchmarks/stdlib/core/string_trim.c3

@@ -0,0 +1,46 @@
+module string_trim_wars;
+
+const String WHITESPACE_TARGET = "    \n\t\r\f\va \tbcde\v\f\r\t\n    ";
+const String WHITESPACE_NUMERIC_TARGET = " 25290   0969  99a \tbcde12332 34 43          0000";
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(64);
+	set_benchmark_max_iterations(1 << 24);
+}
+
+macro void trim_bench($trim_str, String $target = WHITESPACE_TARGET) => @pool()
+{
+	String s1;
+	String s2 = $target.tcopy();
+
+	runtime::@start_benchmark();
+
+	$switch:
+	$case $typeof($trim_str) == String:
+		s1 = s2.trim($trim_str);
+	$case $typeof($trim_str) == AsciiCharset:
+		s1 = s2.trim_charset($trim_str);
+	$default: $error "Unable to determine the right String `trim` operation to use.";
+	$endswitch
+
+	@volatile_load(s1);
+
+	runtime::@end_benchmark();
+}
+
+
+module string_trim_wars @benchmark;
+
+fn void trim_control() => trim_bench(" ");   // only spaces
+
+fn void trim_whitespace_default() => trim_bench("\t\n\r ");   // default set
+fn void trim_whitespace_default_ordered() => trim_bench(" \n\t\r");   // default \w set, but ordered by expected freq
+
+fn void trim_whitespace_bad() => trim_bench("\f\v\n\t\r ");   // bad-perf ordering, all \w
+
+fn void trim_whitespace_ordered_extended() => trim_bench(" \n\t\r\f\v");   // proposed ordering, all \w
+fn void trim_charset_whitespace() => trim_bench(ascii::WHITESPACE_SET);   // use charset, all \w
+
+fn void trim_many() => trim_bench(" \n\t\r\f\v0123456789", WHITESPACE_NUMERIC_TARGET);   // ordered, all \w + num
+fn void trim_charset_many() => trim_bench(ascii::WHITESPACE_SET | ascii::NUMBER_SET, WHITESPACE_NUMERIC_TARGET);   // set, all \w + num

benchmarks/stdlib/crypto/aes_bench.c3

@@ -0,0 +1,31 @@
+module std::crypto::aes_bench;
+
+import std::crypto::aes;
+
+fn void init() @init
+{
+	set_benchmark_warmup_iterations(5);
+	set_benchmark_max_iterations(10_000);
+}
+
+
+AesType aes   = AES256;
+char[] key    = x"603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4";
+char[] text   = x"6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710";
+char[] cipher = x"601ec313775789a5b7a7f504bbf3d228f443e3ca4d62b59aca84e990cacaf5c52b0930daa23de94ce87017ba2d84988ddfc9c58db67aada613c2dd08457941a6";
+char[16] iv     = x"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+
+fn void bench_ctr_xcrypt() @benchmark
+{
+	char[64] out;
+	Aes ctx;
+
+	// encrypt
+	ctx.init(aes, key, iv);
+	ctx.encrypt_buffer(text, &out);
+
+	// decrypt
+	ctx.init(aes, key, iv);
+	ctx.decrypt_buffer(cipher, &out);
+}
+

benchmarks/stdlib/crypto/chacha20.c3

@@ -0,0 +1,39 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module chacha20_benchmarks;
+
+import std::crypto::chacha20;
+
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(1024);
+}
+
+const char[] KEY = x'98bef1469be7269837a45bfbc92a5a6ac762507cf96443bf33b96b1bd4c6f8f6';
+const char[] NONCE = x'44e792d63335abb1582e9253';
+const uint COUNTER = 42;
+
+char[] one_mb @align(ulong.sizeof) = { [0..1024*1024] = 0xA5 };
+
+// This doesn't test both encryption + decryption, because it's a symmetric operation that shares
+//   a single common data transformation. Testing one limb is enough.
+fn void gogo_chacha20() @benchmark
+{
+	chacha20::encrypt_mut(one_mb[..], KEY, NONCE, COUNTER);
+}
+
+// Check what the speed of an unligned buffer looks like.
+fn void gogo_chacha20_unaligned() @benchmark => @pool()
+{
+    char[] copy = mem::talloc_array(char, one_mb.len + 3);
+    char[] im_off_slightly = copy[3..];
+    copy[3..] = one_mb[..];
+    assert((usz)im_off_slightly.ptr % usz.sizeof > 0);
+
+    runtime::@start_benchmark();
+	chacha20::encrypt_mut(im_off_slightly, KEY, NONCE, COUNTER);
+    runtime::@end_benchmark();
+}

benchmarks/stdlib/crypto/crypto_shootout.c3

@@ -0,0 +1,113 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module crypto_hash_benchmarks;
+
+import std::collections::pair;
+
+
+const usz COMMON_ITERATIONS = 1 << 17;
+
+char* common_1mib_ptr;
+char[] common_16;
+char[] common_256;
+char[] common_4kib;
+char[] common_1mib;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(COMMON_ITERATIONS + 3);
+
+	common_1mib_ptr = mem::alloc_array(char, 1024*1024);
+	common_1mib = common_1mib_ptr[:1024*1024];
+	common_1mib[..] = 0xA5;
+
+	common_16 = common_1mib[:16];
+	common_256 = common_1mib[:256];
+	common_4kib = common_1mib[:4096];
+
+	static String[] function_prefixes = {
+		$qnameof(md5_16)[..^4],
+		$qnameof(sha1_16)[..^4],
+		$qnameof(sha2_256_16)[..^4],
+		$qnameof(sha2_512_16)[..^4],
+		//$qnameof(blake2s_256_16)[..^4],
+		//$qnameof(blake2b_256_16)[..^4],
+		$qnameof(blake3_16)[..^4],
+		$qnameof(ripemd_160_16)[..^4],
+		$qnameof(whirlpool_16)[..^4],
+		$qnameof(streebog_256_16)[..^4],
+		$qnameof(streebog_512_16)[..^4],
+	};
+
+	static Pair{ String, uint }[] to_iters = {
+		{ "_4kib", 1 << 15 },
+		{ "_1mib", 1024 },
+	};
+
+	foreach (p : to_iters)
+	{
+		foreach (name : function_prefixes) set_benchmark_func_iterations(name.tconcat(p.first), p.second);
+	}
+}
+
+fn void teardown_bench() @finalizer
+{
+	mem::free(common_1mib_ptr);
+}
+
+
+// =======================================================================================
+module crypto_hash_benchmarks @benchmark;
+
+import std::hash;
+
+
+fn void md5_16() => md5::hash(common_16);
+fn void sha1_16() => sha1::hash(common_16);
+fn void sha2_256_16() => sha256::hash(common_16);
+fn void sha2_512_16() => sha512::hash(common_16);
+//fn void blake2s_256_16() => blake2::s(256, common_16);
+//fn void blake2b_256_16() => blake2::b(256, common_16);
+fn void blake3_16() => blake3::hash(common_16);
+fn void ripemd_160_16() => ripemd::hash{160}(common_16);
+fn void whirlpool_16() => whirlpool::hash(common_16);
+fn void streebog_256_16() => streebog::hash_256(common_16);
+fn void streebog_512_16() => streebog::hash_512(common_16);
+
+fn void md5_256() => md5::hash(common_256);
+fn void sha1_256() => sha1::hash(common_256);
+fn void sha2_256_256() => sha256::hash(common_256);
+fn void sha2_512_256() => sha512::hash(common_256);
+//fn void blake2s_256_256() => blake2::s(256, common_256);
+//fn void blake2b_256_256() => blake2::b(256, common_256);
+fn void blake3_256() => blake3::hash(common_256);
+fn void ripemd_160_256() => ripemd::hash{160}(common_256);
+fn void whirlpool_256() => whirlpool::hash(common_256);
+fn void streebog_256_256() => streebog::hash_256(common_256);
+fn void streebog_512_256() => streebog::hash_512(common_256);
+
+fn void md5_4kib() => md5::hash(common_4kib);
+fn void sha1_4kib() => sha1::hash(common_4kib);
+fn void sha2_256_4kib() => sha256::hash(common_4kib);
+fn void sha2_512_4kib() => sha512::hash(common_4kib);
+//fn void blake2s_256_4kib() => blake2::s(256, common_4kib);
+//fn void blake2b_256_4kib() => blake2::b(256, common_4kib);
+fn void blake3_4kib() => blake3::hash(common_4kib);
+fn void ripemd_160_4kib() => ripemd::hash{160}(common_4kib);
+fn void whirlpool_4kib() => whirlpool::hash(common_4kib);
+fn void streebog_256_4kib() => streebog::hash_256(common_4kib);
+fn void streebog_512_4kib() => streebog::hash_512(common_4kib);
+
+fn void md5_1mib() => md5::hash(common_1mib);
+fn void sha1_1mib() => sha1::hash(common_1mib);
+fn void sha2_256_1mib() => sha256::hash(common_1mib);
+fn void sha2_512_1mib() => sha512::hash(common_1mib);
+//fn void blake2s_256_1mib() => blake2::s(256, common_1mib);
+//fn void blake2b_256_1mib() => blake2::b(256, common_1mib);
+fn void blake3_1mib() => blake3::hash(common_1mib);
+fn void ripemd_160_1mib() => ripemd::hash{160}(common_1mib);
+fn void whirlpool_1mib() => whirlpool::hash(common_1mib);
+fn void streebog_256_1mib() => streebog::hash_256(common_1mib);
+fn void streebog_512_1mib() => streebog::hash_512(common_1mib);

benchmarks/stdlib/hash/blake3.c3

@@ -0,0 +1,57 @@
+module blake3_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(128);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module blake3_bench @benchmark;
+
+import std::hash;
+
+fn void blake3_hash()
+{
+    runtime::@start_benchmark();
+    char[*] myset = blake3::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha512::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_whirlpool()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/md5.c3

@@ -0,0 +1,41 @@
+module md5_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(128);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module md5_bench @benchmark;
+
+import std::hash;
+
+fn void md5_hash()
+{
+    runtime::@start_benchmark();
+    char[*] myset = md5::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/non_crypto_shootout.c3

@@ -0,0 +1,94 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module non_crypto_benchmarks;
+
+
+const usz COMMON_ITERATIONS = 1 << 18;
+
+const char[] COMMON_1 = { 0xA5 };
+const char[] COMMON_4 = { 0xA5, 0xA5, 0xA5, 0xA5, };
+const char[] COMMON_8 = { [0..7] = 0xA5 };
+const char[] COMMON_16 = { [0..15] = 0xA5 };
+const char[] COMMON_32 = { [0..31] = 0xA5 };
+const char[] COMMON_64 = { [0..63] = 0xA5 };
+const char[] COMMON_128 = { [0..127] = 0xA5 };
+const char[] COMMON_1024 = { [0..1023] = 0xA5 };
+
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(COMMON_ITERATIONS + 3);
+}
+
+
+// =======================================================================================
+module non_crypto_benchmarks @benchmark;
+
+import std::hash;
+
+
+fn void fnv64a_1() => fnv64a::hash(COMMON_1);
+fn void fnv32a_1() => fnv32a::hash(COMMON_1);
+fn void wyhash2_1() => wyhash2::hash(COMMON_1);
+fn void metro64_1() => metro64::hash(COMMON_1);
+fn void metro128_1() => metro128::hash(COMMON_1);
+fn void a5hash_1() => a5hash::hash(COMMON_1);
+fn void komi_1() => komi::hash(COMMON_1);
+
+fn void fnv64a_4() => fnv64a::hash(COMMON_4);
+fn void fnv32a_4() => fnv32a::hash(COMMON_4);
+fn void wyhash2_4() => wyhash2::hash(COMMON_4);
+fn void metro64_4() => metro64::hash(COMMON_4);
+fn void metro128_4() => metro128::hash(COMMON_4);
+fn void a5hash_4() => a5hash::hash(COMMON_4);
+fn void komi_4() => komi::hash(COMMON_4);
+
+fn void fnv64a_8() => fnv64a::hash(COMMON_8);
+fn void fnv32a_8() => fnv32a::hash(COMMON_8);
+fn void wyhash2_8() => wyhash2::hash(COMMON_8);
+fn void metro64_8() => metro64::hash(COMMON_8);
+fn void metro128_8() => metro128::hash(COMMON_8);
+fn void a5hash_8() => a5hash::hash(COMMON_8);
+fn void komi_8() => komi::hash(COMMON_8);
+
+fn void fnv64a_16() => fnv64a::hash(COMMON_16);
+fn void fnv32a_16() => fnv32a::hash(COMMON_16);
+fn void wyhash2_16() => wyhash2::hash(COMMON_16);
+fn void metro64_16() => metro64::hash(COMMON_16);
+fn void metro128_16() => metro128::hash(COMMON_16);
+fn void a5hash_16() => a5hash::hash(COMMON_16);
+fn void komi_16() => komi::hash(COMMON_16);
+
+fn void fnv64a_32() => fnv64a::hash(COMMON_32);
+fn void fnv32a_32() => fnv32a::hash(COMMON_32);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_32() => metro64::hash(COMMON_32);
+fn void metro128_32() => metro128::hash(COMMON_32);
+fn void a5hash_32() => a5hash::hash(COMMON_32);
+fn void komi_32() => komi::hash(COMMON_32);
+
+fn void fnv64a_64() => fnv64a::hash(COMMON_64);
+fn void fnv32a_64() => fnv32a::hash(COMMON_64);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_64() => metro64::hash(COMMON_64);
+fn void metro128_64() => metro128::hash(COMMON_64);
+fn void a5hash_64() => a5hash::hash(COMMON_64);
+fn void komi_64() => komi::hash(COMMON_64);
+
+fn void fnv64a_128() => fnv64a::hash(COMMON_128);
+fn void fnv32a_128() => fnv32a::hash(COMMON_128);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_128() => metro64::hash(COMMON_128);
+fn void metro128_128() => metro128::hash(COMMON_128);
+fn void a5hash_128() => a5hash::hash(COMMON_128);
+fn void komi_128() => komi::hash(COMMON_128);
+
+fn void fnv64a_1024() => fnv64a::hash(COMMON_1024);
+fn void fnv32a_1024() => fnv32a::hash(COMMON_1024);
+// NOTE: wyhash2 cannot be used on inputs > 16 bytes.
+fn void metro64_1024() => metro64::hash(COMMON_1024);
+fn void metro128_1024() => metro128::hash(COMMON_1024);
+fn void a5hash_1024() => a5hash::hash(COMMON_1024);
+fn void komi_1024() => komi::hash(COMMON_1024);

benchmarks/stdlib/hash/ripemd.c3

@@ -0,0 +1,76 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module ripemd_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(256);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module ripemd_bench @benchmark;
+
+import std::hash;
+
+fn void ripemd_128()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{128}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void ripemd_160()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{160}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void ripemd_256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{256}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void ripemd_320()
+{
+    runtime::@start_benchmark();
+    char[*] myset = ripemd::hash{320}(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_whirlpool()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/streebog.c3

@@ -0,0 +1,51 @@
+// Copyright (c) 2025 Zack Puhl <github@xmit.xyz>. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module streebog_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(256);
+}
+
+const char[] INPUT = { [0..1024*1024] = 0xA5 };
+const char[*] EXPECTED_256 = x'694676905b7cf099755db1cc186f741f0fd1877aaaa4badcbfb305537f986971';
+const char[*] EXPECTED_512 = x'fe21d08857ea97e79035d1e5c9ba5130786e8d1875bc74d628349560d94d6bdff0b0dcd2f6347eb8b3f0239b6cca76b5028c0ff45f631fcdf77b1d551dd079f3';
+
+
+module streebog_bench @benchmark;
+
+import std::hash;
+
+fn void get_in_the_bog_256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = streebog::hash_256(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void get_in_the_bog_512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = streebog::hash_512(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_whirlpool()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(INPUT);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/hash/whirlpool.c3

@@ -0,0 +1,57 @@
+module whirlpool_bench;
+
+fn void initialize_bench() @init
+{
+	set_benchmark_warmup_iterations(3);
+	set_benchmark_max_iterations(128);
+
+    input = mem::alloc_array(char, BUFSZ);
+    input[:BUFSZ] = (char[]){ [0..BUFSZ-1] = 0xA5 }[..];
+    input_slice = input[:BUFSZ];
+}
+
+fn void teardown_bench() @finalizer
+{
+    mem::free(input);
+    input = null;
+}
+
+char* input;
+char[] input_slice;
+const usz BUFSZ = 1024 * 1024;
+
+module whirlpool_bench @benchmark;
+
+import std::hash;
+
+fn void whirlpool_hash()
+{
+    runtime::@start_benchmark();
+    char[*] myset = whirlpool::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha256()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha256::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_sha512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = sha512::hash(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}
+
+fn void compared_with_streebog_512()
+{
+    runtime::@start_benchmark();
+    char[*] myset = streebog::hash_512(input_slice);
+    runtime::@end_benchmark();
+    mem::zero_volatile(myset[..]);
+}

benchmarks/stdlib/sort/quicksort.c3

@@ -0,0 +1,69 @@
+module sort_bench;
+
+import std::sort;
+
+fn void init() @init
+{
+    set_benchmark_warmup_iterations(5);
+    set_benchmark_max_iterations(10_000);
+}
+
+fn void quicksort_bench() @benchmark
+{
+	// test set: 500 numbers between 0 and 99;
+	int[] data = {
+		71, 28, 2, 13, 62, 10, 54, 78, 63, 86,
+		33, 65, 89, 51, 58, 0, 51, 16, 87, 30,
+		89, 14, 52, 41, 88, 25, 83, 91, 56, 86,
+		14, 64, 76, 18, 39, 24, 79, 62, 34, 58,
+		90, 24, 56, 73, 85, 82, 79, 63, 47, 69,
+		78, 29, 49, 28, 43, 47, 56, 53, 79, 56,
+		19, 63, 29, 52, 71, 93, 61, 46, 30, 11,
+		21, 26, 37, 86, 93, 74, 62, 0, 41, 17,
+		26, 27, 34, 11, 54, 69, 72, 44, 74, 3,
+		61, 62, 80, 90, 3, 82, 16, 12, 28, 1,
+		2, 49, 4, 44, 57, 86, 63, 74, 33, 41,
+		76, 77, 56, 57, 56, 88, 74, 71, 6, 59,
+		40, 42, 94, 55, 21, 17, 17, 63, 21, 83,
+		73, 19, 39, 88, 93, 74, 21, 0, 63, 45,
+		69, 66, 22, 68, 86, 86, 85, 67, 8, 50,
+		23, 98, 64, 80, 64, 36, 40, 30, 73, 36,
+		23, 14, 1, 77, 82, 8, 18, 73, 37, 86,
+		29, 70, 27, 87, 64, 81, 13, 0, 4, 83,
+		90, 17, 71, 66, 38, 39, 54, 22, 86, 18,
+		84, 66, 77, 25, 64, 93, 80, 91, 2, 92,
+		47, 32, 90, 16, 46, 29, 56, 87, 70, 73,
+		89, 41, 5, 54, 93, 63, 16, 39, 71, 84,
+		74, 91, 69, 59, 49, 87, 74, 37, 75, 83,
+		77, 19, 51, 44, 79, 62, 94, 20, 24, 83,
+		37, 70, 57, 32, 93, 8, 29, 11, 7, 92,
+		8, 23, 20, 21, 7, 70, 28, 20, 96, 6,
+		50, 58, 30, 61, 66, 42, 50, 54, 64, 7,
+		10, 53, 63, 44, 16, 39, 83, 73, 3, 29,
+		97, 32, 36, 68, 84, 64, 73, 5, 29, 13,
+		48, 3, 84, 65, 75, 68, 66, 22, 39, 33,
+		39, 24, 27, 85, 18, 34, 3, 63, 32, 9,
+		29, 66, 24, 90, 75, 50, 11, 95, 47, 14,
+		92, 1, 76, 45, 76, 41, 55, 54, 38, 67,
+		43, 40, 5, 61, 97, 11, 61, 24, 92, 24,
+		76, 53, 60, 34, 78, 80, 70, 75, 30, 90,
+		65, 99, 80, 61, 94, 75, 63, 67, 10, 35,
+		23, 42, 31, 48, 14, 68, 84, 14, 79, 1,
+		25, 94, 23, 53, 49, 69, 44, 73, 63, 51,
+		44, 96, 88, 51, 94, 24, 64, 72, 59, 81,
+		73, 93, 14, 35, 9, 53, 25, 48, 50, 88,
+		46, 97, 67, 40, 27, 17, 2, 42, 11, 82,
+		0, 46, 44, 38, 31, 88, 63, 88, 10, 82,
+		77, 61, 24, 39, 27, 33, 10, 91, 69, 22,
+		42, 74, 71, 13, 32, 56, 12, 46, 81, 74,
+		17, 26, 45, 50, 76, 84, 76, 36, 43, 65,
+		81, 64, 0, 49, 70, 11, 76, 19, 60, 55,
+		15, 98, 31, 91, 56, 8, 97, 9, 3, 94,
+		3, 88, 7, 2, 3, 98, 10, 51, 21, 79,
+		99, 3, 8, 76, 52, 13, 40, 90, 85, 15,
+		70, 77, 43, 30, 4, 89, 18, 21, 59, 17,
+	};
+	sort::quicksort(data);
+}
+
+

build-with-docker.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 : ${DOCKER:=docker}
 : ${IMAGE:="c3c-builder"}
@@ -30,7 +30,8 @@ chmod -R 777 build bin
 exec $DOCKER run -i --rm \
     -v "$PWD":/home/c3c/source \
     -w /home/c3c/source $IMAGE bash -c \
-    "cmake -S . -B build \
+    "git config --global --add safe.directory /home/c3c/source && \
+    cmake -S . -B build \
             -G Ninja \
             -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE \
             -DCMAKE_C_COMPILER=clang-$LLVM_VERSION \
@@ -41,4 +42,4 @@ exec $DOCKER run -i --rm \
             -DCMAKE_DLLTOOL=llvm-dlltool-$LLVM_VERSION \
             -DC3_LLVM_VERSION=auto && \
     cmake --build build && \
-    cp -r build/c3c build/lib bin"
+    cp -r build/c3c build/lib bin"

docker/Dockerfile

@@ -2,48 +2,44 @@ ARG UBUNTU_VERSION=22.04
 FROM ubuntu:${UBUNTU_VERSION}
 
 ARG LLVM_VERSION=18
-ENV LLVM_DEV_VERSION=20
+ARG CMAKE_VERSION=3.20.0
 
-ARG CMAKE_VERSION=3.20
+# Prevent interactive prompts during apt install
+ENV DEBIAN_FRONTEND=noninteractive
 
-RUN apt-get update && apt-get install -y wget gnupg software-properties-common zlib1g zlib1g-dev python3 ninja-build curl g++ && \
-    wget https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-$CMAKE_VERSION-linux-x86_64.sh && \
+RUN for i in 1 2 3; do apt-get update && break || sleep 2; done && \
+    apt-get install -y --fix-missing \
+    wget gnupg software-properties-common lsb-release \
+    zlib1g zlib1g-dev python3 ninja-build curl g++ libcurl4-openssl-dev git && \
+    CODENAME=$(lsb_release -cs) && \
+    ARCH=$(uname -m) && \
+    wget https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-${ARCH}.sh && \
     mkdir -p /opt/cmake && \
-    sh cmake-${CMAKE_VERSION}-linux-x86_64.sh --prefix=/opt/cmake --skip-license && \
-    rm cmake-${CMAKE_VERSION}-linux-x86_64.sh && \
-    ln -s /opt/cmake/bin/cmake /usr/local/bin/cmake
+    sh cmake-${CMAKE_VERSION}-linux-${ARCH}.sh --prefix=/opt/cmake --skip-license && \
+    ln -s /opt/cmake/bin/cmake /usr/local/bin/cmake && \
+    rm cmake-${CMAKE_VERSION}-linux-${ARCH}.sh
 
-RUN wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
-    if [ "${LLVM_VERSION}" -lt 18 ]; then \
-        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${LLVM_VERSION} main" && \
-        apt-get update && \
-        apt-get install -y -t llvm-toolchain-focal-${LLVM_VERSION} \
-          libpolly-${LLVM_VERSION}-dev \
-          clang-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
-          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev libmlir-${LLVM_VERSION} \
-          libmlir-${LLVM_VERSION}-dev mlir-${LLVM_VERSION}-tools; \
-    elif [ "${LLVM_VERSION}" -lt "${LLVM_DEV_VERSION}" ]; then \
-        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${LLVM_VERSION} main" && \
-        apt-get update && \
-        apt-get install -y -t llvm-toolchain-focal-${LLVM_VERSION} \
-          libpolly-${LLVM_VERSION}-dev \
-          clang-${LLVM_VERSION} clang++-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
-          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev; \
+RUN CODENAME=$(lsb_release -cs) && \
+    for i in 1 2; do wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key && break || sleep 2; done | apt-key add - && \
+    if [ "${LLVM_VERSION}" -ge 16 ]; then \
+        add-apt-repository "deb http://apt.llvm.org/${CODENAME}/ llvm-toolchain-${CODENAME}-${LLVM_VERSION} main"; \
     else \
-        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main" && \
-        apt-get update && \
-        apt-get install -y -t llvm-toolchain-focal \
-          libpolly-${LLVM_VERSION}-dev \
-          clang-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
-          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev; \
+        add-apt-repository "deb http://apt.llvm.org/${CODENAME}/ llvm-toolchain-${CODENAME} main"; \
     fi && \
+    for i in 1 2 3; do apt-get update && break || sleep 2; done && \
+    apt-get install -y --fix-missing \
+      clang-${LLVM_VERSION} \
+      clang++-${LLVM_VERSION} \
+      llvm-${LLVM_VERSION} \
+      llvm-${LLVM_VERSION}-dev \
+      lld-${LLVM_VERSION} \
+      liblld-${LLVM_VERSION}-dev \
+      libpolly-${LLVM_VERSION}-dev && \
     rm -rf /var/lib/apt/lists/*
 
 RUN groupadd -g 1337 c3c && \
     useradd -m -u 1337 -g c3c c3c
 
-# Add cmake to PATH for user c3c
 USER c3c
 ENV PATH="/opt/cmake/bin:${PATH}"
-
 WORKDIR /home/c3c

flake.lock

@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1738297584,
+        "narHash": "sha256-AYvaFBzt8dU0fcSK2jKD0Vg23K2eIRxfsVXIPCW9a0E=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "9189ac18287c599860e878e905da550aa6dec1cd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,42 @@
+{
+  description = "C3 compiler flake";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs?ref=nixpkgs-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, ... }@inputs: inputs.flake-utils.lib.eachDefaultSystem 
+  (system: 
+    let pkgs = import inputs.nixpkgs { inherit system; }; 
+        c3cBuild = set: pkgs.callPackage ./nix/default.nix (set // { 
+          rev = self.rev or "unknown"; 
+        });
+    in {
+      packages = {
+        default = self.packages.${system}.c3c;
+
+        c3c = c3cBuild {};
+        
+        c3c-checks = c3cBuild { 
+          checks = true; 
+        };
+
+        c3c-debug = c3cBuild { 
+          debug = true; 
+        };
+
+        c3c-debug-checks = c3cBuild { 
+          debug = true; 
+          checks = true; 
+        };
+      };
+
+      devShells = {
+        default = pkgs.callPackage ./nix/shell.nix {
+          c3c = self.packages.${system}.c3c-debug; 
+        };
+      };
+    }
+  );
+}

git_hash.cmake

@@ -4,6 +4,7 @@ set(GIT_HASH "unknown")
 
 if(GIT_FOUND AND EXISTS "${CMAKE_CURRENT_LIST_DIR}/.git")
     execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
                     OUTPUT_VARIABLE GIT_HASH
                     OUTPUT_STRIP_TRAILING_WHITESPACE
                     COMMAND_ERROR_IS_FATAL ANY)

install/install.ps1

@@ -0,0 +1,189 @@
+<#
+.SYNOPSIS
+    C3 install script.
+.DESCRIPTION
+    This script installs C3 on Windows from the command line.
+.PARAMETER C3Version
+    Specifies the version of C3 to install.
+    Default is 'latest'. Can also be set via environment variable 'C3_VERSION'.
+.PARAMETER C3Home
+    Specifies C3's installation directory.
+    Default is '$Env:USERPROFILE\.c3'. Can also be set via environment variable 'C3_HOME'.
+.PARAMETER NoPathUpdate
+    If specified, the script will not modify the PATH environment variable.
+.PARAMETER C3Repourl
+    Specifies the repository URL of C3.
+    Default is 'https://github.com/c3lang/c3c'. Can also be set via environment variable 'C3_REPOURL'.
+.LINK
+    https://c3-lang.org/
+.LINK
+    https://github.com/c3lang/c3c
+#>
+
+# Script parameters with defaults
+param (
+    [string] $C3Version = 'latest',
+    [string] $C3Home = "$Env:USERPROFILE\.c3",
+    [switch] $NoPathUpdate,
+    [string] $C3Repourl = 'https://github.com/c3lang/c3c'
+)
+
+# Enable strict mode for better error handling
+Set-StrictMode -Version Latest
+
+# Function to broadcast environment variable changes to Windows system
+function Publish-Env {
+    # Add P/Invoke type if it does not exist
+    if (-not ("Win32.NativeMethods" -as [Type])) {
+        Add-Type -Namespace Win32 -Name NativeMethods -MemberDefinition @"
+[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+public static extern IntPtr SendMessageTimeout(
+    IntPtr hWnd, uint Msg, UIntPtr wParam, string lParam,
+    uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);
+"@
+    }
+
+    # Constants for broadcasting environment changes
+    $HWND_BROADCAST = [IntPtr] 0xffff
+    $WM_SETTINGCHANGE = 0x1a
+    $result = [UIntPtr]::Zero
+
+    # Broadcast the message to all windows
+    [Win32.Nativemethods]::SendMessageTimeout($HWND_BROADCAST,
+        $WM_SETTINGCHANGE,
+        [UIntPtr]::Zero,
+        "Environment",
+        2,
+        5000,
+        [ref] $result
+    ) | Out-Null
+}
+
+# Function to write or update an environment variable in the registry
+function Write-Env {
+    param(
+        [String] $name,
+        [String] $val,
+        [Switch] $global
+    )
+
+    # Determine the registry key based on scope (user or system)
+    $RegisterKey = if ($global) {
+        Get-Item -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager'
+    } else {
+        Get-Item -Path 'HKCU:'
+    }
+
+    $EnvRegisterKey = $RegisterKey.OpenSubKey('Environment', $true)
+
+    # If value is null, delete the variable
+    if ($null -eq $val) {
+        $EnvRegisterKey.DeleteValue($name)
+    } else {
+        # Determine the correct registry value type
+        $RegistryValueKind = if ($val.Contains('%')) {
+            [Microsoft.Win32.RegistryValueKind]::ExpandString
+        } elseif ($EnvRegisterKey.GetValue($name)) {
+            $EnvRegisterKey.GetValueKind($name)
+        } else {
+            [Microsoft.Win32.RegistryValueKind]::String
+        }
+        $EnvRegisterKey.SetValue($name, $val, $RegistryValueKind)
+    }
+
+    # Broadcast the change to the system
+    Publish-Env
+}
+
+# Function to get an environment variable from the registry
+function Get-Env {
+    param(
+        [String] $name,
+        [Switch] $global
+    )
+
+    # Determine registry key based on scope
+    $RegisterKey = if ($global) {
+        Get-Item -Path 'HKLM:\SYSTEM\CurrentControlSet\Control\Session Manager'
+    } else {
+        Get-Item -Path 'HKCU:'
+    }
+
+    $EnvRegisterKey = $RegisterKey.OpenSubKey('Environment')
+    $RegistryValueOption = [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames
+
+    # Retrieve the value without expanding environment variables
+    $EnvRegisterKey.GetValue($name, $null, $RegistryValueOption)
+}
+
+# Override defaults if environment variables exist
+if ($Env:C3_VERSION) { $C3Version = $Env:C3_VERSION }
+if ($Env:C3_HOME) { $C3Home = $Env:C3_HOME }
+if ($Env:C3_NO_PATH_UPDATE) { $NoPathUpdate = $true }
+if ($Env:C3_REPOURL) { $C3Repourl = $Env:C3_REPOURL -replace '/$', '' }
+
+# Set binary name
+$BINARY = "c3-windows"
+
+# Determine the download URL based on version
+if ($C3Version -eq 'latest') {
+    $DOWNLOAD_URL = "$C3Repourl/releases/latest/download/$BINARY.zip"
+} else {
+    # Ensure version starts with 'v'
+    $C3Version = "v" + ($C3Version -replace '^v', '')
+    $DOWNLOAD_URL = "$C3Repourl/releases/download/$C3Version/$BINARY.zip"
+}
+
+$BinDir = $C3Home
+
+Write-Host "This script will automatically download and install C3 ($C3Version) for you."
+Write-Host "Getting it from this url: $DOWNLOAD_URL"
+Write-Host "The binary will be installed into '$BinDir'"
+
+# Create temporary file for download
+$TEMP_FILE = [System.IO.Path]::GetTempFileName()
+
+try {
+    # Download the binary
+    Invoke-WebRequest -Uri $DOWNLOAD_URL -OutFile $TEMP_FILE
+
+    # Remove previous installation if it exists
+    if (Test-Path -Path $BinDir) {
+        Remove-Item -Path $BinDir -Recurse -Force | Out-Null
+    }
+
+    # Rename temp file to .zip
+    $ZIP_FILE = $TEMP_FILE + ".zip"
+    Rename-Item -Path $TEMP_FILE -NewName $ZIP_FILE
+
+    # Extract downloaded zip
+    Expand-Archive -Path $ZIP_FILE -DestinationPath $Env:USERPROFILE -Force
+
+    # Rename extracted folder to target installation directory
+    Rename-Item -Path "$Env:USERPROFILE/c3-windows-Release" -NewName $BinDir
+} catch {
+    Write-Host "Error: '$DOWNLOAD_URL' is not available or failed to download"
+    exit 1
+} finally {
+    # Cleanup temporary zip file
+    Remove-Item -Path $ZIP_FILE
+}
+
+# Update PATH environment variable if requested
+if (!$NoPathUpdate) {
+    $PATH = Get-Env 'PATH'
+    if ($PATH -notlike "*$BinDir*") {
+        Write-Output "Adding $BinDir to PATH"
+
+        # Persist PATH for future sessions
+        Write-Env -name 'PATH' -val "$BinDir;$PATH"
+
+        # Update PATH for current session
+        $Env:PATH = "$BinDir;$PATH"
+        Write-Output "You may need to restart your shell"
+    } else {
+        Write-Output "$BinDir is already in PATH"
+    }
+} else {
+    Write-Output "You may need to update your PATH manually to use c3"
+}

install/install.sh

@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+set -euo pipefail  # Exit on error, unset variables, and fail pipelines on any error
+
+__wrap__() {
+    # Version of C3 to install (default: latest)
+    VERSION="${C3_VERSION:-latest}"
+    # Installation directory (default: ~/.c3)
+    C3_HOME="${C3_HOME:-$HOME/.c3}"
+    # Expand '~' if present
+    C3_HOME="${C3_HOME/#\~/$HOME}"
+    BIN_DIR="$C3_HOME"
+    # C3 compiler repository URL
+    REPO="c3lang/c3c"
+    REPOURL="${C3_REPOURL:-https://github.com/$REPO}"
+
+    detect_platform() {
+        # Detects the operating system
+        local os_type
+        os_type="$(uname -s | tr '[:upper:]' '[:lower:]')"
+
+        case "$os_type" in
+            darwin)  # macOS
+                echo "macos"
+                ;;
+            msys*|mingw*|cygwin*)  # Windows (Git Bash / MSYS / Cygwin)
+                IS_MSYS=true
+                echo "windows"
+                ;;
+            *)
+                echo $os_type
+                ;;
+        esac
+    }
+
+    # Determine platform string
+    PLATFORM="$(detect_platform)"
+
+    # File extension for the archive (ZIP for Windows, TAR.GZ for others)
+    EXT=".tar.gz"
+    BINARY="c3-${PLATFORM}"
+    if [[ "${IS_MSYS:-false}" == true ]]; then
+        EXT=".zip"
+    fi
+
+    # Determine the download URL (latest release or specific version)
+    if [[ "$VERSION" == "latest" ]]; then
+        URL="${REPOURL%/}/releases/latest/download/${BINARY}${EXT}"
+    else
+        URL="${REPOURL%/}/releases/download/v${VERSION#v}/${BINARY}${EXT}"
+    fi
+
+    # Temporary file for the downloaded archive
+    TEMP_FILE="$(mktemp "${TMPDIR:-/tmp}/.C3_install.XXXXXXXX")"
+    trap 'rm -f "$TEMP_FILE"' EXIT  # Ensure temp file is deleted on exit
+
+    download_file() {
+        # Download the archive using curl or wget
+        # Check that the curl version is not 8.8.0, which is broken for --write-out
+        # https://github.com/curl/curl/issues/13845
+        if command -v curl >/dev/null && [[ "$(curl --version | awk 'NR==1{print $2}')" != "8.8.0" ]]; then
+            curl -SL "$URL" -o "$TEMP_FILE"
+        elif command -v wget >/dev/null; then
+            wget -O "$TEMP_FILE" "$URL"
+        else
+            echo "Error: curl or wget is required." >&2
+            exit 1
+        fi
+    }
+
+    echo "Downloading C3 ($VERSION) from $URL..."
+    download_file
+
+    # Remove existing installation and extract the new one
+    rm -rf "$BIN_DIR"
+    if [[ "$EXT" == ".zip" ]]; then
+        unzip "$TEMP_FILE" -d "$HOME"
+    else
+        tar -xzf "$TEMP_FILE" -C "$HOME"
+    fi
+
+    # Move extracted folder to installation directory
+    mv "$HOME/c3" "$BIN_DIR"
+    chmod +x "$BIN_DIR/c3c"  # Ensure compiler binary is executable
+    echo "✅ Installation completed in $BIN_DIR"
+
+    # Update PATH unless suppressed by environment variable
+    if [ -n "${C3_NO_PATH_UPDATE:-}" ]; then
+        echo "No path update because C3_NO_PATH_UPDATE is set"
+    else
+        update_shell() {
+            FILE="$1"
+            LINE="$2"
+
+            # Create shell config file if missing
+            if [ ! -f "$FILE" ]; then
+                touch "$FILE"
+            fi
+
+            # Add the PATH line if not already present
+            if ! grep -Fxq "$LINE" "$FILE"; then
+                echo "Updating '${FILE}'"
+                echo "$LINE" >>"$FILE"
+                echo "Please restart or source your shell."
+            fi
+        }
+
+        # Detect the current shell and add C3 to its PATH
+        case "$(basename "${SHELL-}")" in
+        bash)
+            # Default to bashrc as that is used in non login shells instead of the profile.
+            LINE="export PATH=\"${BIN_DIR}:\$PATH\""
+            update_shell ~/.bashrc "$LINE"
+            ;;
+        fish)
+            LINE="fish_add_path ${BIN_DIR}"
+            update_shell ~/.config/fish/config.fish "$LINE"
+            ;;
+        zsh)
+            LINE="export PATH=\"${BIN_DIR}:\$PATH\""
+            update_shell ~/.zshrc "$LINE"
+            ;;
+        tcsh)
+            LINE="set path = ( ${BIN_DIR} \$path )"
+            update_shell ~/.tcshrc "$LINE"
+            ;;
+        '')
+            echo "warn: Could not detect shell type." >&2
+            echo "      Please permanently add '${BIN_DIR}' to your \$PATH to enable the 'c3c' command." >&2
+            ;;
+        *)
+            echo "warn: Could not update shell $(basename "$SHELL")" >&2
+            echo "      Please permanently add '${BIN_DIR}' to your \$PATH to enable the 'c3c' command." >&2
+            ;;
+        esac
+    fi
+}
+__wrap__

lib/std/ascii.c3

@@ -1,77 +1,42 @@
+<* This module is scheduled for removal, use std::core::ascii *>
 module std::ascii;
 
 macro bool in_range_m(c, start, len) => (uint)(c - start) < len;
-macro bool is_lower_m(c) => in_range_m(c, 0x61, 26);
-macro bool is_upper_m(c) => in_range_m(c, 0x41, 26);
-macro bool is_digit_m(c) => in_range_m(c, 0x30, 10);
+macro bool is_lower_m(c)  => in_range_m(c, 0x61, 26);
+macro bool is_upper_m(c)  => in_range_m(c, 0x41, 26);
+macro bool is_digit_m(c)  => in_range_m(c, 0x30, 10);
 macro bool is_bdigit_m(c) => in_range_m(c, 0x30, 2);
 macro bool is_odigit_m(c) => in_range_m(c, 0x30, 8);
 macro bool is_xdigit_m(c) => in_range_m(c | 32, 0x61, 6) || is_digit_m(c);
-macro bool is_alpha_m(c) => in_range_m(c | 32, 0x61, 26);
-macro bool is_print_m(c) => in_range_m(c, 0x20, 95);
-macro bool is_graph_m(c) => in_range_m(c, 0x21, 94);
-macro bool is_space_m(c) => in_range_m(c, 0x9, 5) || c == 0x20;
-macro bool is_alnum_m(c) => is_alpha_m(c) || is_digit_m(c);
-macro bool is_punct_m(c) => !is_alnum_m(c) && is_graph_m(c);
-macro bool is_blank_m(c) => c == 0x20 || c == 0x9;
-macro bool is_cntrl_m(c) => c < 0x20 || c == 0x7f;
+macro bool is_alpha_m(c)  => in_range_m(c | 32, 0x61, 26);
+macro bool is_print_m(c)  => in_range_m(c, 0x20, 95);
+macro bool is_graph_m(c)  => in_range_m(c, 0x21, 94);
+macro bool is_space_m(c)  => in_range_m(c, 0x9, 5) || c == 0x20;
+macro bool is_alnum_m(c)  => is_alpha_m(c) || is_digit_m(c);
+macro bool is_punct_m(c)  => !is_alnum_m(c) && is_graph_m(c);
+macro bool is_blank_m(c)  => c == 0x20 || c == 0x9;
+macro bool is_cntrl_m(c)  => c < 0x20 || c == 0x7f;
 macro to_lower_m(c) => is_upper_m(c) ? c + 0x20 : c;
 macro to_upper_m(c) => is_lower_m(c) ? c - 0x20 : c;
 
 fn bool in_range(char c, char start, char len) => in_range_m(c, start, len);
-fn bool is_lower(char c) => is_lower_m(c);
-fn bool is_upper(char c) => is_upper_m(c);
-fn bool is_digit(char c) => is_digit_m(c);
-fn bool is_bdigit(char c) => is_bdigit_m(c);
-fn bool is_odigit(char c) => is_odigit_m(c);
-fn bool is_xdigit(char c) => is_xdigit_m(c);
-fn bool is_alpha(char c) => is_alpha_m(c);
-fn bool is_print(char c) => is_print_m(c);
-fn bool is_graph(char c) => is_graph_m(c);
-fn bool is_space(char c) => is_space_m(c);
-fn bool is_alnum(char c) => is_alnum_m(c);
-fn bool is_punct(char c) => is_punct_m(c);
-fn bool is_blank(char c) => is_blank_m(c);
-fn bool is_cntrl(char c) => is_cntrl_m(c);
-fn char to_lower(char c) => (char)to_lower_m(c);
-fn char to_upper(char c) => (char)to_upper_m(c);
 
 fn bool char.in_range(char c, char start, char len) => in_range_m(c, start, len);
-fn bool char.is_lower(char c) => is_lower_m(c);
-fn bool char.is_upper(char c) => is_upper_m(c);
-fn bool char.is_digit(char c) => is_digit_m(c);
-fn bool char.is_bdigit(char c) => is_bdigit_m(c);
-fn bool char.is_odigit(char c) => is_odigit_m(c);
-fn bool char.is_xdigit(char c) => is_xdigit_m(c);
-fn bool char.is_alpha(char c) => is_alpha_m(c);
-fn bool char.is_print(char c) => is_print_m(c);
-fn bool char.is_graph(char c) => is_graph_m(c);
-fn bool char.is_space(char c) => is_space_m(c);
-fn bool char.is_alnum(char c) => is_alnum_m(c);
-fn bool char.is_punct(char c) => is_punct_m(c);
-fn bool char.is_blank(char c) => is_blank_m(c);
-fn bool char.is_cntrl(char c) => is_cntrl_m(c);
-fn char char.to_lower(char c) => (char)to_lower_m(c);
-fn char char.to_upper(char c) => (char)to_upper_m(c);
-<*
- @require c.is_xdigit()
-*>
-fn char char.from_hex(char c) => c.is_digit() ? c - '0' : 10 + (c | 0x20) - 'a';
 
 fn bool uint.in_range(uint c, uint start, uint len) => in_range_m(c, start, len);
-fn bool uint.is_lower(uint c) => is_lower_m(c);
-fn bool uint.is_upper(uint c) => is_upper_m(c);
-fn bool uint.is_digit(uint c) => is_digit_m(c);
-fn bool uint.is_bdigit(uint c) => is_bdigit_m(c);
-fn bool uint.is_odigit(uint c) => is_odigit_m(c);
-fn bool uint.is_xdigit(uint c) => is_xdigit_m(c);
-fn bool uint.is_alpha(uint c) => is_alpha_m(c);
-fn bool uint.is_print(uint c) => is_print_m(c);
-fn bool uint.is_graph(uint c) => is_graph_m(c);
-fn bool uint.is_space(uint c) => is_space_m(c);
-fn bool uint.is_alnum(uint c) => is_alnum_m(c);
-fn bool uint.is_punct(uint c) => is_punct_m(c);
-fn bool uint.is_blank(uint c) => is_blank_m(c);
-fn bool uint.is_cntrl(uint c) => is_cntrl_m(c);
-fn uint uint.to_lower(uint c) => (uint)to_lower_m(c);
-fn uint uint.to_upper(uint c) => (uint)to_upper_m(c);
+fn bool uint.is_lower(uint c)  @deprecated => is_lower_m(c);
+fn bool uint.is_upper(uint c)  @deprecated => is_upper_m(c);
+fn bool uint.is_digit(uint c)  @deprecated => is_digit_m(c);
+fn bool uint.is_bdigit(uint c) @deprecated => is_bdigit_m(c);
+fn bool uint.is_odigit(uint c) @deprecated => is_odigit_m(c);
+fn bool uint.is_xdigit(uint c) @deprecated => is_xdigit_m(c);
+fn bool uint.is_alpha(uint c)  @deprecated => is_alpha_m(c);
+fn bool uint.is_print(uint c)  @deprecated => is_print_m(c);
+fn bool uint.is_graph(uint c)  @deprecated => is_graph_m(c);
+fn bool uint.is_space(uint c)  @deprecated => is_space_m(c);
+fn bool uint.is_alnum(uint c)  @deprecated => is_alnum_m(c);
+fn bool uint.is_punct(uint c)  @deprecated => is_punct_m(c);
+fn bool uint.is_blank(uint c)  @deprecated => is_blank_m(c);
+fn bool uint.is_cntrl(uint c)  @deprecated => is_cntrl_m(c);
+fn uint uint.to_lower(uint c)  @deprecated => (uint)to_lower_m(c);
+fn uint uint.to_upper(uint c)  @deprecated => (uint)to_upper_m(c);

lib/std/atomic.c3

@@ -1,9 +1,9 @@
-// Copyright (c) 2023 Eduardo José Gómez Hernández. All rights reserved.
+// Copyright (c) 2023-2025 Eduardo José Gómez Hernández. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::atomic::types(<Type>);
+module std::atomic::types;
 
-struct Atomic
+struct Atomic <Type>
 {
 	Type data;
 }
@@ -11,135 +11,130 @@ struct Atomic
 <*
  Loads data atomically, by default this uses SEQ_CONSISTENT ordering.
 
- @param ordering "The ordering, cannot be release or acquire-release."
- @require ordering != RELEASE && ordering != ACQUIRE_RELEASE : "Release and acquire-release are not valid for load"
+ @param $ordering : "The ordering, cannot be release or acquire-release."
+ @require $ordering != RELEASE && $ordering != ACQUIRE_RELEASE : "Release and acquire-release are not valid for load"
 *>
-macro Type Atomic.load(&self, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro Type Atomic.load(&self, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	switch(ordering)
-	{
-		case NOT_ATOMIC: return $$atomic_load(data, false, AtomicOrdering.NOT_ATOMIC.ordinal);
-		case UNORDERED: return $$atomic_load(data, false, AtomicOrdering.UNORDERED.ordinal);
-		case RELAXED: return $$atomic_load(data, false, AtomicOrdering.RELAXED.ordinal);
-		case ACQUIRE: return $$atomic_load(data, false, AtomicOrdering.ACQUIRE.ordinal);
-		case SEQ_CONSISTENT: return $$atomic_load(data, false, AtomicOrdering.SEQ_CONSISTENT.ordinal);
-		case ACQUIRE_RELEASE:
-		case RELEASE: unreachable("Invalid ordering.");
-	}
+	return $$atomic_load(&self.data, false, $ordering.ordinal);
 }
 <*
  Stores data atomically, by default this uses SEQ_CONSISTENT ordering.
 
- @param ordering "The ordering, cannot be acquire or acquire-release."
- @require ordering != ACQUIRE && ordering != ACQUIRE_RELEASE : "Acquire and acquire-release are not valid for store"
+ @param $ordering : "The ordering, cannot be acquire or acquire-release."
+ @require $ordering != ACQUIRE && $ordering != ACQUIRE_RELEASE : "Acquire and acquire-release are not valid for store"
 *>
-macro void Atomic.store(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro void Atomic.store(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	switch(ordering) 
-	{
-		case NOT_ATOMIC: $$atomic_store(data, value, false, AtomicOrdering.NOT_ATOMIC.ordinal);
-		case UNORDERED: $$atomic_store(data, value, false, AtomicOrdering.UNORDERED.ordinal);
-		case RELAXED: $$atomic_store(data, value, false, AtomicOrdering.RELAXED.ordinal);
-		case RELEASE: $$atomic_store(data, value, false, AtomicOrdering.RELEASE.ordinal);
-		case SEQ_CONSISTENT: $$atomic_store(data, value, false, AtomicOrdering.SEQ_CONSISTENT.ordinal);
-		case ACQUIRE_RELEASE:
-		case ACQUIRE: unreachable("Invalid ordering.");
-	}
+	$$atomic_store(&self.data, value, false, $ordering.ordinal);
 }
 
-macro Type Atomic.add(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro Type Atomic.add(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_add, data, value, ordering);
+	return atomic::fetch_add(&self.data, value, $ordering);
 }
 
-macro Type Atomic.sub(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro Type Atomic.sub(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_sub, data, value, ordering);
+	return atomic::fetch_sub(&self.data, value, $ordering);
 }
 
-macro Type Atomic.mul(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro Type Atomic.mul(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_mul, data, value, ordering);
+	return atomic::fetch_mul(&self.data, value, $ordering);
 }
 
-macro Type Atomic.div(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro Type Atomic.div(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_div, data, value, ordering);
+	return atomic::fetch_div(&self.data, value, $ordering);
 }
 
-macro Type Atomic.max(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro Type Atomic.max(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_div, data, value, ordering);
+	return atomic::fetch_max(&self.data, value, $ordering);
 }
 
-macro Type Atomic.min(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
+macro Type Atomic.min(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_min, data, value, ordering);
+	return atomic::fetch_min(&self.data, value, $ordering);
 }
 
-macro Type Atomic.or(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.or(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_or, data, value, ordering);
+	return atomic::fetch_or(&self.data, value, $ordering);
 }
 
-fn Type Atomic.xor(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.xor(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_xor, data, value, ordering);
+	return atomic::fetch_xor(&self.data, value, $ordering);
 }
 
-macro Type Atomic.and(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.and(&self, Type value, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_and, data, value, ordering);
+	return atomic::fetch_and(&self.data, value, $ordering);
 }
 
-macro Type Atomic.shift_right(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.shr(&self, Type amount, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_shift_right, data, amount, ordering);
+	return atomic::fetch_shift_right(&self.data, amount, $ordering);
 }
 
-macro Type Atomic.shift_left(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
+macro Type Atomic.shl(&self, Type amount, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) != FLOAT)
 {
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_shift_left, data, amount, ordering);
+	return atomic::fetch_shift_left(&self.data, amount, $ordering);
 }
 
-macro @atomic_exec(#func, data, value, ordering) @local
+macro Type Atomic.set(&self, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) == BOOL)
 {
-	switch(ordering) 
-	{
-		case RELAXED: return #func(data, value, RELAXED);
-		case ACQUIRE: return #func(data, value, ACQUIRE);
-		case RELEASE: return #func(data, value, RELEASE);
-		case ACQUIRE_RELEASE: return #func(data, value, ACQUIRE_RELEASE);
-		case SEQ_CONSISTENT: return #func(data, value, SEQ_CONSISTENT);
-		default: unreachable("Ordering may not be non-atomic or unordered.");
-	}
+	return atomic::flag_set(&self.data, $ordering);
+}
+
+macro Type Atomic.clear(&self, AtomicOrdering $ordering = SEQ_CONSISTENT) @if(types::flat_kind(Type) == BOOL)
+{
+	return atomic::flag_clear(&self.data, $ordering);
 }
 
 module std::atomic;
 import std::math;
 
+macro bool @is_native_atomic_value(#value) @private
+{
+	return is_native_atomic_type($typeof(#value));
+}
+
+macro bool is_native_atomic_type($Type)
+{
+	$if $Type.sizeof > void*.sizeof:
+		return false;
+	$else
+		$switch $Type.kindof:
+			$case SIGNED_INT:
+			$case UNSIGNED_INT:
+			$case POINTER:
+			$case FUNC:
+			$case FLOAT:
+			$case BOOL:
+				return true;
+			$case TYPEDEF:
+			$case CONSTDEF:
+				return is_native_atomic_type($Type.inner);
+			$default:
+				return false;
+		$endswitch
+	$endif
+}
+
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be added to ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr + y) : "+ must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_add(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
 {
@@ -150,14 +145,16 @@ macro fetch_add(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatil
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be subtracted from ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr - y) : "- must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_sub(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
 {
@@ -168,22 +165,24 @@ macro fetch_sub(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatil
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be multiplied with ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr * y) : "* must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_mul(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
 	var $load_ordering = $ordering;
 	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
 
 	$StorageType* storage_ptr = ($StorageType*)ptr;
 
@@ -193,34 +192,37 @@ macro fetch_mul(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_old_value;
 	$StorageType storage_new_value;
 
-
-	do {
+	do
+	{
 		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
 		old_value = bitcast(storage_old_value, $typeof(*ptr));
 		new_value = old_value * y;
 		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
 
 	return old_value;
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to divide ptr by."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr / y) : "/ must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_div(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
 	var $load_ordering = $ordering;
 	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
 
 	$StorageType* storage_ptr = ($StorageType*)ptr;
 
@@ -230,163 +232,89 @@ macro fetch_div(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_old_value;
 	$StorageType storage_new_value;
 	
-	do {
+	do
+	{
 		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
 		old_value = bitcast(storage_old_value, $typeof(*ptr));
 		new_value = old_value / y;
 		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
 
 	return old_value;
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to perform a bitwise or with."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr | y) : "| must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_or(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
 {
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_or(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value | storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
+	return $$atomic_fetch_or(ptr, y, $volatile, $ordering.ordinal, $alignment);
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to perform a bitwise xor with."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr ^ y) : "^ must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_xor(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
 {
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_xor(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value ^ storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
+	return $$atomic_fetch_xor(ptr, y, $volatile, $ordering.ordinal, $alignment);
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to perform a bitwise and with."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require !$alignment || math::is_power_of_2($alignment) : "Alignment must be a power of two."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr ^ y) : "& must be defined between the values."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_and(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
 {
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_and(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value & storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
+	return $$atomic_fetch_and(ptr, y, $volatile, $ordering.ordinal, $alignment);
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to shift ptr by."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::is_int($typeof(*ptr)) : "Only integer pointers may be used."
+ @require types::is_int($typeof(y)) : "The value for shift right must be an integer"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_shift_right(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
 	var $load_ordering = $ordering;
 	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
 
 	$StorageType* storage_ptr = ($StorageType*)ptr;
 
@@ -397,34 +325,38 @@ macro fetch_shift_right(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_new_value;
 	$StorageType storage_y = ($StorageType)y;
 	
-	do {
+	do
+	{
 		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
 		old_value = bitcast(storage_old_value, $typeof(*ptr));
 		new_value = storage_old_value >> storage_y;
 		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
 
 	return old_value;
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to shift ptr by."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require types::is_int($typeof(y)) "The value for or must be an int"
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::is_int($typeof(*ptr)) : "Only integer pointers may be used."
+ @require types::is_int($typeof(y)) : "The value for shift left must be an integer"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_shift_left(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
 	var $load_ordering = $ordering;
 	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
+	    $load_ordering = SEQ_CONSISTENT;
 	$endif
 	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
+	var $StorageType = types::lower_to_atomic_compatible_type($typeof(*ptr));
 
 	$StorageType* storage_ptr = ($StorageType*)ptr;
 
@@ -435,64 +367,83 @@ macro fetch_shift_left(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
 	$StorageType storage_new_value;
 	$StorageType storage_y = ($StorageType)y;
 	
-	do {
+	do
+	{
 		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
 		old_value = bitcast(storage_old_value, $typeof(*ptr));
 		new_value = storage_old_value << storage_y;
 		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
+	}
+	while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
 
 	return old_value;
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::flat_kind($typeof(*ptr)) == BOOL : "Only bool pointers may be used."
+
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro flag_set(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
 	$typeof(*ptr) old_value;
 	$typeof(*ptr) new_value = true;
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	do
+	{
+		old_value = $$atomic_load(ptr, false, $load_ordering.ordinal);
+	}
+	while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
 
-	do {
-		old_value = $$atomic_load(ptr, false, $ordering.ordinal);
-	} while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
-	
 	return old_value;
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&inout] ptr : "the variable or dereferenced pointer to the data."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require types::flat_kind($typeof(*ptr)) == BOOL : "Only bool pointers may be used."
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro flag_clear(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)
 {
 	$typeof(*ptr) old_value;
 	$typeof(*ptr) new_value = false;
-
-	do {
-		old_value = $$atomic_load(ptr, false, $ordering.ordinal);
-	} while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
+	var $load_ordering = $ordering;
+	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
+	    $load_ordering = SEQ_CONSISTENT;
+	$endif
+	do
+	{
+		old_value = $$atomic_load(ptr, false, $load_ordering.ordinal);
+	}
+	while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
 
 	return old_value;
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&in] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be compared to ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr > y) : "Only values that are comparable with > may be used"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_max(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
 {
@@ -503,13 +454,15 @@ macro fetch_max(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatil
 }
 
 <*
- @param [&in] ptr "the variable or dereferenced pointer to the data."
- @param [in] y "the value to be added to ptr."
- @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
+ @param [&in] ptr : "the variable or dereferenced pointer to the data."
+ @param [in] y : "the value to be compared to ptr."
+ @param $ordering : "atomic ordering of the load, defaults to SEQ_CONSISTENT"
  @return "returns the old value of ptr"
 
- @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
+ @require $defined(*ptr) : "Expected a pointer"
+ @require @is_native_atomic_value(*ptr) : "Only types that are native atomic may be used."
+ @require $defined(*ptr > y) : "Only values that are comparable with > may be used"
+ @require $ordering != NOT_ATOMIC && $ordering != UNORDERED : "Acquire ordering is not valid."
 *>
 macro fetch_min(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
 {

lib/std/atomic_nolibc.c3

@@ -3,8 +3,9 @@
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::atomic;
 
-macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $success, failure, $alignment) {
-	switch(failure)
+macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $success, failure, $alignment)
+{
+	switch (failure)
 	{
 		case AtomicOrdering.RELAXED.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.RELAXED.ordinal, $alignment);
 		case AtomicOrdering.ACQUIRE.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.ACQUIRE.ordinal, $alignment);
@@ -16,7 +17,7 @@ macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $succe
 
 macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, success, failure, $alignment)
 {
-	switch(success)
+	switch (success)
 	{
 		case AtomicOrdering.RELAXED.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.RELAXED.ordinal, failure, $alignment);
 		case AtomicOrdering.ACQUIRE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.ACQUIRE.ordinal, failure, $alignment);
@@ -28,7 +29,7 @@ macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, succes
 	return 0;
 }
 
-fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired, CInt success, CInt failure) @extern("__atomic_compare_exchange") @export
+fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired, CInt success, CInt failure) @weak @export("__atomic_compare_exchange")
 {
 	switch (size)
 	{
@@ -57,7 +58,7 @@ fn CInt __atomic_compare_exchange(CInt size, any ptr, any expected, any desired,
 				nextcase;
 			$endif
 		default:
-			unreachable("Unsuported size (%d) for atomic_compare_exchange", size);
+			unreachable("Unsupported size (%d) for atomic_compare_exchange", size);
 	}
 	return 0;
-}
+}

lib/std/bits.c3

@@ -1,12 +1,12 @@
 module std::bits;
 
 <*
- @require types::is_intlike($typeof(i)) `The input must be an integer or integer vector`
+ @require types::is_intlike($typeof(i)) : `The input must be an integer or integer vector`
 *>
 macro reverse(i) => $$bitreverse(i);
 
 <*
- @require types::is_intlike($typeof(i)) `The input must be an integer or integer vector`
+ @require types::is_intlike($typeof(i)) : `The input must be an integer or integer vector`
 *>
 macro bswap(i) @builtin => $$bswap(i);
 

lib/std/collections/anylist.c3

@@ -1,354 +1,103 @@
-// Copyright (c) 2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2024-2025 Christoffer Lerno. All rights reserved.
 // Use of self source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::collections::anylist;
-import std::io,std::math;
-
-def AnyPredicate = fn bool(any value);
-def AnyTest = fn bool(any type, any context);
-
-struct AnyList (Printable)
-{
-	usz size;
-	usz capacity;
-	Allocator allocator;
-	any* entries;
-}
+import std::collections::interfacelist;
 
+alias AnyPredicate = InterfacePredicate {any};
+alias AnyTest = InterfaceTest {any};
 
 <*
- Use `init` for to use a custom allocator.
+ The AnyList contains a heterogenous set of types. Anything placed in the
+ list will shallowly copied in order to be stored as an `any`. This means
+ that the list will copy and free its elements.
 
- @param initial_capacity "The initial capacity to reserve"
+ However, because we're getting `any` values back when we pop, those operations
+ need to take an allocator, as we can only copy then pop then return the copy.
+
+ If we're not doing pop, then things are easier, since we can just hand over
+ the existing any.
 *>
-fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = null)
+typedef AnyList = inline InterfaceList {any};
+
+<*
+ Return the first element by value, assuming it is the given type.
+
+ @param $Type : "The type of the first element"
+ @return "The first element"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+*>
+macro AnyList.first(&self, $Type)
 {
-	return self.init(allocator ?: allocator::heap(), initial_capacity) @inline;
+	return *anycast(self.first_any(), $Type);
 }
 
 <*
- @param [&inout] allocator "The allocator to use"
- @param initial_capacity "The initial capacity to reserve"
+ Return the first element
+
+ @return "The first element"
+ @return? NO_MORE_ELEMENT
 *>
-fn AnyList* AnyList.init(&self, Allocator allocator, usz initial_capacity = 16)
+fn any? AnyList.first_any(&self) @inline => InterfaceList {any}.first(self);
+
+<*
+ Return the last element by value, assuming it is the given type.
+
+ @param $Type : "The type of the last element"
+ @return "The last element"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+*>
+macro AnyList.last(&self, $Type)
 {
-	self.allocator = allocator;
-	self.size = 0;
-	if (initial_capacity > 0)
-	{
-		initial_capacity = math::next_power_of_2(initial_capacity);
-		self.entries = allocator::alloc_array(allocator, any, initial_capacity);
-	}
-	else
-	{
-		self.entries = null;
-	}
-	self.capacity = initial_capacity;
-	return self;
+	return *anycast(self.last_any(), $Type);
 }
 
 <*
- Initialize the list using the temp allocator.
+ Return the last element
 
- @param initial_capacity "The initial capacity to reserve"
+ @return "The last element"
+ @return? NO_MORE_ELEMENT
 *>
-fn AnyList* AnyList.temp_init(&self, usz initial_capacity = 16)
-{
-	return self.init(allocator::temp(), initial_capacity) @inline;
-}
-
-fn usz! AnyList.to_format(&self, Formatter* formatter) @dynamic
-{
-	switch (self.size)
-	{
-		case 0:
-			return formatter.print("[]")!;
-		case 1:
-			return formatter.printf("[%s]", self.entries[0])!;
-		default:
-			usz n = formatter.print("[")!;
-			foreach (i, element : self.entries[:self.size])
-			{
-				if (i != 0) formatter.print(", ")!;
-				n += formatter.printf("%s", element)!;
-			}
-			n += formatter.print("]")!;
-			return n;
-	}
-}
-
-fn String AnyList.to_new_string(&self, Allocator allocator = null) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
-}
-
-
-fn String AnyList.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String AnyList.to_tstring(&self) => string::tformat("%s", *self);
+fn any? AnyList.last_any(&self) @inline => InterfaceList {any}.last(self);
 
 <*
- Push an element on the list by cloning it.
-*>
-macro void AnyList.push(&self, element)
-{
-	if (!self.allocator) self.allocator = allocator::heap();
-	self.append_internal(allocator::clone(self.allocator, element));
-}
+ Pop a value who's type is known. If the type is incorrect, this
+ will still pop the element.
 
-fn void AnyList.append_internal(&self, any element) @local
-{
-	self.ensure_capacity();
-	self.entries[self.size++] = element;
-}
-
-<*
- Free a retained element removed using *_retained.
+ @param $Type : "The type we assume the value has"
+ @return "The last value as the type given"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
 *>
-fn void AnyList.free_element(&self, any element) @inline
+macro AnyList.pop(&self, $Type)
 {
-	allocator::free(self.allocator, element.ptr);
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.free_element(self.entries[self.size]);
+	return *anycast(self.entries[--self.size], $Type);
 }
 
 <*
  Pop a value who's type is known. If the type is incorrect, this
  will still pop the element.
 
- @return! CastResult.TYPE_MISMATCH, IteratorResult.NO_MORE_ELEMENT
-*>
-macro AnyList.pop(&self, $Type)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	return *anycast(self.entries[--self.size], $Type);
-}
-
-<*
- Pop the last value and allocate the copy using the given allocator.
- @return! IteratorResult.NO_MORE_ELEMENT
-*>
-fn any! AnyList.copy_pop(&self, Allocator allocator = allocator::heap())
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	return allocator::clone_any(allocator, self.entries[--self.size]);
-}
-
-<*
- Pop the last value and allocate the copy using the given allocator.
- @return! IteratorResult.NO_MORE_ELEMENT
- @deprecated `use copy_pop`
-*>
-fn any! AnyList.new_pop(&self, Allocator allocator = allocator::heap())
-{
-	return self.copy_pop(allocator);
-}
-
-<*
- Pop the last value and allocate the copy using the temp allocator
- @return! IteratorResult.NO_MORE_ELEMENT
- @deprecated `use tcopy_pop`
-*>
-fn any! AnyList.temp_pop(&self) => self.copy_pop(allocator::temp());
-
-<*
- Pop the last value and allocate the copy using the temp allocator
- @return! IteratorResult.NO_MORE_ELEMENT
-*>
-fn any! AnyList.tcopy_pop(&self) => self.copy_pop(allocator::temp());
-
-<*
- Pop the last value. It must later be released using list.free_element()
- @return! IteratorResult.NO_MORE_ELEMENT
-*>
-fn any! AnyList.pop_retained(&self)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	return self.entries[--self.size];
-}
-
-fn void AnyList.clear(&self)
-{
-	for (usz i = 0; i < self.size; i++)
-	{
-		self.free_element(self.entries[i]);
-	}
-	self.size = 0;
-}
-
-<*
- Same as pop() but pops the first value instead.
+ @param $Type : "The type we assume the value has"
+ @return "The first value as the type given"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
 *>
 macro AnyList.pop_first(&self, $Type)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	defer self.remove_at(0);
 	return *anycast(self.entries[0], $Type);
 }
 
 <*
- Same as pop_retained() but pops the first value instead.
-*>
-fn any! AnyList.pop_first_retained(&self)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.remove_at(0);
-	return self.entries[0];
-}
+ Return an element in the list by value, assuming it is the given type.
 
-<*
- Same as new_pop() but pops the first value instead.
- @deprecated `use copy_pop_first`
-*>
-fn any! AnyList.new_pop_first(&self, Allocator allocator = allocator::heap())
-{
-	return self.copy_pop_first(allocator) @inline;
-}
-
-<*
- Same as new_pop() but pops the first value instead.
-*>
-fn any! AnyList.copy_pop_first(&self, Allocator allocator = allocator::heap())
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	defer self.remove_at(0);
-	return allocator::clone_any(allocator, self.entries[0]);
-}
-
-<*
- Same as temp_pop() but pops the first value instead.
-*>
-fn any! AnyList.tcopy_pop_first(&self) => self.copy_pop_first(allocator::temp());
-
-<*
- Same as temp_pop() but pops the first value instead.
- @deprecated `use tcopy_pop_first`
-*>
-fn any! AnyList.temp_pop_first(&self) => self.new_pop_first(allocator::temp());
-
-<*
- @require index < self.size
-*>
-fn void AnyList.remove_at(&self, usz index)
-{
-	if (!--self.size || index == self.size) return;
-	self.free_element(self.entries[index]);
-	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
-}
-
-fn void AnyList.add_all(&self, AnyList* other_list)
-{
-	if (!other_list.size) return;
-	self.reserve(other_list.size);
-	foreach (value : other_list)
-	{
-		self.entries[self.size++] = allocator::clone_any(self.allocator, value);
-	}
-}
-
-<*
- Reverse the elements in a list.
-*>
-fn void AnyList.reverse(&self)
-{
-	if (self.size < 2) return;
-	usz half = self.size / 2U;
-	usz end = self.size - 1;
-	for (usz i = 0; i < half; i++)
-	{
-		self.swap(i, end - i);
-	}
-}
-
-fn any[] AnyList.array_view(&self)
-{
-	return self.entries[:self.size];
-}
-
-<*
- Push an element to the front of the list.
-*>
-macro void AnyList.push_front(&self, type)
-{
-	self.insert_at(0, type);
-}
-
-<*
- @require index < self.size
-*>
-macro void AnyList.insert_at(&self, usz index, type) @local
-{
-	any value = allocator::copy(self.allocator, type);
-	self.insert_at_internal(self, index, value);
-}
-
-<*
- @require index < self.size
-*>
-fn void AnyList.insert_at_internal(&self, usz index, any value) @local
-{
-	self.ensure_capacity();
-	for (usz i = self.size; i > index; i--)
-	{
-		self.entries[i] = self.entries[i - 1];
-	}
-	self.size++;
-	self.entries[index] = value;
-}
-
-
-<*
- @require self.size > 0
-*>
-fn void AnyList.remove_last(&self)
-{
-	self.free_element(self.entries[--self.size]);
-}
-
-<*
- @require self.size > 0
-*>
-fn void AnyList.remove_first(&self)
-{
-	self.remove_at(0);
-}
-
-macro AnyList.first(&self, $Type)
-{
-	return *anycast(self.first_any(), $Type);
-}
-
-fn any! AnyList.first_any(&self) @inline
-{
-	return self.size ? self.entries[0] : IteratorResult.NO_MORE_ELEMENT?;
-}
-
-macro AnyList.last(&self, $Type)
-{
-	return *anycast(self.last_any(), $Type);
-}
-
-fn any! AnyList.last_any(&self) @inline
-{
-	return self.size ? self.entries[self.size - 1] : IteratorResult.NO_MORE_ELEMENT?;
-}
-
-fn bool AnyList.is_empty(&self) @inline
-{
-	return !self.size;
-}
-
-fn usz AnyList.len(&self) @operator(len) @inline
-{
-	return self.size;
-}
-
-<*
- @require index < self.size "Index out of range"
+ @param index : "The index of the element to retrieve"
+ @param $Type : "The type of the element"
+ @return "The element at the index"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+ @require index < self.size : "Index out of range"
 *>
 macro AnyList.get(&self, usz index, $Type)
 {
@@ -356,148 +105,18 @@ macro AnyList.get(&self, usz index, $Type)
 }
 
 <*
- @require index < self.size "Index out of range"
+ Return an element in the list.
+
+ @param index : "The index of the element to retrieve"
+ @return "The element at the index"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+ @require index < self.size : "Index out of range"
 *>
-fn any AnyList.get_any(&self, usz index) @inline
-{
-	return self.entries[index];
-}
-
-fn void AnyList.free(&self)
-{
-	if (!self.allocator) return;
-	self.clear();
-	allocator::free(self.allocator, self.entries);
-	self.capacity = 0;
-	self.entries = null;
-}
-
-fn void AnyList.swap(&self, usz i, usz j)
-{
-	any temp = self.entries[i];
-	self.entries[i] = self.entries[j];
-	self.entries[j] = temp;
-}
+fn any AnyList.get_any(&self, usz index) @inline @operator([]) => InterfaceList {any}.get(self, index);
 
 <*
- @param filter "The function to determine if it should be removed or not"
- @return "the number of deleted elements"
+ Return the length of the list.
+
+ @return "The number of elements in the list"
 *>
-fn usz AnyList.remove_if(&self, AnyPredicate filter)
-{
-	return self._remove_if(filter, false);
-}
-
-<*
- @param selection "The function to determine if it should be kept or not"
- @return "the number of deleted elements"
-*>
-fn usz AnyList.retain_if(&self, AnyPredicate selection)
-{
-	return self._remove_if(selection, true);
-}
-
-macro usz AnyList._remove_if(&self, AnyPredicate filter, bool $invert) @local
-{
-	usz size = self.size;
-	for (usz i = size, usz k = size; k > 0; k = i)
-	{
-		// Find last index of item to be deleted.
-		$if $invert:
-			while (i > 0 && !filter(&self.entries[i - 1])) i--;
-		$else
-			while (i > 0 && filter(&self.entries[i - 1])) i--;
-		$endif
-		// Remove the items from this index up to the one not to be deleted.
-		usz n = self.size - k;
-		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
-		self.entries[i:n] = self.entries[k:n];
-		self.size -= k - i;
-		// Find last index of item not to be deleted.
-		$if $invert:
-			while (i > 0 && filter(&self.entries[i - 1])) i--;
-		$else
-			while (i > 0 && !filter(&self.entries[i - 1])) i--;
-		$endif
-	}
-	return size - self.size;
-}
-
-fn usz AnyList.remove_using_test(&self, AnyTest filter, any context)
-{
-	return self._remove_using_test(filter, false, context);
-}
-
-fn usz AnyList.retain_using_test(&self, AnyTest filter, any context)
-{
-	return self._remove_using_test(filter, true, context);
-}
-
-macro usz AnyList._remove_using_test(&self, AnyTest filter, bool $invert, ctx) @local
-{
-	usz size = self.size;
-	for (usz i = size, usz k = size; k > 0; k = i)
-	{
-		// Find last index of item to be deleted.
-		$if $invert:
-			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
-		$else
-			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
-		$endif
-		// Remove the items from this index up to the one not to be deleted.
-		usz n = self.size - k;
-		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
-		self.entries[i:n] = self.entries[k:n];
-		self.size -= k - i;
-		// Find last index of item not to be deleted.
-		$if $invert:
-			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
-		$else
-			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
-		$endif
-	}
-	return size - self.size;
-}
-
-<*
- Reserve at least min_capacity
-*>
-fn void AnyList.reserve(&self, usz min_capacity)
-{
-	if (!min_capacity) return;
-	if (self.capacity >= min_capacity) return;
-	if (!self.allocator) self.allocator = allocator::heap();
-	min_capacity = math::next_power_of_2(min_capacity);
-	self.entries = allocator::realloc(self.allocator, self.entries, any.sizeof * min_capacity);
-	self.capacity = min_capacity;
-}
-
-macro any AnyList.@item_at(&self, usz index) @operator([])
-{
-	return self.entries[index];
-}
-
-<*
- @require index <= self.size "Index out of range"
-*>
-macro void AnyList.set(&self, usz index, value)
-{
-	if (index == self.size)
-	{
-		self.push(value);
-		return;
-	}
-	self.free_element(self.entries[index]);
-	self.entries[index] = allocator::copy(self.allocator, value);
-}
-
-fn void AnyList.ensure_capacity(&self, usz added = 1) @inline @private
-{
-	usz new_size = self.size + added;
-	if (self.capacity >= new_size) return;
-
-	assert(new_size < usz.max / 2U);
-	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;
-	while (new_capacity < new_size) new_capacity *= 2U;
-	self.reserve(new_capacity);
-}
+fn usz AnyList.len(&self) @operator(len) @inline => InterfaceList {any}.len(self);

lib/std/collections/bitset.c3

@@ -1,18 +1,22 @@
+// Copyright (c) 2023-2025 C3 team. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
 <*
- @require SIZE > 0
+ @require SIZE > 0 : "The size of the bitset in bits must be at least 1"
 *>
-module std::collections::bitset(<SIZE>);
+module std::collections::bitset <SIZE>;
 
-def Type = uint;
-
-const BITS = Type.sizeof * 8;
+const BITS = uint.sizeof * 8;
 const SZ = (SIZE + BITS - 1) / BITS;
 
 struct BitSet
 {
-	Type[SZ] data;
+	uint[SZ] data;
 }
 
+<*
+ @return "The number of bits set"
+*>
 fn usz BitSet.cardinality(&self)
 {
 	usz n;
@@ -24,7 +28,11 @@ fn usz BitSet.cardinality(&self)
 }
 
 <*
- @require i < SIZE
+ Set a bit in the bitset.
+
+ @param i : "The index to set"
+
+ @require i < SIZE : "Index was out of range"
 *>
 fn void BitSet.set(&self, usz i)
 {
@@ -34,7 +42,86 @@ fn void BitSet.set(&self, usz i)
 }
 
 <*
- @require i < SIZE
+ Perform xor over all bits, mutating itself
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+macro BitSet BitSet.xor_self(&self, BitSet set) @operator(^=)
+{
+	foreach (i, &x : self.data) *x ^= set.data[i];
+	return *self;
+}
+
+<*
+ Perform xor over all bits, returning a new bit set.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+fn BitSet BitSet.xor(&self, BitSet set) @operator(^)
+{
+	BitSet new_set @noinit;
+	foreach (i, x : self.data) new_set.data[i] = x ^ set.data[i];
+	return new_set;
+}
+
+<*
+ Perform or over all bits, returning a new bit set.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+fn BitSet BitSet.or(&self, BitSet set) @operator(|)
+{
+	BitSet new_set @noinit;
+	foreach (i, x : self.data) new_set.data[i] = x | set.data[i];
+	return new_set;
+}
+
+<*
+ Perform or over all bits, mutating itself
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+macro BitSet BitSet.or_self(&self, BitSet set) @operator(|=)
+{
+	foreach (i, &x : self.data) *x |= set.data[i];
+	return *self;
+}
+
+<*
+ Perform & over all bits, returning a new bit set.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+fn BitSet BitSet.and(&self, BitSet set) @operator(&)
+{
+	BitSet new_set @noinit;
+	foreach (i, x : self.data) new_set.data[i] = x & set.data[i];
+	return new_set;
+}
+
+<*
+ Perform & over all bits, mutating itself.
+
+ @param set : "The bit set to xor with"
+ @return "The resulting bit set"
+*>
+macro BitSet BitSet.and_self(&self, BitSet set) @operator(&=)
+{
+	foreach (i, &x : self.data) *x &= set.data[i];
+	return *self;
+}
+
+<*
+ Unset (clear) a bit in the bitset.
+
+ @param i : "The index to set"
+
+ @require i < SIZE : "Index was out of range"
 *>
 fn void BitSet.unset(&self, usz i)
 {
@@ -44,7 +131,12 @@ fn void BitSet.unset(&self, usz i)
 }
 
 <*
- @require i < SIZE
+ Get a particular bit in the bitset
+
+ @param i : "The index of the bit"
+
+ @require i < SIZE : "Index was out of range"
+ @pure
 *>
 fn bool BitSet.get(&self, usz i) @operator([]) @inline
 {
@@ -53,13 +145,23 @@ fn bool BitSet.get(&self, usz i) @operator([]) @inline
 	return self.data[q] & (1 << r) != 0;
 }
 
+<*
+ Return the number of bits.
+
+ @pure
+*>
 fn usz BitSet.len(&self) @operator(len) @inline
 {
 	return SZ * BITS;
 }
 
 <*
- @require i < SIZE
+ Change a particular bit in the bitset
+
+ @param i : "The index of the bit"
+ @param value : "The value to set the bit to"
+
+ @require i < SIZE : "Index was out of range"
 *>
 fn void BitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline
 {
@@ -70,12 +172,12 @@ fn void BitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline
 <*
  @require Type.kindof == UNSIGNED_INT
 *>
-module std::collections::growablebitset(<Type>);
+module std::collections::growablebitset <Type>;
 import std::collections::list;
 
 const BITS = Type.sizeof * 8;
 
-def GrowableBitSetList = List(<Type>);
+alias GrowableBitSetList = List{Type};
 
 struct GrowableBitSet
 {
@@ -84,17 +186,17 @@ struct GrowableBitSet
 
 <*
  @param initial_capacity
- @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
 *>
-fn GrowableBitSet* GrowableBitSet.new_init(&self, usz initial_capacity = 1, Allocator allocator = allocator::heap())
+fn GrowableBitSet* GrowableBitSet.init(&self, Allocator allocator, usz initial_capacity = 1)
 {
-	self.data.new_init(initial_capacity, allocator);
+	self.data.init(allocator, initial_capacity);
 	return self;
 }
 
-fn GrowableBitSet* GrowableBitSet.temp_init(&self, usz initial_capacity = 1)
+fn GrowableBitSet* GrowableBitSet.tinit(&self, usz initial_capacity = 1)
 {
-	return self.new_init(initial_capacity, allocator::temp()) @inline;
+	return self.init(tmem, initial_capacity) @inline;
 }
 
 fn void GrowableBitSet.free(&self)
@@ -117,15 +219,10 @@ fn void GrowableBitSet.set(&self, usz i)
 	usz q = i / BITS;
 	usz r = i % BITS;
 	usz current_len = self.data.len();
-	if (q >= current_len)
+	while (q >= current_len)
 	{
-		usz n = q + 1;
-		self.data.reserve(n);
-		if (n - 1 >= current_len)
-		{
-			self.data.entries[current_len .. (n - 1)] = 0;
-		}
-		self.data.size = n;
+		self.data.push(0);
+		current_len++;
 	}
 	self.data.set(q, self.data[q] | (1 << r));
 }

lib/std/collections/elastic_array.c3

@@ -2,16 +2,16 @@
 // Use of self source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 <*
- @require MAX_SIZE >= 1 `The size must be at least 1 element big.`
+ @require MAX_SIZE >= 1 : `The size must be at least 1 element big.`
 *>
-module std::collections::elastic_array(<Type, MAX_SIZE>);
+module std::collections::elastic_array <Type, MAX_SIZE>;
 import std::io, std::math, std::collections::list_common;
 
-def ElementPredicate = fn bool(Type *type);
-def ElementTest = fn bool(Type *type, any context);
+alias ElementPredicate = fn bool(Type *type);
+alias ElementTest = fn bool(Type *type, any context);
 const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
 const ELEMENT_IS_POINTER = Type.kindof == POINTER;
-macro type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+macro bool type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
 
 struct ElasticArray (Printable)
 {
@@ -19,7 +19,7 @@ struct ElasticArray (Printable)
 	Type[MAX_SIZE] entries;
 }
 
-fn usz! ElasticArray.to_format(&self, Formatter* formatter) @dynamic
+fn usz? ElasticArray.to_format(&self, Formatter* formatter) @dynamic
 {
 	switch (self.size)
 	{
@@ -39,38 +39,28 @@ fn usz! ElasticArray.to_format(&self, Formatter* formatter) @dynamic
 	}
 }
 
-fn String ElasticArray.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String ElasticArray.to_new_string(&self, Allocator allocator = nul) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
-}
-
 fn String ElasticArray.to_tstring(&self)
 {
 	return string::tformat("%s", *self);
 }
 
-fn void! ElasticArray.push_try(&self, Type element) @inline
+fn void? ElasticArray.push_try(&self, Type element) @inline
 {
-	if (self.size == MAX_SIZE) return AllocationFailure.OUT_OF_MEMORY?;
+	if (self.size == MAX_SIZE) return mem::OUT_OF_MEMORY~;
 	self.entries[self.size++] = element;
 }
 
 <*
- @require self.size < MAX_SIZE `Tried to exceed the max size`
+ @require self.size < MAX_SIZE : `Tried to exceed the max size`
 *>
 fn void ElasticArray.push(&self, Type element) @inline
 {
 	self.entries[self.size++] = element;
 }
 
-fn Type! ElasticArray.pop(&self)
+fn Type? ElasticArray.pop(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	return self.entries[--self.size];
 }
 
@@ -82,9 +72,9 @@ fn void ElasticArray.clear(&self)
 <*
  @require self.size > 0
 *>
-fn Type! ElasticArray.pop_first(&self)
+fn Type? ElasticArray.pop_first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	defer self.remove_at(0);
 	return self.entries[0];
 }
@@ -131,7 +121,24 @@ fn usz ElasticArray.add_all_to_limit(&self, ElasticArray* other_list)
 
  @param [in] array
 *>
-fn usz ElasticArray.add_array_to_limit(&self, Type[] array)
+fn usz ElasticArray.add_array_to_limit(&self, Type[] array) @deprecated("Use push_all_to_limit")
+{
+	if (!array.len) return 0;
+	foreach (i, &value : array)
+	{
+		if (self.size == MAX_SIZE) return array.len - i;
+		self.entries[self.size++] = *value;
+	}
+	return 0;
+}
+
+<*
+ Add as many values from this array as possible, returning the
+ number of elements that didn't fit.
+
+ @param [in] array
+*>
+fn usz ElasticArray.push_all_to_limit(&self, Type[] array)
 {
 	if (!array.len) return 0;
 	foreach (i, &value : array)
@@ -146,10 +153,26 @@ fn usz ElasticArray.add_array_to_limit(&self, Type[] array)
  Add the values of an array to this list.
 
  @param [in] array
- @require array.len + self.size <= MAX_SIZE `Size would exceed max.`
+ @require array.len + self.size <= MAX_SIZE : `Size would exceed max.`
  @ensure self.size >= array.len
 *>
-fn void ElasticArray.add_array(&self, Type[] array)
+fn void ElasticArray.add_array(&self, Type[] array) @deprecated("Use push_all")
+{
+	if (!array.len) return;
+	foreach (&value : array)
+	{
+		self.entries[self.size++] = *value;
+	}
+}
+
+<*
+ Add the values of an array to this list.
+
+ @param [in] array
+ @require array.len + self.size <= MAX_SIZE : `Size would exceed max.`
+ @ensure self.size >= array.len
+*>
+fn void ElasticArray.push_all(&self, Type[] array)
 {
 	if (!array.len) return;
 	foreach (&value : array)
@@ -159,29 +182,12 @@ fn void ElasticArray.add_array(&self, Type[] array)
 }
 
 
-
-<*
- IMPORTANT The returned array must be freed using free_aligned.
-*>
-fn Type[] ElasticArray.to_new_aligned_array(&self)
-{
-	return list_common::list_to_new_aligned_array(Type, self, allocator::heap());
-}
-
 <*
  IMPORTANT The returned array must be freed using free_aligned.
 *>
 fn Type[] ElasticArray.to_aligned_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_aligned_array(Type, self, allocator);
-}
-
-<*
- @require !type_is_overaligned() : "This function is not available on overaligned types"
-*>
-macro Type[] ElasticArray.to_new_array(&self)
-{
-	return list_common::list_to_array(Type, self, allocator::heap());
+	return list_common::list_to_aligned_array(Type, self, allocator);
 }
 
 <*
@@ -189,15 +195,15 @@ macro Type[] ElasticArray.to_new_array(&self)
 *>
 macro Type[] ElasticArray.to_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_array(Type, self, allocator);
+	return list_common::list_to_array(Type, self, allocator);
 }
 
 fn Type[] ElasticArray.to_tarray(&self)
 {
 	$if type_is_overaligned():
-	return self.to_aligned_array(allocator::temp());
+	return self.to_aligned_array(tmem);
 	$else
-	return self.to_array(allocator::temp());
+	return self.to_array(tmem);
 	$endif;
 }
 
@@ -215,7 +221,7 @@ fn Type[] ElasticArray.array_view(&self)
 }
 
 <*
- @require self.size < MAX_SIZE `List would exceed max size`
+ @require self.size < MAX_SIZE : `List would exceed max size`
 *>
 fn void ElasticArray.push_front(&self, Type type) @inline
 {
@@ -223,9 +229,9 @@ fn void ElasticArray.push_front(&self, Type type) @inline
 }
 
 <*
- @require self.size < MAX_SIZE `List would exceed max size`
+ @require self.size < MAX_SIZE : `List would exceed max size`
 *>
-fn void! ElasticArray.push_front_try(&self, Type type) @inline
+fn void? ElasticArray.push_front_try(&self, Type type) @inline
 {
 	return self.insert_at_try(0, type);
 }
@@ -233,14 +239,14 @@ fn void! ElasticArray.push_front_try(&self, Type type) @inline
 <*
  @require index <= self.size
 *>
-fn void! ElasticArray.insert_at_try(&self, usz index, Type value)
+fn void? ElasticArray.insert_at_try(&self, usz index, Type value)
 {
-	if (self.size == MAX_SIZE) return AllocationFailure.OUT_OF_MEMORY?;
+	if (self.size == MAX_SIZE) return mem::OUT_OF_MEMORY~;
 	self.insert_at(index, value);
 }
 
 <*
- @require self.size < MAX_SIZE `List would exceed max size`
+ @require self.size < MAX_SIZE : `List would exceed max size`
  @require index <= self.size
 *>
 fn void ElasticArray.insert_at(&self, usz index, Type type)
@@ -261,27 +267,27 @@ fn void ElasticArray.set_at(&self, usz index, Type type)
 	self.entries[index] = type;
 }
 
-fn void! ElasticArray.remove_last(&self) @maydiscard
+fn void? ElasticArray.remove_last(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	self.size--;
 }
 
-fn void! ElasticArray.remove_first(&self) @maydiscard
+fn void? ElasticArray.remove_first(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	self.remove_at(0);
 }
 
-fn Type! ElasticArray.first(&self)
+fn Type? ElasticArray.first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	return self.entries[0];
 }
 
-fn Type! ElasticArray.last(&self)
+fn Type? ElasticArray.last(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	return self.entries[self.size - 1];
 }
 
@@ -311,7 +317,7 @@ fn void ElasticArray.swap(&self, usz i, usz j)
 }
 
 <*
- @param filter "The function to determine if it should be removed or not"
+ @param filter : "The function to determine if it should be removed or not"
  @return "the number of deleted elements"
 *>
 fn usz ElasticArray.remove_if(&self, ElementPredicate filter)
@@ -320,7 +326,7 @@ fn usz ElasticArray.remove_if(&self, ElementPredicate filter)
 }
 
 <*
- @param selection "The function to determine if it should be kept or not"
+ @param selection : "The function to determine if it should be kept or not"
  @return "the number of deleted elements"
 *>
 fn usz ElasticArray.retain_if(&self, ElementPredicate selection)
@@ -356,22 +362,22 @@ fn void ElasticArray.set(&self, usz index, Type value) @operator([]=)
 
 
 // Functions for equatable types
-fn usz! ElasticArray.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? ElasticArray.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
 {
 	foreach (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
-fn usz! ElasticArray.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? ElasticArray.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
 {
 	foreach_r (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
 fn bool ElasticArray.equals(&self, ElasticArray other_list) @if(ELEMENT_IS_EQUATABLE)
@@ -387,8 +393,8 @@ fn bool ElasticArray.equals(&self, ElasticArray other_list) @if(ELEMENT_IS_EQUAT
 <*
  Check for presence of a value in a list.
 
- @param [&in] self "the list to find elements in"
- @param value "The value to search for"
+ @param [&in] self : "the list to find elements in"
+ @param value : "The value to search for"
  @return "True if the value is found, false otherwise"
 *>
 fn bool ElasticArray.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
@@ -401,8 +407,8 @@ fn bool ElasticArray.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 }
 
 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
  @return "true if the value was found"
 *>
 fn bool ElasticArray.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
@@ -411,8 +417,8 @@ fn bool ElasticArray.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABL
 }
 
 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
  @return "true if the value was found"
 *>
 fn bool ElasticArray.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
@@ -421,8 +427,8 @@ fn bool ElasticArray.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATAB
 }
 
 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
  @return "the number of deleted elements."
 *>
 fn usz ElasticArray.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
@@ -452,4 +458,4 @@ fn usz ElasticArray.compact_count(&self) @if(ELEMENT_IS_POINTER)
 fn usz ElasticArray.compact(&self) @if(ELEMENT_IS_POINTER)
 {
 	return list_common::list_compact(self);
-}
+}

lib/std/collections/enummap.c3

@@ -1,11 +1,13 @@
 <*
  @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enummap"
+ @require Enum.values.len > 0 : "Only non-empty enums may be used with enummap"
 *>
-module std::collections::enummap(<Enum, ValueType>);
+module std::collections::enummap <Enum, ValueType>;
 import std::io;
+
 struct EnumMap (Printable)
 {
-	ValueType[Enum.len] values;
+	ValueType[Enum.values.len] values;
 }
 
 fn void EnumMap.init(&self, ValueType init_value)
@@ -16,33 +18,18 @@ fn void EnumMap.init(&self, ValueType init_value)
 	}
 }
 
-fn usz! EnumMap.to_format(&self, Formatter* formatter) @dynamic
+fn usz? EnumMap.to_format(&self, Formatter* formatter) @dynamic
 {
 	usz n = formatter.print("{ ")!;
 	foreach (i, &value : self.values)
 	{
 		if (i != 0) formatter.print(", ")!;
-		n += formatter.printf("%s: %s", (Enum)i, *value)!;
+		n += formatter.printf("%s: %s", Enum.from_ordinal(i), *value)!;
 	}
 	n += formatter.print(" }")!;
 	return n;
 }
 
-fn String EnumMap.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String EnumMap.to_new_string(&self, Allocator allocator = null) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
-}
-
-fn String EnumMap.to_tstring(&self) @dynamic
-{
-	return string::tformat("%s", *self);
-}
-
 <*
  @return "The total size of this map, which is the same as the number of enum values"
  @pure

lib/std/collections/enumset.c3

@@ -5,20 +5,21 @@
 <*
  @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enumset"
 *>
-module std::collections::enumset(<Enum>);
+module std::collections::enumset <Enum>;
 import std::io;
 
-def EnumSetType = $typefrom(private::type_for_enum_elements(Enum.elements)) @private;
+const ENUM_COUNT @private = Enum.values.len;
+alias EnumSetType @private = $typefrom(type_for_enum_elements(ENUM_COUNT));
 
-const IS_CHAR_ARRAY = Enum.elements > 128;
-distinct EnumSet (Printable) = EnumSetType;
+const IS_CHAR_ARRAY = ENUM_COUNT > 128;
+typedef EnumSet (Printable) = EnumSetType;
 
 fn void EnumSet.add(&self, Enum v)
 {
 	$if IS_CHAR_ARRAY:
-		(*self)[(usz)v / 8] |= (char)(1u << ((usz)v % 8));
+		(*self)[(usz)v.ordinal / 8] |= (char)(1u << ((usz)v.ordinal % 8));
 	$else
-		*self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v);
+		*self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v.ordinal);
 	$endif
 }
 
@@ -35,11 +36,11 @@ fn bool EnumSet.remove(&self, Enum v)
 {
 	$if IS_CHAR_ARRAY:
 		if (!self.has(v) @inline) return false;
-		(*self)[(usz)v / 8] &= (char)~(1u << ((usz)v % 8));
+		(*self)[(usz)v.ordinal / 8] &= (char)~(1u << ((usz)v.ordinal % 8));
 		return true;
 	$else
 		EnumSetType old = (EnumSetType)*self;
-		EnumSetType new = old & ~(1u << (EnumSetType)v);
+		EnumSetType new = old & ~(1u << (EnumSetType)v.ordinal);
 		*self = (EnumSet)new;
 		return old != new;
 	$endif
@@ -48,9 +49,9 @@ fn bool EnumSet.remove(&self, Enum v)
 fn bool EnumSet.has(&self, Enum v)
 {
 	$if IS_CHAR_ARRAY:
-		return (bool)(((*self)[(usz)v / 8] << ((usz)v % 8)) & 0x01);
+		return (bool)(((*self)[(usz)v.ordinal / 8] << ((usz)v.ordinal % 8)) & 0x01);
 	$else
-		return ((EnumSetType)*self & (1u << (EnumSetType)v)) != 0;
+		return ((EnumSetType)*self & (1u << (EnumSetType)v.ordinal)) != 0;
 	$endif
 }
 
@@ -126,7 +127,7 @@ fn EnumSet EnumSet.xor_of(&self, EnumSet s)
 	$endif
 }
 
-fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
+fn usz? EnumSet.to_format(&set, Formatter* formatter) @dynamic
 {
 	usz n = formatter.print("[")!;
 	bool found;
@@ -141,26 +142,9 @@ fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
 	return n;
 }
 
-fn String EnumSet.to_new_string(&set, Allocator allocator = allocator::heap()) @dynamic
+macro typeid type_for_enum_elements(usz $elements) @local
 {
-	return string::format("%s", *set, allocator: allocator);
-}
-
-fn String EnumSet.to_string(&set, Allocator allocator) @dynamic
-{
-	return string::format("%s", *set, allocator: allocator);
-}
-
-fn String EnumSet.to_tstring(&set) @dynamic
-{
-	return string::tformat("%s", *set);
-}
-
-module std::collections::enumset::private;
-
-macro typeid type_for_enum_elements(usz $elements)
-{
-	$switch
+	$switch:
 		$case ($elements > 128):
 			return char[($elements + 7) / 8].typeid;
 		$case ($elements > 64):

lib/std/collections/hashmap.c3

@@ -2,38 +2,48 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 <*
- @require $defined(Key{}.hash()) `No .hash function found on the key`
+ @require $defined((Key){}.hash()) : `No .hash function found on the key`
 *>
-module std::collections::map(<Key, Value>);
+module std::collections::map <Key, Value>;
 import std::math;
+import std::io @norecurse;
 
-struct HashMap
+const uint DEFAULT_INITIAL_CAPACITY = 16;
+const uint MAXIMUM_CAPACITY = 1u << 31;
+const float DEFAULT_LOAD_FACTOR = 0.75;
+const VALUE_IS_EQUATABLE = Value.is_eq;
+const bool COPY_KEYS = types::implements_copy(Key);
+
+const Allocator MAP_HEAP_ALLOCATOR = (Allocator)&dummy;
+
+const HashMap ONHEAP = { .allocator = MAP_HEAP_ALLOCATOR };
+
+struct Entry
+{
+	uint hash;
+	Key key;
+	Value value;
+	Entry* next;
+}
+
+struct HashMap (Printable)
 {
 	Entry*[] table;
 	Allocator allocator;
-	uint count; // Number of elements
-	uint threshold; // Resize limit
+	<* Last inserted LinkedEntry *>
+	uint count;
+	<* Resize limit *>
+	uint threshold;
 	float load_factor;
 }
 
-<*
- @param [&inout] allocator "The allocator to use"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require !self.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = null)
-{
-	return self.init(allocator ?: allocator::heap(), capacity, load_factor);
-}
 
 <*
- @param [&inout] allocator "The allocator to use"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require !self.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
 *>
 fn HashMap* HashMap.init(&self, Allocator allocator, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
@@ -46,47 +56,59 @@ fn HashMap* HashMap.init(&self, Allocator allocator, uint capacity = DEFAULT_INI
 }
 
 <*
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require !self.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
 *>
-fn HashMap* HashMap.temp_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+fn HashMap* HashMap.tinit(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	return self.init(allocator::temp(), capacity, load_factor) @inline;
+	return self.init(tmem, capacity, load_factor) @inline;
 }
 
 <*
- @param [&inout] allocator "The allocator to use"
- @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require !self.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @param [&inout] allocator : "The allocator to use"
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
 *>
-macro HashMap* HashMap.new_init_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+macro HashMap* HashMap.init_with_key_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	self.new_init(capacity, load_factor, allocator);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		self.set($vaarg[$i], $vaarg[$i+1]);
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i += 2:
+		self.set($vaarg[$i], $vaarg[$i + 1]);
 	$endfor
 	return self;
 }
 
 <*
- @param [in] keys "The keys for the HashMap entries"
- @param [in] values "The values for the HashMap entries"
- @param [&inout] allocator "The allocator to use"
- @require keys.len == values.len "Both keys and values arrays must be the same length"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require !self.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
 *>
-fn HashMap* HashMap.new_init_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+macro HashMap* HashMap.tinit_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_key_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] keys : "The keys for the HashMap entries"
+ @param [in] values : "The values for the HashMap entries"
+ @param [&inout] allocator : "The allocator to use"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashMap* HashMap.init_from_keys_and_values(&self, Allocator allocator, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
 	assert(keys.len == values.len);
-	self.new_init(capacity, load_factor, allocator);
+	self.init(allocator, capacity, load_factor);
 	for (usz i = 0; i < keys.len; i++)
 	{
 		self.set(keys[i], values[i]);
@@ -94,79 +116,51 @@ fn HashMap* HashMap.new_init_from_keys_and_values(&self, Key[] keys, Value[] val
 	return self;
 }
 
-<*
- @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require !self.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-macro HashMap* HashMap.temp_init_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
-{
-	self.temp_init(capacity, load_factor);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		self.set($vaarg[$i], $vaarg[$i+1]);
-	$endfor
-	return self;
-}
 
 <*
- @param [in] keys "The keys for the HashMap entries"
- @param [in] values "The values for the HashMap entries"
- @param [&inout] allocator "The allocator to use"
- @require keys.len == values.len "Both keys and values arrays must be the same length"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require !self.allocator "Map was already initialized"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ @param [in] keys : "The keys for the HashMap entries"
+ @param [in] values : "The values for the HashMap entries"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
 *>
-fn HashMap* HashMap.temp_init_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+fn HashMap* HashMap.tinit_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	assert(keys.len == values.len);
-	self.temp_init(capacity, load_factor);
-	for (usz i = 0; i < keys.len; i++)
-	{
-		self.set(keys[i], values[i]);
-	}
-	return self;
+	return self.init_from_keys_and_values(tmem, keys, values, capacity, load_factor);
 }
 
 <*
  Has this hash map been initialized yet?
 
- @param [&in] map "The hash map we are testing"
+ @param [&in] map : "The hash map we are testing"
  @return "Returns true if it has been initialized, false otherwise"
 *>
 fn bool HashMap.is_initialized(&map)
 {
-	return (bool)map.allocator;
+	return map.allocator && map.allocator.ptr != &dummy;
 }
 
 <*
- @param [&in] other_map "The map to copy from."
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_map : "The map to copy from."
+ @require !self.is_initialized() : "Map was already initialized"
 *>
-fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map)
+fn HashMap* HashMap.init_from_map(&self, Allocator allocator, HashMap* other_map)
 {
-	return self.init_from_map(other_map, allocator::heap()) @inline;
-}
-
-<*
- @param [&inout] allocator "The allocator to use"
- @param [&in] other_map "The map to copy from."
-*>
-fn HashMap* HashMap.init_from_map(&self, HashMap* other_map, Allocator allocator)
-{
-	self.new_init(other_map.table.len, other_map.load_factor, allocator);
-	self.put_all_for_create(other_map);
+	self.init(allocator, other_map.table.len, other_map.load_factor);
+	hashmap_put_all_for_create(self, other_map);
 	return self;
 }
 
 <*
- @param [&in] other_map "The map to copy from."
+ @param [&in] other_map : "The map to copy from."
+ @require !map.is_initialized() : "Map was already initialized"
 *>
-fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map)
+fn HashMap* HashMap.tinit_from_map(&map, HashMap* other_map)
 {
-	return map.init_from_map(other_map, allocator::temp()) @inline;
+	return map.init_from_map(tmem, other_map) @inline;
 }
 
 fn bool HashMap.is_empty(&map) @inline
@@ -179,31 +173,50 @@ fn usz HashMap.len(&map) @inline
 	return map.count;
 }
 
-fn Value*! HashMap.get_ref(&map, Key key)
+fn Value*? HashMap.get_ref(&map, Key key)
 {
-	if (!map.count) return SearchResult.MISSING?;
+	if (!map.count) return NOT_FOUND~;
 	uint hash = rehash(key.hash());
 	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
 	{
 		if (e.hash == hash && equals(key, e.key)) return &e.value;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
-fn Entry*! HashMap.get_entry(&map, Key key)
+fn Value* HashMap.get_or_create_ref(&map, Key key) @operator(&[])
 {
-	if (!map.count) return SearchResult.MISSING?;
+	uint hash = rehash(key.hash());
+	if (map.count)
+	{
+		for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+		{
+			if (e.hash == hash && equals(key, e.key)) return &e.value;
+		}
+	}
+	map.set(key, {});
+	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+    {
+    	if (e.hash == hash && equals(key, e.key)) return &e.value;
+    }
+	unreachable();
+}
+
+fn Entry*? HashMap.get_entry(&map, Key key)
+{
+	if (!map.count) return NOT_FOUND~;
 	uint hash = rehash(key.hash());
 	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
 	{
 		if (e.hash == hash && equals(key, e.key)) return e;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
 <*
- Get the value or update and
- @require $assignable(#expr, Value)
+ Get the value or set it to the value
+
+ @require $defined(Value val = #expr)
 *>
 macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
 {
@@ -220,11 +233,11 @@ macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
 		if (e.hash == hash && equals(key, e.key)) return e.value;
 	}
 	Value val = #expr;
-	map.add_entry(hash, key, val, index);
+	hashmap_add_entry(map, hash, key, val, index);
 	return val;
 }
 
-fn Value! HashMap.get(&map, Key key) @operator([])
+fn Value? HashMap.get(&map, Key key) @operator([])
 {
 	return *map.get_ref(key) @inline;
 }
@@ -237,9 +250,14 @@ fn bool HashMap.has_key(&map, Key key)
 fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
 {
 	// If the map isn't initialized, use the defaults to initialize it.
-	if (!map.allocator)
+	switch (map.allocator.ptr)
 	{
-		map.new_init();
+		case &dummy:
+			map.init(mem);
+		case null:
+			map.tinit();
+		default:
+			break;
 	}
 	uint hash = rehash(key.hash());
 	uint index = index_for(hash, map.table.len);
@@ -251,13 +269,13 @@ fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
 			return true;
 		}
 	}
-	map.add_entry(hash, key, value, index);
+	hashmap_add_entry(map, hash, key, value, index);
 	return false;
 }
 
-fn void! HashMap.remove(&map, Key key) @maydiscard
+fn void? HashMap.remove(&map, Key key) @maydiscard
 {
-	if (!map.remove_entry_for_key(key)) return SearchResult.MISSING?;
+	if (!hashmap_remove_entry_for_key(map, key)) return NOT_FOUND~;
 }
 
 fn void HashMap.clear(&map)
@@ -272,9 +290,9 @@ fn void HashMap.clear(&map)
 		{
 			Entry *to_delete = next;
 			next = next.next;
-			map.free_entry(to_delete);
+			hashmap_free_entry(map, to_delete);
 		}
-		map.free_entry(entry);
+		hashmap_free_entry(map, entry);
 		*entry_ref = null;
 	}
 	map.count = 0;
@@ -282,37 +300,24 @@ fn void HashMap.clear(&map)
 
 fn void HashMap.free(&map)
 {
-	if (!map.allocator) return;
+	if (!map.is_initialized()) return;
 	map.clear();
-	map.free_internal(map.table.ptr);
+	hashmap_free_internal(map, map.table.ptr);
 	map.table = {};
 }
 
-fn Key[] HashMap.tcopy_keys(&map)
+fn Key[] HashMap.tkeys(&self)
 {
-	return map.copy_keys(allocator::temp()) @inline;
+	return self.keys(tmem) @inline;
 }
 
-fn Key[] HashMap.key_tlist(&map) @deprecated("Use 'tcopy_keys'")
+fn Key[] HashMap.keys(&self, Allocator allocator)
 {
-	return map.copy_keys(allocator::temp()) @inline;
-}
+	if (!self.count) return {};
 
-<*
- @deprecated "use copy_keys"
-*>
-fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())
-{
-	return map.copy_keys(allocator) @inline;
-}
-
-fn Key[] HashMap.copy_keys(&map, Allocator allocator = allocator::heap())
-{
-	if (!map.count) return {};
-
-	Key[] list = allocator::alloc_array(allocator, Key, map.count);
+	Key[] list = allocator::alloc_array(allocator, Key, self.count);
 	usz index = 0;
-	foreach (Entry* entry : map.table)
+	foreach (Entry* entry : self.table)
 	{
 		while (entry)
 		{
@@ -329,53 +334,33 @@ fn Key[] HashMap.copy_keys(&map, Allocator allocator = allocator::heap())
 
 macro HashMap.@each(map; @body(key, value))
 {
-	map.@each_entry(; Entry* entry) {
+	map.@each_entry(; Entry* entry)
+	{
 		@body(entry.key, entry.value);
 	};
 }
 
 macro HashMap.@each_entry(map; @body(entry))
 {
-	if (map.count)
+	if (!map.count) return;
+	foreach (Entry* entry : map.table)
 	{
-		foreach (Entry* entry : map.table)
+		while (entry)
 		{
-			while (entry)
-			{
-				@body(entry);
-				entry = entry.next;
-			}
+			@body(entry);
+			entry = entry.next;
 		}
 	}
 }
 
-<*
- @deprecated `use tcopy_values`
-*>
-fn Value[] HashMap.value_tlist(&map)
-{
-	return map.copy_values(allocator::temp()) @inline;
-}
+fn Value[] HashMap.tvalues(&self) => self.values(tmem) @inline;
 
-fn Value[] HashMap.tcopy_values(&map)
+fn Value[] HashMap.values(&self, Allocator allocator)
 {
-	return map.copy_values(allocator::temp()) @inline;
-}
-
-<*
- @deprecated `use copy_values`
-*>
-fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())
-{
-	return map.copy_values(allocator);
-}
-
-fn Value[] HashMap.copy_values(&map, Allocator allocator = allocator::heap())
-{
-	if (!map.count) return {};
-	Value[] list = allocator::alloc_array(allocator, Value, map.count);
+	if (!self.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, self.count);
 	usz index = 0;
-	foreach (Entry* entry : map.table)
+	foreach (Entry* entry : self.table)
 	{
 		while (entry)
 		{
@@ -400,9 +385,24 @@ fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
 	return false;
 }
 
+fn HashMapIterator HashMap.iter(&self)
+{
+	return { .map = self, .index = -1 };
+}
+
+fn HashMapValueIterator HashMap.value_iter(&self)
+{
+	return { .map = self, .index = -1 };
+}
+
+fn HashMapKeyIterator HashMap.key_iter(&self)
+{
+	return { .map = self, .index = -1 };
+}
+
 // --- private methods
 
-fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
+fn void hashmap_add_entry(HashMap* map, uint hash, Key key, Value value, uint bucket_index) @private
 {
 	$if COPY_KEYS:
 	key = key.copy(map.allocator);
@@ -411,11 +411,11 @@ fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_ind
 	map.table[bucket_index] = entry;
 	if (map.count++ >= map.threshold)
 	{
-		map.resize(map.table.len * 2);
+		hashmap_resize(map, map.table.len * 2);
 	}
 }
 
-fn void HashMap.resize(&map, uint new_capacity) @private
+fn void hashmap_resize(HashMap* map, uint new_capacity) @private
 {
 	Entry*[] old_table = map.table;
 	uint old_capacity = old_table.len;
@@ -425,13 +425,25 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 		return;
 	}
 	Entry*[] new_table = allocator::new_array(map.allocator, Entry*, new_capacity);
-	map.transfer(new_table);
+	hashmap_transfer(map, new_table);
 	map.table = new_table;
-	map.free_internal(old_table.ptr);
+	hashmap_free_internal(map, old_table.ptr);
 	map.threshold = (uint)(new_capacity * map.load_factor);
 }
 
-fn void HashMap.transfer(&map, Entry*[] new_table) @private
+fn usz? HashMap.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each_entry(; Entry* entry)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s: %s", entry.key, entry.value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void hashmap_transfer(HashMap* map, Entry*[] new_table) @private
 {
 	Entry*[] src = map.table;
 	uint new_capacity = new_table.len;
@@ -450,17 +462,20 @@ fn void HashMap.transfer(&map, Entry*[] new_table) @private
 	}
 }
 
-fn void HashMap.put_all_for_create(&map, HashMap* other_map) @private
+fn void hashmap_put_all_for_create(HashMap* map, HashMap* other_map) @private
 {
 	if (!other_map.count) return;
 	foreach (Entry *e : other_map.table)
 	{
-		if (!e) continue;
-		map.put_for_create(e.key, e.value);
+		while (e)
+		{
+			hashmap_put_for_create(map, e.key, e.value);
+			e = e.next;
+		}
 	}
 }
 
-fn void HashMap.put_for_create(&map, Key key, Value value) @private
+fn void hashmap_put_for_create(HashMap* map, Key key, Value value) @private
 {
 	uint hash = rehash(key.hash());
 	uint i = index_for(hash, map.table.len);
@@ -472,16 +487,17 @@ fn void HashMap.put_for_create(&map, Key key, Value value) @private
 			return;
 		}
 	}
-	map.create_entry(hash, key, value, i);
+	hashmap_create_entry(map, hash, key, value, i);
 }
 
-fn void HashMap.free_internal(&map, void* ptr) @inline @private
+fn void hashmap_free_internal(HashMap* map, void* ptr) @inline @private
 {
 	allocator::free(map.allocator, ptr);
 }
 
-fn bool HashMap.remove_entry_for_key(&map, Key key) @private
+fn bool hashmap_remove_entry_for_key(HashMap* map, Key key) @private
 {
+	if (!map.count) return false;
 	uint hash = rehash(key.hash());
 	uint i = index_for(hash, map.table.len);
 	Entry* prev = map.table[i];
@@ -500,7 +516,7 @@ fn bool HashMap.remove_entry_for_key(&map, Key key) @private
 			{
 				prev.next = next;
 			}
-			map.free_entry(e);
+			hashmap_free_entry(map, e);
 			return true;
 		}
 		prev = e;
@@ -509,7 +525,7 @@ fn bool HashMap.remove_entry_for_key(&map, Key key) @private
 	return false;
 }
 
-fn void HashMap.create_entry(&map, uint hash, Key key, Value value, int bucket_index) @private
+fn void hashmap_create_entry(HashMap* map, uint hash, Key key, Value value, int bucket_index) @private
 {
 	Entry *e = map.table[bucket_index];
 	$if COPY_KEYS:
@@ -520,11 +536,75 @@ fn void HashMap.create_entry(&map, uint hash, Key key, Value value, int bucket_i
 	map.count++;
 }
 
-fn void HashMap.free_entry(&self, Entry *entry) @local
+fn void hashmap_free_entry(HashMap* map, Entry *entry) @local
 {
 	$if COPY_KEYS:
-	allocator::free(self.allocator, entry.key);
+	allocator::free(map.allocator, entry.key);
 	$endif
-	self.free_internal(entry);
+	hashmap_free_internal(map, entry);
 }
 
+
+struct HashMapIterator
+{
+	HashMap* map;
+	int top_index;
+	int index;
+	Entry* current_entry;
+}
+
+typedef HashMapValueIterator = HashMapIterator;
+typedef HashMapKeyIterator = HashMapIterator;
+
+
+<*
+ @require idx < self.map.count
+*>
+fn Entry HashMapIterator.get(&self, usz idx) @operator([])
+{
+	if (idx < self.index)
+	{
+		self.top_index = 0;
+		self.current_entry = null;
+		self.index = -1;
+	}
+	while (self.index != idx)
+	{
+		if (self.current_entry)
+		{
+			self.current_entry = self.current_entry.next;
+			if (self.current_entry) self.index++;
+			continue;
+		}
+		self.current_entry = self.map.table[self.top_index++];
+		if (self.current_entry) self.index++;
+	}
+	return *self.current_entry;
+}
+
+fn Value HashMapValueIterator.get(&self, usz idx) @operator([])
+{
+	return ((HashMapIterator*)self).get(idx).value;
+}
+
+fn Key HashMapKeyIterator.get(&self, usz idx) @operator([])
+{
+	return ((HashMapIterator*)self).get(idx).key;
+}
+
+fn usz HashMapValueIterator.len(self) @operator(len) => self.map.count;
+fn usz HashMapKeyIterator.len(self) @operator(len) => self.map.count;
+fn usz HashMapIterator.len(self) @operator(len) => self.map.count;
+
+fn uint rehash(uint hash) @inline @private
+{
+	hash ^= (hash >> 20) ^ (hash >> 12);
+	return hash ^ ((hash >> 7) ^ (hash >> 4));
+}
+
+macro uint index_for(uint hash, uint capacity) @private
+{
+	return hash & (capacity - 1);
+}
+
+int dummy @local;

lib/std/collections/hashset.c3

@@ -0,0 +1,654 @@
+<*
+ @require $defined((Value){}.hash()) : `No .hash function found on the value`
+*>
+module std::collections::set <Value>;
+import std::math;
+import std::io @norecurse;
+
+const uint DEFAULT_INITIAL_CAPACITY = 16;
+const uint MAXIMUM_CAPACITY = 1u << 31;
+const float DEFAULT_LOAD_FACTOR = 0.75;
+
+const Allocator SET_HEAP_ALLOCATOR = (Allocator)&dummy;
+
+<* Copy the ONHEAP allocator to initialize to a set that is heap allocated *>
+const HashSet ONHEAP = { .allocator = SET_HEAP_ALLOCATOR };
+
+struct Entry
+{
+	uint hash;
+	Value value;
+	Entry* next;
+}
+
+struct HashSet (Printable)
+{
+	Entry*[] table;
+	Allocator allocator;
+	<* Number of elements *>
+	usz count;
+	<* Resize limit *>
+	usz threshold;
+	float load_factor;
+}
+
+fn usz HashSet.len(&self) @operator(len) => self.count;
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.init(&self, Allocator allocator, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.threshold = (usz) (capacity * load_factor);
+	self.load_factor = load_factor;
+	self.table = allocator::new_array(allocator, Entry*, capacity);
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.tinit(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(tmem, capacity, load_factor) @inline;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro HashSet* HashSet.init_with_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i++:
+		self.add($vaarg[$i]);
+	$endfor
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro HashSet* HashSet.tinit_with_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] values : "The values for the HashSet"
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.init_from_values(&self, Allocator allocator, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	foreach (v : values) self.add(v);
+	return self;
+}
+
+<*
+ @param [in] values : "The values for the HashSet entries"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn HashSet* HashSet.tinit_from_values(&self, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_from_values(tmem, values, capacity, load_factor);
+}
+
+<*
+ Has this hash set been initialized yet?
+
+ @param [&in] set : "The hash set we are testing"
+ @return "Returns true if it has been initialized, false otherwise"
+*>
+fn bool HashSet.is_initialized(&set)
+{
+	return set.allocator && set.allocator.ptr != &dummy;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_set : "The set to copy from."
+ @require !self.is_initialized() : "Set was already initialized"
+*>
+fn HashSet* HashSet.init_from_set(&self, Allocator allocator, HashSet* other_set)
+{
+	self.init(allocator, other_set.table.len, other_set.load_factor);
+	hashset_put_all_for_create(self, other_set);
+	return self;
+}
+
+<*
+ @param [&in] other_set : "The set to copy from."
+ @require !set.is_initialized() : "Set was already initialized"
+*>
+fn HashSet* HashSet.tinit_from_set(&set, HashSet* other_set)
+{
+	return set.init_from_set(tmem, other_set) @inline;
+}
+
+<*
+ Check if the set is empty
+
+ @return "true if it is empty"
+ @pure
+*>
+fn bool HashSet.is_empty(&set) @inline
+{
+	return !set.count;
+}
+
+<*
+ Add all elements in the slice to the set.
+
+ @param [in] list
+ @return "The number of new elements added"
+ @ensure total <= list.len
+*>
+fn usz HashSet.add_all(&set, Value[] list)
+{
+	usz total;
+	foreach (v : list)
+	{
+		if (set.add(v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other
+ @return "The number of new elements added"
+ @ensure return <= other.count
+*>
+fn usz HashSet.add_all_from(&set, HashSet* other)
+{
+	usz total;
+	other.@each(;Value value)
+	{
+		if (set.add(value)) total++;
+	};
+	return total;
+}
+
+<*
+ @param value : "The value to add"
+ @return "true if the value didn't exist in the set"
+*>
+fn bool HashSet.add(&set, Value value)
+{
+	// If the set isn't initialized, use the defaults to initialize it.
+	switch (set.allocator.ptr)
+	{
+		case &dummy:
+			set.init(mem);
+		case null:
+			set.tinit();
+		default:
+			break;
+	}
+	uint hash = rehash(value.hash());
+	uint index = index_for(hash, set.table.len);
+	for (Entry *e = set.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return false;
+	}
+	hashset_add_entry(set, hash, value, index);
+	return true;
+}
+
+<*
+ Iterate over all the values in the set
+*>
+macro HashSet.@each(set; @body(value))
+{
+	if (!set.count) return;
+	foreach (Entry* entry : set.table)
+	{
+		while (entry)
+		{
+			@body(entry.value);
+			entry = entry.next;
+		}
+	}
+}
+
+<*
+ Check if the set contains the given value.
+
+ @param value : "The value to check"
+ @return "true if it exists in the set"
+*>
+fn bool HashSet.contains(&set, Value value)
+{
+	if (!set.count) return false;
+	uint hash = rehash(value.hash());
+	for (Entry *e = set.table[index_for(hash, set.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return true;
+	}
+	return false;
+}
+
+<*
+ Remove a single value from the set.
+
+ @param value : "The value to remove"
+ @return? NOT_FOUND : "If the entry is not found"
+*>
+fn void? HashSet.remove(&set, Value value) @maydiscard
+{
+	if (!hashset_remove_entry_for_value(set, value)) return NOT_FOUND~;
+}
+
+fn usz HashSet.remove_all(&set, Value[] values)
+{
+	usz total;
+	foreach (v : values)
+	{
+		if (hashset_remove_entry_for_value(set, v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other : "Other set"
+*>
+fn usz HashSet.remove_all_from(&set, HashSet* other)
+{
+	usz total;
+	other.@each(;Value val)
+    {
+		if (hashset_remove_entry_for_value(set, val)) total++;
+    };
+    return total;
+}
+
+<*
+ Free all memory allocated by the hash set.
+*>
+fn void HashSet.free(&set)
+{
+	if (!set.is_initialized()) return;
+	set.clear();
+	hashset_free_internal(set, set.table.ptr);
+	*set = {};
+}
+
+<*
+ Clear all elements from the set while keeping the underlying storage
+
+ @ensure set.count == 0
+*>
+fn void HashSet.clear(&set)
+{
+	if (!set.count) return;
+
+	foreach (Entry** &entry_ref : set.table)
+	{
+		Entry* entry = *entry_ref;
+		if (!entry) continue;
+
+		Entry *next = entry.next;
+		while (next)
+		{
+			Entry *to_delete = next;
+			next = next.next;
+			hashset_free_entry(set, to_delete);
+		}
+
+		hashset_free_entry(set, entry);
+		*entry_ref = null;
+	}
+	set.count = 0;
+}
+
+fn void HashSet.reserve(&set, usz capacity)
+{
+	if (capacity > set.threshold)
+	{
+		hashset_resize(set, math::next_power_of_2(capacity));
+	}
+}
+
+fn Value[] HashSet.tvalues(&self) => self.values(tmem) @inline;
+
+fn Value[] HashSet.values(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, self.count);
+	usz index = 0;
+	foreach (Entry* entry : self.table)
+	{
+		while (entry)
+		{
+			list[index++] = entry.value;
+			entry = entry.next;
+		}
+	}
+	return list;
+}
+
+// --- Set Operations ---
+
+<*
+ Returns the union of two sets (A | B)
+
+ @param [&in] other : "The other set to union with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the union of both sets"
+*>
+fn HashSet HashSet.set_union(&self, Allocator allocator, HashSet* other)
+{
+	usz new_capacity = math::next_power_of_2(self.count + other.count);
+	HashSet result;
+	result.init(allocator, new_capacity, self.load_factor);
+	result.add_all_from(self);
+	result.add_all_from(other);
+	return result;
+}
+
+fn HashSet HashSet.tset_union(&self, HashSet* other) => self.set_union(tmem, other);
+
+<*
+ Returns the intersection of the two sets (A & B)
+
+ @param [&in] other : "The other set to intersect with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the intersection of both sets"
+*>
+fn HashSet HashSet.intersection(&self, Allocator allocator, HashSet* other)
+{
+	HashSet result;
+	result.init(allocator, math::min(self.table.len, other.table.len), self.load_factor);
+
+	// Iterate through the smaller set for efficiency
+	HashSet* smaller = self.count <= other.count ? self : other;
+	HashSet* larger = self.count > other.count ? self : other;
+
+	smaller.@each(;Value value)
+	{
+		if (larger.contains(value)) result.add(value);
+	};
+
+	return result;
+}
+
+fn HashSet HashSet.tintersection(&self, HashSet* other) => self.intersection(tmem, other);
+
+<*
+ Return this set - other, so (A & ~B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set but not in the other"
+*>
+fn HashSet HashSet.difference(&self, Allocator allocator, HashSet* other)
+{
+	HashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	self.@each(;Value value)
+	{
+		if (!other.contains(value))
+		{
+			result.add(value);
+		}
+	};
+	return result;
+}
+
+fn HashSet HashSet.tdifference(&self, HashSet* other) => self.difference(tmem, other) @inline;
+
+<*
+ Return (A ^ B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set or the other, but not both"
+*>
+fn HashSet HashSet.symmetric_difference(&self, Allocator allocator, HashSet* other)
+{
+	HashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	result.add_all_from(self);
+	other.@each(;Value value)
+	{
+		if (!result.add(value))
+		{
+			result.remove(value);
+		}
+	};
+	return result;
+}
+
+fn HashSet HashSet.tsymmetric_difference(&self, HashSet* other) => self.symmetric_difference(tmem, other) @inline;
+
+<*
+ Check if this hash set is a subset of another set.
+
+ @param [&in] other : "The other set to check against"
+ @return "True if all elements of this set are in the other set"
+*>
+fn bool HashSet.is_subset(&self, HashSet* other)
+{
+	if (self.count == 0) return true;
+	if (self.count > other.count) return false;
+
+	self.@each(;Value value)
+	{
+		if (!other.contains(value)) return false;
+	};
+	return true;
+}
+
+
+// --- private methods
+
+fn void hashset_add_entry(HashSet* set, uint hash, Value value, uint bucket_index) @private
+{
+	Entry* entry = allocator::new(set.allocator, Entry, { .hash = hash, .value = value, .next = set.table[bucket_index] });
+	set.table[bucket_index] = entry;
+	if (set.count++ >= set.threshold)
+	{
+		hashset_resize(set, set.table.len * 2);
+	}
+}
+
+fn void hashset_resize(HashSet* self, usz new_capacity) @private
+{
+	Entry*[] old_table = self.table;
+	usz old_capacity = old_table.len;
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		self.threshold = uint.max;
+		return;
+	}
+	Entry*[] new_table = allocator::new_array(self.allocator, Entry*, new_capacity);
+	hashset_transfer(self, new_table);
+	self.table = new_table;
+	hashset_free_internal(self, old_table.ptr);
+	self.threshold = (uint)(new_capacity * self.load_factor);
+}
+
+fn usz? HashSet.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each(; Value value)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s", value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void hashset_transfer(HashSet* self, Entry*[] new_table) @private
+{
+	Entry*[] src = self.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, Entry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			Entry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void hashset_put_all_for_create(HashSet* set, HashSet* other_set) @private
+{
+	if (!other_set.count) return;
+	foreach (Entry *e : other_set.table)
+	{
+		while (e)
+		{
+			hashset_put_for_create(set, e.value);
+			e = e.next;
+		}
+	}
+}
+
+fn void hashset_put_for_create(HashSet* set, Value value) @private
+{
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	for (Entry *e = set.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value))
+		{
+			// Value already exists, no need to do anything
+			return;
+		}
+	}
+	hashset_create_entry(set, hash, value, i);
+}
+
+fn void hashset_free_internal(HashSet* self, void* ptr) @inline @private
+{
+	allocator::free(self.allocator, ptr);
+}
+
+fn void hashset_create_entry(HashSet* set, uint hash, Value value, int bucket_index) @private
+{
+	Entry* entry = allocator::new(set.allocator, Entry, {
+		.hash = hash,
+		.value = value,
+		.next = set.table[bucket_index]
+	});
+	set.table[bucket_index] = entry;
+	set.count++;
+}
+
+<*
+ Removes the entry for the specified value if present
+ @return "true if found and removed, false otherwise"
+*>
+fn bool hashset_remove_entry_for_value(HashSet* set, Value value) @private
+{
+	if (!set.count) return false;
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	Entry* prev = set.table[i];
+	Entry* e = prev;
+	while (e)
+	{
+		Entry *next = e.next;
+		if (e.hash == hash && equals(value, e.value))
+		{
+			set.count--;
+			if (prev == e)
+			{
+				set.table[i] = next;
+			}
+			else
+			{
+				prev.next = next;
+			}
+			hashset_free_entry(set, e);
+			return true;
+		}
+		prev = e;
+		e = next;
+	}
+
+	return false;
+}
+
+fn void hashset_free_entry(HashSet* set, Entry *entry) @private
+{
+	allocator::free(set.allocator, entry);
+}
+
+struct HashSetIterator
+{
+	HashSet* set;
+	usz bucket_index;
+	Entry* current;
+}
+
+fn HashSetIterator HashSet.iter(&set) => { .set = set, .bucket_index = 0, .current = null };
+
+fn Value? HashSetIterator.next(&self)
+{
+	if (self.current)
+	{
+		Value value = self.current.value;
+		self.current = self.current.next;
+		return value;
+	}
+
+	while (self.bucket_index < self.set.table.len)
+	{
+		self.current = self.set.table[self.bucket_index++];
+		if (self.current)
+		{
+			Value value = self.current.value;
+			self.current = self.current.next;
+			return value;
+		}
+	}
+
+	return NOT_FOUND~;
+}
+
+fn usz HashSetIterator.len(&self) @operator(len)
+{
+	return self.set.count;
+}
+
+<* @pure *>
+fn uint rehash(uint hash) @inline @private
+{
+	hash ^= (hash >> 20) ^ (hash >> 12);
+	return hash ^ ((hash >> 7) ^ (hash >> 4));
+}
+
+macro uint index_for(uint hash, uint capacity) @private => hash & (capacity - 1);
+
+int dummy @local;

lib/std/collections/interfacelist.c3

@@ -0,0 +1,539 @@
+// Copyright (c) 2024-2025 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+<*
+ @require Type.kindof == INTERFACE || Type.kindof == ANY : "The kind of an interfacelist must be an interface or `any`"
+*>
+module std::collections::interfacelist <Type>;
+import std::io,std::math;
+
+alias InterfacePredicate = fn bool(Type value);
+alias InterfaceTest = fn bool(Type type, Type context);
+
+<*
+ The InterfaceList contains a heterogenous set of types implementing an interface. anything placed in the
+ list will shallowly copied in order to be stored as the interface. This means
+ that the list will copy and free its elements.
+
+ However, because we're getting interface values back when we pop, those operations
+ need to take an allocator, as we can only copy then pop then return the copy.
+
+ If we're not doing pop, then things are easier, since we can just hand over
+ the existing value.
+*>
+struct InterfaceList (Printable)
+{
+	usz size;
+	usz capacity;
+	Allocator allocator;
+	Type* entries;
+}
+
+
+<*
+ Initialize the list. If not initialized then it will use the temp allocator
+ when something is pushed to it.
+
+ @param [&inout] allocator : "The allocator to use"
+ @param initial_capacity : "The initial capacity to reserve, defaults to 16"
+*>
+fn InterfaceList* InterfaceList.init(&self, Allocator allocator, usz initial_capacity = 16)
+{
+	self.allocator = allocator;
+	self.size = 0;
+	if (initial_capacity > 0)
+	{
+		initial_capacity = math::next_power_of_2(initial_capacity);
+		self.entries = allocator::alloc_array(allocator, Type, initial_capacity);
+	}
+	else
+	{
+		self.entries = null;
+	}
+	self.capacity = initial_capacity;
+	return self;
+}
+
+<*
+ Initialize the list using the temp allocator.
+
+ @param initial_capacity : "The initial capacity to reserve"
+*>
+fn InterfaceList* InterfaceList.tinit(&self, usz initial_capacity = 16)
+{
+	return self.init(tmem, initial_capacity) @inline;
+}
+
+fn bool InterfaceList.is_initialized(&self) @inline => self.allocator != null;
+
+<*
+ Push an element on the list by cloning it.
+ @require $defined(Type t = &element) : "Element must implement the interface"
+*>
+macro void InterfaceList.push(&self, element)
+{
+	if (!self.allocator) self.allocator = tmem;
+	interfacelist_append(self, allocator::clone(self.allocator, element));
+}
+
+<*
+ Free a retained element removed using *_retained.
+*>
+fn void InterfaceList.free_element(&self, Type element) @inline
+{
+	allocator::free(self.allocator, element.ptr);
+}
+
+<*
+ Copy the last value, pop it and return the copy of it.
+
+ @param [&inout] allocator : "The allocator to use for copying"
+ @return "A copy of the last value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.copy_pop(&self, Allocator allocator)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.free_element(self.entries[self.size]);
+	return (Type)allocator::clone_any(allocator, self.entries[--self.size]);
+}
+
+<*
+ Copy the last value, pop it and return the copy of it.
+
+ @return "A temp copy of the last value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.tcopy_pop(&self) => self.copy_pop(tmem);
+
+<*
+ Pop the last value. It must later be released using `list.free_element()`.
+
+ @return "The last value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.pop_retained(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	return self.entries[--self.size];
+}
+
+<*
+ Remove all elements in the list.
+*>
+fn void InterfaceList.clear(&self)
+{
+	for (usz i = 0; i < self.size; i++)
+	{
+		self.free_element(self.entries[i]);
+	}
+	self.size = 0;
+}
+
+<*
+ Pop the first value. It must later be released using `list.free_element()`.
+
+ @return "The first value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.pop_first_retained(&self)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.remove_at(0);
+	return self.entries[0];
+}
+
+<*
+ Copy the first value, pop it and return the copy of it.
+
+ @param [&inout] allocator : "The allocator to use for copying"
+ @return "A copy of the first value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.copy_pop_first(&self, Allocator allocator)
+{
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer self.free_element(self.entries[self.size]);
+	defer self.remove_at(0);
+	return (Type)allocator::clone_any(allocator, self.entries[0]);
+}
+
+<*
+ Copy the first value, pop it and return the temp copy of it.
+
+ @return "A temp copy of the first value if it exists"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.tcopy_pop_first(&self) => self.copy_pop_first(tmem);
+
+<*
+ Remove the element at the particular index.
+
+ @param index : "The index of the element to remove"
+ @require index < self.size
+*>
+fn void InterfaceList.remove_at(&self, usz index)
+{
+	if (!--self.size || index == self.size) return;
+	self.free_element(self.entries[index]);
+	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
+}
+
+<*
+ Add all the elements in another InterfaceList.
+
+ @param [&in] other_list : "The list to add"
+*>
+fn void InterfaceList.add_all(&self, InterfaceList* other_list)
+{
+	if (!other_list.size) return;
+	self.reserve(other_list.size);
+	foreach (value : other_list)
+	{
+		self.entries[self.size++] = (Type)allocator::clone_any(self.allocator, value);
+	}
+}
+
+<*
+ Reverse the order of the elements in the list.
+*>
+fn void InterfaceList.reverse(&self)
+{
+	if (self.size < 2) return;
+	usz half = self.size / 2U;
+	usz end = self.size - 1;
+	for (usz i = 0; i < half; i++)
+	{
+		self.swap(i, end - i);
+	}
+}
+
+<*
+ Return a view of the data as a slice.
+
+ @return "The slice view"
+*>
+fn Type[] InterfaceList.array_view(&self)
+{
+	return self.entries[:self.size];
+}
+
+<*
+ Push an element to the front of the list.
+
+ @param value : "The value to push to the list"
+ @require $defined(Type t = &value) : "Value must implement the interface"
+*>
+macro void InterfaceList.push_front(&self, value)
+{
+	self.insert_at(0, value);
+}
+
+<*
+ Insert an element at a particular index.
+
+ @param index : "the index where the element should be inserted"
+ @param type : "the value to insert"
+ @require index <= self.size : "The index is out of bounds"
+ @require $defined(Type t = &type) : "Type must implement the interface"
+*>
+macro void InterfaceList.insert_at(&self, usz index, type)
+{
+	if (index == self.size)
+	{
+		self.push(type);
+		return;
+	}
+	Type value = allocator::clone(self.allocator, type);
+	self._insert_at(self, index, value);
+}
+
+<*
+ Remove the last element in the list. The list may not be empty.
+
+ @require self.size > 0 : "The list was already empty"
+*>
+fn void InterfaceList.remove_last(&self)
+{
+	self.free_element(self.entries[--self.size]);
+}
+
+<*
+ Remove the first element in the list, the list may not be empty.
+
+ @require self.size > 0
+*>
+fn void InterfaceList.remove_first(&self)
+{
+	self.remove_at(0);
+}
+
+<*
+ Return the first element
+
+ @return "The first element"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.first(&self) @inline
+{
+	return self.size ? self.entries[0] : NO_MORE_ELEMENT~;
+}
+
+<*
+ Return the last element
+
+ @return "The last element"
+ @return? NO_MORE_ELEMENT
+*>
+fn Type? InterfaceList.last(&self) @inline
+{
+	return self.size ? self.entries[self.size - 1] : NO_MORE_ELEMENT~;
+}
+
+<*
+ Return whether the list is empty.
+
+ @return "True if the list is empty"
+*>
+fn bool InterfaceList.is_empty(&self) @inline
+{
+	return !self.size;
+}
+
+<*
+ Return the length of the list.
+
+ @return "The number of elements in the list"
+*>
+fn usz InterfaceList.len(&self) @operator(len) @inline
+{
+	return self.size;
+}
+
+<*
+ Return an element in the list.
+
+ @param index : "The index of the element to retrieve"
+ @return "The element at the index"
+ @return? TYPE_MISMATCH, NO_MORE_ELEMENT
+ @require index < self.size : "Index out of range"
+*>
+fn Type InterfaceList.get(&self, usz index) @inline @operator([])
+{
+	return self.entries[index];
+}
+
+<*
+ Completely free and clear a list.
+*>
+fn void InterfaceList.free(&self)
+{
+	if (!self.allocator) return;
+	self.clear();
+	allocator::free(self.allocator, self.entries);
+	self.capacity = 0;
+	self.entries = null;
+}
+
+<*
+ Swap two elements in a list.
+
+ @param i : "Index of one of the elements"
+ @param j : "Index of the other element"
+ @require i < self.size : "The first index is out of range"
+ @require j < self.size : "The second index is out of range"
+*>
+fn void InterfaceList.swap(&self, usz i, usz j)
+{
+	Type temp = self.entries[i];
+	self.entries[i] = self.entries[j];
+	self.entries[j] = temp;
+}
+
+<*
+ Print the list to a formatter.
+*>
+fn usz? InterfaceList.to_format(&self, Formatter* formatter) @dynamic
+{
+	switch (self.size)
+	{
+		case 0:
+			return formatter.print("[]")!;
+		case 1:
+			return formatter.printf("[%s]", self.entries[0])!;
+		default:
+			usz n = formatter.print("[")!;
+			foreach (i, element : self.entries[:self.size])
+			{
+				if (i != 0) formatter.print(", ")!;
+				n += formatter.printf("%s", element)!;
+			}
+			n += formatter.print("]")!;
+			return n;
+	}
+}
+
+<*
+ Remove Type elements matching the predicate.
+
+ @param filter : "The function to determine if it should be removed or not"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.remove_if(&self, InterfacePredicate filter)
+{
+	return interfacelist_remove_if(self, filter, false);
+}
+
+<*
+ Retain the elements matching the predicate.
+
+ @param selection : "The function to determine if it should be kept or not"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.retain_if(&self, InterfacePredicate selection)
+{
+	return interfacelist_remove_if(self, selection, true);
+}
+
+<*
+ Remove Type elements matching the predicate.
+
+ @param filter : "The function to determine if it should be removed or not"
+ @param context : "The context to the function"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.remove_using_test(&self, InterfaceTest filter, Type context)
+{
+	return interfacelist_remove_using_test(self, filter, false, context);
+}
+
+<*
+ Retain Type elements matching the predicate.
+
+ @param selection : "The function to determine if it should be retained or not"
+ @param context : "The context to the function"
+ @return "the number of deleted elements"
+*>
+fn usz InterfaceList.retain_using_test(&self, InterfaceTest selection, Type context)
+{
+	return interfacelist_remove_using_test(self, selection, true, context);
+}
+
+<*
+ Reserve memory so that at least the `min_capacity` exists.
+
+ @param min_capacity : "The min capacity to hold"
+*>
+fn void InterfaceList.reserve(&self, usz min_capacity)
+{
+	if (!min_capacity) return;
+	if (self.capacity >= min_capacity) return;
+	if (!self.allocator) self.allocator = tmem;
+	min_capacity = math::next_power_of_2(min_capacity);
+	self.entries = allocator::realloc(self.allocator, self.entries, Type.sizeof * min_capacity);
+	self.capacity = min_capacity;
+}
+
+<*
+ Set the element at Type index.
+
+ @param index : "The index where to set the value."
+ @param value : "The value to set"
+ @require index <= self.size : "Index out of range"
+ @require $defined(Type t = &value) : "Value must implement the interface"
+*>
+macro void InterfaceList.set(&self, usz index, value)
+{
+	if (index == self.size)
+	{
+		self.push(value);
+		return;
+	}
+	self.free_element(self.entries[index]);
+	self.entries[index] = allocator::clone(self.allocator, value);
+}
+
+// -- private
+
+fn void interfacelist_ensure_capacity(InterfaceList* self, usz added = 1) @inline @private
+{
+	usz new_size = self.size + added;
+	if (self.capacity >= new_size) return;
+
+	assert(new_size < usz.max / 2U);
+	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;
+	while (new_capacity < new_size) new_capacity *= 2U;
+	self.reserve(new_capacity);
+}
+
+fn void interfacelist_append(InterfaceList* self, Type element) @local
+{
+	interfacelist_ensure_capacity(self);
+	self.entries[self.size++] = element;
+}
+
+<*
+ @require index < self.size
+*>
+fn void interfacelist_insert_at(InterfaceList* self, usz index, Type value) @local
+{
+	interfacelist_ensure_capacity(self);
+	for (usz i = self.size; i > index; i--)
+	{
+		self.entries[i] = self.entries[i - 1];
+	}
+	self.size++;
+	self.entries[index] = value;
+}
+
+macro usz interfacelist_remove_using_test(InterfaceList* self, InterfaceTest filter, bool $invert, ctx) @local
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && filter(self.entries[i - 1], ctx)) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && !filter(self.entries[i - 1], ctx)) i--;
+		$endif
+	}
+	return size - self.size;
+}
+
+macro usz interfacelist_remove_if(InterfaceList* self, InterfacePredicate filter, bool $invert) @local
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && filter(self.entries[i - 1])) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && !filter(self.entries[i - 1])) i--;
+		$endif
+	}
+	return size - self.size;
+}

lib/std/collections/linked_blockingqueue.c3

@@ -0,0 +1,333 @@
+module std::collections::blockingqueue <Value>;
+import std::thread, std::time;
+
+
+const INITIAL_CAPACITY = 16;
+
+struct QueueEntry 
+{
+	Value value;
+	<* Next in queue order *>
+	QueueEntry* next;
+	<* Previous in queue order *>
+	QueueEntry* prev;
+}
+
+struct LinkedBlockingQueue 
+{
+	<* First element in queue *>
+	QueueEntry* head;
+	<* Last element in queue *>
+	QueueEntry* tail;
+	<* Current number of elements *>
+	usz count;
+	<* Maximum capacity (0 for unbounded) *>
+	usz capacity;
+	Mutex lock;
+	ConditionVariable not_empty;
+	ConditionVariable not_full;
+	Allocator allocator;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param capacity : "Maximum capacity (0 for unbounded)"
+ @require !self.is_initialized() : "Queue was already initialized"
+*>
+fn LinkedBlockingQueue* LinkedBlockingQueue.init(&self, Allocator allocator, usz capacity = 0)
+{
+	self.allocator = allocator;
+	self.capacity = capacity;
+	self.count = 0;
+	self.head = null;
+	self.tail = null;
+
+	self.lock.init()!!;
+	self.not_empty.init()!!;
+	self.not_full.init()!!;
+	return self;
+}
+
+fn LinkedBlockingQueue* LinkedBlockingQueue.tinit(&self, usz capacity = 0)
+{
+	return self.init(tmem, capacity) @inline;
+}
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+*>
+fn void LinkedBlockingQueue.free(&self)
+{
+	self.lock.@in_lock()
+	{
+		// Free all remaining entries
+		QueueEntry* entry = self.head;
+		while (entry != null)
+		{
+			QueueEntry* next = entry.next;
+			allocator::free(self.allocator, entry);
+			entry = next;
+		}
+	};
+
+	self.lock.destroy();
+	self.not_empty.destroy();
+	self.not_full.destroy();
+}
+
+fn void linkedblockingqueue_link_entry(LinkedBlockingQueue* self, QueueEntry* entry) @private
+{
+	entry.next = null;
+	entry.prev = self.tail;
+
+	if (self.tail == null)
+	{
+		// First element in queue
+		self.head = entry;
+	}
+	else
+	{
+		// Append to tail
+		self.tail.next = entry;
+	}
+	self.tail = entry;
+	self.count++;
+}
+
+
+fn QueueEntry* linkedblockingqueue_unlink_head(LinkedBlockingQueue* self) @private
+{
+	if (self.head == null) return null;
+
+	QueueEntry* entry = self.head;
+	self.head = entry.next;
+
+	if (self.head != null)
+	{
+		self.head.prev = null;
+	}
+	else
+	{
+		// Queue is now empty
+		self.tail = null;
+	}
+
+	self.count--;
+	return entry;
+}
+
+<*
+ @param value : "Value to add to the queue"
+ @require self.is_initialized() : "Queue must be initialized"
+*>
+fn void LinkedBlockingQueue.push(&self, Value value)
+{
+	self.lock.@in_lock()
+	{
+		while (self.capacity > 0 && self.count >= self.capacity)
+		{
+			self.not_full.wait(&self.lock);
+		}
+
+		QueueEntry* entry = allocator::new(self.allocator, QueueEntry, {
+			.value = value,
+			.next = null,
+			.prev = null
+		});
+		linkedblockingqueue_link_entry(self, entry);
+
+		// Signal that queue is no longer empty
+		self.not_empty.signal();
+	};
+}
+
+<*
+ Get a value from the queue, blocking if there is no element in the queue.
+
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The removed value"
+*>
+fn Value LinkedBlockingQueue.poll(&self)
+{
+	self.lock.@in_lock()
+	{
+		while (self.count == 0)
+		{
+			self.not_empty.wait(&self.lock);
+		}
+
+		QueueEntry* entry = linkedblockingqueue_unlink_head(self);
+		Value value = entry.value;
+		allocator::free(self.allocator, entry);
+		if (self.capacity > 0)
+		{
+			self.not_full.signal();
+		}
+		return value;
+	};
+}
+
+<*
+ Pop an element from the queue, fail is it is empty.
+
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The removed value"
+ @return? NO_MORE_ELEMENT : "If the queue is empty"
+*>
+fn Value? LinkedBlockingQueue.pop(&self)
+{
+	self.lock.@in_lock()
+	{
+		if (self.count == 0) return NO_MORE_ELEMENT~;
+
+		QueueEntry* entry = linkedblockingqueue_unlink_head(self);
+		Value value = entry.value;
+		allocator::free(self.allocator, entry);
+
+		if (self.capacity > 0)
+		{
+			self.not_full.signal();
+		}
+		return value;
+	};
+}
+
+<*
+ Poll with a timeout.
+
+ @param timeout : "Timeout in microseconds"
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The removed value or null if timeout occurred"
+ @return? NO_MORE_ELEMENT : "If we reached the timeout"
+*>
+fn Value? LinkedBlockingQueue.poll_timeout(&self, Duration timeout)
+{
+	self.lock.@in_lock()
+	{
+		// Use while loop to handle spurious wakeups
+		if (!self.count)
+		{
+			Time start = time::now();
+			Time end = start + timeout;
+			while (!self.count)
+			{
+        		if (end <= time::now()) break;
+        		if (catch self.not_empty.wait_until(&self.lock, end)) break;
+			}
+			if (!self.count) return NO_MORE_ELEMENT~;
+		}
+
+		QueueEntry* entry = linkedblockingqueue_unlink_head(self);
+		Value value = entry.value;
+		allocator::free(self.allocator, entry);
+
+		// Must signal not_full after removing an item
+		if (self.capacity > 0)
+		{
+			self.not_full.signal();
+		}
+		return value;
+	};
+}
+
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "Current size of the queue"
+*>
+fn usz LinkedBlockingQueue.size(&self)
+{
+	self.lock.@in_lock()
+	{
+		return self.count;
+	};
+}
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "True if queue is empty"
+*>
+fn bool LinkedBlockingQueue.is_empty(&self)
+{
+	self.lock.@in_lock()
+	{
+		return self.count == 0;
+	};
+}
+
+<*
+ Try to push, return CAPACITY_EXCEEDED if the queue is full.
+
+ @param value : "Value to add to the queue"
+ @require self.is_initialized() : "Queue must be initialized"
+ @return? CAPACITY_EXCEEDED : "If the queue is full"
+*>
+fn void? LinkedBlockingQueue.try_push(&self, Value value)
+{
+	self.lock.@in_lock()
+	{
+		if (self.capacity > 0 && self.count >= self.capacity) return CAPACITY_EXCEEDED~;
+
+		QueueEntry* entry = allocator::new(self.allocator, QueueEntry, {
+			.value = value,
+			.next = null,
+			.prev = null
+		});
+		linkedblockingqueue_link_entry(self, entry);
+		self.not_empty.signal();
+	};
+}
+
+<*
+ Try to push, return CAPACITY_EXCEEDED if the queue is still full after timeout is reached.
+
+ @param value : "Value to add to the queue"
+ @param timeout : "Timeout in microseconds"
+ @require self.is_initialized() : "Queue must be initialized"
+ @return? CAPACITY_EXCEEDED : "If the queue is full"
+*>
+fn void? LinkedBlockingQueue.push_timeout(&self, Value value, Duration timeout)
+{
+	self.lock.@in_lock()
+	{
+		if (self.capacity > 0 && self.count >= self.capacity)
+		{
+			Time start = time::now();
+			Time end = start + timeout;
+        	while (self.capacity > 0 && self.count >= self.capacity)
+			{
+        		if (end <= time::now()) break;
+				if (catch self.not_empty.wait_until(&self.lock, end)) break;
+			}
+			if (self.capacity > 0 && self.count >= self.capacity) return CAPACITY_EXCEEDED~;
+		}
+
+		QueueEntry* entry = allocator::new(self.allocator, QueueEntry, {
+			.value = value,
+			.next = null,
+			.prev = null
+		});
+		linkedblockingqueue_link_entry(self, entry);
+		self.not_empty.signal();
+	};
+}
+
+<*
+ @require self.is_initialized() : "Queue must be initialized"
+ @return "The head value or NO_MORE_ELEMENT~ if queue is empty"
+*>
+fn Value? LinkedBlockingQueue.peek(&self)
+{
+	self.lock.@in_lock()
+	{
+		return (self.head != null) ? self.head.value : NO_MORE_ELEMENT~;
+	};
+}
+
+<*
+ @return "True if queue is initialized"
+*>
+fn bool LinkedBlockingQueue.is_initialized(&self)
+{
+	return self.allocator && self.lock.initialized;
+}

lib/std/collections/linked_hashmap.c3

@@ -0,0 +1,651 @@
+// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+<*
+ @require $defined((Key){}.hash()) : `No .hash function found on the key`
+*>
+module std::collections::map <Key, Value>;
+import std::math;
+import std::io @norecurse;
+
+const LinkedHashMap LINKEDONHEAP = { .allocator = MAP_HEAP_ALLOCATOR };
+
+struct LinkedEntry
+{
+	uint hash;
+	Key key;
+	Value value;
+	<* For bucket chain *>
+	LinkedEntry* next;
+	<* Previous in insertion order *>
+	LinkedEntry* before;
+	<* Next in insertion order *>
+	LinkedEntry* after;
+}
+
+struct LinkedHashMap (Printable)
+{
+	LinkedEntry*[] table;
+	Allocator allocator;
+	usz count;
+	usz threshold;
+	float load_factor;
+	<* First inserted LinkedEntry *>
+	LinkedEntry* head;
+	<* Last inserted LinkedEntry *>
+	LinkedEntry* tail;
+}
+
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.init(&self, Allocator allocator, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.load_factor = load_factor;
+	self.threshold = (usz)(capacity * load_factor);
+	self.table = allocator::new_array(allocator, LinkedEntry*, capacity);
+	self.head = null;
+	self.tail = null;
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.tinit(&self, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(tmem, capacity, load_factor) @inline;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashMap* LinkedHashMap.init_with_key_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i += 2:
+		self.set($vaarg[$i], $vaarg[$i + 1]);
+	$endfor
+	return self;
+}
+
+<*
+ @require $vacount % 2 == 0 : "There must be an even number of arguments provided for keys and values"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashMap* LinkedHashMap.tinit_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_key_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] keys : "The keys for the LinkedHashMap entries"
+ @param [in] values : "The values for the LinkedHashMap entries"
+ @param [&inout] allocator : "The allocator to use"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.init_from_keys_and_values(&self, Allocator allocator, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	assert(keys.len == values.len);
+	self.init(allocator, capacity, load_factor);
+	for (usz i = 0; i < keys.len; i++)
+	{
+		self.set(keys[i], values[i]);
+	}
+	return self;
+}
+
+<*
+ @param [in] keys : "The keys for the LinkedHashMap entries"
+ @param [in] values : "The values for the LinkedHashMap entries"
+ @require keys.len == values.len : "Both keys and values arrays must be the same length"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Map was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashMap* LinkedHashMap.tinit_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_from_keys_and_values(tmem, keys, values, capacity, load_factor);
+}
+
+<*
+ Has this hash map been initialized yet?
+
+ @param [&in] map : "The hash map we are testing"
+ @return "Returns true if it has been initialized, false otherwise"
+*>
+fn bool LinkedHashMap.is_initialized(&map)
+{
+	return map.allocator && map.allocator.ptr != &dummy;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_map : "The map to copy from."
+ @require !self.is_initialized() : "Map was already initialized"
+*>
+fn LinkedHashMap* LinkedHashMap.init_from_map(&self, Allocator allocator, LinkedHashMap* other_map)
+{
+	self.init(allocator, other_map.table.len, other_map.load_factor);
+	linkedhashmap_put_all_for_create(self, other_map);
+	return self;
+}
+
+<*
+ @param [&in] other_map : "The map to copy from."
+ @require !map.is_initialized() : "Map was already initialized"
+*>
+fn LinkedHashMap* LinkedHashMap.tinit_from_map(&map, LinkedHashMap* other_map)
+{
+	return map.init_from_map(tmem, other_map) @inline;
+}
+
+fn bool LinkedHashMap.is_empty(&map) @inline
+{
+	return !map.count;
+}
+
+fn usz LinkedHashMap.len(&map) @inline => map.count;
+
+fn Value*? LinkedHashMap.get_ref(&map, Key key)
+{
+	if (!map.count) return NOT_FOUND~;
+	uint hash = rehash(key.hash());
+	for (LinkedEntry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return &e.value;
+	}
+	return NOT_FOUND~;
+}
+
+fn LinkedEntry*? LinkedHashMap.get_entry(&map, Key key)
+{
+	if (!map.count) return NOT_FOUND~;
+	uint hash = rehash(key.hash());
+	for (LinkedEntry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e;
+	}
+	return NOT_FOUND~;
+}
+
+<*
+ Get the value or set it to the value
+
+ @require $defined(Value val = #expr)
+*>
+macro Value LinkedHashMap.@get_or_set(&map, Key key, Value #expr)
+{
+	if (!map.count)
+	{
+		Value val = #expr;
+		map.set(key, val);
+		return val;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (LinkedEntry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e.value;
+	}
+	Value val = #expr;
+	map.add_entry(hash, key, val, index);
+	return val;
+}
+
+fn Value? LinkedHashMap.get(&map, Key key) @operator([]) => *map.get_ref(key) @inline;
+
+fn bool LinkedHashMap.has_key(&map, Key key) => @ok(map.get_ref(key));
+
+fn bool LinkedHashMap.set(&map, Key key, Value value) @operator([]=)
+{
+	// If the map isn't initialized, use the defaults to initialize it.
+	switch (map.allocator.ptr)
+	{
+		case &dummy:
+			map.init(mem);
+		case null:
+			map.tinit();
+		default:
+			break;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (LinkedEntry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return true;
+		}
+	}
+	linkedhashmap_add_entry(map, hash, key, value, index);
+	return false;
+}
+
+fn void? LinkedHashMap.remove(&map, Key key) @maydiscard
+{
+	if (!linkedhashmap_remove_entry_for_key(map, key)) return NOT_FOUND~;
+}
+
+fn void LinkedHashMap.clear(&map)
+{
+	if (!map.count) return;
+
+	LinkedEntry* entry = map.head;
+	while (entry)
+	{
+		LinkedEntry* next = entry.after;
+		linkedhashmap_free_entry(map, entry);
+		entry = next;
+	}
+
+	foreach (LinkedEntry** &bucket : map.table)
+	{
+		*bucket = null;
+	}
+
+	map.count = 0;
+	map.head = null;
+	map.tail = null;
+}
+
+fn void LinkedHashMap.free(&map)
+{
+	if (!map.is_initialized()) return;
+	map.clear();
+	linkedhashmap_free_internal(map, map.table.ptr);
+	map.table = {};
+}
+
+fn Key[] LinkedHashMap.tkeys(&self)
+{
+	return self.keys(tmem) @inline;
+}
+
+fn Key[] LinkedHashMap.keys(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+
+	Key[] list = allocator::alloc_array(allocator, Key, self.count);
+	usz index = 0;
+
+	LinkedEntry* entry = self.head;
+	while (entry)
+	{
+		$if COPY_KEYS:
+			list[index++] = entry.key.copy(allocator);
+		$else
+			list[index++] = entry.key;
+		$endif
+		entry = entry.after;
+	}
+	return list;
+}
+
+macro LinkedHashMap.@each(map; @body(key, value))
+{
+	map.@each_entry(; LinkedEntry* entry)
+	{
+		@body(entry.key, entry.value);
+	};
+}
+
+macro LinkedHashMap.@each_entry(map; @body(entry))
+{
+	LinkedEntry* entry = map.head;
+	while (entry)
+	{
+		@body(entry);
+		entry = entry.after;
+	}
+}
+
+fn Value[] LinkedHashMap.tvalues(&map) => map.values(tmem) @inline;
+
+fn Value[] LinkedHashMap.values(&self, Allocator allocator)
+{
+	if (!self.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, self.count);
+	usz index = 0;
+	LinkedEntry* entry = self.head;
+	while (entry)
+	{
+		list[index++] = entry.value;
+		entry = entry.after;
+	}
+	return list;
+}
+
+fn bool LinkedHashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
+{
+	if (!map.count) return false;
+
+	LinkedEntry* entry = map.head;
+	while (entry)
+	{
+		if (equals(v, entry.value)) return true;
+		entry = entry.after;
+	}
+	return false;
+}
+
+fn LinkedHashMapIterator LinkedHashMap.iter(&self) => { .map = self, .current = self.head, .started = false };
+
+fn LinkedHashMapValueIterator LinkedHashMap.value_iter(&self) => { .map = self, .current = self.head, .started = false };
+
+fn LinkedHashMapKeyIterator LinkedHashMap.key_iter(&self) => { .map = self, .current = self.head, .started = false };
+
+fn bool LinkedHashMapIterator.next(&self)
+{
+	if (!self.started)
+	{
+		self.current = self.map.head;
+		self.started = true;
+	}
+	else if (self.current)
+	{
+		self.current = self.current.after;
+	}
+	return self.current != null;
+}
+
+fn LinkedEntry*? LinkedHashMapIterator.get(&self)
+{
+	return self.current ? self.current : NOT_FOUND~;
+}
+
+fn Value*? LinkedHashMapValueIterator.get(&self)
+{
+	return self.current ? &self.current.value : NOT_FOUND~;
+}
+
+fn Key*? LinkedHashMapKeyIterator.get(&self)
+{
+	return self.current ? &self.current.key : NOT_FOUND~;
+}
+
+fn bool LinkedHashMapIterator.has_next(&self)
+{
+	if (!self.started) return self.map.head != null;
+	return self.current && self.current.after != null;
+}
+
+// --- private methods
+
+fn void linkedhashmap_add_entry(LinkedHashMap* map, uint hash, Key key, Value value, uint bucket_index) @private
+{
+	$if COPY_KEYS:
+	key = key.copy(map.allocator);
+	$endif
+
+	LinkedEntry* entry = allocator::new(map.allocator, LinkedEntry, {
+		.hash = hash,
+		.key = key,
+		.value = value,
+		.next = map.table[bucket_index],
+		.before = map.tail,
+		.after = null
+	});
+
+	// Update bucket chain
+	map.table[bucket_index] = entry;
+
+	// Update linked list
+	if (map.tail)
+	{
+		map.tail.after = entry;
+		entry.before = map.tail;
+	}
+	else
+	{
+		map.head = entry;
+	}
+	map.tail = entry;
+
+	if (map.count++ >= map.threshold)
+	{
+		linkedhashmap_resize(map, map.table.len * 2);
+	}
+}
+
+fn void linkedhashmap_resize(LinkedHashMap* map, uint new_capacity) @private
+{
+	LinkedEntry*[] old_table = map.table;
+	uint old_capacity = old_table.len;
+
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		map.threshold = uint.max;
+		return;
+	}
+
+	LinkedEntry*[] new_table = allocator::new_array(map.allocator, LinkedEntry*, new_capacity);
+	map.table = new_table;
+	map.threshold = (uint)(new_capacity * map.load_factor);
+
+	// Rehash all entries - linked list order remains unchanged
+	foreach (uint i, LinkedEntry *e : old_table)
+	{
+		if (!e) continue;
+
+		// Split the bucket chain into two chains based on new bit
+		LinkedEntry* lo_head = null;
+		LinkedEntry* lo_tail = null;
+		LinkedEntry* hi_head = null;
+		LinkedEntry* hi_tail = null;
+
+		do
+		{
+			LinkedEntry* next = e.next;
+			if ((e.hash & old_capacity) == 0)
+			{
+				if (!lo_tail)
+				{
+					lo_head = e;
+				}
+				else
+				{
+					lo_tail.next = e;
+				}
+				lo_tail = e;
+			}
+			else
+			{
+				if (!hi_tail)
+				{
+					hi_head = e;
+				}
+				else
+				{
+					hi_tail.next = e;
+				}
+				hi_tail = e;
+			}
+			e.next = null;
+			e = next;
+		}
+		while (e);
+
+		if (lo_tail)
+		{
+			lo_tail.next = null;
+			new_table[i] = lo_head;
+		}
+		if (hi_tail)
+		{
+			hi_tail.next = null;
+			new_table[i + old_capacity] = hi_head;
+		}
+	}
+
+	linkedhashmap_free_internal(map, old_table.ptr);
+}
+
+fn usz? LinkedHashMap.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each_entry(; LinkedEntry* entry)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s: %s", entry.key, entry.value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void linkedhashmap_transfer(LinkedHashMap* map, LinkedEntry*[] new_table) @private
+{
+	LinkedEntry*[] src = map.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, LinkedEntry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			LinkedEntry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void linkedhashmap_put_all_for_create(LinkedHashMap* map, LinkedHashMap* other_map) @private
+{
+	if (!other_map.count) return;
+	other_map.@each(; Key key, Value value) {
+		map.set(key, value);
+	};
+}
+
+fn void linkedhashmap_put_for_create(LinkedHashMap* map, Key key, Value value) @private
+{
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	for (LinkedEntry *e = map.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return;
+		}
+	}
+	linkedhashmap_create_entry(map, hash, key, value, i);
+}
+
+fn void linkedhashmap_free_internal(LinkedHashMap* map, void* ptr) @inline @private
+{
+	allocator::free(map.allocator, ptr);
+}
+
+fn bool linkedhashmap_remove_entry_for_key(LinkedHashMap* map, Key key) @private
+{
+	if (!map.count) return false;
+
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	LinkedEntry* prev = null;
+	LinkedEntry* e = map.table[i];
+
+	while (e)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			if (prev)
+			{
+				prev.next = e.next;
+			}
+			else
+			{
+				map.table[i] = e.next;
+			}
+
+			if (e.before)
+			{
+				e.before.after = e.after;
+			}
+			else
+			{
+				map.head = e.after;
+			}
+
+			if (e.after)
+			{
+				e.after.before = e.before;
+			}
+			else
+			{
+				map.tail = e.before;
+			}
+
+			map.count--;
+			linkedhashmap_free_entry(map, e);
+			return true;
+		}
+		prev = e;
+		e = e.next;
+	}
+	return false;
+}
+
+fn void linkedhashmap_create_entry(LinkedHashMap* map, uint hash, Key key, Value value, int bucket_index) @private
+{
+	LinkedEntry *e = map.table[bucket_index];
+	$if COPY_KEYS:
+		key = key.copy(map.allocator);
+	$endif
+	LinkedEntry* entry = allocator::new(map.allocator, LinkedEntry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
+	map.table[bucket_index] = entry;
+	map.count++;
+}
+
+fn void linkedhashmap_free_entry(LinkedHashMap* self, LinkedEntry *entry) @local
+{
+	$if COPY_KEYS:
+		allocator::free(self.allocator, entry.key);
+	$endif
+	linkedhashmap_free_internal(self, entry);
+}
+
+
+struct LinkedHashMapIterator
+{
+	LinkedHashMap* map;
+	LinkedEntry* current;
+	bool started;
+}
+
+typedef LinkedHashMapValueIterator = inline LinkedHashMapIterator;
+typedef LinkedHashMapKeyIterator = inline LinkedHashMapIterator;
+
+fn usz LinkedHashMapValueIterator.len(self) @operator(len) => self.map.count;
+fn usz LinkedHashMapKeyIterator.len(self) @operator(len) => self.map.count;
+fn usz LinkedHashMapIterator.len(self) @operator(len) => self.map.count;
+
+int dummy @local;

lib/std/collections/linked_hashset.c3

@@ -0,0 +1,730 @@
+<*
+ @require $defined((Value){}.hash()) : `No .hash function found on the value`
+*>
+module std::collections::set <Value>;
+import std::math;
+import std::io @norecurse;
+
+const LinkedHashSet LINKEDONHEAP = { .allocator = SET_HEAP_ALLOCATOR };
+
+struct LinkedEntry
+{
+	uint hash;
+	Value value;
+	<* For bucket chain *>
+	LinkedEntry* next;
+	<* Previous in insertion order *>
+	LinkedEntry* before;
+	<* Next in insertion order *>
+	LinkedEntry* after;
+}
+
+struct LinkedHashSet (Printable)
+{
+	LinkedEntry*[] table;
+	Allocator allocator;
+	<* Number of elements *>
+	usz count;
+	<* Resize limit *>
+	usz threshold;
+	float load_factor;
+	<* Resize limit *>
+	LinkedEntry* head;
+	<* First inserted LinkedEntry *>
+	LinkedEntry* tail;
+}
+
+fn usz LinkedHashSet.len(&self) @operator(len) => self.count;
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.init(&self, Allocator allocator, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.threshold = (usz)(capacity * load_factor);
+	self.load_factor = load_factor;
+	self.table = allocator::new_array(allocator, LinkedEntry*, capacity);
+
+	self.head = null;
+	self.tail = null;
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.tinit(&self, usz capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(tmem, capacity, load_factor) @inline;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashSet* LinkedHashSet.init_with_values(&self, Allocator allocator, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	$for var $i = 0; $i < $vacount; $i++:
+		self.add($vaarg[$i]);
+	$endfor
+	return self;
+}
+
+<*
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+macro LinkedHashSet* LinkedHashSet.tinit_with_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_with_values(tmem, $vasplat, capacity: capacity, load_factor: load_factor);
+}
+
+<*
+ @param [in] values : "The values for the LinkedHashSet"
+ @param [&inout] allocator : "The allocator to use"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.init_from_values(&self, Allocator allocator, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.init(allocator, capacity, load_factor);
+	foreach (v : values) self.add(v);
+	return self;
+}
+
+<*
+ @param [in] values : "The values for the LinkedHashSet entries"
+ @require capacity > 0 : "The capacity must be 1 or higher"
+ @require load_factor > 0.0 : "The load factor must be higher than 0"
+ @require !self.is_initialized() : "Set was already initialized"
+ @require capacity < MAXIMUM_CAPACITY : "Capacity cannot exceed maximum"
+*>
+fn LinkedHashSet* LinkedHashSet.tinit_from_values(&self, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init_from_values(tmem, values, capacity, load_factor);
+}
+
+<*
+ Has this linked hash set been initialized yet?
+
+ @param [&in] set : "The linked hash set we are testing"
+ @return "Returns true if it has been initialized, false otherwise"
+*>
+fn bool LinkedHashSet.is_initialized(&set)
+{
+	return set.allocator && set.allocator.ptr != &dummy;
+}
+
+<*
+ @param [&inout] allocator : "The allocator to use"
+ @param [&in] other_set : "The set to copy from."
+ @require !self.is_initialized() : "Set was already initialized"
+*>
+fn LinkedHashSet* LinkedHashSet.init_from_set(&self, Allocator allocator, LinkedHashSet* other_set)
+{
+	self.init(allocator, other_set.table.len, other_set.load_factor);
+	LinkedEntry* entry = other_set.head;
+	while (entry) // Save insertion order
+	{
+		linkedhashset_put_for_create(self, entry.value);
+		entry = entry.after;
+	}
+	return self;
+}
+
+<*
+ @param [&in] other_set : "The set to copy from."
+ @require !set.is_initialized() : "Set was already initialized"
+*>
+fn LinkedHashSet* LinkedHashSet.tinit_from_set(&set, LinkedHashSet* other_set)
+{
+	return set.init_from_set(tmem, other_set) @inline;
+}
+
+<*
+ Check if the set is empty
+
+ @return "true if it is empty"
+ @pure
+*>
+fn bool LinkedHashSet.is_empty(&set) @inline
+{
+	return !set.count;
+}
+
+<*
+ Add all elements in the slice to the set.
+
+ @param [in] list
+ @return "The number of new elements added"
+ @ensure total <= list.len
+*>
+fn usz LinkedHashSet.add_all(&set, Value[] list)
+{
+	usz total;
+	foreach (v : list)
+	{
+		if (set.add(v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other
+ @return "The number of new elements added"
+ @ensure return <= other.count
+*>
+fn usz LinkedHashSet.add_all_from(&set, LinkedHashSet* other)
+{
+	usz total;
+	other.@each(;Value value)
+	{
+		if (set.add(value)) total++;
+	};
+	return total;
+}
+
+<*
+ @param value : "The value to add"
+ @return "true if the value didn't exist in the set"
+*>
+fn bool LinkedHashSet.add(&set, Value value)
+{
+	// If the set isn't initialized, use the defaults to initialize it.
+	switch (set.allocator.ptr)
+	{
+		case &dummy:
+			set.init(mem);
+		case null:
+			set.tinit();
+		default:
+			break;
+	}
+	uint hash = rehash(value.hash());
+	uint index = index_for(hash, set.table.len);
+	for (LinkedEntry *e = set.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return false;
+	}
+	linkedhashset_add_entry(set, hash, value, index);
+	return true;
+}
+
+<*
+ Iterate over all the values in the set
+*>
+macro LinkedHashSet.@each(set; @body(value))
+{
+	if (!set.count) return;
+    LinkedEntry* entry = set.head;
+	while (entry)
+	{
+		@body(entry.value);
+		entry = entry.after;
+	}
+}
+
+<*
+ Check if the set contains the given value.
+
+ @param value : "The value to check"
+ @return "true if it exists in the set"
+*>
+fn bool LinkedHashSet.contains(&set, Value value)
+{
+	if (!set.count) return false;
+	uint hash = rehash(value.hash());
+	for (LinkedEntry *e = set.table[index_for(hash, set.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value)) return true;
+	}
+	return false;
+}
+
+<*
+ Remove a single value from the set.
+
+ @param value : "The value to remove"
+ @return? NOT_FOUND : "If the entry is not found"
+*>
+fn void? LinkedHashSet.remove(&set, Value value) @maydiscard
+{
+	if (!linkedhashset_remove_entry_for_value(set, value)) return NOT_FOUND~;
+}
+
+fn usz LinkedHashSet.remove_all(&set, Value[] values)
+{
+	usz total;
+	foreach (v : values)
+	{
+		if (linkedhashset_remove_entry_for_value(set, v)) total++;
+	}
+	return total;
+}
+
+<*
+ @param [&in] other : "Other set"
+*>
+fn usz LinkedHashSet.remove_all_from(&set, LinkedHashSet* other)
+{
+	usz total;
+	other.@each(;Value val)
+    {
+		if (linkedhashset_remove_entry_for_value(set, val)) total++;
+    };
+    return total;
+}
+
+<*
+ Free all memory allocated by the hash set.
+*>
+fn void LinkedHashSet.free(&set)
+{
+	if (!set.is_initialized()) return;
+	set.clear();
+	linkedhashset_free_internal(set, set.table.ptr);
+	set.table = {};
+}
+
+<*
+ Clear all elements from the set while keeping the underlying storage
+
+ @ensure set.count == 0
+*>
+fn void LinkedHashSet.clear(&set)
+{
+	if (!set.count) return;
+
+	LinkedEntry* entry = set.head;
+	while (entry)
+	{
+		LinkedEntry* next = entry.after;
+		linkedhashset_free_entry(set, entry);
+		entry = next;
+	}
+
+	foreach (LinkedEntry** &bucket : set.table)
+	{
+		*bucket = null;
+	}
+
+	set.count = 0;
+	set.head = null;
+	set.tail = null;
+}
+
+fn void LinkedHashSet.reserve(&set, usz capacity)
+{
+	if (capacity > set.threshold)
+	{
+		linkedhashset_resize(set, math::next_power_of_2(capacity));
+	}
+}
+
+// --- Set Operations ---
+
+<*
+ Returns the union of two sets (A | B)
+
+ @param [&in] other : "The other set to union with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the union of both sets"
+*>
+fn LinkedHashSet LinkedHashSet.set_union(&self, Allocator allocator, LinkedHashSet* other)
+{
+	usz new_capacity = math::next_power_of_2(self.count + other.count);
+	LinkedHashSet result;
+	result.init(allocator, new_capacity, self.load_factor);
+	result.add_all_from(self);
+	result.add_all_from(other);
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tset_union(&self, LinkedHashSet* other) => self.set_union(tmem, other) @inline;
+
+<*
+ Returns the intersection of the two sets (A & B)
+
+ @param [&in] other : "The other set to intersect with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing the intersection of both sets"
+*>
+fn LinkedHashSet LinkedHashSet.intersection(&self, Allocator allocator, LinkedHashSet* other)
+{
+	LinkedHashSet result;
+	result.init(allocator, math::min(self.table.len, other.table.len), self.load_factor);
+
+	// Iterate through the smaller set for efficiency
+	LinkedHashSet* smaller = self.count <= other.count ? self : other;
+	LinkedHashSet* larger = self.count > other.count ? self : other;
+
+	smaller.@each(;Value value)
+    {
+		if (larger.contains(value)) result.add(value);
+	};
+
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tintersection(&self, LinkedHashSet* other) => self.intersection(tmem, other) @inline;
+
+<*
+ Return this set - other, so (A & ~B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set but not in the other"
+*>
+fn LinkedHashSet LinkedHashSet.difference(&self, Allocator allocator, LinkedHashSet* other)
+{
+	LinkedHashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	self.@each(;Value value)
+	{
+		if (!other.contains(value))
+		{
+			result.add(value);
+		}
+	};
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tdifference(&self, LinkedHashSet* other) => self.difference(tmem, other) @inline;
+
+<*
+ Return (A ^ B)
+
+ @param [&in] other : "The other set to compare with"
+ @param [&inout] allocator : "Allocator for the new set"
+ @return "A new set containing elements in this set or the other, but not both"
+*>
+fn LinkedHashSet LinkedHashSet.symmetric_difference(&self, Allocator allocator, LinkedHashSet* other)
+{
+	LinkedHashSet result;
+	result.init(allocator, self.table.len, self.load_factor);
+	result.add_all_from(self);
+	other.@each(;Value value)
+	{
+		if (!result.add(value))
+		{
+			result.remove(value);
+		}
+	};
+	return result;
+}
+
+fn LinkedHashSet LinkedHashSet.tsymmetric_difference(&self, LinkedHashSet* other) => self.symmetric_difference(tmem, other) @inline;
+
+<*
+ Check if this hash set is a subset of another set.
+
+ @param [&in] other : "The other set to check against"
+ @return "True if all elements of this set are in the other set"
+*>
+fn bool LinkedHashSet.is_subset(&self, LinkedHashSet* other)
+{
+	if (self.count == 0) return true;
+	if (self.count > other.count) return false;
+
+	self.@each(; Value value) {
+		if (!other.contains(value)) return false;
+	};
+	return true;
+}
+
+// --- private methods
+
+fn void linkedhashset_add_entry(LinkedHashSet* set, uint hash, Value value, uint bucket_index) @private
+{
+	LinkedEntry* entry = allocator::new(set.allocator, LinkedEntry, {
+		.hash = hash,
+		.value = value,
+		.next = set.table[bucket_index],
+		.before = set.tail,
+		.after = null
+	});
+
+	// Update bucket chain
+	set.table[bucket_index] = entry;
+
+	// Update linked list
+	if (set.tail)
+	{
+		set.tail.after = entry;
+		entry.before = set.tail;
+	}
+	else
+	{
+		set.head = entry;
+	}
+	set.tail = entry;
+
+	if (set.count++ >= set.threshold)
+	{
+		linkedhashset_resize(set, set.table.len * 2);
+	}
+}
+
+fn void linkedhashset_resize(LinkedHashSet* set, usz new_capacity) @private
+{
+	LinkedEntry*[] old_table = set.table;
+	usz old_capacity = old_table.len;
+
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		set.threshold = uint.max;
+		return;
+	}
+
+	LinkedEntry*[] new_table = allocator::new_array(set.allocator, LinkedEntry*, new_capacity);
+	set.table = new_table;
+	set.threshold = (uint)(new_capacity * set.load_factor);
+
+	// Rehash all entries - linked list order remains unchanged
+	foreach (uint i, LinkedEntry *e : old_table)
+	{
+		if (!e) continue;
+
+		// Split the bucket chain into two chains based on new bit
+		LinkedEntry* lo_head = null;
+		LinkedEntry* lo_tail = null;
+		LinkedEntry* hi_head = null;
+		LinkedEntry* hi_tail = null;
+
+		do
+		{
+			LinkedEntry* next = e.next;
+			if ((e.hash & old_capacity) == 0)
+			{
+				if (!lo_tail)
+				{
+					lo_head = e;
+				}
+				else
+				{
+					lo_tail.next = e;
+				}
+				lo_tail = e;
+			}
+			else
+			{
+				if (!hi_tail)
+				{
+					hi_head = e;
+				}
+				else
+				{
+					hi_tail.next = e;
+				}
+				hi_tail = e;
+			}
+			e.next = null;
+			e = next;
+		}
+		while (e);
+
+		if (lo_tail)
+		{
+			lo_tail.next = null;
+			new_table[i] = lo_head;
+		}
+		if (hi_tail)
+		{
+			hi_tail.next = null;
+			new_table[i + old_capacity] = hi_head;
+		}
+	}
+
+	linkedhashset_free_internal(set, old_table.ptr);
+}
+
+fn usz? LinkedHashSet.to_format(&self, Formatter* f) @dynamic
+{
+	usz len;
+	len += f.print("{ ")!;
+	self.@each(; Value value)
+	{
+		if (len > 2) len += f.print(", ")!;
+		len += f.printf("%s", value)!;
+	};
+	return len + f.print(" }");
+}
+
+fn void linked_hashset_transfer(LinkedHashSet* set, LinkedEntry*[] new_table) @private
+{
+	LinkedEntry*[] src = set.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, LinkedEntry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			LinkedEntry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void linkedhashset_put_for_create(LinkedHashSet* set, Value value) @private
+{
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	for (LinkedEntry *e = set.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(value, e.value))
+		{
+			// Value already exists, no need to do anything
+			return;
+		}
+	}
+	linkedhashset_create_entry(set, hash, value, i);
+}
+
+fn void linkedhashset_free_internal(LinkedHashSet* set, void* ptr) @inline @private
+{
+	allocator::free(set.allocator, ptr);
+}
+
+fn void linkedhashset_create_entry(LinkedHashSet* set, uint hash, Value value, int bucket_index) @private
+{
+	LinkedEntry* entry = allocator::new(set.allocator, LinkedEntry, {
+		.hash = hash,
+		.value = value,
+		.next = set.table[bucket_index],
+		.before = set.tail,
+		.after = null
+	});
+
+	set.table[bucket_index] = entry;
+
+	// Update linked list
+	if (set.tail)
+	{
+		set.tail.after = entry;
+		entry.before = set.tail;
+	}
+	else
+	{
+		set.head = entry;
+	}
+	set.tail = entry;
+
+	set.count++;
+}
+
+fn bool linkedhashset_remove_entry_for_value(LinkedHashSet* set, Value value) @private
+{
+	if (!set.count) return false;
+
+	uint hash = rehash(value.hash());
+	uint i = index_for(hash, set.table.len);
+	LinkedEntry* prev = null;
+	LinkedEntry* e = set.table[i];
+
+	while (e)
+	{
+		if (e.hash == hash && equals(value, e.value))
+		{
+			if (prev)
+			{
+				prev.next = e.next;
+			}
+			else
+			{
+				set.table[i] = e.next;
+			}
+
+			if (e.before)
+			{
+				e.before.after = e.after;
+			}
+			else
+			{
+				set.head = e.after;
+			}
+
+			if (e.after)
+			{
+				e.after.before = e.before;
+			}
+			else
+			{
+				set.tail = e.before;
+			}
+
+			set.count--;
+			linkedhashset_free_entry(set, e);
+			return true;
+		}
+		prev = e;
+		e = e.next;
+	}
+	return false;
+}
+
+fn void linkedhashset_free_entry(LinkedHashSet* set, LinkedEntry *entry) @private
+{
+	allocator::free(set.allocator, entry);
+}
+
+struct LinkedHashSetIterator
+{
+	LinkedHashSet* set;
+	LinkedEntry* current;
+	bool started;
+}
+
+fn LinkedHashSetIterator LinkedHashSet.iter(&set) => { .set = set, .current = set.head, .started = false };
+
+fn bool LinkedHashSetIterator.next(&self)
+{
+	if (!self.started)
+	{
+		self.current = self.set.head;
+		self.started = true;
+	}
+	else if (self.current)
+	{
+		self.current = self.current.after;
+	}
+	return self.current != null;
+}
+
+fn Value*? LinkedHashSetIterator.get(&self)
+{
+	return self.current ? &self.current.value : NOT_FOUND~;
+}
+
+fn bool LinkedHashSetIterator.has_next(&self)
+{
+	if (!self.started) return self.set.head != null;
+	return self.current && self.current.after != null;
+}
+
+fn usz LinkedHashSetIterator.len(&self) @operator(len)
+{
+    return self.set.count;
+}
+
+int dummy @local;

lib/std/collections/linkedlist.c3

@@ -1,14 +1,15 @@
 // Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of self source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::collections::linkedlist(<Type>);
+module std::collections::linkedlist <Type>;
+import std::io;
 
 const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
 
-struct Node @private
+struct Node
 {
-	Node *next;
-	Node *prev;
+	Node* next;
+	Node* prev;
 	Type value;
 }
 
@@ -16,12 +17,35 @@ struct LinkedList
 {
 	Allocator allocator;
 	usz size;
-	Node *_first;
-	Node *_last;
+	Node* _first;
+	Node* _last;
+}
+
+fn usz? LinkedList.to_format(&self, Formatter* f) @dynamic
+{
+	usz len = f.print("{ ")!;
+	for (Node* node = self._first; node != null; node = node.next)
+	{
+		len += f.printf(node.next ? "%s, " : "%s", node.value)!;
+	}
+	return len + f.print(" }");
+}
+
+macro LinkedList @new(Allocator allocator, Type[] #default_values = {})
+{
+	LinkedList new_list;
+	new_list.init(allocator);
+	new_list.push_all(#default_values);
+	return new_list;
+}
+
+macro LinkedList @tnew(Type[] #default_values = {})
+{
+	return @new(tmem, #default_values);
 }
 
 <*
- @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
  @return "the initialized list"
 *>
 fn LinkedList* LinkedList.init(&self, Allocator allocator)
@@ -30,22 +54,15 @@ fn LinkedList* LinkedList.init(&self, Allocator allocator)
 	return self;
 }
 
-<*
- @return "the initialized list"
-*>
-fn LinkedList* LinkedList.new_init(&self)
+fn LinkedList* LinkedList.tinit(&self)
 {
-	return self.init(allocator::heap()) @inline;
+	return self.init(tmem) @inline;
 }
 
-
-fn LinkedList* LinkedList.temp_init(&self)
-{
-	return self.init(allocator::temp()) @inline;
-}
+fn bool LinkedList.is_initialized(&self) @inline => self.allocator != null;
 
 <*
- @require self.allocator
+ @require self.is_initialized()
 *>
 macro void LinkedList.free_node(&self, Node* node) @private
 {
@@ -54,7 +71,7 @@ macro void LinkedList.free_node(&self, Node* node) @private
 
 macro Node* LinkedList.alloc_node(&self) @private
 {
-	if (!self.allocator) self.allocator = allocator::heap();
+	if (!self.allocator) self.allocator = tmem;
 	return allocator::alloc(self.allocator, Node);
 }
 
@@ -75,6 +92,11 @@ fn void LinkedList.push_front(&self, Type value)
 	self.size++;
 }
 
+fn void LinkedList.push_front_all(&self, Type[] value)
+{
+	foreach_r (v : value) self.push_front(v);
+}
+
 fn void LinkedList.push(&self, Type value)
 {
 	Node *last = self._last;
@@ -92,18 +114,23 @@ fn void LinkedList.push(&self, Type value)
 	self.size++;
 }
 
-fn Type! LinkedList.peek(&self) => self.first() @inline;
-fn Type! LinkedList.peek_last(&self) => self.last() @inline;
-
-fn Type! LinkedList.first(&self)
+fn void LinkedList.push_all(&self, Type[] value)
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
+	foreach (v : value) self.push(v);
+}
+
+fn Type? LinkedList.peek(&self) => self.first() @inline;
+fn Type? LinkedList.peek_last(&self) => self.last() @inline;
+
+fn Type? LinkedList.first(&self)
+{
+	if (!self._first) return NO_MORE_ELEMENT~;
 	return self._first.value;
 }
 
-fn Type! LinkedList.last(&self)
+fn Type? LinkedList.last(&self)
 {
-	if (!self._last) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self._last) return NO_MORE_ELEMENT~;
 	return self._last.value;
 }
 
@@ -140,6 +167,7 @@ macro Node* LinkedList.node_at_index(&self, usz index)
 	while (index--) node = node.next;
 	return node;
 }
+
 <*
  @require index < self.size
 *>
@@ -148,6 +176,14 @@ fn Type LinkedList.get(&self, usz index)
 	return self.node_at_index(index).value;
 }
 
+<*
+ @require index < self.size
+*>
+fn Type* LinkedList.get_ref(&self, usz index)
+{
+	return &self.node_at_index(index).value;
+}
+
 <*
  @require index < self.size
 *>
@@ -156,12 +192,32 @@ fn void LinkedList.set(&self, usz index, Type element)
 	self.node_at_index(index).value = element;
 }
 
+fn usz? LinkedList.index_of(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
+{
+	for (Node* node = self._first, usz i = 0; node != null; node = node.next, ++i)
+	{
+		if (node.value == t) return i;
+	}
+	return NOT_FOUND~;
+}
+
+fn usz? LinkedList.rindex_of(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
+{
+	for (Node* node = self._last, usz i = self.size - 1; node != null; node = node.prev, --i)
+	{
+		if (node.value == t) return i;
+		if (i == 0) break;
+	}
+	return NOT_FOUND~;
+}
+
+
 <*
  @require index < self.size
 *>
 fn void LinkedList.remove_at(&self, usz index)
 {
-	self.unlink(self.node_at_index(index));
+	linked_list_unlink(self, self.node_at_index(index));
 }
 
 <*
@@ -176,47 +232,47 @@ fn void LinkedList.insert_at(&self, usz index, Type element)
 		case self.size:
 			self.push(element);
 		default:
-			self.link_before(self.node_at_index(index), element);
+			linked_list_link_before(self, self.node_at_index(index), element);
 	}
 }
 <*
  @require succ != null
 *>
-fn void LinkedList.link_before(&self, Node *succ, Type value) @private
+fn void linked_list_link_before(LinkedList* l, Node *succ, Type value) @private
 {
 	Node* pred = succ.prev;
-	Node* new_node = self.alloc_node();
+	Node* new_node = l.alloc_node();
 	*new_node = { .prev = pred, .next = succ, .value = value };
 	succ.prev = new_node;
 	if (!pred)
 	{
-		self._first = new_node;
+		l._first = new_node;
 	}
 	else
 	{
 		pred.next = new_node;
 	}
-	self.size++;
+	l.size++;
 }
 
 <*
- @require self._first
+ @require l._first != null
 *>
-fn void LinkedList.unlink_first(&self) @private
+fn void linked_list_unlink_first(LinkedList* l) @private
 {
-	Node* f = self._first;
+	Node* f = l._first;
 	Node* next = f.next;
-	self.free_node(f);
-	self._first = next;
+	l.free_node(f);
+	l._first = next;
 	if (!next)
 	{
-		self._last = null;
+		l._last = null;
 	}
 	else
 	{
 		next.prev = null;
 	}
-	self.size--;
+	l.size--;
 }
 
 fn usz LinkedList.remove(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
@@ -229,7 +285,7 @@ fn usz LinkedList.remove(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
 		{
 			case equals(node.value, t):
 				Node* next = node.next;
-				self.unlink(node);
+				linked_list_unlink(self, node);
 				node = next;
 			default:
 				node = node.next;
@@ -238,10 +294,10 @@ fn usz LinkedList.remove(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
 	return start - self.size;
 }
 
-fn Type! LinkedList.pop(&self)
+fn Type? LinkedList.pop(&self)
 {
-	if (!self._last) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.unlink_last();
+	if (!self._last) return NO_MORE_ELEMENT~;
+	defer linked_list_unlink_last(self);
 	return self._last.value;
 }
 
@@ -250,23 +306,23 @@ fn bool LinkedList.is_empty(&self)
 	return !self._first;
 }
 
-fn Type! LinkedList.pop_front(&self)
+fn Type? LinkedList.pop_front(&self)
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.unlink_first();
+	if (!self._first) return NO_MORE_ELEMENT~;
+	defer linked_list_unlink_first(self);
 	return self._first.value;
 }
 
-fn void! LinkedList.remove_last(&self) @maydiscard
+fn void? LinkedList.remove_last(&self) @maydiscard
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	self.unlink_last();
+	if (!self._first) return NO_MORE_ELEMENT~;
+	linked_list_unlink_last(self);
 }
 
-fn void! LinkedList.remove_first(&self) @maydiscard
+fn void? LinkedList.remove_first(&self) @maydiscard
 {
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	self.unlink_first();
+	if (!self._first) return NO_MORE_ELEMENT~;
+	linked_list_unlink_first(self);
 }
 
 
@@ -276,7 +332,7 @@ fn bool LinkedList.remove_first_match(&self, Type t) @if(ELEMENT_IS_EQUATABLE)
 	{
 		if (node.value == t)
 		{
-			self.unlink(node);
+			linked_list_unlink(self, node);
 			return true;
 		}
 	}
@@ -289,16 +345,16 @@ fn bool LinkedList.remove_last_match(&self, Type t)  @if(ELEMENT_IS_EQUATABLE)
 	{
 		if (node.value == t)
 		{
-			self.unlink(node);
+			linked_list_unlink(self, node);
 			return true;
 		}
 	}
 	return false;
 }
 <*
- @require self._last
+ @require self._last != null
 *>
-fn void LinkedList.unlink_last(&self) @inline @private
+fn void linked_list_unlink_last(LinkedList* self) @inline @private
 {
 	Node* l = self._last;
 	Node* prev = l.prev;
@@ -318,7 +374,7 @@ fn void LinkedList.unlink_last(&self) @inline @private
 <*
  @require x != null
 *>
-fn void LinkedList.unlink(&self, Node* x) @private
+fn void linked_list_unlink(LinkedList* self, Node* x) @private
 {
 	Node* next = x.next;
 	Node* prev = x.prev;
@@ -341,3 +397,69 @@ fn void LinkedList.unlink(&self, Node* x) @private
 	self.free_node(x);
 	self.size--;
 }
+
+
+macro bool LinkedList.eq(&self, other) @operator(==) @if(ELEMENT_IS_EQUATABLE)
+{
+	Node* node1 = self._first;
+	Node* node2 = other._first;
+	while (true)
+	{
+		if (!node1) return node2 == null;
+		if (!node2) return false;
+		if (node1.value != node2.value) return false;
+		node1 = node1.next;
+		node2 = node2.next;
+	}
+	return true;
+}
+
+fn LinkedListArrayView LinkedList.array_view(&self)
+{
+	return { .list = self, .current_node = self._first };
+}
+
+
+struct LinkedListArrayView
+{
+	LinkedList* list;
+	Node* current_node;
+	usz current_index;
+}
+
+fn usz LinkedListArrayView.len(&self) @operator(len) => self.list.size;
+
+<*
+ @require index < self.list.size
+*>
+fn Type LinkedListArrayView.get(&self, usz index) @operator([])
+{
+	return *self.get_ref(index);
+}
+
+<*
+ @require index < self.list.size
+*>
+fn Type* LinkedListArrayView.get_ref(&self, usz index) @operator(&[])
+{
+	if (index == self.list.size - 1)
+	{
+		self.current_node = self.list._last;
+		self.current_index = index;
+	}
+
+	while (self.current_index != index)
+	{
+		switch
+		{
+			case index < self.current_index:   // reverse iteration
+				self.current_node = self.current_node.prev;
+				self.current_index--;
+			case index > self.current_index:
+				self.current_node = self.current_node.next;
+				self.current_index++;
+		}
+	}
+
+	return &self.current_node.value;
+}

lib/std/collections/list.c3

@@ -1,15 +1,19 @@
 // Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
 // Use of self source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-module std::collections::list(<Type>);
+module std::collections::list <Type>;
 import std::io, std::math, std::collections::list_common;
 
-def ElementPredicate = fn bool(Type *type);
-def ElementTest = fn bool(Type *type, any context);
+alias ElementPredicate = fn bool(Type *type);
+alias ElementTest = fn bool(Type *type, any context);
 const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
 const ELEMENT_IS_POINTER = Type.kindof == POINTER;
 
-macro type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+const Allocator LIST_HEAP_ALLOCATOR = (Allocator)&dummy;
+
+const List ONHEAP = { .allocator = LIST_HEAP_ALLOCATOR };
+
+macro bool type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
 
 struct List (Printable)
 {
@@ -20,10 +24,10 @@ struct List (Printable)
 }
 
 <*
- @param initial_capacity "The initial capacity to reserve"
- @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ @param initial_capacity : "The initial capacity to reserve"
+ @param [&inout] allocator : "The allocator to use, defaults to the heap allocator"
 *>
-fn List* List.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap())
+fn List* List.init(&self, Allocator allocator, usz initial_capacity = 16)
 {
 	self.allocator = allocator;
 	self.size = 0;
@@ -33,54 +37,57 @@ fn List* List.new_init(&self, usz initial_capacity = 16, Allocator allocator = a
 	return self;
 }
 
+
 <*
  Initialize the list using the temp allocator.
 
- @param initial_capacity "The initial capacity to reserve"
+ @param initial_capacity : "The initial capacity to reserve"
 *>
-fn List* List.temp_init(&self, usz initial_capacity = 16)
+fn List* List.tinit(&self, usz initial_capacity = 16)
 {
-	return self.new_init(initial_capacity, allocator::temp()) @inline;
+	return self.init(tmem, initial_capacity) @inline;
 }
 
 <*
  Initialize a new list with an array.
 
- @param [in] values `The values to initialize the list with.`
- @require self.size == 0 "The List must be empty"
+ @param [in] values : `The values to initialize the list with.`
+ @require self.size == 0 : "The List must be empty"
 *>
-fn List* List.new_init_with_array(&self, Type[] values, Allocator allocator = allocator::heap())
+fn List* List.init_with_array(&self, Allocator allocator, Type[] values)
 {
-	self.new_init(values.len, allocator) @inline;
-	self.add_array(values) @inline;
+	self.init(allocator, values.len) @inline;
+	self.push_all(values) @inline;
 	return self;
 }
 
 <*
  Initialize a temporary list with an array.
 
- @param [in] values `The values to initialize the list with.`
- @require self.size == 0 "The List must be empty"
+ @param [in] values : `The values to initialize the list with.`
+ @require self.size == 0 : "The List must be empty"
 *>
-fn List* List.temp_init_with_array(&self, Type[] values)
+fn List* List.tinit_with_array(&self, Type[] values)
 {
-	self.temp_init(values.len) @inline;
-	self.add_array(values) @inline;
+	self.tinit(values.len) @inline;
+	self.push_all(values) @inline;
 	return self;
 }
 
 <*
- @require self.capacity == 0 "The List must not be allocated"
+ @require !self.is_initialized() : "The List must not be allocated"
 *>
-fn void List.init_wrapping_array(&self, Type[] types, Allocator allocator = allocator::heap())
+fn void List.init_wrapping_array(&self, Allocator allocator, Type[] types)
 {
 	self.allocator = allocator;
 	self.capacity = types.len;
 	self.entries = types.ptr;
-	self.set_size(types.len);
+	list_set_size(self, types.len);
 }
 
-fn usz! List.to_format(&self, Formatter* formatter) @dynamic
+fn bool List.is_initialized(&self) @inline => self.allocator != null && self.allocator != (Allocator)&dummy;
+
+fn usz? List.to_format(&self, Formatter* formatter) @dynamic
 {
 	switch (self.size)
 	{
@@ -100,56 +107,47 @@ fn usz! List.to_format(&self, Formatter* formatter) @dynamic
 	}
 }
 
-fn String List.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
-{
-	return string::format("%s", *self, allocator: allocator);
-}
-
-fn String List.to_tstring(&self)
-{
-	return string::tformat("%s", *self);
-}
-
 fn void List.push(&self, Type element) @inline
 {
 	self.reserve(1);
-	self.entries[self.set_size(self.size + 1)] = element;
+	self.entries[list_set_size(self, self.size + 1)] = element;
 }
 
-fn Type! List.pop(&self)
+fn Type? List.pop(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.set_size(self.size - 1);
+	if (!self.size) return NO_MORE_ELEMENT~;
+	defer list_set_size(self, self.size - 1);
 	return self.entries[self.size - 1];
 }
 
 fn void List.clear(&self)
 {
-	self.set_size(0);
+	list_set_size(self, 0);
 }
 
-fn Type! List.pop_first(&self)
+fn Type? List.pop_first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	defer self.remove_at(0);
 	return self.entries[0];
 }
 
 <*
- @require index < self.size `Removed element out of bounds`
+ @require index < self.size : `Removed element out of bounds`
 *>
 fn void List.remove_at(&self, usz index)
 {
-	self.set_size(self.size - 1);
-	if (!self.size || index == self.size) return;
-	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
+	usz new_size = self.size - 1;
+	defer list_set_size(self, new_size);
+	if (!new_size || index == new_size) return;
+	self.entries[index .. new_size - 1] = self.entries[index + 1 .. new_size];
 }
 
 fn void List.add_all(&self, List* other_list)
 {
 	if (!other_list.size) return;
 	self.reserve(other_list.size);
-	usz index = self.set_size(self.size + other_list.size);
+	usz index = list_set_size(self, self.size + other_list.size);
 	foreach (&value : other_list)
 	{
 		self.entries[index++] = *value;
@@ -160,25 +158,25 @@ fn void List.add_all(&self, List* other_list)
 <*
  IMPORTANT The returned array must be freed using free_aligned.
 *>
-fn Type[] List.to_new_aligned_array(&self, Allocator allocator = allocator::heap())
+fn Type[] List.to_aligned_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_aligned_array(Type, self, allocator);
+	return list_common::list_to_aligned_array(Type, self, allocator);
 }
 
 <*
  @require !type_is_overaligned() : "This function is not available on overaligned types"
 *>
-macro Type[] List.to_new_array(&self, Allocator allocator = allocator::heap())
+macro Type[] List.to_array(&self, Allocator allocator)
 {
-	return list_common::list_to_new_array(Type, self, allocator);
+	return list_common::list_to_array(Type, self, allocator);
 }
 
 fn Type[] List.to_tarray(&self)
 {
 	$if type_is_overaligned():
-	return self.to_new_aligned_array(allocator::temp());
+	return self.to_aligned_array(tmem);
 	$else
-	return self.to_new_array(allocator::temp());
+	return self.to_array(tmem);
 	$endif;
 }
 
@@ -201,11 +199,25 @@ fn Type[] List.array_view(&self)
  @param [in] array
  @ensure self.size >= array.len
 *>
-fn void List.add_array(&self, Type[] array)
+fn void List.add_array(&self, Type[] array) @deprecated("Use push_all")
 {
 	if (!array.len) return;
 	self.reserve(array.len);
-	usz index = self.set_size(self.size + array.len);
+	usz index = list_set_size(self, self.size + array.len);
+	self.entries[index : array.len] = array[..];
+}
+
+<*
+ Add the values of an array to this list.
+
+ @param [in] array
+ @ensure self.size >= array.len
+*>
+fn void List.push_all(&self, Type[] array)
+{
+	if (!array.len) return;
+	self.reserve(array.len);
+	usz index = list_set_size(self, self.size + array.len);
 	self.entries[index : array.len] = array[..];
 }
 
@@ -215,16 +227,16 @@ fn void List.push_front(&self, Type type) @inline
 }
 
 <*
- @require index <= self.size `Insert was out of bounds`
+ @require index <= self.size : `Insert was out of bounds`
 *>
 fn void List.insert_at(&self, usz index, Type type)
 {
 	self.reserve(1);
-	for (usz i = self.size; i > index; i--)
+	list_set_size(self, self.size + 1);
+	for (isz i = self.size - 1; i > index; i--)
 	{
 		self.entries[i] = self.entries[i - 1];
 	}
-	self.set_size(self.size + 1);
 	self.entries[index] = type;
 }
 
@@ -236,27 +248,27 @@ fn void List.set_at(&self, usz index, Type type)
 	self.entries[index] = type;
 }
 
-fn void! List.remove_last(&self) @maydiscard
+fn void? List.remove_last(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	self.set_size(self.size - 1);
+	if (!self.size) return NO_MORE_ELEMENT~;
+	list_set_size(self, self.size - 1);
 }
 
-fn void! List.remove_first(&self) @maydiscard
+fn void? List.remove_first(&self) @maydiscard
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	self.remove_at(0);
 }
 
-fn Type! List.first(&self)
+fn Type? List.first(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	return self.entries[0];
 }
 
-fn Type! List.last(&self)
+fn Type? List.last(&self)
 {
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!self.size) return NO_MORE_ELEMENT~;
 	return self.entries[self.size - 1];
 }
 
@@ -276,7 +288,7 @@ fn usz List.len(&self) @operator(len) @inline
 }
 
 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 fn Type List.get(&self, usz index) @inline
 {
@@ -285,9 +297,9 @@ fn Type List.get(&self, usz index) @inline
 
 fn void List.free(&self)
 {
-	if (!self.allocator || !self.capacity) return;
+	if (!self.allocator || self.allocator.ptr == &dummy || !self.capacity) return;
 
-	self.pre_free(); // Remove sanitizer annotation
+	list_pre_free(self); // Remove sanitizer annotation
 
 	$if type_is_overaligned():
 		allocator::free_aligned(self.allocator, self.entries);
@@ -300,7 +312,7 @@ fn void List.free(&self)
 }
 
 <*
- @require i < self.size && j < self.size `Access out of bounds`
+ @require i < self.size && j < self.size : `Access out of bounds`
 *>
 fn void List.swap(&self, usz i, usz j)
 {
@@ -308,7 +320,7 @@ fn void List.swap(&self, usz i, usz j)
 }
 
 <*
- @param filter "The function to determine if it should be removed or not"
+ @param filter : "The function to determine if it should be removed or not"
  @return "the number of deleted elements"
 *>
 fn usz List.remove_if(&self, ElementPredicate filter)
@@ -317,7 +329,7 @@ fn usz List.remove_if(&self, ElementPredicate filter)
 }
 
 <*
- @param selection "The function to determine if it should be kept or not"
+ @param selection : "The function to determine if it should be kept or not"
  @return "the number of deleted elements"
 *>
 fn usz List.retain_if(&self, ElementPredicate selection)
@@ -328,7 +340,8 @@ fn usz List.retain_if(&self, ElementPredicate selection)
 fn usz List.remove_using_test(&self, ElementTest filter, any context)
 {
 	usz old_size = self.size;
-	defer {
+	defer
+	{
 		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
 	return list_common::list_remove_using_test(self, filter, false, context);
@@ -345,13 +358,23 @@ fn usz List.retain_using_test(&self, ElementTest filter, any context)
 	return list_common::list_remove_using_test(self, filter, true, context);
 }
 
-fn void List.ensure_capacity(&self, usz min_capacity) @local
+fn void list_ensure_capacity(List* self, usz min_capacity) @local
 {
 	if (!min_capacity) return;
 	if (self.capacity >= min_capacity) return;
-	if (!self.allocator) self.allocator = allocator::heap();
 
-	self.pre_free(); // Remove sanitizer annotation
+	// Get a proper allocator
+	switch (self.allocator.ptr)
+	{
+		case &dummy:
+			self.allocator = mem;
+		case null:
+			self.allocator = tmem;
+		default:
+			break;
+	}
+
+	list_pre_free(self); // Remove sanitizer annotation
 
 	min_capacity = math::next_power_of_2(min_capacity);
 	$if type_is_overaligned():
@@ -361,11 +384,11 @@ fn void List.ensure_capacity(&self, usz min_capacity) @local
 	$endif;
 	self.capacity = min_capacity;
 
-	self.post_alloc(); // Add sanitizer annotation
+	list_post_alloc(self); // Add sanitizer annotation
 }
 
 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 macro Type List.@item_at(&self, usz index) @operator([])
 {
@@ -373,7 +396,7 @@ macro Type List.@item_at(&self, usz index) @operator([])
 }
 
 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
 {
@@ -381,7 +404,7 @@ fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
 }
 
 <*
- @require index < self.size `Access out of bounds`
+ @require index < self.size : `Access out of bounds`
 *>
 fn void List.set(&self, usz index, Type value) @operator([]=)
 {
@@ -396,21 +419,24 @@ fn void List.reserve(&self, usz added)
 	assert(new_size < usz.max / 2U);
 	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;
 	while (new_capacity < new_size) new_capacity *= 2U;
-	self.ensure_capacity(new_capacity);
+	list_ensure_capacity(self, new_capacity);
 }
 
 fn void List._update_size_change(&self,usz old_size, usz new_size)
 {
 	if (old_size == new_size) return;
-	sanitizer::annotate_contiguous_container(self.entries,
+	$if env::ADDRESS_SANITIZER:
+		if (self.allocator.ptr != &allocator::LIBC_ALLOCATOR) return;
+		sanitizer::annotate_contiguous_container(self.entries,
 	                                         &self.entries[self.capacity],
 	                                         &self.entries[old_size],
 	                                         &self.entries[new_size]);
+	$endif
 }
 <*
  @require new_size == 0 || self.capacity != 0
 *>
-fn usz List.set_size(&self, usz new_size) @inline @private
+fn usz list_set_size(List* self, usz new_size) @inline @private
 {
 	usz old_size = self.size;
 	self._update_size_change(old_size, new_size);
@@ -418,16 +444,16 @@ fn usz List.set_size(&self, usz new_size) @inline @private
 	return old_size;
 }
 
-macro void List.pre_free(&self) @private
+macro void list_pre_free(List* self) @private
 {
 	if (!self.capacity) return;
 	self._update_size_change(self.size, self.capacity);
 }
 
 <*
- @require self.capacity
+ @require self.capacity > 0
 *>
-macro void List.post_alloc(&self) @private
+macro void list_post_alloc(List* self) @private
 {
 	self._update_size_change(self.capacity, self.size);
 }
@@ -435,22 +461,22 @@ macro void List.post_alloc(&self) @private
 // Functions for equatable types
 
 
-fn usz! List.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? List.index_of(&self, Type type) @if (ELEMENT_IS_EQUATABLE)
 {
 	foreach (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
-fn usz! List.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+fn usz? List.rindex_of(&self, Type type) @if (ELEMENT_IS_EQUATABLE)
 {
 	foreach_r (i, v : self)
 	{
 		if (equals(v, type)) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
 fn bool List.equals(&self, List other_list) @if(ELEMENT_IS_EQUATABLE)
@@ -466,8 +492,8 @@ fn bool List.equals(&self, List other_list) @if(ELEMENT_IS_EQUATABLE)
 <*
  Check for presence of a value in a list.
 
- @param [&in] self "the list to find elements in"
- @param value "The value to search for"
+ @param [&in] self : "the list to find elements in"
+ @param value : "The value to search for"
  @return "True if the value is found, false otherwise"
 *>
 fn bool List.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
@@ -480,8 +506,8 @@ fn bool List.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 }
 
 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
  @return "true if the value was found"
 *>
 fn bool List.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
@@ -490,8 +516,8 @@ fn bool List.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 }
 
 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
  @return "true if the value was found"
 *>
 fn bool List.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
@@ -499,14 +525,15 @@ fn bool List.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 	return @ok(self.remove_at(self.index_of(value)));
 }
 <*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
+ @param [&inout] self : "The list to remove elements from"
+ @param value : "The value to remove"
  @return "the number of deleted elements."
 *>
 fn usz List.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 {
 	usz old_size = self.size;
-	defer {
+	defer
+	{
 		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
 	return list_common::list_remove_item(self, value);
@@ -544,35 +571,4 @@ fn usz List.compact(&self) @if(ELEMENT_IS_POINTER)
 	return list_common::list_compact(self);
 }
 
-// --> Deprecated
-
-<*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
- @return "true if the value was found"
-*>
-fn bool List.remove_last_match(&self, Type value) @if(ELEMENT_IS_EQUATABLE) @deprecated
-{
-	return self.remove_last_item(value) @inline;
-}
-
-<*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
- @return "true if the value was found"
-*>
-fn bool List.remove_first_match(&self, Type value) @if(ELEMENT_IS_EQUATABLE) @deprecated
-{
-	return self.remove_first_item(value) @inline;
-}
-
-
-<*
- @param [&inout] self "The list to remove elements from"
- @param value "The value to remove"
- @return "the number of deleted elements."
-*>
-fn usz List.remove_all_matches(&self, Type value) @if(ELEMENT_IS_EQUATABLE) @deprecated
-{
-	return self.remove_item(value) @inline;
-}
+int dummy @local;

lib/std/collections/list_common.c3

@@ -3,17 +3,17 @@ module std::collections::list_common;
 <*
  IMPORTANT The returned array must be freed using free_aligned.
 *>
-macro list_to_new_aligned_array($Type, self, Allocator allocator)
+macro list_to_aligned_array($Type, self, Allocator allocator)
 {
-	if (!self.size) return $Type[] {};
+	if (!self.size) return ($Type[]){};
 	$Type[] result = allocator::alloc_array_aligned(allocator, $Type, self.size);
 	result[..] = self.entries[:self.size];
 	return result;
 }
 
-macro list_to_new_array($Type, self, Allocator allocator)
+macro list_to_array($Type, self, Allocator allocator)
 {
-	if (!self.size) return $Type[] {};
+	if (!self.size) return ($Type[]){};
 	$Type[] result = allocator::alloc_array(allocator, $Type, self.size);
 	result[..] = self.entries[:self.size];
 	return result;

lib/std/collections/map.c3

@@ -1,505 +0,0 @@
-// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
-// Use of this source code is governed by the MIT license
-// a copy of which can be found in the LICENSE_STDLIB file.
-module std::collections::map(<Key, Value>);
-import std::math;
-
-const uint DEFAULT_INITIAL_CAPACITY = 16;
-const uint MAXIMUM_CAPACITY = 1u << 31;
-const float DEFAULT_LOAD_FACTOR = 0.75;
-const VALUE_IS_EQUATABLE = Value.is_eq;
-const bool COPY_KEYS = types::implements_copy(Key);
-
-distinct Map = void*;
-
-struct MapImpl
-{
-	Entry*[] table;
-	Allocator allocator;
-	uint count; // Number of elements
-	uint threshold; // Resize limit
-	float load_factor;
-}
-
-<*
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map new(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	MapImpl* map = allocator::alloc(allocator, MapImpl);
-	_init(map, capacity, load_factor, allocator);
-	return (Map)map;
-}
-
-<*
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map temp(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
-{
-	MapImpl* map = mem::temp_alloc(MapImpl);
-	_init(map, capacity, load_factor, allocator::temp());
-	return (Map)map;
-}
-
-<*
- @param [&inout] allocator "The allocator to use"
- @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-macro Map new_init_with_key_values(..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	Map map = new(capacity, load_factor, allocator);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		map.set($vaarg[$i], $vaarg[$i+1]);
-	$endfor
-	return map;
-}
-
-<*
- @param [in] keys "Array of keys for the Map entries"
- @param [in] values "Array of values for the Map entries"
- @param [&inout] allocator "The allocator to use"
- @require keys.len == values.len "Both keys and values arrays must be the same length"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map new_init_from_keys_and_values(Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	assert(keys.len == values.len);
-	Map map = new(capacity, load_factor, allocator);
-	for (usz i = 0; i < keys.len; i++)
-	{
-		map.set(keys[i], values[i]);
-	}
-	return map;
-}
-
-<*
- @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-macro Map temp_new_with_key_values(..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
-{
-	Map map = temp(capacity, load_factor);
-	$for (var $i = 0; $i < $vacount; $i += 2)
-		map.set($vaarg[$i], $vaarg[$i+1]);
-	$endfor
-	return map;
-}
-
-<*
- @param [in] keys "The keys for the HashMap entries"
- @param [in] values "The values for the HashMap entries"
- @param [&inout] allocator "The allocator to use"
- @require keys.len == values.len "Both keys and values arrays must be the same length"
- @require capacity > 0 "The capacity must be 1 or higher"
- @require load_factor > 0.0 "The load factor must be higher than 0"
- @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
-*>
-fn Map temp_init_from_keys_and_values(Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
-{
-	assert(keys.len == values.len);
-	Map map = temp(capacity, load_factor);
-	for (usz i = 0; i < keys.len; i++)
-	{
-		map.set(keys[i], values[i]);
-	}
-	return map;
-}
-
-<*
- @param [&in] other_map "The map to copy from."
-*>
-fn Map new_from_map(Map other_map, Allocator allocator = null)
-{
-	MapImpl* other_map_impl = (MapImpl*)other_map;
-	if (!other_map_impl)
-	{
-		if (allocator) return new(allocator: allocator);
-		return null;
-	}
-	MapImpl* map = (MapImpl*)new(other_map_impl.table.len, other_map_impl.load_factor, allocator ?: allocator::heap());
-	if (!other_map_impl.count) return (Map)map;
-	foreach (Entry *e : other_map_impl.table)
-	{
-		if (!e) continue;
-		map._put_for_create(e.key, e.value);
-	}
-	return (Map)map;
-}
-
-<*
- @param [&in] other_map "The map to copy from."
-*>
-fn Map temp_from_map(Map other_map)
-{
-	return new_from_map(other_map, allocator::temp());
-}
-
-fn bool Map.is_empty(map) @inline
-{
-	return !map || !((MapImpl*)map).count;
-}
-
-fn usz Map.len(map) @inline
-{
-	return map ? ((MapImpl*)map).count : 0;
-}
-
-fn Value*! Map.get_ref(self, Key key)
-{
-	MapImpl *map = (MapImpl*)self;
-	if (!map || !map.count) return SearchResult.MISSING?;
-	uint hash = rehash(key.hash());
-	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
-	{
-		if (e.hash == hash && equals(key, e.key)) return &e.value;
-	}
-	return SearchResult.MISSING?;
-}
-
-fn Entry*! Map.get_entry(map, Key key)
-{
-	MapImpl *map_impl = (MapImpl*)map;
-	if (!map_impl || !map_impl.count) return SearchResult.MISSING?;
-	uint hash = rehash(key.hash());
-	for (Entry *e = map_impl.table[index_for(hash, map_impl.table.len)]; e != null; e = e.next)
-	{
-		if (e.hash == hash && equals(key, e.key)) return e;
-	}
-	return SearchResult.MISSING?;
-}
-
-<*
- Get the value or update and
- @require $assignable(#expr, Value)
-*>
-macro Value Map.@get_or_set(&self, Key key, Value #expr)
-{
-	MapImpl *map = (MapImpl*)*self;
-	if (!map || !map.count)
-	{
-		Value val = #expr;
-		map.set(key, val);
-		return val;
-	}
-	uint hash = rehash(key.hash());
-	uint index = index_for(hash, map.table.len);
-	for (Entry *e = map.table[index]; e != null; e = e.next)
-	{
-		if (e.hash == hash && equals(key, e.key)) return e.value;
-	}
-	Value val = #expr;
-	map.add_entry(hash, key, val, index);
-	return val;
-}
-
-fn Value! Map.get(map, Key key) @operator([])
-{
-	return *map.get_ref(key) @inline;
-}
-
-fn bool Map.has_key(map, Key key)
-{
-	return @ok(map.get_ref(key));
-}
-
-macro Value Map.set_value_return(&map, Key key, Value value) @operator([]=)
-{
-	map.set(key, value);
-	return value;
-}
-
-fn bool Map.set(&self, Key key, Value value)
-{
-	// If the map isn't initialized, use the defaults to initialize it.
-	if (!*self) *self = new();
-	MapImpl* map = (MapImpl*)*self;
-	uint hash = rehash(key.hash());
-	uint index = index_for(hash, map.table.len);
-	for (Entry *e = map.table[index]; e != null; e = e.next)
-	{
-		if (e.hash == hash && equals(key, e.key))
-		{
-			e.value = value;
-			return true;
-		}
-	}
-	map._add_entry(hash, key, value, index);
-	return false;
-}
-
-fn void! Map.remove(map, Key key) @maydiscard
-{
-	if (!map || !((MapImpl*)map)._remove_entry_for_key(key)) return SearchResult.MISSING?;
-}
-
-fn void Map.clear(self)
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !map.count) return;
-	foreach (Entry** &entry_ref : map.table)
-	{
-		Entry* entry = *entry_ref;
-		if (!entry) continue;
-		Entry *next = entry.next;
-		while (next)
-		{
-			Entry *to_delete = next;
-			next = next.next;
-			map._free_entry(to_delete);
-		}
-		map._free_entry(entry);
-		*entry_ref = null;
-	}
-	map.count = 0;
-}
-
-fn void Map.free(self)
-{
-	if (!self) return;
-	MapImpl* map = (MapImpl*)self;
-	self.clear();
-	map._free_internal(map.table.ptr);
-	map.table = {};
-	allocator::free(map.allocator, map);
-}
-
-fn Key[] Map.temp_keys_list(map)
-{
-	return map.new_keys_list(allocator::temp()) @inline;
-}
-
-fn Key[] Map.new_keys_list(self, Allocator allocator = allocator::heap())
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !map.count) return {};
-
-	Key[] list = allocator::alloc_array(allocator, Key, map.count);
-	usz index = 0;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			list[index++] = entry.key;
-			entry = entry.next;
-		}
-	}
-	return list;
-}
-
-macro Map.@each(map; @body(key, value))
-{
-	map.@each_entry(; Entry* entry) {
-		@body(entry.key, entry.value);
-	};
-}
-
-macro Map.@each_entry(self; @body(entry))
-{
-	MapImpl *map = (MapImpl*)self;
-	if (!map || !map.count) return;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			@body(entry);
-			entry = entry.next;
-		}
-	}
-}
-
-fn Value[] Map.temp_values_list(map)
-{
-	return map.new_values_list(allocator::temp()) @inline;
-}
-
-fn Value[] Map.new_values_list(self, Allocator allocator = allocator::heap())
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !map.count) return {};
-	Value[] list = allocator::alloc_array(allocator, Value, map.count);
-	usz index = 0;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			list[index++] = entry.value;
-			entry = entry.next;
-		}
-	}
-	return list;
-}
-
-fn bool Map.has_value(self, Value v) @if(VALUE_IS_EQUATABLE)
-{
-	MapImpl* map = (MapImpl*)self;
-	if (!map || !map.count) return false;
-	foreach (Entry* entry : map.table)
-	{
-		while (entry)
-		{
-			if (equals(v, entry.value)) return true;
-			entry = entry.next;
-		}
-	}
-	return false;
-}
-
-// --- private methods
-
-fn void MapImpl._add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
-{
-	$if COPY_KEYS:
-	key = key.copy(map.allocator);
-	$endif
-	Entry* entry = allocator::new(map.allocator, Entry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
-	map.table[bucket_index] = entry;
-	if (map.count++ >= map.threshold)
-	{
-		map._resize(map.table.len * 2);
-	}
-}
-
-fn void MapImpl._resize(&map, uint new_capacity) @private
-{
-	Entry*[] old_table = map.table;
-	uint old_capacity = old_table.len;
-	if (old_capacity == MAXIMUM_CAPACITY)
-	{
-		map.threshold = uint.max;
-		return;
-	}
-	Entry*[] new_table = allocator::new_array(map.allocator, Entry*, new_capacity);
-	map._transfer(new_table);
-	map.table = new_table;
-	map._free_internal(old_table.ptr);
-	map.threshold = (uint)(new_capacity * map.load_factor);
-}
-
-fn uint rehash(uint hash) @inline @private
-{
-	hash ^= (hash >> 20) ^ (hash >> 12);
-	return hash ^ ((hash >> 7) ^ (hash >> 4));
-}
-
-macro uint index_for(uint hash, uint capacity) @private
-{
-	return hash & (capacity - 1);
-}
-
-fn void MapImpl._transfer(&map, Entry*[] new_table) @private
-{
-	Entry*[] src = map.table;
-	uint new_capacity = new_table.len;
-	foreach (uint j, Entry *e : src)
-	{
-		if (!e) continue;
-		do
-		{
-			Entry* next = e.next;
-			uint i = index_for(e.hash, new_capacity);
-			e.next = new_table[i];
-			new_table[i] = e;
-			e = next;
-		}
-		while (e);
-	}
-}
-
-fn void _init(MapImpl* impl, uint capacity, float load_factor, Allocator allocator) @private
-{
-	capacity = math::next_power_of_2(capacity);
-	*impl = {
-		.allocator = allocator,
-		.load_factor = load_factor,
-		.threshold = (uint)(capacity * load_factor),
-		.table = allocator::new_array(allocator, Entry*, capacity)
-	};
-}
-
-fn void MapImpl._put_for_create(&map, Key key, Value value) @private
-{
-	uint hash = rehash(key.hash());
-	uint i = index_for(hash, map.table.len);
-	for (Entry *e = map.table[i]; e != null; e = e.next)
-	{
-		if (e.hash == hash && equals(key, e.key))
-		{
-			e.value = value;
-			return;
-		}
-	}
-	map._create_entry(hash, key, value, i);
-}
-
-fn void MapImpl._free_internal(&map, void* ptr) @inline @private
-{
-	allocator::free(map.allocator, ptr);
-}
-
-fn bool MapImpl._remove_entry_for_key(&map, Key key) @private
-{
-	if (!map.count) return false;
-	uint hash = rehash(key.hash());
-	uint i = index_for(hash, map.table.len);
-	Entry* prev = map.table[i];
-	Entry* e = prev;
-	while (e)
-	{
-		Entry *next = e.next;
-		if (e.hash == hash && equals(key, e.key))
-		{
-			map.count--;
-			if (prev == e)
-			{
-				map.table[i] = next;
-			}
-			else
-			{
-				prev.next = next;
-			}
-			map._free_entry(e);
-			return true;
-		}
-		prev = e;
-		e = next;
-	}
-	return false;
-}
-
-fn void MapImpl._create_entry(&map, uint hash, Key key, Value value, int bucket_index) @private
-{
-	Entry *e = map.table[bucket_index];
-	$if COPY_KEYS:
-	key = key.copy(map.allocator);
-	$endif
-	Entry* entry = allocator::new(map.allocator, Entry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
-	map.table[bucket_index] = entry;
-	map.count++;
-}
-
-fn void MapImpl._free_entry(&self, Entry *entry) @local
-{
-	$if COPY_KEYS:
-	allocator::free(self.allocator, entry.key);
-	$endif
-	self._free_internal(entry);
-}
-
-struct Entry
-{
-	uint hash;
-	Key key;
-	Value value;
-	Entry* next;
-}

lib/std/collections/maybe.c3

@@ -1,11 +1,28 @@
-module std::collections::maybe(<Type>);
+module std::collections::maybe <Type>;
+import std::io;
 
-struct Maybe
+struct Maybe (Printable)
 {
 	Type value;
 	bool has_value;
 }
 
+fn usz? Maybe.to_format(&self, Formatter* f) @dynamic
+{
+	if (self.has_value) return f.printf("[%s]", self.value);
+	return f.printf("[EMPTY]");
+}
+
+fn void Maybe.set(&self, Type val)
+{
+	*self = { .value = val, .has_value = true };
+}
+
+fn void Maybe.reset(&self)
+{
+	*self = {};
+}
+
 fn Maybe value(Type val)
 {
 	return { .value = val, .has_value = true };
@@ -13,7 +30,16 @@ fn Maybe value(Type val)
 
 const Maybe EMPTY = { };
 
-macro Type! Maybe.get(self)
+macro Type? Maybe.get(self)
 {
-	return self.has_value ? self.value : SearchResult.MISSING?;
+	return self.has_value ? self.value : NOT_FOUND~;
+}
+
+fn bool Maybe.equals(self, Maybe other) @operator(==) @if(types::is_equatable_type(Type))
+{
+	if (self.has_value)
+	{
+		return other.has_value && equals(self.value, other.value);
+	}
+	return !other.has_value;
 }

lib/std/collections/object.c3

@@ -25,7 +25,7 @@ struct Object (Printable)
 }
 
 
-fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
+fn usz? Object.to_format(&self, Formatter* formatter) @dynamic
 {
 	switch (self.type)
 	{
@@ -50,7 +50,7 @@ fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
 			usz n = formatter.printf("{")!;
 			@stack_mem(1024; Allocator mem)
 			{
-				foreach (i, key : self.map.copy_keys(mem))
+				foreach (i, key : self.map.keys(mem))
 				{
 					if (i > 0) n += formatter.printf(",")!;
 					n += formatter.printf(`"%s":`, key)!;
@@ -151,45 +151,46 @@ fn bool Object.is_indexable(&self) => self.is_empty() || self.is_array();
 <*
  @require self.is_keyable()
 *>
-fn void Object.init_map_if_needed(&self) @private
+fn void object_init_map_if_needed(Object* self) @private
 {
 	if (self.is_empty())
 	{
 		self.type = ObjectInternalMap.typeid;
-		self.map.new_init(allocator: self.allocator);
+		self.map.init(self.allocator);
 	}
 }
 
 <*
  @require self.is_indexable()
 *>
-fn void Object.init_array_if_needed(&self) @private
+fn void object_init_array_if_needed(Object* self) @private
 {
 	if (self.is_empty())
 	{
 		self.type = ObjectInternalList.typeid;
-		self.array.new_init(allocator: self.allocator);
+		self.array.init(self.allocator);
 	}
 }
 
 <*
  @require self.is_keyable()
 *>
-fn void Object.set_object(&self, String key, Object* new_object) @private
+fn void object_set_object(Object* self, String key, Object* new_object) @private
 {
-	self.init_map_if_needed();
-	ObjectInternalMapEntry*! entry = self.map.get_entry(key);
-	defer
-	{
-		(void)entry.value.free();
-	}
+	object_init_map_if_needed(self);
+	Object*? val = self.map.get_entry(key).value;
+	defer (void)val.free();
 	self.map.set(key, new_object);
 }
 
+<*
+ @require self.allocator != null : "This object is not properly initialized, was it really created using 'new'"
+ @require $typeof(value) != void* ||| value == null : "void pointers cannot be stored in an object"
+*>
 macro Object* Object.object_from_value(&self, value) @private
 {
 	var $Type = $typeof(value);
-	$switch
+	$switch:
 		$case types::is_int($Type):
 			return new_int(value, self.allocator);
 		$case types::is_float($Type):
@@ -201,9 +202,8 @@ macro Object* Object.object_from_value(&self, value) @private
 		$case $Type.typeid == Object*.typeid:
 			return value;
 		$case $Type.typeid == void*.typeid:
-			if (value != null) return CastResult.TYPE_MISMATCH?;
 			return &NULL_OBJECT;
-		$case $assignable(value, String):
+		$case $defined(String x = value):
 			return new_string(value, self.allocator);
 		$default:
 			$error "Unsupported object type.";
@@ -214,7 +214,7 @@ macro Object* Object.object_from_value(&self, value) @private
 macro Object* Object.set(&self, String key, value)
 {
 	Object* val = self.object_from_value(value);
-	self.set_object(key, val);
+	object_set_object(self, key, val);
 	return val;
 }
 
@@ -242,8 +242,7 @@ macro Object* Object.push(&self, value)
 <*
  @require self.is_keyable()
 *>
-fn Object*! Object.get(&self, String key) => self.is_empty() ? SearchResult.MISSING? : self.map.get(key);
-
+fn Object*? Object.get(&self, String key) => self.is_empty() ? NOT_FOUND~ : self.map.get(key);
 
 fn bool Object.has_key(&self, String key) => self.is_map() && self.map.has_key(key);
 
@@ -268,7 +267,7 @@ fn usz Object.get_len(&self)
 *>
 fn void Object.push_object(&self, Object* to_append)
 {
-	self.init_array_if_needed();
+	object_init_array_if_needed(self);
 	self.array.push(to_append);
 }
 
@@ -277,7 +276,7 @@ fn void Object.push_object(&self, Object* to_append)
 *>
 fn void Object.set_object_at(&self, usz index, Object* to_set)
 {
-	self.init_array_if_needed();
+	object_init_array_if_needed(self);
 	while (self.array.len() < index)
 	{
 		self.array.push(&NULL_OBJECT);
@@ -292,7 +291,7 @@ fn void Object.set_object_at(&self, usz index, Object* to_set)
 }
 
 <*
- @require $Type.kindof.is_int() "Expected an integer type."
+ @require $Type.kindof.is_int() : "Expected an integer type."
 *>
 macro get_integer_value(Object* value, $Type)
 {
@@ -308,7 +307,7 @@ macro get_integer_value(Object* value, $Type)
 			return ($Type)value.s.to_uint128();
 		$endif
 	}
-	if (!value.is_int()) return NumberConversion.MALFORMED_INTEGER?;
+	if (!value.is_int()) return string::MALFORMED_INTEGER~;
 	return ($Type)value.i;
 }
 
@@ -331,77 +330,77 @@ macro Object.get_integer(&self, $Type, String key) @private
 	return get_integer_value(self.get(key), $Type);
 }
 
-fn ichar! Object.get_ichar(&self, String key) => self.get_integer(ichar, key);
-fn short! Object.get_short(&self, String key) => self.get_integer(short, key);
-fn int! Object.get_int(&self, String key) => self.get_integer(int, key);
-fn long! Object.get_long(&self, String key) => self.get_integer(long, key);
-fn int128! Object.get_int128(&self, String key) => self.get_integer(int128, key);
+fn ichar? Object.get_ichar(&self, String key) => self.get_integer(ichar, key);
+fn short? Object.get_short(&self, String key) => self.get_integer(short, key);
+fn int? Object.get_int(&self, String key) => self.get_integer(int, key);
+fn long? Object.get_long(&self, String key) => self.get_integer(long, key);
+fn int128? Object.get_int128(&self, String key) => self.get_integer(int128, key);
 
-fn ichar! Object.get_ichar_at(&self, usz index) => self.get_integer_at(ichar, index);
-fn short! Object.get_short_at(&self, usz index) => self.get_integer_at(short, index);
-fn int! Object.get_int_at(&self, usz index) => self.get_integer_at(int, index);
-fn long! Object.get_long_at(&self, usz index) => self.get_integer_at(long, index);
-fn int128! Object.get_int128_at(&self, usz index) => self.get_integer_at(int128, index);
+fn ichar? Object.get_ichar_at(&self, usz index) => self.get_integer_at(ichar, index);
+fn short? Object.get_short_at(&self, usz index) => self.get_integer_at(short, index);
+fn int? Object.get_int_at(&self, usz index) => self.get_integer_at(int, index);
+fn long? Object.get_long_at(&self, usz index) => self.get_integer_at(long, index);
+fn int128? Object.get_int128_at(&self, usz index) => self.get_integer_at(int128, index);
 
-fn char! Object.get_char(&self, String key) => self.get_integer(ichar, key);
-fn short! Object.get_ushort(&self, String key) => self.get_integer(ushort, key);
-fn uint! Object.get_uint(&self, String key) => self.get_integer(uint, key);
-fn ulong! Object.get_ulong(&self, String key) => self.get_integer(ulong, key);
-fn uint128! Object.get_uint128(&self, String key) => self.get_integer(uint128, key);
+fn char? Object.get_char(&self, String key) => self.get_integer(ichar, key);
+fn short? Object.get_ushort(&self, String key) => self.get_integer(ushort, key);
+fn uint? Object.get_uint(&self, String key) => self.get_integer(uint, key);
+fn ulong? Object.get_ulong(&self, String key) => self.get_integer(ulong, key);
+fn uint128? Object.get_uint128(&self, String key) => self.get_integer(uint128, key);
 
-fn char! Object.get_char_at(&self, usz index) => self.get_integer_at(char, index);
-fn ushort! Object.get_ushort_at(&self, usz index) => self.get_integer_at(ushort, index);
-fn uint! Object.get_uint_at(&self, usz index) => self.get_integer_at(uint, index);
-fn ulong! Object.get_ulong_at(&self, usz index) => self.get_integer_at(ulong, index);
-fn uint128! Object.get_uint128_at(&self, usz index) => self.get_integer_at(uint128, index);
+fn char? Object.get_char_at(&self, usz index) => self.get_integer_at(char, index);
+fn ushort? Object.get_ushort_at(&self, usz index) => self.get_integer_at(ushort, index);
+fn uint? Object.get_uint_at(&self, usz index) => self.get_integer_at(uint, index);
+fn ulong? Object.get_ulong_at(&self, usz index) => self.get_integer_at(ulong, index);
+fn uint128? Object.get_uint128_at(&self, usz index) => self.get_integer_at(uint128, index);
 
 <*
  @require self.is_keyable()
 *>
-fn String! Object.get_string(&self, String key)
+fn String? Object.get_string(&self, String key)
 {
 	Object* value = self.get(key)!;
-	if (!value.is_string()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_string()) return TYPE_MISMATCH~;
 	return value.s;
 }
 
 <*
  @require self.is_indexable()
 *>
-fn String! Object.get_string_at(&self, usz index)
+fn String? Object.get_string_at(&self, usz index)
 {
 	Object* value = self.get_at(index);
-	if (!value.is_string()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_string()) return TYPE_MISMATCH~;
 	return value.s;
 }
 
 <*
  @require self.is_keyable()
 *>
-macro String! Object.get_enum(&self, $EnumType, String key)
+macro String? Object.get_enum(&self, $EnumType, String key)
 {
 	Object value = self.get(key)!;
-	if ($EnumType.typeid != value.type) return CastResult.TYPE_MISMATCH?;
+	if ($EnumType.typeid != value.type) return TYPE_MISMATCH~;
 	return ($EnumType)value.i;
 }
 
 <*
  @require self.is_indexable()
 *>
-macro String! Object.get_enum_at(&self, $EnumType, usz index)
+macro String? Object.get_enum_at(&self, $EnumType, usz index)
 {
 	Object value = self.get_at(index);
-	if ($EnumType.typeid != value.type) return CastResult.TYPE_MISMATCH?;
+	if ($EnumType.typeid != value.type) return TYPE_MISMATCH~;
 	return ($EnumType)value.i;
 }
 
 <*
  @require self.is_keyable()
 *>
-fn bool! Object.get_bool(&self, String key)
+fn bool? Object.get_bool(&self, String key)
 {
 	Object* value = self.get(key)!;
-	if (!value.is_bool()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_bool()) return TYPE_MISMATCH~;
 	return value.b;
 }
 
@@ -409,17 +408,17 @@ fn bool! Object.get_bool(&self, String key)
 <*
  @require self.is_indexable()
 *>
-fn bool! Object.get_bool_at(&self, usz index)
+fn bool? Object.get_bool_at(&self, usz index)
 {
 	Object* value = self.get_at(index);
-	if (!value.is_bool()) return CastResult.TYPE_MISMATCH?;
+	if (!value.is_bool()) return TYPE_MISMATCH~;
 	return value.b;
 }
 
 <*
  @require self.is_keyable()
 *>
-fn double! Object.get_float(&self, String key)
+fn double? Object.get_float(&self, String key)
 {
 	Object* value = self.get(key)!;
 	switch (value.type.kindof)
@@ -431,14 +430,14 @@ fn double! Object.get_float(&self, String key)
 		case FLOAT:
 			return value.f;
 		default:
-			return CastResult.TYPE_MISMATCH?;
+			return TYPE_MISMATCH~;
 	}
 }
 
 <*
  @require self.is_indexable()
 *>
-fn double! Object.get_float_at(&self, usz index)
+fn double? Object.get_float_at(&self, usz index)
 {
 	Object* value = self.get_at(index);
 	switch (value.type.kindof)
@@ -450,7 +449,7 @@ fn double! Object.get_float_at(&self, usz index)
 		case FLOAT:
 			return value.f;
 		default:
-			return CastResult.TYPE_MISMATCH?;
+			return TYPE_MISMATCH~;
 	}
 }
 
@@ -462,7 +461,7 @@ fn Object* Object.get_or_create_obj(&self, String key)
 	return container;
 }
 
-def ObjectInternalMap = HashMap(<String, Object*>) @private;
-def ObjectInternalList = List(<Object*>) @private;
-def ObjectInternalMapEntry = Entry(<String, Object*>) @private;
+alias ObjectInternalMap      @private = HashMap {String, Object*};
+alias ObjectInternalList     @private = List {Object*};
+alias ObjectInternalMapEntry @private = Entry {String, Object*};
 

lib/std/collections/priorityqueue.c3

@@ -1,7 +1,7 @@
 //  priorityqueue.c3
 //  A priority queue using a classic binary heap for C3.
 //
-//  Copyright (c) 2022 David Kopec
+//  Copyright (c) 2022-2025 David Kopec
 //
 //  Permission is hereby granted, free of charge, to any person obtaining a copy
 //  of this software and associated documentation files (the "Software"), to deal
@@ -20,30 +20,27 @@
 //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
-module std::collections::priorityqueue(<Type>);
-import std::collections::priorityqueue::private;
-
-distinct PriorityQueue = inline PrivatePriorityQueue(<Type, false>);
-distinct PriorityQueueMax = inline PrivatePriorityQueue(<Type, true>);
-
-module std::collections::priorityqueue::private(<Type, MAX>);
+module std::collections::priorityqueue;
 import std::collections::list, std::io;
 
-def Heap = List(<Type>);
+typedef PriorityQueue <Type> = inline PrivatePriorityQueue{Type, false};
+typedef PriorityQueueMax <Type> = inline PrivatePriorityQueue{Type, true};
 
-struct PrivatePriorityQueue (Printable)
+struct PrivatePriorityQueue (Printable) <Type, MAX>
 {
-	Heap heap;
+	List{Type} heap;
 }
 
-fn void PrivatePriorityQueue.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap()) @inline
+fn PrivatePriorityQueue* PrivatePriorityQueue.init(&self, Allocator allocator, usz initial_capacity = 16, ) @inline
 {
-	self.heap.new_init(initial_capacity, allocator);
+	self.heap.init(allocator, initial_capacity);
+	return self;
 }
 
-fn void PrivatePriorityQueue.temp_init(&self, usz initial_capacity = 16) @inline
+fn PrivatePriorityQueue* PrivatePriorityQueue.tinit(&self, usz initial_capacity = 16) @inline
 {
-	self.heap.new_init(initial_capacity, allocator::temp()) @inline;
+	self.init(tmem, initial_capacity);
+	return self;
 }
 
 
@@ -67,6 +64,9 @@ fn void PrivatePriorityQueue.push(&self, Type element)
 	}
 }
 
+<*
+ @require index < self.len() : "Index out of range"
+*>
 fn void PrivatePriorityQueue.remove_at(&self, usz index)
 {
 	if (index == 0)
@@ -79,11 +79,11 @@ fn void PrivatePriorityQueue.remove_at(&self, usz index)
 <*
  @require self != null
 *>
-fn Type! PrivatePriorityQueue.pop(&self)
+fn Type? PrivatePriorityQueue.pop(&self)
 {
 	usz i = 0;
 	usz len = self.heap.len();
-	if (!len) return IteratorResult.NO_MORE_ELEMENT?;
+	if (!len) return NO_MORE_ELEMENT~;
 	usz new_count = len - 1;
 	self.heap.swap(0, new_count);
 	while OUTER: ((2 * i + 1) < new_count)
@@ -117,10 +117,9 @@ fn Type! PrivatePriorityQueue.pop(&self)
 	return self.heap.pop();
 }
 
-fn Type! PrivatePriorityQueue.first(&self)
+fn Type? PrivatePriorityQueue.first(&self)
 {
-	if (!self.len()) return IteratorResult.NO_MORE_ELEMENT?;
-	return self.heap.get(0);
+	return self.heap.first();
 }
 
 fn void PrivatePriorityQueue.free(&self)
@@ -130,12 +129,12 @@ fn void PrivatePriorityQueue.free(&self)
 
 fn usz PrivatePriorityQueue.len(&self) @operator(len)
 {
-	return self.heap.len();
+	return self.heap.len() @inline;
 }
 
 fn bool PrivatePriorityQueue.is_empty(&self)
 {
-	return self.heap.is_empty();
+	return self.heap.is_empty() @inline;
 }
 
 <*
@@ -146,13 +145,8 @@ fn Type PrivatePriorityQueue.get(&self, usz index) @operator([])
 	return self.heap[index];
 }
 
-fn usz! PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic
+fn usz? PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic
 {
 	return self.heap.to_format(formatter);
 }
 
-fn String PrivatePriorityQueue.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
-{
-	return self.heap.to_new_string(allocator);
-}
-

lib/std/collections/range.c3

@@ -1,7 +1,7 @@
 <*
  @require Type.is_ordered : "The type must be ordered"
 *>
-module std::collections::range(<Type>);
+module std::collections::range <Type>;
 import std::io;
 
 struct Range (Printable)
@@ -29,22 +29,7 @@ fn Type Range.get(&self, usz index) @operator([])
 	return (Type)(self.start + (usz)index);
 }
 
-fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic @deprecated
-{
-	return string::format("[%s..%s]", self.start, self.end, allocator: allocator);
-}
-
-fn String Range.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("[%s..%s]", self.start, self.end, allocator: allocator);
-}
-
-fn String Range.to_tstring(&self)
-{
-	return self.to_string(allocator::temp());
-}
-
-fn usz! Range.to_format(&self, Formatter* formatter) @dynamic
+fn usz? Range.to_format(&self, Formatter* formatter) @dynamic
 {
 	return formatter.printf("[%s..%s]", self.start, self.end)!;
 }
@@ -66,26 +51,11 @@ fn bool ExclusiveRange.contains(&self, Type value) @inline
 	return value >= self.start && value < self.end;
 }
 
-fn usz! ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic
+fn usz? ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic
 {
 	return formatter.printf("[%s..<%s]", self.start, self.end)!;
 }
 
-fn String ExclusiveRange.to_new_string(&self, Allocator allocator = null) @dynamic
-{
-	return self.to_string(allocator ?: allocator::heap());
-}
-
-fn String ExclusiveRange.to_string(&self, Allocator allocator) @dynamic
-{
-	return string::format("[%s..<%s]", self.start, self.end, allocator: allocator);
-}
-
-fn String ExclusiveRange.to_tstring(&self)
-{
-	return self.to_new_string(allocator::temp());
-}
-
 <*
  @require index < self.len() : "Can't index into an empty range"
 *>

lib/std/collections/ringbuffer.c3

@@ -1,8 +1,14 @@
-module std::collections::ringbuffer(<Type, SIZE>);
+<*
+ @require Type.kindof == ARRAY : "Required an array type"
+*>
+module std::collections::ringbuffer <Type>;
+import std::io;
 
-struct RingBuffer
+alias Element = $typeof((Type){}[0]);
+
+struct RingBuffer (Printable)
 {
-	Type[SIZE] buf;
+	Type buf;
 	usz written;
 	usz head;
 }
@@ -12,9 +18,9 @@ fn void RingBuffer.init(&self) @inline
 	*self = {};
 }
 
-fn void RingBuffer.push(&self, Type c)
+fn void RingBuffer.push(&self, Element c)
 {
-	if (self.written < SIZE)
+	if (self.written < self.buf.len)
 	{
 		self.buf[self.written] = c;
 		self.written++;
@@ -22,14 +28,14 @@ fn void RingBuffer.push(&self, Type c)
 	else
 	{
 		self.buf[self.head] = c;
-		self.head = (self.head + 1) % SIZE;
+		self.head = (self.head + 1) % self.buf.len;
 	}
 }
 
-fn Type RingBuffer.get(&self, usz index) @operator([])
+fn Element RingBuffer.get(&self, usz index) @operator([])
 {
-	index %= SIZE;
-	usz avail = SIZE - self.head;
+	index %= self.buf.len;
+	usz avail = self.buf.len - self.head;
 	if (index < avail)
 	{
 		return self.buf[self.head + index];
@@ -37,25 +43,31 @@ fn Type RingBuffer.get(&self, usz index) @operator([])
 	return self.buf[index - avail];
 }
 
-fn Type! RingBuffer.pop(&self)
+fn Element? RingBuffer.pop(&self)
 {
 	switch
 	{
 		case self.written == 0:
-			return SearchResult.MISSING?;
-		case self.written < SIZE:
+			return NO_MORE_ELEMENT~;
+		case self.written < self.buf.len:
 			self.written--;
 			return self.buf[self.written];
 		default:
-			self.head = (self.head - 1) % SIZE;
+			self.head = (self.head - 1) % self.buf.len;
 			return self.buf[self.head];
 	}
 }
 
-fn usz RingBuffer.read(&self, usz index, Type[] buffer)
+fn usz? RingBuffer.to_format(&self, Formatter* format) @dynamic
 {
-	index %= SIZE;
-	if (self.written < SIZE)
+	// Improve this?
+	return format.printf("%s", self.buf);
+}
+
+fn usz RingBuffer.read(&self, usz index, Element[] buffer)
+{
+	index %= self.buf.len;
+	if (self.written < self.buf.len)
 	{
 		if (index >= self.written) return 0;
 		usz end = self.written - index;
@@ -63,7 +75,7 @@ fn usz RingBuffer.read(&self, usz index, Type[] buffer)
 		buffer[:n] = self.buf[index:n];
 		return n;
 	}
-	usz end = SIZE - self.head;
+	usz end = self.buf.len - self.head;
 	if (index >= end)
 	{
 		index -= end;
@@ -72,13 +84,13 @@ fn usz RingBuffer.read(&self, usz index, Type[] buffer)
 		buffer[:n] = self.buf[index:n];
 		return n;
 	}
-	if (buffer.len <= SIZE - index)
+	if (buffer.len <= self.buf.len - index)
 	{
 		usz n = buffer.len;
 		buffer[:n] = self.buf[self.head + index:n];
 		return n;
 	}
-	usz n1 = SIZE - index;
+	usz n1 = self.buf.len - index;
 	buffer[:n1] = self.buf[self.head + index:n1];
 	buffer = buffer[n1..];
 	index -= n1;
@@ -87,10 +99,10 @@ fn usz RingBuffer.read(&self, usz index, Type[] buffer)
 	return n1 + n2;
 }
 
-fn void RingBuffer.write(&self, Type[] buffer)
+fn void RingBuffer.write(&self, Element[] buffer)
 {
 	usz i;
-	while (self.written < SIZE && i < buffer.len)
+	while (self.written < self.buf.len && i < buffer.len)
 	{
 		self.buf[self.written] = buffer[i++];
 		self.written++;
@@ -98,6 +110,6 @@ fn void RingBuffer.write(&self, Type[] buffer)
 	foreach (c : buffer[i..])
 	{
 		self.buf[self.head] = c;
-		self.head = (self.head + 1) % SIZE;
+		self.head = (self.head + 1) % self.buf.len;
 	}
 }

lib/std/collections/tuple.c3

@@ -1,16 +1,72 @@
-module std::collections::tuple(<Type1, Type2>);
+module std::collections::pair <Type1, Type2>;
+import std::io;
 
-struct Tuple
+struct Pair (Printable)
 {
 	Type1 first;
 	Type2 second;
 }
 
-module std::collections::triple(<Type1, Type2, Type3>);
+fn usz? Pair.to_format(&self, Formatter* f) @dynamic
+{
+	return f.printf("{ %s, %s }", self.first, self.second);
+}
 
-struct Triple
+<*
+ @param [&out] a
+ @param [&out] b
+ @require $defined(*a = self.first) : "You cannot assign the first value to a"
+ @require $defined(*b = self.second) : "You cannot assign the second value to b"
+*>
+macro void Pair.unpack(&self, a, b)
+{
+	*a = self.first;
+	*b = self.second;
+}
+
+fn bool Pair.equal(self, Pair other) @operator(==) @if (types::has_equals(Type1) &&& types::has_equals(Type2))
+{
+	return self.first == other.first && self.second == other.second;
+}
+
+module std::collections::triple <Type1, Type2, Type3>;
+import std::io;
+
+struct Triple (Printable)
 {
 	Type1 first;
 	Type2 second;
 	Type3 third;
+}
+
+fn usz? Triple.to_format(&self, Formatter* f) @dynamic
+{
+	return f.printf("{ %s, %s, %s }", self.first, self.second, self.third);
+}
+<*
+ @param [&out] a
+ @param [&out] b
+ @param [&out] c
+ @require $defined(*a = self.first) : "You cannot assign the first value to a"
+ @require $defined(*b = self.second) : "You cannot assign the second value to b"
+ @require $defined(*c = self.third) : "You cannot assign the second value to c"
+*>
+macro void Triple.unpack(&self, a, b, c)
+{
+	*a = self.first;
+	*b = self.second;
+	*c = self.third;
+}
+
+fn bool Triple.equal(self, Triple other) @operator(==) @if (types::has_equals(Type1) &&& types::has_equals(Type2) &&& types::has_equals(Type3))
+{
+	return self.first == other.first && self.second == other.second && self.third == other.third;
+}
+
+module std::collections::tuple <Type1, Type2>;
+
+struct Tuple @deprecated("Use 'Pair' instead")
+{
+	Type1 first;
+	Type2 second;
 }

lib/std/compression/qoi.c3

@@ -7,10 +7,12 @@ const uint PIXELS_MAX = 400000000;
  Purely informative. It will be saved to the file header,
  but does not affect how chunks are en-/decoded.
 *>
-enum QOIColorspace : char (char id)
+constdef QOIColorspace : char
 {
-	SRGB = 0, 	// sRGB with linear alpha
-	LINEAR = 1 	// all channels linear
+	<* sRGB with linear alpha *>
+	SRGB = 0,
+	<* all channels linear *>
+	LINEAR = 1
 }
 
 <*
@@ -19,7 +21,7 @@ enum QOIColorspace : char (char id)
  AUTO can be used when decoding to automatically determine
  the channels from the file's header.
 *>
-enum QOIChannels : char (char id)
+constdef QOIChannels : inline char
 {
 	AUTO = 0,
 	RGB = 3,
@@ -37,19 +39,11 @@ struct QOIDesc
 	QOIChannels channels;
 	QOIColorspace colorspace;
 }
-
 <*
  QOI Errors.
  These are all the possible bad outcomes.
 *>
-fault QOIError
-{
-	INVALID_PARAMETERS,
-	FILE_OPEN_FAILED,
-	FILE_WRITE_FAILED,
-	INVALID_DATA,
-	TOO_MANY_PIXELS
-}
+faultdef INVALID_PARAMETERS, FILE_OPEN_FAILED, FILE_WRITE_FAILED, INVALID_DATA, TOO_MANY_PIXELS;
 
 
 // Let the user decide if they want to use std::io
@@ -67,27 +61,17 @@ import std::io;
  The function returns an optional, which can either be a QOIError
  or the number of bytes written on success.
 
- @param [in] filename `The file's name to write the image to`
- @param [in] input `The raw RGB or RGBA pixels to encode`
- @param [&in] desc `The descriptor of the image`
+ @param [in] filename : `The file's name to write the image to`
+ @param [in] input : `The raw RGB or RGBA pixels to encode`
+ @param [&in] desc : `The descriptor of the image`
 *>
-fn usz! write(String filename, char[] input, QOIDesc* desc)
+fn usz? write(String filename, char[] input, QOIDesc* desc) => @pool()
 {
-	@pool() {
-		// encode data
-		char[] output = encode(input, desc)!;
+	// encode data
+	char[] output = encode(tmem, input, desc)!;
 
-		// open file
-		File! f = file::open(filename, "wb");
-		if (catch f) { return QOIError.FILE_OPEN_FAILED?; }
-
-		// write data to file and close it
-		usz! written = f.write(output);
-		if (catch written) { return QOIError.FILE_WRITE_FAILED?; }
-		if (catch f.close()) { return QOIError.FILE_WRITE_FAILED?; }
-
-		return written;
-	};
+	file::save(filename, output)!;
+	return output.len;
 }
 
 
@@ -108,22 +92,21 @@ fn usz! write(String filename, char[] input, QOIDesc* desc)
  The returned pixel data should be free()d after use, or the decoding
  and use of the data should be wrapped in a @pool() { ... }; block.
 
- @param [in] filename `The file's name to read the image from`
- @param [&out] desc `The descriptor to fill with the image's info`
- @param channels `The channels to be used`
+ @param [in] filename : `The file's name to read the image from`
+ @param [&out] desc : `The descriptor to fill with the image's info`
+ @param channels : `The channels to be used`
+ @return? FILE_OPEN_FAILED, INVALID_DATA, TOO_MANY_PIXELS
 *>
-fn char[]! read(String filename, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap())
+fn char[]? read(Allocator allocator, String filename, QOIDesc* desc, QOIChannels channels = AUTO) => @pool()
 {
 	// read file
-	char[]! data = file::load_new(filename);
-	if (catch data) return QOIError.FILE_OPEN_FAILED?;
-	defer mem::free(data);
-
+	char[] data = file::load_temp(filename) ?? FILE_OPEN_FAILED~!;
 	// pass data to decode function
-	return decode(data, desc, channels, allocator);
+	return decode(allocator, data, desc, channels);
 }
 
 
+
 // Back to basic non-stdio mode
 module std::compression::qoi;
 import std::bits;
@@ -138,20 +121,21 @@ import std::bits;
  and use of the data should be wrapped in a @pool() { ... }; block.
  See the write() function for an example.
 
- @param [in] input `The raw RGB or RGBA pixels to encode`
- @param [&in] desc `The descriptor of the image`
+ @param [in] input : `The raw RGB or RGBA pixels to encode`
+ @param [&in] desc : `The descriptor of the image`
+ @return? INVALID_PARAMETERS, TOO_MANY_PIXELS, INVALID_DATA
 *>
-fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::heap())
+fn char[]? encode(Allocator allocator, char[] input, QOIDesc* desc) @nodiscard
 {
 	// check info in desc
-	if (desc.width == 0 || desc.height == 0) return QOIError.INVALID_PARAMETERS?;
-	if (desc.channels == AUTO) return QOIError.INVALID_PARAMETERS?;
+	if (desc.width == 0 || desc.height == 0) return INVALID_PARAMETERS~;
+	if (desc.channels == AUTO) return INVALID_PARAMETERS~;
 	uint pixels = desc.width * desc.height;
-	if (pixels > PIXELS_MAX) return QOIError.TOO_MANY_PIXELS?;
+	if (pixels > PIXELS_MAX) return TOO_MANY_PIXELS~;
 	
 	// check input data size
-	uint image_size = pixels * desc.channels.id;
-	if (image_size != input.len) return QOIError.INVALID_DATA?;
+	uint image_size = pixels * desc.channels;
+	if (image_size != input.len) return INVALID_DATA~;
 
 	// allocate memory for encoded data (output)
 	// header + chunk tag and RGB(A) data for each pixel + end of stream
@@ -164,13 +148,13 @@ fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::
 		.be_magic = bswap('qoif'),
 		.be_width = bswap(desc.width),
 		.be_height = bswap(desc.height),
-		.channels = desc.channels.id,
-		.colorspace = desc.colorspace.id
+		.channels = desc.channels,
+		.colorspace = desc.colorspace
 	};
 
 	uint pos = Header.sizeof; 	// Current position in output
 	uint loc;					// Current position in image (top-left corner)
-	uint loc_end = image_size - desc.channels.id; // End of image data
+	uint loc_end = image_size - desc.channels; // End of image data
 	char run_length = 0; 		// Length of the current run
 	
 	Pixel[64] palette; // Zero-initialized by default
@@ -181,7 +165,7 @@ fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::
 	ichar[<3>] luma; // ...and luma
 
 	// write chunks
-	for (loc = 0; loc < image_size; loc += desc.channels.id)
+	for (loc = 0; loc < image_size; loc += desc.channels)
 	{
 		// set previous pixel
 		prev = p;
@@ -191,81 +175,89 @@ fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::
 		if (desc.channels == RGBA) p.a = input[loc + 3];
 
 		// check if we can run the previous pixel
-		if (prev == p) {
+		if (prev == p)
+		{
 			run_length++;
-			if (run_length == 62 || loc == loc_end) {
-				*@extract(OpRun, output, &pos) = { OP_RUN, run_length - 1 };
-				run_length = 0;
-			}
-		} else {
-			// end last run if there was one
-			if (run_length > 0) {
+			if (run_length == 62 || loc == loc_end)
+			{
 				*@extract(OpRun, output, &pos) = { OP_RUN, run_length - 1 };
 				run_length = 0;
 			}
+			continue;
+		}
+		// end last run if there was one
+		if (run_length > 0)
+		{
+			*@extract(OpRun, output, &pos) = { OP_RUN, run_length - 1 };
+			run_length = 0;
+		}
 
-			switch {
-				// check if we can index the palette
-				case (palette[p.hash()] == p):
-					*@extract(OpIndex, output, &pos) = {
-						OP_INDEX,
-						p.hash()
+		switch
+		{
+			// check if we can index the palette
+			case (palette[p.hash()] == p):
+				*@extract(OpIndex, output, &pos) = {
+					OP_INDEX,
+					p.hash()
+				};
+
+			// check if we can use diff or luma
+			case (prev != p && prev.a == p.a):
+				// diff the pixels
+				diff = p.rgb - prev.rgb;
+				if (diff.r > -3 && diff.r < 2
+					&& diff.g > -3 && diff.g < 2
+					&& diff.b > -3 && diff.b < 2)
+				{
+					*@extract(OpDiff, output, &pos) = {
+						OP_DIFF,
+						(char)diff.r + 2,
+						(char)diff.g + 2,
+						(char)diff.b + 2
 					};
-
-				// check if we can use diff or luma
-				case (prev != p && prev.a == p.a):
-					// diff the pixels
-					diff = p.rgb - prev.rgb;
-					if (
-						diff.r > -3 && diff.r < 2 &&
-						diff.g > -3 && diff.g < 2 &&
-						diff.b > -3 && diff.b < 2
-					) {
-						*@extract(OpDiff, output, &pos) = {
-							OP_DIFF,
-							(char)diff.r + 2,
-							(char)diff.g + 2,
-							(char)diff.b + 2
-						};
-						palette[p.hash()] = p;
-					} else {
-						// check luma eligibility
-						luma = { diff.r - diff.g, diff.g, diff.b - diff.g };
-						if (
-							luma.r >= -8 && luma.r <= 7 &&
-							luma.g >= -32 && luma.g <= 31 &&
-							luma.b >= -8 && luma.b <= 7
-						) {
-							*@extract(OpLuma, output, &pos) = {
-								OP_LUMA,
-								(char)luma.g + 32,
-								(char)luma.r + 8,
-								(char)luma.b + 8
-							};
-							palette[p.hash()] = p;
-						} else { nextcase; }
-					}
-
-				// worst case scenario: just encode the raw pixel
-				default:
-					if (prev.a != p.a) {
-						*@extract(OpRGBA, output, &pos) = { OP_RGBA, p.r, p.g, p.b, p.a };
-					} else {
-						*@extract(OpRGB, output, &pos) = { OP_RGB, p.r, p.g, p.b };
-					}
 					palette[p.hash()] = p;
-			}
+					break;
+				}
+				// check luma eligibility
+				luma = { diff.r - diff.g, diff.g, diff.b - diff.g };
+				if (luma.r >= -8 && luma.r <= 7
+					&& luma.g >= -32 && luma.g <= 31
+					&& luma.b >= -8 && luma.b <= 7)
+				{
+					*@extract(OpLuma, output, &pos) = {
+						OP_LUMA,
+						(char)luma.g + 32,
+						(char)luma.r + 8,
+						(char)luma.b + 8
+					};
+					palette[p.hash()] = p;
+					break;
+				}
+				nextcase;
+
+			// worst case scenario: just encode the raw pixel
+			default:
+				if (prev.a != p.a)
+				{
+					*@extract(OpRGBA, output, &pos) = { OP_RGBA, p.r, p.g, p.b, p.a };
+				}
+				else
+				{
+					*@extract(OpRGB, output, &pos) = { OP_RGB, p.r, p.g, p.b };
+				}
+				palette[p.hash()] = p;
 		}
 	}
 
 	// write end of stream
-	output[pos:END_OF_STREAM.len] = END_OF_STREAM;
+	output[pos:END_OF_STREAM.len] = END_OF_STREAM[..];
 	pos += END_OF_STREAM.len;
 	
 	return output[:pos];
 }
 
 
+
 <*
  Decode a QOI image from memory.
 
@@ -283,34 +275,35 @@ fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::
  The returned pixel data should be free()d after use, or the decoding
  and use of the data should be wrapped in a @pool() { ... }; block.
 
- @param [in] data `The QOI image data to decode`
- @param [&out] desc `The descriptor to fill with the image's info`
- @param channels `The channels to be used`
+ @param [in] data : `The QOI image data to decode`
+ @param [&out] desc : `The descriptor to fill with the image's info`
+ @param channels : `The channels to be used`
+ @return? INVALID_DATA, TOO_MANY_PIXELS
 *>
-fn char[]! decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap())
+fn char[]? decode(Allocator allocator, char[] data, QOIDesc* desc, QOIChannels channels = AUTO) @nodiscard
 {
 	// check input data
-	if (data.len < Header.sizeof + END_OF_STREAM.len) return QOIError.INVALID_DATA?;
+	if (data.len < Header.sizeof + END_OF_STREAM.len) return INVALID_DATA~;
 
 	// get header
 	Header* header = (Header*)data.ptr;
 
 	// check magic bytes (FourCC)
-	if (bswap(header.be_magic) != 'qoif') return QOIError.INVALID_DATA?;
+	if (bswap(header.be_magic) != 'qoif') return INVALID_DATA~;
 
 	// copy header data to desc
-	desc.width = bswap(header.be_width);
-	desc.height = bswap(header.be_height);
-	desc.channels = @enumcast(QOIChannels, header.channels)!; 			// Rethrow if invalid
-	desc.colorspace = @enumcast(QOIColorspace, header.colorspace)!;	// Rethrow if invalid
-	if (desc.channels == AUTO) return QOIError.INVALID_DATA?; // Channels must be specified in the header
+	uint width = desc.width = bswap(header.be_width);
+	uint height = desc.height = bswap(header.be_height);
+	QOIChannels desc_channels = desc.channels = header.channels;
+	desc.colorspace = header.colorspace;
+	if (desc_channels == AUTO) return INVALID_DATA~; // Channels must be specified in the header
 
 	// check width and height
-	if (desc.width == 0 || desc.height == 0) return QOIError.INVALID_DATA?;
+	if (width == 0 || height == 0) return INVALID_DATA~;
 
 	// check pixel count
-	ulong pixels = (ulong)desc.width * (ulong)desc.height;
-	if (pixels > PIXELS_MAX) return QOIError.TOO_MANY_PIXELS?;
+	ulong pixels = (ulong)width * (ulong)height;
+	if (pixels > PIXELS_MAX) return TOO_MANY_PIXELS~;
 
 	uint pos = Header.sizeof; 	// Current position in data
 	uint loc;					// Current position in image (top-left corner)
@@ -320,14 +313,14 @@ fn char[]! decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, Alloc
 	Pixel[64] palette; // Zero-initialized by default
 	Pixel p = { 0, 0, 0, 255 };
 
-	if (channels == AUTO) channels = desc.channels;
+	if (channels == AUTO) channels = desc_channels;
 	
 	// allocate memory for image data
-	usz image_size = (usz)pixels * channels.id;
+	usz image_size = (usz)pixels * channels;
 	char[] image = allocator::alloc_array(allocator, char, image_size);
 	defer catch allocator::free(allocator, image);
 
-	for (loc = 0; loc < image_size; loc += channels.id)
+	for (loc = 0; loc < image_size; loc += channels)
 	{
 		// get chunk tag
 		tag = data[pos];
@@ -373,7 +366,7 @@ fn char[]! decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, Alloc
 		}
 
 		// draw the pixel
-		if (channels == RGBA) { image[loc:4] = p.rgba; } else { image[loc:3] = p.rgb; }
+		if (channels == RGBA) { image[loc:4] = p.rgba[..]; } else { image[loc:3] = p.rgb[..]; }
 	}
 	
 	return image;
@@ -400,28 +393,25 @@ const OP_RUN = 0b11;
 
 struct Header @packed
 {
-	uint be_magic;	// magic bytes "qoif"
-	uint be_width;	// image width in pixels (BE)
-	uint be_height;	// image height in pixels (BE)
+	<* magic bytes "qoif" *>
+	uint be_magic;
+	<* image width in pixels (BE) *>
+	uint be_width;
+	<* image height in pixels (BE) *>
+	uint be_height;
 
 	// informative fields
-	char channels;	// 3 = RGB, 4 = RGB
-	char colorspace;	// 0 = sRGB with linear alpha, 1 = all channels linear
+	<* 3 = RGB, 4 = RGB *>
+	QOIChannels channels;
+	<* 0 = sRGB with linear alpha, 1 = all channels linear *>
+	QOIColorspace colorspace;
 }
 
 const char[*] END_OF_STREAM = {0, 0, 0, 0, 0, 0, 0, 1};
 
-// inefficient, but it's only run once at a time
-macro @enumcast($Type, raw)
+typedef Pixel = inline char[<4>];
+macro char Pixel.hash(Pixel p)
 {
-	foreach (value : $Type.values) {
-		if (value.id == raw) return value;
-	}
-	return QOIError.INVALID_DATA?;
-}
-
-distinct Pixel = inline char[<4>];
-macro char Pixel.hash(Pixel p) {
 	return (p.r * 3 + p.g * 5 + p.b * 7 + p.a * 11) % 64;
 }
 
@@ -452,7 +442,7 @@ bitstruct OpDiff : char
 	char diff_green : 2..3;
 	char diff_blue : 0..1;
 }
-bitstruct OpLuma : ushort
+bitstruct OpLuma : ushort @align(1)
 {
 	char tag : 6..7;
 	char diff_green : 0..5;

lib/std/core/allocators/arena_allocator.c3

@@ -1,9 +1,13 @@
-// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2023-2025 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::mem::allocator;
 import std::math;
 
+// The arena allocator allocates up to its maximum data
+// and then fails to allocate more, returning out of memory.
+// It supports mark and reset to mark.
+
 struct ArenaAllocator (Allocator)
 {
 	char[] data;
@@ -12,6 +16,8 @@ struct ArenaAllocator (Allocator)
 
 <*
  Initialize a memory arena for use using the provided bytes.
+
+ @param [inout] data : "The memory to use for the arena."
 *>
 fn ArenaAllocator* ArenaAllocator.init(&self, char[] data)
 {
@@ -20,18 +26,44 @@ fn ArenaAllocator* ArenaAllocator.init(&self, char[] data)
 	return self;
 }
 
+<*
+ Reset the usage completely.
+*>
 fn void ArenaAllocator.clear(&self)
 {
 	self.used = 0;
 }
 
-struct ArenaAllocatorHeader @local
+<*
+ Given some memory, create an arena allocator on the stack for it.
+
+ @param [inout] bytes : `The bytes to use, may be empty.`
+
+ @return `An arena allocator using the bytes`
+*>
+macro ArenaAllocator* wrap(char[] bytes)
 {
-	usz size;
-	char[*] data;
+	return (ArenaAllocator){}.init(bytes);
 }
 
 <*
+ "Mark" the current state of the arena allocator by returning the use count.
+
+ @return `The value to pass to 'reset' in order to reset to the current use.`
+*>
+fn usz ArenaAllocator.mark(&self) => self.used;
+
+<*
+ Reset to a previous mark.
+
+ @param mark : `The previous mark.`
+ @require mark <= self.used : "Invalid mark - out of range"
+*>
+fn void ArenaAllocator.reset(&self, usz mark) => self.used = mark;
+
+<*
+ Implements the Allocator interface method.
+
  @require ptr != null
 *>
 fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic
@@ -45,24 +77,25 @@ fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic
 	}
 }
 
-fn usz ArenaAllocator.mark(&self) @dynamic => self.used;
-fn void ArenaAllocator.reset(&self, usz mark) @dynamic => self.used = mark;
 
 <*
+ Implements the Allocator interface method.
+
  @require !alignment || math::is_power_of_2(alignment)
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
  @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	usz total_len = self.data.len;
-	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE~;
 	void* start_mem = self.data.ptr;
 	void* unaligned_pointer_to_offset = start_mem + self.used + ArenaAllocatorHeader.sizeof;
 	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
 	usz end = (usz)(mem - self.data.ptr) + size;
-	if (end > total_len) return AllocationFailure.OUT_OF_MEMORY?;
+	if (end > total_len) return mem::OUT_OF_MEMORY~;
 	self.used = end;
 	ArenaAllocatorHeader* header = mem - ArenaAllocatorHeader.sizeof;
 	header.size = size;
@@ -71,17 +104,20 @@ fn void*! ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz a
 }
 
 <*
+ Implements the Allocator interface method.
+
  @require !alignment || math::is_power_of_2(alignment)
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
  @require old_pointer != null
  @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
+fn void*? ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	assert(old_pointer >= self.data.ptr, "Pointer originates from a different allocator.");
 	usz total_len = self.data.len;
-	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE~;
 	ArenaAllocatorHeader* header = old_pointer - ArenaAllocatorHeader.sizeof;
 	usz old_size = header.size;
 	// Do last allocation and alignment match?
@@ -94,7 +130,7 @@ fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignmen
 		else
 		{
 			usz new_used = self.used + size - old_size;
-			if (new_used > total_len) return AllocationFailure.OUT_OF_MEMORY?;
+			if (new_used > total_len) return mem::OUT_OF_MEMORY~;
 			self.used = new_used;
 		}
 		header.size = size;
@@ -102,6 +138,14 @@ fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignmen
 	}
 	// Otherwise just allocate new memory.
 	void* mem = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	mem::copy(mem, old_pointer, math::min(size, old_size), mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
-}
+}
+
+// Internal data
+
+struct ArenaAllocatorHeader @local
+{
+	usz size;
+	char[*] data;
+}

lib/std/core/allocators/backed_arena_allocator.c3

@@ -0,0 +1,219 @@
+module std::core::mem::allocator;
+import std::io, std::math;
+
+<*
+ The backed arena allocator provides an allocator that will allocate from a pre-allocated chunk of memory
+ provided by it's backing allocator. The allocator supports mark / reset operations, so it can be used
+ as a stack (push-pop) allocator. If the initial memory is used up, it will fall back to regular allocations,
+ that will be safely freed on `reset`.
+
+ While this allocator is similar to the dynamic arena, it supports multiple "save points", which the dynamic arena
+ doesn't.
+*>
+struct BackedArenaAllocator (Allocator)
+{
+	Allocator backing_allocator;
+	ExtraPage* last_page;
+	usz used;
+	usz capacity;
+	char[*] data;
+}
+
+struct AllocChunk @local
+{
+	usz size;
+	char[*] data;
+}
+
+const usz PAGE_IS_ALIGNED @local = (usz)isz.max + 1u;
+
+struct ExtraPage @local
+{
+	ExtraPage* prev_page;
+	void* start;
+	usz mark;
+	usz size;
+	usz ident;
+	char[*] data;
+}
+
+macro usz ExtraPage.pagesize(&self) => self.size & ~PAGE_IS_ALIGNED;
+macro bool ExtraPage.is_aligned(&self) => self.size & PAGE_IS_ALIGNED == PAGE_IS_ALIGNED;
+
+<*
+ @require size >= 16
+*>
+fn BackedArenaAllocator*? new_backed_allocator(usz size, Allocator allocator)
+{
+	BackedArenaAllocator* temp = allocator::alloc_with_padding(allocator, BackedArenaAllocator, size)!;
+	temp.last_page = null;
+	temp.backing_allocator = allocator;
+	temp.used = 0;
+	temp.capacity = size;
+	return temp;
+}
+
+fn void BackedArenaAllocator.destroy(&self)
+{
+	self.reset(0);
+	if (self.last_page) (void)_free_page(self, self.last_page);
+	allocator::free(self.backing_allocator, self);
+}
+
+fn usz BackedArenaAllocator.mark(&self) => self.used;
+
+fn void BackedArenaAllocator.release(&self, void* old_pointer, bool) @dynamic
+{
+	usz old_size = *(usz*)(old_pointer - DEFAULT_SIZE_PREFIX);
+	if (old_pointer + old_size == &self.data[self.used])
+	{
+		self.used -= old_size;
+		asan::poison_memory_region(&self.data[self.used], old_size);
+	}
+}
+fn void BackedArenaAllocator.reset(&self, usz mark)
+{
+	ExtraPage *last_page = self.last_page;
+	while (last_page && last_page.mark > mark)
+	{
+		self.used = last_page.mark;
+		ExtraPage *to_free = last_page;
+		last_page = last_page.prev_page;
+		_free_page(self, to_free)!!;
+	}
+	self.last_page = last_page;
+	$if env::COMPILER_SAFE_MODE || env::ADDRESS_SANITIZER:
+		if (!last_page)
+		{
+			usz cleaned = self.used - mark;
+			if (cleaned > 0)
+			{
+				$if env::COMPILER_SAFE_MODE && !env::ADDRESS_SANITIZER:
+					self.data[mark : cleaned] = 0xAA;
+				$endif
+				asan::poison_memory_region(&self.data[mark], cleaned);
+			}
+		}
+	$endif
+	self.used = mark;
+}
+
+fn void? _free_page(BackedArenaAllocator* self, ExtraPage* page) @inline @local
+{
+	void* mem = page.start;
+	return self.backing_allocator.release(mem, page.is_aligned());
+}
+
+fn void*? _realloc_page(BackedArenaAllocator* self, ExtraPage* page, usz size, usz alignment) @inline @local
+{
+	// Then the actual start pointer:
+	void* real_pointer = page.start;
+
+	// Walk backwards to find the pointer to this page.
+	ExtraPage **pointer_to_prev = &self.last_page;
+	// Remove the page from the list
+	while (*pointer_to_prev != page)
+	{
+		pointer_to_prev = &((*pointer_to_prev).prev_page);
+	}
+	*pointer_to_prev = page.prev_page;
+	usz page_size = page.pagesize();
+	// Clear on size > original size.
+	void* data = self.acquire(size, NO_ZERO, alignment)!;
+	mem::copy(data, &page.data[0], page_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	self.backing_allocator.release(real_pointer, page.is_aligned());
+	return data;
+}
+
+fn void*? BackedArenaAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+{
+	AllocChunk *chunk = pointer - AllocChunk.sizeof;
+	if (chunk.size == (usz)-1)
+	{
+		assert(self.last_page, "Realloc of unrelated pointer");
+		// First grab the page
+		ExtraPage *page = pointer - ExtraPage.sizeof;
+		return _realloc_page(self, page, size, alignment);
+	}
+
+	AllocChunk* data = self.acquire(size, NO_ZERO, alignment)!;
+	mem::copy(data, pointer, math::min(size, chunk.size), mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+
+	return data;
+}
+
+<*
+ @require size > 0
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+*>
+fn void*? BackedArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	alignment = alignment_for_allocation(alignment);
+	void* start_mem = &self.data;
+	void* starting_ptr = start_mem + self.used;
+	void* aligned_header_start = mem::aligned_pointer(starting_ptr, AllocChunk.alignof);
+	void* mem = aligned_header_start + AllocChunk.sizeof;
+	if (alignment > AllocChunk.alignof)
+	{
+		mem = mem::aligned_pointer(mem, alignment);
+	}
+	usz new_usage = (usz)(mem - start_mem) + size;
+
+	// Arena allocation, simple!
+	if (new_usage <= self.capacity)
+	{
+		asan::unpoison_memory_region(starting_ptr, new_usage - self.used);
+		AllocChunk* chunk_start = mem - AllocChunk.sizeof;
+		chunk_start.size = size;
+		self.used = new_usage;
+		if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+		return mem;
+	}
+
+	// Fallback to backing allocator
+	ExtraPage* page;
+
+	// We have something we need to align.
+	if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
+	{
+		// This is actually simpler, since it will create the offset for us.
+		usz total_alloc_size = mem::aligned_offset(ExtraPage.sizeof + size, alignment);
+		if (init_type == ZERO)
+		{
+			mem = allocator::calloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+		}
+		else
+		{
+			mem = allocator::malloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+		}
+		void* start = mem;
+		mem += mem::aligned_offset(ExtraPage.sizeof, alignment);
+		page = (ExtraPage*)mem - 1;
+		page.start = start;
+		page.size = size | PAGE_IS_ALIGNED;
+	}
+	else
+	{
+		// Here we might need to pad
+		usz padded_header_size = mem::aligned_offset(ExtraPage.sizeof, mem::DEFAULT_MEM_ALIGNMENT);
+		usz total_alloc_size = padded_header_size + size;
+		void* alloc = self.backing_allocator.acquire(total_alloc_size, init_type, 0)!;
+
+		// Find the page.
+		page = alloc + padded_header_size - ExtraPage.sizeof;
+		assert(mem::ptr_is_aligned(page, BackedArenaAllocator.alignof));
+		assert(mem::ptr_is_aligned(&page.data[0], mem::DEFAULT_MEM_ALIGNMENT));
+		page.start = alloc;
+		page.size = size;
+	}
+
+	// Mark it as a page
+	page.ident = ~(usz)0;
+	// Store when it was created
+	page.mark = ++self.used;
+	// Hook up the page.
+	page.prev_page = self.last_page;
+	self.last_page = page;
+	return &page.data[0];
+}

lib/std/core/allocators/dynamic_arena.c3

@@ -4,6 +4,17 @@
 module std::core::mem::allocator;
 import std::math;
 
+<*
+ The dynamic arena allocator is an arena allocator that can grow by adding additional arena "pages".
+ It only supports reset, at which point all pages except the first one is released to the backing
+ allocator.
+
+ If you want multiple save points, use the BackedArenaAllocator instead.
+
+ The advantage over the BackedArenaAllocator, is that when allocating beyond the first "page", it will
+ retain the characteristics of an arena allocator (allocating a large piece of memory then handing off
+ memory from that memory), whereas the BackedArenaAllocator will have heap allocator characteristics.
+*>
 struct DynamicArenaAllocator (Allocator)
 {
 	Allocator backing_allocator;
@@ -16,7 +27,7 @@ struct DynamicArenaAllocator (Allocator)
  @param [&inout] allocator
  @require page_size >= 128
 *>
-fn void DynamicArenaAllocator.init(&self, usz page_size, Allocator allocator)
+fn void DynamicArenaAllocator.init(&self, Allocator allocator, usz page_size)
 {
 	self.page = null;
 	self.unused_page = null;
@@ -61,8 +72,8 @@ struct DynamicArenaChunk @local
 }
 
 <*
- @require ptr
- @require self.page `tried to free pointer on invalid allocator`
+ @require ptr != null
+ @require self.page != null  : `tried to free pointer on invalid allocator`
 *>
 fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
 {
@@ -75,11 +86,12 @@ fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
 }
 
 <*
- @require size > 0 `Resize doesn't support zeroing`
- @require old_pointer != null `Resize doesn't handle null pointers`
- @require self.page `tried to realloc pointer on invalid allocator`
+ @require size > 0 : `Resize doesn't support zeroing`
+ @require old_pointer != null : `Resize doesn't handle null pointers`
+ @require self.page != null  : `tried to realloc pointer on invalid allocator`
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	DynamicArenaPage* current_page = self.page;
 	alignment = alignment_for_allocation(alignment);
@@ -105,13 +117,12 @@ fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz a
 		return old_pointer;
 	}
 	void* new_mem = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(new_mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT);
+	mem::copy(new_mem, old_pointer, math::min(old_size, size), mem::DEFAULT_MEM_ALIGNMENT);
 	return new_mem;
 }
 
-fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
+fn void DynamicArenaAllocator.reset(&self)
 {
-	assert(mark == 0, "Unexpectedly reset dynamic arena allocator with mark %d", mark);
 	DynamicArenaPage* page = self.page;
 	DynamicArenaPage** unused_page_ptr = &self.unused_page;
 	while (page)
@@ -126,52 +137,32 @@ fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
 	self.page = page;
 }
 
-<*
- @require math::is_power_of_2(alignment)
- @require size > 0
-*>
-fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @local
-{
-	// First, make sure that we can align it, extending the page size if needed.
-	usz page_size = max(self.page_size, mem::aligned_offset(size + DynamicArenaChunk.sizeof + alignment, alignment));
-	assert(page_size > size + DynamicArenaChunk.sizeof);
-	// Grab the page without alignment (we do it ourselves)
-	void* mem = allocator::malloc_try(self.backing_allocator, page_size)!;
-	DynamicArenaPage*! page = allocator::new_try(self.backing_allocator, DynamicArenaPage);
-	if (catch err = page)
-	{
-		allocator::free(self.backing_allocator, mem);
-		return err?;
-	}
-	page.memory = mem;
-	void* mem_start = mem::aligned_pointer(mem + DynamicArenaChunk.sizeof, alignment);
-	assert(mem_start + size < mem + page_size);
-	DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
-	chunk.size = size;
-	page.prev_arena = self.page;
-	page.total = page_size;
-	page.used = mem_start + size - page.memory;
-	self.page = page;
-	page.current_stack_ptr = mem_start;
-	return mem_start;
-}
+
 
 <*
- @require size > 0 `acquire expects size > 0`
+ @require size > 0 : `acquire expects size > 0`
  @require !alignment || math::is_power_of_2(alignment)
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	DynamicArenaPage* page = self.page;
-	void* ptr = {|
+
+	void* ptr @noinit;
+	do SET_DONE:
+	{
 		if (!page && self.unused_page)
 		{
 			self.page = page = self.unused_page;
 			self.unused_page = page.prev_arena;
 			page.prev_arena = null;
 		}
-		if (!page) return self._alloc_new(size, alignment);
+		if (!page)
+		{
+			ptr = _alloc_new(self, size, alignment)!;
+			break SET_DONE;
+		}
 		void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof, alignment);
 		usz new_used = start - page.memory + size;
 		if ALLOCATE_NEW: (new_used > page.total)
@@ -188,15 +179,46 @@ fn void*! DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type
 					break ALLOCATE_NEW;
 				}
 			}
-			return self._alloc_new(size, alignment);
+			ptr = _alloc_new(self, size, alignment)!;
+			break SET_DONE;
 		}
 		page.used = new_used;
 		assert(start + size == page.memory + page.used);
-		void* mem = start;
-		DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem - 1;
+		ptr = start;
+		DynamicArenaChunk* chunk = (DynamicArenaChunk*)ptr - 1;
 		chunk.size = size;
-		return mem;
-	|}!;
+	};
 	if (init_type == ZERO) mem::clear(ptr, size, mem::DEFAULT_MEM_ALIGNMENT);
 	return ptr;
 }
+
+<*
+ @require math::is_power_of_2(alignment)
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? _alloc_new(DynamicArenaAllocator* self, usz size, usz alignment) @local
+{
+	// First, make sure that we can align it, extending the page size if needed.
+	usz page_size = max(self.page_size, mem::aligned_offset(size + DynamicArenaChunk.sizeof + alignment, alignment));
+	assert(page_size > size + DynamicArenaChunk.sizeof);
+	// Grab the page without alignment (we do it ourselves)
+	void* mem = allocator::malloc_try(self.backing_allocator, page_size)!;
+	DynamicArenaPage*? page = allocator::new_try(self.backing_allocator, DynamicArenaPage);
+	if (catch err = page)
+	{
+		allocator::free(self.backing_allocator, mem);
+		return err~;
+	}
+	page.memory = mem;
+	void* mem_start = mem::aligned_pointer(mem + DynamicArenaChunk.sizeof, alignment);
+	assert(mem_start + size < mem + page_size);
+	DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
+	chunk.size = size;
+	page.prev_arena = self.page;
+	page.total = page_size;
+	page.used = mem_start + size - page.memory;
+	self.page = page;
+	page.current_stack_ptr = mem_start;
+	return mem_start;
+}

lib/std/core/allocators/heap_allocator.c3

@@ -1,10 +1,17 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2025 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 
 module std::core::mem::allocator;
 import std::math;
 
+<*
+ The SimpleHeapAllocator implements a simple heap allocator on top of an allocator function.
+
+ It uses the given allocator function to allocate memory from some source, but never frees it.
+ This allocator is intended to be used in environments where there isn't any native libc malloc,
+ and it has to be emulated from a memory region, or wrapping linear memory as is the case for plain WASM.
+*>
 struct SimpleHeapAllocator (Allocator)
 {
 	MemoryAllocFn alloc_fn;
@@ -12,8 +19,8 @@ struct SimpleHeapAllocator (Allocator)
 }
 
 <*
- @require allocator "An underlying memory provider must be given"
- @require !self.free_list "The allocator may not be already initialized"
+ @require allocator != null  : "An underlying memory provider must be given"
+ @require !self.free_list : "The allocator may not be already initialized"
 *>
 fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)
 {
@@ -21,62 +28,62 @@ fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)
 	self.free_list = null;
 }
 
-fn void*! SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
-		return alignment > 0 ? @aligned_alloc(self._calloc, size, alignment) : self._calloc(size);
+		return alignment > 0 ? @aligned_alloc_fn(self, simple_alloc_calloc, size, alignment) : simple_alloc_calloc(self, size);
 	}
-	return alignment > 0 ? @aligned_alloc(self._alloc, size, alignment) : self._alloc(size);
+	return alignment > 0 ? @aligned_alloc_fn(self, simple_alloc_alloc, size, alignment) : simple_alloc_alloc(self, size);
 }
 
-fn void*! SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	return alignment > 0
-		? @aligned_realloc(self._calloc, self._free, old_pointer, size, alignment)
-		:  self._realloc(old_pointer, size);
+		? @aligned_realloc_fn(self, simple_alloc_calloc, simple_alloc_free, old_pointer, size, alignment)
+		:  simple_alloc_realloc(self, old_pointer, size);
 }
 
 fn void SimpleHeapAllocator.release(&self, void* old_pointer, bool aligned) @dynamic
 {
 	if (aligned)
 	{
-		@aligned_free(self._free, old_pointer)!!;
+		@aligned_free_fn(self, simple_alloc_free, old_pointer)!!;
 	}
 	else
 	{
-		self._free(old_pointer);
+		simple_alloc_free(self, old_pointer);
 	}
 }
 
 <*
  @require old_pointer && bytes > 0
 *>
-fn void*! SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @local
+fn void*? simple_alloc_realloc(SimpleHeapAllocator* self, void* old_pointer, usz bytes) @local
 {
 	// Find the block header.
 	Header* block = (Header*)old_pointer - 1;
 	if (block.size >= bytes) return old_pointer;
-	void* new = self._alloc(bytes)!;
+	void* new = simple_alloc_alloc(self, bytes)!;
 	usz max_to_copy = math::min(block.size, bytes);
 	mem::copy(new, old_pointer, max_to_copy);
-	self._free(old_pointer);
+	simple_alloc_free(self, old_pointer);
 	return new;
 }
 
-fn void*! SimpleHeapAllocator._calloc(&self, usz bytes) @local
+fn void*? simple_alloc_calloc(SimpleHeapAllocator* self, usz bytes) @local
 {
-	void* data = self._alloc(bytes)!;
+	void* data = simple_alloc_alloc(self, bytes)!;
 	mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
 	return data;
 }
 
-fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
+fn void*? simple_alloc_alloc(SimpleHeapAllocator* self, usz bytes) @local
 {
 	usz aligned_bytes = mem::aligned_offset(bytes, mem::DEFAULT_MEM_ALIGNMENT);
 	if (!self.free_list)
 	{
-		self.add_block(aligned_bytes)!;
+		simple_alloc_add_block(self, aligned_bytes)!;
 	}
 
 	Header* current = self.free_list;
@@ -98,7 +105,7 @@ fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 				return current + 1;
 			case current.size > aligned_bytes:
 				Header* unallocated = (Header*)((char*)current + aligned_bytes + Header.sizeof);
-				unallocated.size = current.size - aligned_bytes;
+				unallocated.size = current.size - aligned_bytes - Header.sizeof;
 				unallocated.next = current.next;
 				if (current == self.free_list)
 				{
@@ -116,22 +123,22 @@ fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 				current = current.next;
 		}
 	}
-	self.add_block(aligned_bytes)!;
-	return self._alloc(aligned_bytes);
+	simple_alloc_add_block(self, aligned_bytes)!;
+	return simple_alloc_alloc(self, aligned_bytes);
 }
 
-fn void! SimpleHeapAllocator.add_block(&self, usz aligned_bytes) @local
+fn void? simple_alloc_add_block(SimpleHeapAllocator* self, usz aligned_bytes) @local
 {
 	assert(mem::aligned_offset(aligned_bytes, mem::DEFAULT_MEM_ALIGNMENT) == aligned_bytes);
 	char[] result = self.alloc_fn(aligned_bytes + Header.sizeof)!;
 	Header* new_block = (Header*)result.ptr;
 	new_block.size = result.len - Header.sizeof;
 	new_block.next = null;
-	self._free(new_block + 1);
+	simple_alloc_free(self, new_block + 1);
 }
 
 
-fn void SimpleHeapAllocator._free(&self, void* ptr) @local
+fn void simple_alloc_free(SimpleHeapAllocator* self, void* ptr) @local
 {
 	// Empty ptr -> do nothing.
 	if (!ptr) return;

lib/std/core/allocators/libc_allocator.c3

@@ -1,45 +1,43 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2025 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
-
 module std::core::mem::allocator @if(env::LIBC);
 import std::io;
 import libc;
 
+<*
+ The LibcAllocator is a wrapper around malloc to conform to the Allocator interface.
+*>
+typedef LibcAllocator (Allocator) = uptr;
 const LibcAllocator LIBC_ALLOCATOR = {};
-distinct LibcAllocator (Allocator, Printable) = uptr;
-
-fn String LibcAllocator.to_string(&self, Allocator allocator) @dynamic => "Libc allocator".copy(allocator);
-fn usz! LibcAllocator.to_format(&self, Formatter *format) @dynamic => format.print("Libc allocator");
 
 module std::core::mem::allocator @if(env::POSIX);
 import std::os;
 import libc;
 
-
-fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
 		void* data @noinit;
 		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
 		{
-			if (posix::posix_memalign(&data, alignment, bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+			if (posix::posix_memalign(&data, alignment, bytes)) return mem::OUT_OF_MEMORY~;
 			mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
 			return data;
 		}
-		return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+		return libc::calloc(1, bytes) ?: mem::OUT_OF_MEMORY~;
 	}
 	else
 	{
 		void* data @noinit;
 		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
 		{
-			if (posix::posix_memalign(&data, alignment, bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+			if (posix::posix_memalign(&data, alignment, bytes)) return mem::OUT_OF_MEMORY~;
 		}
 		else
 		{
-			if (!(data = libc::malloc(bytes))) return AllocationFailure.OUT_OF_MEMORY?;
+			if (!(data = libc::malloc(bytes))) return mem::OUT_OF_MEMORY~;
 		}
 		$if env::TESTING:
 			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
@@ -48,27 +46,34 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz a
 	}
 }
 
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
-	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
-	void* new_ptr;
-	if (posix::posix_memalign(&new_ptr, alignment, new_bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+ 	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~;
 
-	$switch
-	$case env::DARWIN:
-		usz old_usable_size = darwin::malloc_size(old_ptr);
-	$case env::LINUX:
-		usz old_usable_size = linux::malloc_usable_size(old_ptr);
-	$default:
-		usz old_usable_size = new_bytes;
-	$endswitch
+	// Try realloc, even though it might be unaligned.
+	void* new_ptr = libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~!;
+
+	// If it's aligned then we're done!
+	uptr ptr_val = (uptr)new_ptr;
+	if (ptr_val & (alignment - 1) == 0) return new_ptr;
+
+	// We failed, so we need to use memalign
+	// We will free new_ptr before we exit.
+	defer libc::free(new_ptr);
+
+	// Create a pointer which is sure to be aligned.
+	void* aligned_ptr;
+	if (posix::posix_memalign(&aligned_ptr, alignment, new_bytes))
+	{
+		return mem::OUT_OF_MEMORY~;
+	}
+	// Now it is safe to copy the full range of data.
+	mem::copy(aligned_ptr, new_ptr, new_bytes, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	return aligned_ptr;
 
-	usz copy_size = new_bytes < old_usable_size ? new_bytes : old_usable_size;
-	mem::copy(new_ptr, old_ptr, copy_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
-	libc::free(old_ptr);
-	return new_ptr;
 }
 
+
 fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
 {
 	libc::free(old_ptr);
@@ -78,31 +83,31 @@ module std::core::mem::allocator @if(env::WIN32);
 import std::os::win32;
 import libc;
 
-fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
 		if (alignment > 0)
 		{
-			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
+			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: mem::OUT_OF_MEMORY~;
 		}
-		return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+		return libc::calloc(1, bytes) ?: mem::OUT_OF_MEMORY~;
 	}
 	void* data = alignment > 0 ? win32::_aligned_malloc(bytes, alignment) : libc::malloc(bytes);
-	if (!data) return AllocationFailure.OUT_OF_MEMORY?;
+	if (!data) return mem::OUT_OF_MEMORY~;
 	$if env::TESTING:
 		for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
 	$endif
 	return data;
 }
 
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
 	if (alignment)
 	{
-		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
+		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: mem::OUT_OF_MEMORY~;
 	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+	return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~;
 }
 
 fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
@@ -118,17 +123,17 @@ fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
 module std::core::mem::allocator @if(!env::WIN32 && !env::POSIX && env::LIBC);
 import libc;
 
-fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
 		void* data = alignment ? @aligned_alloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment)!! : libc::calloc(bytes, 1);
-		return data ?: AllocationFailure.OUT_OF_MEMORY?;
+		return data ?: mem::OUT_OF_MEMORY~;
 	}
 	else
 	{
 		void* data = alignment ? @aligned_alloc(libc::malloc, bytes, alignment)!! : libc::malloc(bytes);
-		if (!data) return AllocationFailure.OUT_OF_MEMORY?;
+		if (!data) return mem::OUT_OF_MEMORY~;
 		$if env::TESTING:
 			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
 		$endif
@@ -137,14 +142,14 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz a
 }
 
 
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
 	if (alignment)
 	{
 		void* data = @aligned_realloc(fn void*(usz bytes) => libc::malloc(bytes), libc::free, old_ptr, new_bytes, alignment)!!;
-		return data ?: AllocationFailure.OUT_OF_MEMORY?;
+		return data ?: mem::OUT_OF_MEMORY~;
 	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+	return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY~;
 }
 
 

lib/std/core/allocators/on_stack_allocator.c3

@@ -1,5 +1,14 @@
 module std::core::mem::allocator;
+import std::math;
+<*
+ The OnStackAllocator is similar to the ArenaAllocator: it allocates from a chunk of memory
+ given to it.
 
+ The difference is that when it runs out of memory it will go directly to its backing allocator
+ rather than failing.
+
+ It is utilized by the @stack_mem macro as an alternative to the temp allocator.
+*>
 struct OnStackAllocator (Allocator)
 {
 	Allocator backing_allocator;
@@ -8,7 +17,6 @@ struct OnStackAllocator (Allocator)
 	OnStackAllocatorExtraChunk* chunk;
 }
 
-
 struct OnStackAllocatorExtraChunk @local
 {
 	bool is_aligned;
@@ -56,13 +64,13 @@ struct OnStackAllocatorHeader
 }
 
 <*
- @require old_pointer
+ @require old_pointer != null
 *>
 fn void OnStackAllocator.release(&self, void* old_pointer, bool aligned) @dynamic
 {
 	if (allocation_in_stack_mem(self, old_pointer)) return;
 	on_stack_allocator_remove_chunk(self, old_pointer);
-	self.release(old_pointer, aligned);
+	self.backing_allocator.release(old_pointer, aligned);
 }
 
 fn bool allocation_in_stack_mem(OnStackAllocator* a, void* ptr) @local
@@ -102,9 +110,9 @@ fn OnStackAllocatorExtraChunk* on_stack_allocator_find_chunk(OnStackAllocator* a
 <*
  @require size > 0
  @require old_pointer != null
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 *>
-fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	if (!allocation_in_stack_mem(self, old_pointer))
 	{
@@ -116,15 +124,15 @@ fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignm
 	OnStackAllocatorHeader* header = old_pointer - OnStackAllocatorHeader.sizeof;
 	usz old_size = header.size;
 	void* mem = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	mem::copy(mem, old_pointer, math::min(old_size, size), mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
 }
 
 <*
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
  @require size > 0
 *>
-fn void*! OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	bool aligned = alignment > 0;
 	alignment = alignment_for_allocation(alignment);

lib/std/core/allocators/temp_allocator.c3

@@ -1,29 +1,60 @@
-module std::core::mem::allocator;
+module std::core::mem::allocator @if(!(env::POSIX || env::WIN32) || !$feature(VMEM_TEMP));
 import std::io, std::math;
 
+// This implements the temp allocator.
+// The temp allocator is a specialized allocator only intended for use where
+// the allocation is strictly stack-like.
+//
+// It is *not* thread-safe: you cannot safely use the
+// temp allocator on a thread and pass it to another thread.
+//
+// Fundamentally the temp allocator is a thread local arena allocator
+// but the stack-like behaviour puts additional constraints to it.
+//
+// It works great for allocating temporary data in a scope then dropping
+// that data, however you should not be storing temporary data in globals
+// or locals that have a lifetime outside of the current temp allocator scope.
+//
+// Furthermore, note that the temp allocator is bounded, with additional
+// allocations on top of that causing heap allocations. Such heap allocations
+// will be cleaned up but is undesirable from a performance standpoint.
+//
+// If you want customizable behaviour similar to the temp allocator, consider
+// the ArenaAllocator, BackedArenaAllocator or the DynamicArenaAllocator.
+//
+// Experimenting with the temp allocator to make it work outside of its
+// standard usage patterns will invariably end in tears and frustrated
+// hair pulling.
+//
+// Use one of the ArenaAllocators instead.
+
+struct TempAllocator (Allocator)
+{
+	Allocator backing_allocator;
+	TempAllocatorPage* last_page;
+	TempAllocator* derived;
+	bool allocated;
+	usz reserve_size;
+	usz realloc_size;
+	usz min_size;
+	usz used;
+	usz capacity;
+	usz original_capacity;
+	char[*] data;
+}
+
 struct TempAllocatorChunk @local
 {
 	usz size;
 	char[*] data;
 }
 
-struct TempAllocator (Allocator)
-{
-	Allocator backing_allocator;
-	TempAllocatorPage* last_page;
-	usz used;
-	usz capacity;
-	char[*] data;
-}
-
-const usz PAGE_IS_ALIGNED @private = (usz)isz.max + 1u;
-
+const usz PAGE_IS_ALIGNED @local = (usz)isz.max + 1u;
 
 struct TempAllocatorPage
 {
 	TempAllocatorPage* prev_page;
 	void* start;
-	usz mark;
 	usz size;
 	usz ident;
 	char[*] data;
@@ -33,26 +64,109 @@ macro usz TempAllocatorPage.pagesize(&self) => self.size & ~PAGE_IS_ALIGNED;
 macro bool TempAllocatorPage.is_aligned(&self) => self.size & PAGE_IS_ALIGNED == PAGE_IS_ALIGNED;
 
 <*
- @require size >= 16
+ @require size >= 64
+ @require realloc_size >= 64
+ @require allocator.type != TempAllocator.typeid : "You may not create a temp allocator with a TempAllocator as the backing allocator."
+ @require min_size > TempAllocator.sizeof + 64 : "Min size must meaningfully hold the data + some bytes"
 *>
-fn TempAllocator*! new_temp_allocator(usz size, Allocator allocator)
+fn TempAllocator*? new_temp_allocator(Allocator allocator, usz size, usz reserve = temp_allocator_reserve_size, usz min_size = temp_allocator_min_size, usz realloc_size = temp_allocator_realloc_size)
 {
 	TempAllocator* temp = allocator::alloc_with_padding(allocator, TempAllocator, size)!;
 	temp.last_page = null;
 	temp.backing_allocator = allocator;
 	temp.used = 0;
-	temp.capacity = size;
+	temp.min_size = min_size;
+	temp.realloc_size = realloc_size;
+	temp.reserve_size = reserve;
+	temp.allocated = true;
+	temp.derived = null;
+	temp.original_capacity = temp.capacity = size;
 	return temp;
 }
-
-fn void TempAllocator.destroy(&self)
+<*
+ @require !self.derived
+*>
+fn TempAllocator*? TempAllocator.derive_allocator(&self, usz reserve = 0)
 {
-	self.reset(0);
-	if (self.last_page) (void)self._free_page(self.last_page);
-	allocator::free(self.backing_allocator, self);
+	if (!reserve) reserve = self.reserve_size;
+	usz remaining = self.capacity - self.used;
+	void* mem @noinit;
+	usz size @noinit;
+	if (self.min_size + reserve > remaining)
+	{
+		return self.derived = new_temp_allocator(self.backing_allocator, self.realloc_size, self.reserve_size, self.min_size, self.realloc_size)!;
+	}
+	usz start = mem::aligned_offset(self.used + reserve, mem::DEFAULT_MEM_ALIGNMENT);
+	void* ptr = &self.data[start];
+	TempAllocator* temp = (TempAllocator*)ptr;
+	$if env::ADDRESS_SANITIZER:
+        asan::unpoison_memory_region(ptr, TempAllocator.sizeof);
+	$endif
+	temp.last_page = null;
+    temp.backing_allocator = self.backing_allocator;
+    temp.used = 0;
+    temp.min_size = self.min_size;
+    temp.reserve_size = self.reserve_size;
+    temp.realloc_size = self.realloc_size;
+    temp.allocated = false;
+    temp.derived = null;
+    temp.original_capacity = temp.capacity = self.capacity - start - TempAllocator.sizeof;
+    self.capacity = start;
+	self.derived = temp;
+    return temp;
 }
 
-fn usz TempAllocator.mark(&self) @dynamic => self.used;
+<*
+ Reset the entire temp allocator, which will merge all the children into it.
+*>
+fn void TempAllocator.reset(&self)
+{
+	TempAllocator* child = self.derived;
+	if (!child) return;
+	while (child)
+	{
+		TempAllocator* old = child;
+		child = old.derived;
+		temp_allocator_destroy(old);
+	}
+	self.capacity = self.original_capacity;
+	$if env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(&self.data[self.used], self.capacity - self.used);
+	$endif
+	self.derived = null;
+}
+
+<*
+ @require self.allocated : "Only a top level allocator should be freed."
+*>
+fn void TempAllocator.free(&self)
+{
+	self.reset();
+	temp_allocator_destroy(self);
+}
+
+fn void temp_allocator_destroy(TempAllocator* self)
+{
+	TempAllocatorPage *last_page = self.last_page;
+	while (last_page)
+	{
+		TempAllocatorPage *to_free = last_page;
+		last_page = last_page.prev_page;
+		_free_page(self, to_free)!!;
+	}
+	if (self.allocated)
+	{
+		allocator::free(self.backing_allocator, self);
+		return;
+	}
+	$if env::COMPILER_SAFE_MODE || env::ADDRESS_SANITIZER:
+    	$if env::COMPILER_SAFE_MODE && !env::ADDRESS_SANITIZER:
+    		self.data[0 : self.used] = 0xAA;
+		$else
+            asan::poison_memory_region(&self.data[0], self.used);
+    	$endif
+    $endif
+}
 
 fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
 {
@@ -63,61 +177,10 @@ fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
 		asan::poison_memory_region(&self.data[self.used], old_size);
 	}
 }
-fn void TempAllocator.reset(&self, usz mark) @dynamic
-{
-	TempAllocatorPage *last_page = self.last_page;
-	while (last_page && last_page.mark > mark)
-	{
-		self.used = last_page.mark;
-		TempAllocatorPage *to_free = last_page;
-		last_page = last_page.prev_page;
-		self._free_page(to_free)!!;
-	}
-	self.last_page = last_page;
-	$if env::COMPILER_SAFE_MODE || env::ADDRESS_SANITIZER:
-		if (!last_page)
-		{
-			usz cleaned = self.used - mark;
-			if (cleaned > 0)
-			{
-				$if env::COMPILER_SAFE_MODE:
-					self.data[mark : cleaned] = 0xAA;
-				$endif
-				asan::poison_memory_region(&self.data[mark], cleaned);
-			}
-		}
-	$endif
-	self.used = mark;
-}
 
-fn void! TempAllocator._free_page(&self, TempAllocatorPage* page) @inline @local
-{
-	void* mem = page.start;
-	return self.backing_allocator.release(mem, page.is_aligned());
-}
 
-fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
-{
-	// Then the actual start pointer:
-	void* real_pointer = page.start;
 
-	// Walk backwards to find the pointer to this page.
-	TempAllocatorPage **pointer_to_prev = &self.last_page;
-	// Remove the page from the list
-	while (*pointer_to_prev != page)
-	{
-		pointer_to_prev = &((*pointer_to_prev).prev_page);
-	}
-	*pointer_to_prev = page.prev_page;
-	usz page_size = page.pagesize();
-	// Clear on size > original size.
-	void* data = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(data, &page.data[0], page_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
-	self.backing_allocator.release(real_pointer, page.is_aligned());
-	return data;
-}
-
-fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+fn void*? TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
 {
 	TempAllocatorChunk *chunk = pointer - TempAllocatorChunk.sizeof;
 	if (chunk.size == (usz)-1)
@@ -125,21 +188,49 @@ fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @d
 		assert(self.last_page, "Realloc of non temp pointer");
 		// First grab the page
 		TempAllocatorPage *page = pointer - TempAllocatorPage.sizeof;
-		return self._realloc_page(page, size, alignment);
+		return _realloc_page(self, page, size, alignment);
+	}
+	bool is_realloc_of_last = chunk.size + pointer == &self.data[self.used];
+	if (is_realloc_of_last)
+	{
+		isz diff = size - chunk.size;
+		if (diff == 0) return pointer;
+		if (self.capacity - self.used > diff)
+		{
+			chunk.size += diff;
+			self.used += diff;
+			$if env::ADDRESS_SANITIZER:
+				if (diff < 0)
+				{
+					asan::poison_memory_region(pointer + chunk.size, -diff);
+				}
+				else
+				{
+					asan::unpoison_memory_region(pointer, chunk.size);
+				}
+			$endif
+			return pointer;
+		}
+	}
+	void* data = self.acquire(size, NO_ZERO, alignment)!;
+	usz len_to_copy = chunk.size > size ? size : chunk.size;
+	mem::copy(data, pointer, len_to_copy, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	if (is_realloc_of_last)
+	{
+		self.used = (uptr)chunk - (uptr)&self.data;
+		$if env::ADDRESS_SANITIZER:
+			asan::poison_memory_region(chunk, TempAllocatorChunk.sizeof + chunk.size);
+		$endif
 	}
-
-	TempAllocatorChunk* data = self.acquire(size, NO_ZERO, alignment)!;
-	mem::copy(data, pointer, chunk.size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
-
 	return data;
 }
 
 <*
  @require size > 0
  @require !alignment || math::is_power_of_2(alignment)
- @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 *>
-fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	void* start_mem = &self.data;
@@ -179,8 +270,10 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 		{
 			mem = allocator::malloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
 		}
+		void* start = mem;
+		mem += mem::aligned_offset(TempAllocatorPage.sizeof, alignment);
 		page = (TempAllocatorPage*)mem - 1;
-		page.start = mem;
+		page.start = start;
 		page.size = size | PAGE_IS_ALIGNED;
 	}
 	else
@@ -200,29 +293,117 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 
 	// Mark it as a page
 	page.ident = ~(usz)0;
-	// Store when it was created
-	page.mark = ++self.used;
 	// Hook up the page.
 	page.prev_page = self.last_page;
 	self.last_page = page;
 	return &page.data[0];
 }
 
-fn void! TempAllocator.print_pages(&self, File* f)
+
+fn void? _free_page(TempAllocator* self, TempAllocatorPage* page) @inline @local
 {
-	TempAllocatorPage *last_page = self.last_page;
-	if (!last_page)
-	{
-		io::fprintf(f, "No pages.\n")!;
-		return;
-	}
-	io::fprintf(f, "---Pages----\n")!;
-	uint index = 0;
-	while (last_page)
-	{
-		bool is_not_aligned = !(last_page.size & (1u64 << 63));
-		io::fprintf(f, "%d. Alloc: %d %d at %p%s\n", ++index,
-				last_page.size & ~(1u64 << 63), last_page.mark, &last_page.data[0], is_not_aligned ? "" : " [aligned]")!;
-		last_page = last_page.prev_page;
-	}
+	void* mem = page.start;
+	return self.backing_allocator.release(mem, page.is_aligned());
+}
+
+fn void*? _realloc_page(TempAllocator* self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
+{
+	// Then the actual start pointer:
+	void* real_pointer = page.start;
+
+	// Walk backwards to find the pointer to this page.
+	TempAllocatorPage **pointer_to_prev = &self.last_page;
+	// Remove the page from the list
+	while (*pointer_to_prev != page)
+	{
+		pointer_to_prev = &((*pointer_to_prev).prev_page);
+	}
+	*pointer_to_prev = page.prev_page;
+	usz page_size = page.pagesize();
+	// Clear on size > original size.
+	void* data = self.acquire(size, NO_ZERO, alignment)!;
+	if (page_size > size) page_size = size;
+	mem::copy(data, &page.data[0], page_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	self.backing_allocator.release(real_pointer, page.is_aligned());
+	return data;
+}
+
+module std::core::mem::allocator @if((env::POSIX || env::WIN32) && $feature(VMEM_TEMP));
+import std::math;
+
+
+tlocal VmemOptions temp_allocator_default_options = {
+	.shrink_on_reset = env::MEMORY_ENV != NORMAL,
+	.protect_unused_pages = env::COMPILER_OPT_LEVEL <= O1 || env::COMPILER_SAFE_MODE,
+	.scratch_released_data = env::COMPILER_SAFE_MODE
+};
+
+
+fn TempAllocator*? new_temp_allocator(Allocator allocator, usz size, usz reserve = temp_allocator_reserve_size, usz min_size = temp_allocator_min_size, usz realloc_size = temp_allocator_realloc_size)
+{
+	Vmem mem;
+	TempAllocator* t = allocator::new(allocator, TempAllocator);
+	defer catch allocator::free(allocator, t);
+	t.vmem.init(preferred_size: isz.sizeof > 4 ? 4 * mem::GB : 512 * mem::MB,
+	            reserve_page_size: isz.sizeof > 4 ? 256 * mem::KB : 0,
+	            options: temp_allocator_default_options)!;
+	t.allocator = allocator;
+	return t;
+}
+
+struct TempAllocator (Allocator)
+{
+	Vmem vmem;
+	TempAllocator* derived;
+	Allocator allocator;
+}
+
+<*
+ @require size > 0
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+*>
+fn void*? TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	return self.vmem.acquire(size, init_type, alignment) @inline;
+}
+
+fn TempAllocator*? TempAllocator.derive_allocator(&self, usz reserve = 0)
+{
+	if (self.derived) return self.derived;
+	return self.derived = new_temp_allocator(self.allocator, 0)!;
+}
+
+<*
+ Reset the entire temp allocator, destroying all children
+*>
+fn void TempAllocator.reset(&self)
+{
+	TempAllocator* child = self.derived;
+	if (!child) return;
+	child.reset();
+	child.vmem.reset(0);
+}
+fn void TempAllocator.free(&self)
+{
+	_destroy(self);
+}
+
+fn void _destroy(TempAllocator* self) @local
+{
+	TempAllocator* child = self.derived;
+	if (!child) return;
+	child.destroy();
+	self.vmem.free() @inline;
+	allocator::free(self.allocator, self) @inline;
+}
+
+fn void*? TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+{
+	return self.vmem.resize(pointer, size, alignment) @inline;
+}
+
+fn void TempAllocator.release(&self, void* old_pointer, bool b) @dynamic
+{
+	self.vmem.release(old_pointer, b) @inline;
 }

lib/std/core/allocators/tracking_allocator.c3

@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021-2025 Christoffer Lerno. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 
@@ -13,28 +13,34 @@ struct Allocation
 	void*[MAX_BACKTRACE] backtrace;
 }
 
-def AllocMap = HashMap(<uptr, Allocation>);
+alias AllocMap = HashMap { uptr, Allocation };
 
 // A simple tracking allocator.
 // It tracks allocations using a hash map but
 // is not compatible with allocators that uses mark()
+//
+// It is also embarrassingly single-threaded, so
+// do not use it to track allocations that cross threads.
+
 struct TrackingAllocator (Allocator)
 {
 	Allocator inner_allocator;
 	AllocMap map;
 	usz mem_total;
 	usz allocs_total;
+	usz usage;
+	usz max_usage;
 }
 
 <*
  Initialize a tracking allocator to wrap (and track) another allocator.
 
- @param [&inout] allocator "The allocator to track"
+ @param [&inout] allocator : "The allocator to track"
 *>
 fn void TrackingAllocator.init(&self, Allocator allocator)
 {
 	*self = { .inner_allocator = allocator };
-	self.map.new_init(allocator: allocator);
+	self.map.init(allocator);
 }
 
 <*
@@ -49,13 +55,10 @@ fn void TrackingAllocator.free(&self)
 <*
  @return "the total allocated memory not yet freed."
 *>
-fn usz TrackingAllocator.allocated(&self)
+fn usz TrackingAllocator.allocated(&self) => @pool()
 {
 	usz allocated = 0;
-	@pool()
-	{
-		foreach (&allocation : self.map.value_tlist()) allocated += allocation.size;
-	};
+	foreach (&allocation : self.map.tvalues()) allocated += allocation.size;
 	return allocated;
 }
 
@@ -69,9 +72,14 @@ fn usz TrackingAllocator.total_allocated(&self) => self.mem_total;
 *>
 fn usz TrackingAllocator.total_allocation_count(&self) => self.allocs_total;
 
+<*
+ @return "the maximum amount of memory allocated"
+*>
+fn usz TrackingAllocator.max_allocated(&self) => self.max_usage;
+
 fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)
 {
-	return self.map.value_tlist();
+	return self.map.tvalues();
 }
 
 <*
@@ -79,7 +87,7 @@ fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)
 *>
 fn usz TrackingAllocator.allocation_count(&self) => self.map.count;
 
-fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	void* data = self.inner_allocator.acquire(size, init_type, alignment)!;
 	self.allocs_total++;
@@ -87,27 +95,34 @@ fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, us
 	backtrace::capture_current(&bt);
 	self.map.set((uptr)data, { data, size, bt });
 	self.mem_total += size;
+	self.usage += size;
+	if (self.usage > self.max_usage) self.max_usage = self.usage;
 	return data;
 }
 
-fn void*! TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	void* data = self.inner_allocator.resize(old_pointer, size, alignment)!;
+	self.usage -= self.map[(uptr)old_pointer]!!.size;
 	self.map.remove((uptr)old_pointer);
 	void*[MAX_BACKTRACE] bt;
 	backtrace::capture_current(&bt);
 	self.map.set((uptr)data, { data, size, bt });
 	self.mem_total += size;
+	self.usage += size;
+	if (self.usage > self.max_usage) self.max_usage = self.usage;
 	self.allocs_total++;
 	return data;
 }
 
 fn void TrackingAllocator.release(&self, void* old_pointer, bool is_aligned) @dynamic
 {
+	usz? old_size = self.map[(uptr)old_pointer].size;
 	if (catch self.map.remove((uptr)old_pointer))
 	{
 		unreachable("Attempt to release untracked pointer %p, this is likely a bug.", old_pointer);
 	}
+	self.usage -= old_size!!;
 	self.inner_allocator.release(old_pointer, is_aligned);
 }
 
@@ -116,101 +131,104 @@ fn void TrackingAllocator.clear(&self)
 	self.map.clear();
 }
 
+fn bool TrackingAllocator.has_leaks(&self)
+{
+	return self.map.len() > 0;
+}
+
 fn void TrackingAllocator.print_report(&self) => self.fprint_report(io::stdout())!!;
 
-fn void! TrackingAllocator.fprint_report(&self, OutStream out)
-{
 
+fn void? TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
+{
 	usz total = 0;
 	usz entries = 0;
 	bool leaks = false;
-	@pool()
-	{
-		Allocation[] allocs = self.map.value_tlist();
-		if (allocs.len)
-		{
-			if (!allocs[0].backtrace[0])
-			{
-				io::fprintn(out, "======== Memory Report ========")!;
-				io::fprintn(out, "Size in bytes   Address")!;
-				foreach (i, &allocation : allocs)
-				{
-					entries++;
-					total += allocation.size;
-					io::fprintfn(out, "%13s   %p", allocation.size, allocation.ptr)!;
-				}
-				io::fprintn(out, "===============================")!;
 
-			}
-			else
+	Allocation[] allocs = self.map.tvalues();
+	if (allocs.len)
+	{
+		if (!allocs[0].backtrace[0])
+		{
+			io::fprintn(out, "======== Memory Report ========")!;
+			io::fprintn(out, "Size in bytes   Address")!;
+			foreach (i, &allocation : allocs)
 			{
-				io::fprintn(out, "================================== Memory Report ==================================")!;
-				io::fprintn(out, "Size in bytes   Address          Function                       ")!;
-				foreach (i, &allocation : allocs)
-				{
-					entries++;
-					total += allocation.size;
-					BacktraceList backtraces = {};
-					Backtrace trace = backtrace::BACKTRACE_UNKNOWN;
-					if (allocation.backtrace[3])
-					{
-						trace = backtrace::symbolize_backtrace(allocation.backtrace[3:1], allocator::temp()).get(0) ?? backtrace::BACKTRACE_UNKNOWN;
-					}
-					if (trace.function.len)	leaks = true;
-					io::fprintfn(out, "%13s   %p   %s:%d", allocation.size,
-						allocation.ptr, trace.function.len ? trace.function : "???",
-						trace.line ? trace.line : 0)!;
-				}
-				io::fprintn(out, "===================================================================================")!;
+				entries++;
+				total += allocation.size;
+				io::fprintfn(out, "%13s   %p", allocation.size, allocation.ptr)!;
 			}
+			io::fprintn(out, "===============================")!;
+
 		}
 		else
 		{
-			io::fprintn(out, "* NO ALLOCATIONS FOUND *")!;
-		}
-		io::fprintfn(out, "- Total currently allocated memory:            %d", total)!;
-		io::fprintfn(out, "- Total current allocations:                   %d", entries)!;
-		io::fprintfn(out, "- Total allocations (freed and retained):      %d", self.allocs_total)!;
-		io::fprintfn(out, "- Total allocated memory (freed and retained): %d", self.mem_total)!;
-		if (leaks)
-		{
-			io::fprintn(out)!;
-			io::fprintn(out, "Full leak report:")!;
+			io::fprintn(out, "================================== Memory Report ==================================")!;
+			io::fprintn(out, "Size in bytes   Address          Function                       ")!;
 			foreach (i, &allocation : allocs)
 			{
-				if (!allocation.backtrace[3])
-				{
-					io::fprintfn(out, "Allocation %d (%d bytes) - no backtrace available.", i + 1, allocation.size)!;
-					continue;
-				}
+				entries++;
+				total += allocation.size;
 				BacktraceList backtraces = {};
-				usz end = MAX_BACKTRACE;
-				foreach (j, val : allocation.backtrace)
+				Backtrace trace = backtrace::BACKTRACE_UNKNOWN;
+				if (allocation.backtrace[3])
 				{
-					if (!val)
-					{
-						end = j;
-						break;
-					}
+					trace = backtrace::symbolize_backtrace(tmem, allocation.backtrace[3:1]).get(0) ?? backtrace::BACKTRACE_UNKNOWN;
 				}
-				BacktraceList list = backtrace::symbolize_backtrace(allocation.backtrace[3..(end - 1)], allocator::temp())!;
-				io::fprintfn(out, "Allocation %d (%d bytes): ", i + 1, allocation.size)!;
-				foreach (trace : list)
+				if (trace.function.len)	leaks = true;
+				io::fprintfn(out, "%13s   %p   %s:%d", allocation.size,
+					allocation.ptr, trace.function.len ? trace.function : "???",
+					trace.line ? trace.line : 0)!;
+			}
+			io::fprintn(out, "===================================================================================")!;
+		}
+	}
+	else
+	{
+		io::fprintn(out, "* NO ALLOCATIONS FOUND *")!;
+	}
+	io::fprintfn(out, "- Total currently allocated memory:            %d", total)!;
+	io::fprintfn(out, "- Total current allocations:                   %d", entries)!;
+	io::fprintfn(out, "- Total allocations (freed and retained):      %d", self.allocs_total)!;
+	io::fprintfn(out, "- Total allocated memory (freed and retained): %d", self.mem_total)!;
+	io::fprintfn(out, "- Maximum memory usage:                        %d", self.max_usage)!;
+	if (leaks)
+	{
+		io::fprintn(out)!;
+		io::fprintn(out, "Full leak report:")!;
+		foreach (i, &allocation : allocs)
+		{
+			if (!allocation.backtrace[3])
+			{
+				io::fprintfn(out, "Allocation %d (%d bytes) - no backtrace available.", i + 1, allocation.size)!;
+				continue;
+			}
+			BacktraceList backtraces = {};
+			usz end = MAX_BACKTRACE;
+			foreach (j, val : allocation.backtrace)
+			{
+				if (!val)
 				{
-					if (trace.has_file())
-					{
-						io::fprintfn(out, "   %s (in %s:%d)", trace.function, trace.file, trace.line);
-						continue;
-					}
-					if (trace.is_unknown())
-					{
-						io::fprintfn(out, "   ??? (in unknown)");
-						continue;
-					}
-					io::fprintfn(out, "   %s (source unavailable)", trace.function);
+					end = j;
+					break;
 				}
 			}
+			BacktraceList list = backtrace::symbolize_backtrace(tmem, allocation.backtrace[3..(end - 1)])!;
+			io::fprintfn(out, "Allocation %d (%d bytes): ", i + 1, allocation.size)!;
+			foreach (trace : list)
+			{
+				if (trace.has_file())
+				{
+					io::fprintfn(out, "   %s (in %s:%d)", trace.function, trace.file, trace.line);
+					continue;
+				}
+				if (trace.is_unknown())
+				{
+					io::fprintfn(out, "   ??? (in unknown)");
+					continue;
+				}
+				io::fprintfn(out, "   %s (source unavailable)", trace.function);
+			}
 		}
-	};
-
-}
+	}
+}

lib/std/core/allocators/vmem.c3

@@ -0,0 +1,255 @@
+module std::core::mem::allocator @if(env::POSIX || env::WIN32);
+import std::math, std::os::posix, libc, std::bits;
+import std::core::mem;
+import std::core::env;
+
+
+
+// Virtual Memory allocator
+
+faultdef VMEM_RESERVE_FAILED;
+
+struct Vmem (Allocator)
+{
+	VirtualMemory memory;
+	usz allocated;
+	usz pagesize;
+	usz page_pot;
+	usz last_page;
+	usz high_water;
+	VmemOptions options;
+}
+
+bitstruct VmemOptions : int
+{
+	<* Release memory on reset *>
+	bool shrink_on_reset;
+	<* Protect unused pages on reset *>
+	bool protect_unused_pages;
+	<* Overwrite released data with 0xAA *>
+	bool scratch_released_data;
+}
+
+<*
+ Implements the Allocator interface method.
+
+ @require !reserve_page_size || math::is_power_of_2(reserve_page_size)
+ @require reserve_page_size <= preferred_size : "The min reserve_page_size size must be less or equal to the preferred size"
+ @require preferred_size >= 1 * mem::KB : "The preferred size must exceed 1 KB"
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY, VMEM_RESERVE_FAILED
+*>
+fn void? Vmem.init(&self, usz preferred_size, usz reserve_page_size = 0, VmemOptions options = { true, true, env::COMPILER_SAFE_MODE }, usz min_size = 0)
+{
+	static usz page_size = 0;
+	if (!page_size) page_size = mem::os_pagesize();
+	if (page_size < reserve_page_size) page_size = reserve_page_size;
+	preferred_size = mem::aligned_offset(preferred_size, page_size);
+	if (!min_size) min_size = max(preferred_size / 1024, 1);
+	VirtualMemory? memory = mem::OUT_OF_MEMORY~;
+	while (preferred_size >= min_size)
+	{
+		memory = vm::virtual_alloc(preferred_size, PROTECTED);
+		// It worked?
+		if (try memory) break;
+		switch (@catch(memory))
+		{
+			case mem::OUT_OF_MEMORY:
+			case vm::RANGE_OVERFLOW:
+				// Try a smaller size.
+				preferred_size /= 2;
+				continue;
+			default:
+				break;
+		}
+	}
+	if (catch memory) return VMEM_RESERVE_FAILED~;
+	if (page_size > preferred_size) page_size = preferred_size;
+	$if env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(memory.ptr, memory.size);
+	$endif
+	*self = { .memory = memory,
+	          .high_water = 0,
+			  .pagesize = page_size,
+			  .page_pot = page_size.ctz(),
+			  .options  = options,
+	        };
+}
+
+<*
+ Implements the Allocator interface method.
+
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? Vmem.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+{
+	alignment = alignment_for_allocation(alignment);
+	usz total_len = self.memory.size;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE~;
+	void* start_mem = self.memory.ptr;
+	void* unaligned_pointer_to_offset = start_mem + self.allocated + VmemHeader.sizeof;
+	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
+	usz after = (usz)(mem - start_mem) + size;
+	if (after > total_len) return mem::OUT_OF_MEMORY~;
+	if (init_type == ZERO && self.high_water <= self.allocated)
+	{
+		init_type = NO_ZERO;
+	}
+	protect(self, after)!;
+	VmemHeader* header = mem - VmemHeader.sizeof;
+	header.size = size;
+	if (init_type == ZERO) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+	return mem;
+}
+
+fn bool Vmem.owns_pointer(&self, void* ptr) @inline
+{
+	return (uptr)ptr >= (uptr)self.memory.ptr && (uptr)ptr < (uptr)self.memory.ptr + self.memory.size;
+}
+<*
+ Implements the Allocator interface method.
+
+ @require !alignment || math::is_power_of_2(alignment)
+ @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+ @require old_pointer != null
+ @require size > 0
+ @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
+*>
+fn void*? Vmem.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
+{
+	if (size > self.memory.size) return mem::INVALID_ALLOC_SIZE~;
+	alignment = alignment_for_allocation(alignment);
+	assert(self.owns_pointer(old_pointer), "Pointer originates from a different allocator: %p, not in %p - %p", old_pointer, self.memory.ptr, self.memory.ptr + self.allocated);
+	VmemHeader* header = old_pointer - VmemHeader.sizeof;
+    usz old_size = header.size;
+    if (old_size == size) return old_pointer;
+    // Do last allocation and alignment match?
+    if (self.memory.ptr + self.allocated == old_pointer + old_size && mem::ptr_is_aligned(old_pointer, alignment))
+    {
+    	if (old_size > size)
+    	{
+    		unprotect(self, self.allocated + size - old_size);
+    	}
+    	else
+    	{
+    		usz allocated = self.allocated + size - old_size;
+    		if (allocated > self.memory.size) return mem::OUT_OF_MEMORY~;
+    		protect(self, allocated)!;
+    	}
+    	header.size = size;
+    	return old_pointer;
+    }
+    if (old_size > size)
+    {
+        $if env::ADDRESS_SANITIZER:
+    	    asan::poison_memory_region(old_pointer + size, old_size - size);
+    	$endif
+    	header.size = size;
+    	return old_pointer;
+    }
+    // Otherwise just allocate new memory.
+    void* mem = self.acquire(size, NO_ZERO, alignment)!;
+    assert(size > old_size);
+    mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+    return mem;
+}
+
+<*
+ Implements the Allocator interface method.
+
+ @require ptr != null
+*>
+fn void Vmem.release(&self, void* ptr, bool) @dynamic
+{
+	assert(self.owns_pointer(ptr), "Pointer originates from a different allocator %p.", ptr);
+	VmemHeader* header = ptr - VmemHeader.sizeof;
+	// Reclaim memory if it's the last element.
+	if (ptr + header.size == self.memory.ptr + self.allocated)
+	{
+		unprotect(self, self.allocated - header.size - VmemHeader.sizeof);
+	}
+}
+
+fn usz Vmem.mark(&self)
+{
+	return self.allocated;
+}
+
+<*
+ @require mark <= self.allocated : "Invalid mark"
+*>
+fn void Vmem.reset(&self, usz mark)
+{
+	if (mark == self.allocated) return;
+	unprotect(self, mark);
+}
+
+fn void Vmem.free(&self)
+{
+	if (!self.memory.ptr) return;
+	$switch:
+		$case env::ADDRESS_SANITIZER:
+			asan::poison_memory_region(self.memory.ptr, self.memory.size);
+		$case env::COMPILER_SAFE_MODE:
+    	    ((char*)self.memory.ptr)[0:self.allocated] = 0xAA;
+	$endswitch
+	(void)self.memory.destroy();
+	*self = {};
+}
+
+// Internal data
+
+struct VmemHeader @local
+{
+	usz size;
+	char[*] data;
+}
+
+macro void? protect(Vmem* mem, usz after) @local
+{
+	usz shift = mem.page_pot;
+	usz page_after = (after + mem.pagesize - 1) >> shift;
+	usz last_page = mem.last_page;
+	bool over_high_water = mem.high_water < after;
+	if (page_after > last_page)
+	{
+		usz page_start = last_page << shift;
+		usz page_len = (page_after - last_page) << shift;
+		mem.memory.commit(page_start, page_len)!;
+		if (mem.options.protect_unused_pages || over_high_water)
+		{
+			mem.memory.protect(page_start, page_len, READWRITE)!;
+		}
+		mem.last_page = page_after;
+	}
+	$if env::ADDRESS_SANITIZER:
+		asan::unpoison_memory_region(mem.memory.ptr + mem.allocated, after - mem.allocated);
+	$endif
+	mem.allocated = after;
+	if (over_high_water) mem.high_water = after;
+}
+
+macro void unprotect(Vmem* mem, usz after) @local
+{
+	usz shift = mem.page_pot;
+	usz last_page = mem.last_page;
+	usz page_after = mem.last_page = (after + mem.pagesize - 1) >> shift;
+	$if env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(mem.memory.ptr + after, mem.allocated - after);
+	$else
+		if (mem.options.scratch_released_data)
+		{
+			mem::set(mem.memory.ptr + after, 0xAA, mem.allocated - after);
+		}
+	$endif
+	if ((mem.options.shrink_on_reset || mem.options.protect_unused_pages) && page_after < last_page)
+	{
+		usz start = page_after << shift;
+		usz len = (last_page - page_after) << shift;
+		if (mem.options.shrink_on_reset) (void)mem.memory.decommit(start, len, false);
+		if (mem.options.protect_unused_pages) (void)mem.memory.protect(start, len, PROTECTED);
+	}
+	mem.allocated = after;
+}

lib/std/core/ansi.c3

@@ -0,0 +1,165 @@
+module std::core::string::ansi;
+import std::io;
+
+constdef Ansi : inline String
+{
+	RESET              = "\e[0m",
+	BOLD               = "\e[1m",
+	DIM                = "\e[2m",
+	ITALIC             = "\e[3m",
+	UNDERLINE          = "\e[4m",
+	BLINK              = "\e[5m",
+	BLINK_FAST         = "\e[6m",
+	INVERT             = "\e[7m",
+	HIDDEN             = "\e[8m",
+	STRIKETHROUGH      = "\e[9m",
+	DOUBLE_UNDER       = "\e[21m",
+	NO_DIM             = "\e[22m",
+	NO_ITALIC          = "\e[23m",
+	NO_UNDERLINE       = "\e[24m",
+	NO_BLINK           = "\e[25m",
+	NO_INVERT          = "\e[27m",
+	NO_HIDDEN          = "\e[28m",
+	NO_STRIKETHROUGH   = "\e[29m",
+	BLACK              = "\e[30m",
+	RED                = "\e[31m",
+	GREEN              = "\e[32m",
+	YELLOW             = "\e[33m",
+	BLUE               = "\e[34m",
+	MAGENTA            = "\e[35m",
+	CYAN               = "\e[36m",
+	WHITE              = "\e[37m",
+	DEFAULT            = "\e[39m",
+	BRIGHT_BLACK       = "\e[90m",
+	BRIGHT_RED         = "\e[91m",
+	BRIGHT_GREEN       = "\e[92m",
+	BRIGHT_YELLOW      = "\e[93m",
+	BRIGHT_BLUE        = "\e[94m",
+	BRIGHT_MAGENTA     = "\e[95m",
+	BRIGHT_CYAN        = "\e[96m",
+	BRIGHT_WHITE       = "\e[97m",
+	BG_BLACK           = "\e[40m",
+	BG_RED             = "\e[41m",
+	BG_GREEN           = "\e[42m",
+	BG_YELLOW          = "\e[43m",
+	BG_BLUE            = "\e[44m",
+	BG_MAGENTA         = "\e[45m",
+	BG_CYAN            = "\e[46m",
+	BG_WHITE           = "\e[47m",
+	BG_DEFAULT         = "\e[49m",
+	BG_BRIGHT_BLACK    = "\e[100m",
+	BG_BRIGHT_RED      = "\e[101m",
+	BG_BRIGHT_GREEN    = "\e[102m",
+	BG_BRIGHT_YELLOW   = "\e[103m",
+	BG_BRIGHT_BLUE     = "\e[104m",
+	BG_BRIGHT_MAGENTA  = "\e[105m",
+	BG_BRIGHT_CYAN     = "\e[106m",
+	BG_BRIGHT_WHITE    = "\e[107m",
+}
+
+struct AnsiColor (Printable)
+{
+	char r, g, b;
+	bool bg;
+}
+
+fn usz? AnsiColor.to_format(&self, Formatter* fmt) @dynamic
+{
+	return fmt.printf("\e[%s8;2;%s;%s;%sm", self.bg ? 4 : 3, self.r, self.g, self.b);
+}
+
+<*
+ 24-bit color code
+
+ @return `A struct that, when formatted with '%s', sets the foreground or background colour to the specified rgb value`
+*>
+fn AnsiColor get_color_rgb(char r, char g, char b, bool bg = false)
+{
+	return {r, g, b, bg};
+}
+
+<*
+ 24-bit color code
+
+ @return `A struct that, when formatted with '%s', sets the foreground or background colour of printed text to the specified rgb value`
+*>
+fn AnsiColor get_color(uint rgb, bool bg = false)
+{
+	return {(char)(rgb >> 16), (char)((rgb & 0x00FF00) >> 8), (char)rgb, bg};
+}
+
+<*
+ 8-bit color code
+
+ @return `the formatting char for the given background color`
+*>
+macro String color_8bit(char $index, bool $bg = false) @const
+{
+	int $mode = $bg ? 4 : 3;
+	return @sprintf("\e[%s8;5;%sm", $mode, $index);
+}
+
+<*
+ 24-bit color code
+
+ @return `the string for the given foreground color`
+*>
+macro String color_rgb(char $r, char $g, char $b, bool $bg = false) @const
+{
+	int $mode = $bg ? 4 : 3;
+	return @sprintf("\e[%s8;2;%s;%s;%sm", $mode, $r, $g, $b);
+}
+
+<*
+ 24-bit color code rgb
+
+ @require $rgb <= 0xFF_FF_FF : `Expected a 24 bit RGB value`
+ @return `the string char for the given foreground color`
+*>
+macro String color(uint $rgb, bool $bg = false) @const
+{
+	int $mode = $bg ? 4 : 3;
+	return @sprintf("\e[%s8;2;%s;%s;%sm", $mode, $rgb >> 16, ($rgb & 0xFF00) >> 8, $rgb & 0xFF);
+}
+
+<*
+ 24-bit color code rgb
+
+ @require rgb <= 0xFF_FF_FF : `Expected a 24 bit RGB value`
+ @return `the string char for the given foreground color`
+*>
+fn String make_color(Allocator mem, uint rgb, bool bg = false) @deprecated("use get_color instead")
+{
+	return make_color_rgb(mem, (char)(rgb >> 16), (char)((rgb & 0xFF00) >> 8), (char)rgb, bg);
+}
+
+<*
+ 24-bit color code rgb
+
+ @require rgb <= 0xFF_FF_FF : `Expected a 24 bit RGB value`
+ @return `the string char for the given foreground color`
+*>
+fn String make_tcolor(uint rgb, bool bg = false) @deprecated("use get_color instead")
+{
+	return make_color_rgb(tmem, (char)(rgb >> 16), (char)((rgb & 0xFF00) >> 8), (char)rgb, bg);
+}
+
+<*
+ 24-bit color code rgb
+
+ @return `the string char for the given foreground color`
+*>
+fn String make_color_rgb(Allocator mem, char r, char g, char b, bool bg = false) @deprecated("use get_color_rgb instead")
+{
+	return string::format(mem, "\e[%s8;2;%s;%s;%sm", bg ? 4 : 3, r, g, b);
+}
+
+<*
+ 24-bit color code rgb
+
+ @return `the string char for the given foreground color`
+*>
+fn String make_tcolor_rgb(char r, char g, char b, bool bg = false) @deprecated("use get_color_rgb instead")
+{
+	return string::format(tmem, "\e[%s8;2;%s;%s;%sm", bg ? 4 : 3, r, g, b);
+}

lib/std/core/array.c3

@@ -1,61 +1,96 @@
 module std::core::array;
-import std::core::array::slice;
+import std::collections::pair, std::io;
 
 <*
+ Returns true if the array contains at least one element, else false
+
  @param [in] array
  @param [in] element
- @return "the first index of the element"
- @return! SearchResult.MISSING
+ @require $kindof(array) == SLICE || $kindof(array) == ARRAY
+ @require @typematch(array[0], element) : "array and element must have the same type"
 *>
-macro index_of(array, element)
+macro bool contains(array, element)
+{
+	foreach (&item : array)
+	{
+		if (*item == element) return true;
+	}
+	return false;
+}
+
+
+<*
+ Return the first index of element found in the array, searching from the start.
+
+ @param [in] array
+ @param [in] element
+ @require $kindof(array) == SLICE || $kindof(array) == ARRAY
+ @require @typematch(array[0], element) : "array and element must have the same type"
+ @return "the first index of the element"
+ @return? NOT_FOUND
+*>
+macro usz? index_of(array, element)
 {
 	foreach (i, &e : array)
 	{
 		if (*e == element) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
+
 <*
- @require @typekind(array) == VECTOR || @typekind(array) == ARRAY
- @require @typekind(array[0]) == VECTOR || @typekind(array[0]) == ARRAY
+ Slice a 2d array and create a Slice2d from it.
+
+ @param array_ptr : "the pointer to create a slice from"
+ @param x : "The starting position of the slice x, optional"
+ @param y : "The starting position of the slice y, optional"
+ @param xlen : "The length of the slice in x, defaults to the length of the array"
+ @param ylen : "The length of the slice in y, defaults to the length of the array"
+ @return "A Slice2d from the array"
+ @require $kindof(array_ptr) == POINTER
+ @require $kindof(*array_ptr) == VECTOR || $kindof(*array_ptr) == ARRAY
+ @require $kindof((*array_ptr)[0]) == VECTOR || $kindof((*array_ptr)[0]) == ARRAY
 *>
-macro slice2d(array, x = 0, xlen = 0, y = 0, ylen = 0)
+macro slice2d(array_ptr, x = 0, xlen = 0, y = 0, ylen = 0)
 {
-	if (xlen < 1) xlen = $typeof(array[0]).len + xlen;
-	if (ylen < 1) ylen = $typeof(array).len + ylen;
-	var $ElementType = $typeof(array[0][0]);
-	return Slice2d(<$ElementType>) { ($ElementType*)&array, $typeof(array[0]).len, y, ylen, x, xlen };
+	if (xlen < 1) xlen = $typeof((*array_ptr)[0]).len + xlen;
+	if (ylen < 1) ylen = $typeof((*array_ptr)).len + ylen;
+	var $ElementType = $typeof((*array_ptr)[0][0]);
+	return (Slice2d{$ElementType}) { ($ElementType*)array_ptr, $typeof((*array_ptr)[0]).len, y, ylen, x, xlen };
 }
 
 
 <*
+ Return the first index of element found in the array, searching in reverse from the end.
+
  @param [in] array
  @param [in] element
  @return "the last index of the element"
- @return! SearchResult.MISSING
+ @return? NOT_FOUND
 *>
-macro rindex_of(array, element)
+macro usz? rindex_of(array, element)
 {
 	foreach_r (i, &e : array)
 	{
 		if (*e == element) return i;
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
 }
 
+
 <*
  Concatenate two arrays or slices, returning a slice containing the concatenation of them.
 
  @param [in] arr1
  @param [in] arr2
- @param [&inout] allocator "The allocator to use, default is the heap allocator"
- @require @typekind(arr1) == SLICE || @typekind(arr1) == ARRAY
- @require @typekind(arr2) == SLICE || @typekind(arr2) == ARRAY
- @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
+ @param [&inout] allocator : "The allocator to use, default is the heap allocator"
+ @require $kindof(arr1) == SLICE || $kindof(arr1) == ARRAY
+ @require $kindof(arr2) == SLICE || $kindof(arr2) == ARRAY
+ @require @typematch(arr1[0], arr2[0]) : "Arrays must have the same type"
  @ensure result.len == arr1.len + arr2.len
 *>
-macro concat(arr1, arr2, Allocator allocator) @nodiscard
+macro concat(Allocator allocator, arr1, arr2) @nodiscard
 {
 	var $Type = $typeof(arr1[0]);
 	$Type[] result = allocator::alloc_array(allocator, $Type, arr1.len + arr2.len);
@@ -69,21 +104,6 @@ macro concat(arr1, arr2, Allocator allocator) @nodiscard
 	}
 	return result;
 }
-<*
- Concatenate two arrays or slices, returning a slice containing the concatenation of them.
-
- @param [in] arr1
- @param [in] arr2
- @param [&inout] allocator "The allocator to use, default is the heap allocator"
- @require @typekind(arr1) == SLICE || @typekind(arr1) == ARRAY
- @require @typekind(arr2) == SLICE || @typekind(arr2) == ARRAY
- @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
- @ensure result.len == arr1.len + arr2.len
-*>
-macro concat_new(arr1, arr2, Allocator allocator = allocator::heap()) @nodiscard
-{
-	return concat(arr1, arr2, allocator);
-}
 
 <*
  Concatenate two arrays or slices, returning a slice containing the concatenation of them,
@@ -91,72 +111,509 @@ macro concat_new(arr1, arr2, Allocator allocator = allocator::heap()) @nodiscard
 
  @param [in] arr1
  @param [in] arr2
- @require @typekind(arr1) == SLICE || @typekind(arr1) == ARRAY
- @require @typekind(arr2) == SLICE || @typekind(arr2) == ARRAY
- @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
- @ensure result.len == arr1.len + arr2.len
+ @require $kindof(arr1) == SLICE || $kindof(arr1) == ARRAY
+ @require $kindof(arr2) == SLICE || $kindof(arr2) == ARRAY
+ @require @typematch(arr1[0], arr2[0]) : "Arrays must have the same type"
+ @ensure return.len == arr1.len + arr2.len
 *>
-macro tconcat(arr1, arr2) @nodiscard => concat(arr1, arr2, allocator::temp());
+macro tconcat(arr1, arr2) @nodiscard => concat(tmem, arr1, arr2);
 
-module std::core::array::slice(<Type>);
 
-struct Slice2d
+<*
+ Apply a reduction/folding operation to an iterable type. This walks along the input array
+ and applies an `#operation` to each value, returning it to the `identity` (or "accumulator")
+ base value.
+
+ For example:
+ ```c3
+ int[] my_slice = { 1, 8, 12 };
+ int folded = array::@reduce(my_slice, 2, fn (i, e) => i * e);
+ assert(folded == (2 * 1 * 8 * 12));
+ ```
+
+ Notice how the given `identity` value started the multiplication chain at 2. When enumerating
+ `my_slice`, each element is accumulated onto the `identity` value with each sequential iteration.
+ ```
+ i = 2;   // identity value
+ i *= 1;   // my_slice[0]
+ i *= 8;   // my_slice[1]
+ i *= 12;   // my_slice[2]
+ ```
+
+ @param [in] array
+ @param identity
+ @param #operation : "The reduction/folding lambda function or function pointer to apply."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@reduce_fn(array, identity)) $func = #operation) : "Invalid lambda or function pointer type"
+*>
+macro @reduce(array, identity, #operation)
 {
-	Type* ptr;
-	usz inner_len;
-	usz ystart;
-	usz ylen;
-	usz xstart;
-	usz xlen;
-}
-
-fn usz Slice2d.len(&self) @operator(len)
-{
-	return self.ylen;
-}
-
-fn usz Slice2d.count(&self)
-{
-	return self.ylen * self.xlen;
-}
-
-macro void Slice2d.@each(&self; @body(usz[<2>], Type))
-{
-	foreach (y, line : *self)
-	{
-		foreach (x, val : line)
-		{
-			@body({ x, y }, val);
-		}
-	}
-}
-
-macro void Slice2d.@each_ref(&self; @body(usz[<2>], Type*))
-{
-	foreach (y, line : *self)
-	{
-		foreach (x, &val : line)
-		{
-			@body({ x, y }, val);
-		}
-	}
+	$typefrom(@reduce_fn(array, identity)) $func = #operation;
+	foreach (index, element : array) identity = $func(identity, element, index);
+	return identity;
 }
 
 <*
- @require idy >= 0 && idy < self.ylen
+ Apply a summation operator (+) to an identity value across a span of array elements
+ and return the final accumulated result.
+
+ @pure
+
+ @param [in] array
+ @param identity_value : "The base accumulator value to use for the sum"
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[0] + array[0]) : "Array element type must implement the '+' operator"
+ @require $defined($typeof(array[0]) t = identity_value) : "The identity type must be assignable to the array element type"
 *>
-macro Type[] Slice2d.get(self, usz idy) @operator([])
+macro @sum(array, identity_value = 0)
 {
-	return (self.ptr + self.inner_len * (idy + self.ystart))[self.xstart:self.xlen];
+	return @reduce(array, ($typeof(array[0]))identity_value, fn (acc, e, u) => acc + e);
 }
 
 <*
- @require y >= 0 && y < self.ylen
- @require x >= 0 && x < self.xlen
+ Apply a product operator (*) to an identity value across a span of array elements
+ and return the final accumulated result.
+
+ @pure
+
+ @param [in] array
+ @param identity_value : "The base accumulator value to use for the product"
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[0] * array[0]) : "Array element type must implement the '*' operator"
+ @require $defined($typeof(array[0]) t = identity_value) : "The identity type must be assignable to the array element type"
 *>
-fn Slice2d Slice2d.slice(&self, isz x = 0, isz xlen = 0, isz y = 0, isz ylen = 0)
+macro @product(array, identity_value = 1)
 {
-	if (xlen < 1) xlen = self.xlen + xlen;
-	if (ylen < 1) ylen = self.ylen + ylen;
-	return { self.ptr, self.inner_len, y + self.ystart, ylen, x + self.xstart, xlen };
+	return @reduce(array, ($typeof(array[0]))identity_value, fn (acc, e, u) => acc * e);
+}
+
+<*
+ Applies a given predicate function to each element of an array and returns a new
+ array of `usz` values, each element representing an index within the original array
+ where the predicate returned `true`.
+
+ The `.len` value of the returned array can also be used to quickly identify how many
+ input array elements matched the predicate.
+
+ For example:
+ ```c3
+ int[] arr = { 0, 20, 4, 30 };
+ int[] matched_indices = array::@indices_of(mem, arr, fn (u, a) => a > 10);
+ ```
+
+ The `matched_indices` variable should contain a dynamically-allocated array of `[1, 3]`,
+ and thus its count indicates that 2 of the 4 elements matched the predicate condition.
+
+ @param [&inout] allocator
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro usz[] @indices_of(Allocator allocator, array, #predicate)
+{
+	usz[] results = allocator::new_array(allocator, usz, lengthof(array));
+	usz matches;
+
+	$typefrom(@predicate_fn(array)) $predicate = #predicate;
+	foreach (index, element : array)
+	{
+		if ($predicate(element, index)) results[matches++] = index;
+	}
+
+	return results[:matches];
+}
+
+<*
+ Array `@indices_of` using the temp allocator.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro usz[] @tindices_of(array, #predicate)
+{
+	return @indices_of(tmem, array, #predicate);
+}
+
+
+<*
+ Applies a predicate function to each element of an input array and returns a new array
+ containing shallow copies of _only_ the elements for which the predicate function returned
+ a `true` value.
+
+ For example:
+ ```c3
+ int[] my_arr = { 1, 2, 4, 10, 11, 45 };
+ int[] evens = array::@filter(mem, my_arr, fn (e, u) => !(e % 2));
+ assert(evens == (int[]){2, 4, 10 });
+ ```
+
+ @param [&inout] allocator
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro @filter(Allocator allocator, array, #predicate) @nodiscard
+{
+	var $InnerType = $typeof(array[0]);
+
+	usz[] matched_indices = @indices_of(allocator, array, #predicate);
+	defer allocator::free(allocator, matched_indices.ptr);   // can free this upon leaving this call
+
+	if (!matched_indices.len) return ($InnerType[]){};
+
+	$InnerType[] result = allocator::new_array(allocator, $InnerType, matched_indices.len);
+
+	foreach (i, index : matched_indices) result[i] = array[index];
+
+	return result;
+}
+
+<*
+ Array `@filter` using the temp allocator.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro @tfilter(array, #predicate) @nodiscard
+{
+	return @filter(tmem, array, #predicate);
+}
+
+
+<*
+ Returns `true` if _any_ element of the input array returns `true` when
+ the `#predicate` function is applied.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro bool @any(array, #predicate)
+{
+	$typefrom(@predicate_fn(array)) $predicate = #predicate;
+	foreach (index, element : array) if ($predicate(element, index)) return true;
+	return false;
+}
+
+
+<*
+ Returns `true` if _all_ elements of the input array return `true` when
+ the `#predicate` function is applied.
+
+ @param [in] array
+ @param #predicate
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined($typefrom(@predicate_fn(array)) p = #predicate)
+*>
+macro bool @all(array, #predicate)
+{
+	$typefrom(@predicate_fn(array)) $predicate = #predicate;
+	foreach (index, element : array) if (!$predicate(element, index)) return false;
+	return true;
+}
+
+
+<*
+ Extract a copy of all even-index elements from an input array.
+
+ @param [&inout] allocator : "The allocator used to create the return array."
+ @param [in] array : "The array from which to extract all even elements."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[:lengthof(array)]) : "Expected a sliceable list"
+*>
+macro even(Allocator allocator, array)
+{
+	return unlace_impl{$typeof(array[0])}(allocator, array[:lengthof(array)]);
+}
+
+
+<*
+ Extract a copy of all odd-index elements from an input array.
+
+ @param [&inout] allocator : "The allocator used to create the return array."
+ @param [in] array : "The array from which to extract all odd elements."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $defined(array[:lengthof(array)]) : "Expected a sliceable list"
+*>
+macro odd(Allocator allocator, array)
+{
+	return unlace_impl{$typeof(array[0])}(allocator, lengthof(array) > 1 ? array[1..] : ($typeof(array[0])[]){});
+}
+
+<*
+ Private implementation of `even` and `odd` macros, expecting a slice and returning one as well.
+ This function always extracts the even elements of the input slice.
+
+ @param [&inout] allocator : "The allocator used to create the return array."
+ @param [in] array : "The array from which to extract all odd elements."
+*>
+fn Type[] unlace_impl(Allocator allocator, Type[] array) <Type> @private
+{
+	usz new_len = array.len / 2 + (array.len % 2 == 0 ? 0 : 1);
+	if (new_len == 0) return (Type[]){};
+	Type[] new_array = allocator::new_array(allocator, Type, new_len);
+	foreach (x, &new : new_array) *new = types::implements_copy(Type) ??? array[x * 2].copy(allocator) : array[x * 2];
+	return new_array[:new_len];
+}
+
+<*
+ Unlace or partition an input list into its component parts such that `[a, b, c, d, e]` becomes
+ `[a, c, e]` and `[b, d]`. Returned arrays are allocated by the given allocator and are returned
+ via two `out` parameters, `left` and `right`.
+
+ @param [&inout] allocator : "The allocator used to create the returned arrays."
+ @param [in] array : "The input array to unlace."
+ @param [out] left : "Stores a copy of all even-index array elements."
+ @param [out] right : "Stores a copy of all odd-index array elements."
+
+ @require @is_valid_list(array) : "Expected a valid list"
+ @require $typeof(left) == $typeof(array[0])[]*
+ @require $typeof(right) == $typeof(array[0])[]*
+*>
+macro unlace(Allocator allocator, array, left, right)
+{
+	if (left) *left = even(allocator, array);
+	if (right) *right = odd(allocator, array);
+}
+
+
+<*
+ Zip together two separate arrays/slices into a single array of Pairs or return values. Values will
+ be collected up to the length of the shorter array if `fill_with` is left undefined; otherwise, they
+ will be collected up to the length of the LONGER array, with missing values in the shorter array being
+ assigned to the value of `fill_with`. Return array elements do not have to be of the same type.
+
+ For example:
+ ```c3
+ uint[] chosen_session_ids = server::get_random_sessions(instance)[:128];
+ String[200] refreshed_session_keys = prng::new_keys_batch();
+
+ Pair { uint, String }[] sessions_meta = array::zip(mem, chosen_session_ids, refreshed_session_keys);
+ // The resulting Pair{}[] slice is then length of the shortest of the two arrays, so 128.
+
+ foreach (i, &sess : sessions:meta) {
+     // distribute new session keys to associated instance IDs
+ }
+ ```
+
+ Or:
+ ```c3
+ String[] client_names = server::online_usernames(instance);
+ uint128[] session_ids = server::user_keys();
+
+ // in this example, we 'know' ahead of time that 'session_ids' can only ever be SHORTER
+ //   than 'client_names', but never longer, because it's possible new users have logged
+ //   in without getting whatever this 'session ID' is delegated to them.
+ Pair { String, uint128 }[] zipped = array::tzip(client_names, session_ids, fill_with: uint128.max);
+
+ server::refresh_session_keys_by_pair(zipped)!;
+ ```
+
+ ### When an `operation` is supplied...
+ Apply an operation to each element of two slices or arrays and return the results of
+ each operation into a newly allocated array.
+
+ This essentially combines Iterable1 with Iterable2 using the `operation` functor.
+
+ See the functional `zipWith` construct, which has a more appropriate name than, e.g., `map`;
+   a la: https://hackage.haskell.org/package/base-4.21.0.0/docs/Prelude.html#v:zipWith
+
+ Similar to "normal" `zip`, this macro pads the shorter input array with a given `fill_with`, or
+ an empty value if one isn't supplied. This `fill_with` is supplied to the `operation` functor
+ _BEFORE_ calculating its result while zipping.
+
+ For example: a functor of `fn char (char a, char b) => a + b` with a `fill_with` of 7,
+ where the `left` array is the shorter iterable, will put 7 into that lambda in each place
+ where `left` is being filled in during the zip operation.
+
+ @param [&inout] allocator : "The allocator to use; default is the heap allocator."
+ @param [in] left : "The left-side array. These items will be placed as the First in each Pair"
+ @param [in] right : "The right-side array. These items will be placed as the Second in each Pair"
+ @param #operation : "The function to apply. Must have a signature of `$typeof(a) (a, b)`, where the type of 'a' and 'b' is the element type of left/right respectively."
+ @param fill_with : "The value used to fill or pad the shorter iterable to the length of the longer one while zipping."
+
+ @require @is_valid_list(left) &&& @is_valid_list(right) : "Left and right sides must be integer indexable"
+ @require @is_valid_operation(left, right, ...#operation) : "The operator must take two parameters matching the elements of the left and right side"
+ @require @is_valid_fill(left, right, ...fill_with) : "The specified fill value does not match either the left or the right array's underlying type."
+*>
+macro @zip(Allocator allocator, left, right, #operation = ..., fill_with = ...) @nodiscard
+{
+	var $LeftType = $typeof(left[0]);
+	var $RightType = $typeof(right[0]);
+
+	var $Type = Pair { $LeftType, $RightType };
+	bool $is_op = $defined(#operation);
+	$if $is_op:
+		$Type = $typeof(#operation).returns;
+	$endif
+
+	usz left_len = lengthof(left);
+	usz right_len = lengthof(right);
+
+	$LeftType left_fill;
+	$RightType right_fill;
+	usz result_len = min(left_len, right_len);
+	$if $defined(fill_with):
+		switch
+		{
+			case left_len > right_len:
+				$if !$defined(($RightType)fill_with):
+					unreachable();
+				$else
+					right_fill = ($RightType)fill_with;
+					result_len = left_len;
+				$endif
+			case left_len < right_len:
+				$if !$defined(($LeftType)fill_with):
+					unreachable();
+				$else
+					left_fill = ($LeftType)fill_with;
+					result_len = right_len;
+				$endif
+		}
+	$endif
+
+	if (result_len == 0) return ($Type[]){};
+
+	$Type[] result = allocator::alloc_array(allocator, $Type, result_len);
+
+	foreach (idx, &item : result)
+	{
+		$if $is_op:
+			var $LambdaType = $typeof(fn $Type ($LeftType a, $RightType b) => ($Type){});
+			$LambdaType $operation = ($LambdaType)#operation;
+			$LeftType lval = idx >= left_len ? left_fill : left[idx];
+			$RightType rval = idx >= right_len ? right_fill : right[idx];
+			*item = $operation(lval, rval);
+		$else
+			*item = {
+				idx >= left_len ? left_fill : left[idx],
+				idx >= right_len ? right_fill : right[idx]
+			};
+		$endif
+	}
+
+	return result;
+}
+
+<*
+ Array 'zip' using the temp allocator.
+
+ @param [in] left : "The left-side array. These items will be placed as the First in each Pair"
+ @param [in] right : "The right-side array. These items will be placed as the Second in each Pair"
+ @param #operation : "The function to apply. Must have a signature of `$typeof(a) (a, b)`, where the type of 'a' and 'b' is the element type of left/right respectively."
+ @param fill_with : "The value used to fill or pad the shorter iterable to the length of the longer one while zipping."
+
+ @require @is_valid_list(left) &&& @is_valid_list(right) : "Left and right sides must be integer indexable"
+ @require @is_valid_operation(left, right, ...#operation) : "The operator must take two parameters matching the elements of the left and right side"
+ @require @is_valid_fill(left, right, ...fill_with) : "The specified fill value does not match either the left or the right array's underlying type."
+*>
+macro @tzip(left, right, #operation = ..., fill_with = ...) @nodiscard
+{
+	return @zip(tmem, left, right, #operation: ...#operation, fill_with: ...fill_with);
+}
+
+
+<*
+ Apply an operation to each element of two slices or arrays and store the results of
+ each operation into the 'left' value.
+
+ This is useful because no memory allocations are required in order to perform the operation.
+
+ A good example of using this might be using algorithmic transformations on data in-place:
+ ```
+ char[] partial_cipher = get_next_plaintext_block();
+
+ array::@zip_into(
+     partial_cipher[ENCRYPT_OFFSET:BASE_KEY.len],
+	 BASE_KEY,
+	 fn char (char a, char b) => a ^ (b * 5) % 37
+ );
+ ```
+
+ This parameterizes the lambda function with left (`partial_cipher`) and right (`BASE_KEY`) slice
+ elements and stores the end result in-place within the left slice. This is in contrast to a
+ regular `zip_with` which will create a cloned final result and return it.
+
+ @param [inout] left : `Slice to store results of applied functor/operation.`
+ @param [in] right : `Slice to apply in the functor/operation.`
+ @param #operation : "The function to apply. Must have a signature of `$typeof(a) (a, b)`, where the type of 'a' and 'b' is the element type of left/right respectively."
+
+ @require @is_valid_list(left) : "Expected a valid list"
+ @require @is_valid_list(right) : "Expected a valid list"
+ @require lengthof(right) >= lengthof(left) : `Right side length must be >= the destination (left) side length; consider using a sub-array of data for the assignment.`
+ @require $defined($typefrom(@zip_into_fn(left, right)) x = #operation) : "The functor must use the same types as the `left` and `right` inputs, and return a value of the `left` type."
+*>
+macro @zip_into(left, right, #operation)
+{
+	$typefrom(@zip_into_fn(left, right)) $operation = #operation;
+
+	foreach (i, &v : left) *v = $operation(left[i], right[i]);
+}
+
+
+// --- helper functions
+module std::core::array @private;
+
+
+macro typeid @predicate_fn(#array) @const
+{
+	return $typeof(fn bool ($typeof(#array[0]) a, usz index = 0) => true).typeid;
+}
+
+macro typeid @reduce_fn(#array, #identity) @const
+{
+	return @typeid(fn $typeof(#identity) ($typeof(#identity) i, $typeof(#array[0]) a, usz index = 0) => i);
+}
+
+macro typeid @zip_into_fn(#left, #right) @const
+{
+	return @typeid(fn $typeof(#left[0]) ($typeof(#left[0]) l, $typeof(#right[0]) r) => l);
+}
+
+macro bool @is_valid_operation(#left, #right, #operation = ...) @const
+{
+	$switch:
+		$case !$defined(#operation):
+			return true;
+		$case $kindof(#operation) != FUNC:
+			return false;
+		$default:
+			return $defined(#operation(#left[0], #right[0]));
+	$endswitch
+}
+
+macro bool @is_valid_list(#expr) @const
+{
+	return $defined(#expr[0], lengthof(#expr));
+}
+
+macro bool @is_valid_fill(left, right, fill_with = ...)
+{
+	$if !$defined(fill_with):
+		return true;
+	$else
+		usz left_len = lengthof(left);
+		usz right_len = lengthof(right);
+		if (left_len == right_len) return true;
+		return left_len > right_len ? $defined(($typeof(right[0]))fill_with) : $defined(($typeof(left[0]))fill_with);
+	$endif
 }

lib/std/core/ascii.c3

@@ -0,0 +1,156 @@
+<*
+ This module contains utils for handling ASCII characters. They only operate on
+ characters corresponding to 0-127.
+*>
+module std::core::ascii;
+
+macro bool @is_lower(c)  => ASCII_LOOKUP[c].lower;      // Is a-z
+macro bool @is_upper(c)  => ASCII_LOOKUP[c].upper;      // Is A-Z
+macro bool @is_digit(c)  => ASCII_LOOKUP[c].digit;      // Is 0-9
+macro bool @is_bdigit(c) => ASCII_LOOKUP[c].bin_digit;  // Is 0-1
+macro bool @is_odigit(c) => ASCII_LOOKUP[c].oct_digit;  // Is 0-7
+macro bool @is_xdigit(c) => ASCII_LOOKUP[c].hex_digit;  // Is 0-9 or a-f or A-F
+macro bool @is_alpha(c)  => ASCII_LOOKUP[c].alpha;      // Is a-z or A-Z
+macro bool @is_print(c)  => ASCII_LOOKUP[c].printable;  // Is a printable character (space or higher and < 127
+macro bool @is_graph(c)  => ASCII_LOOKUP[c].graph;      // Does it show any graphics (printable but not space)
+macro bool @is_space(c)  => ASCII_LOOKUP[c].space;      // Is it a space character: space, tab, linefeed etc
+macro bool @is_alnum(c)  => ASCII_LOOKUP[c].alphanum;   // Is it alpha or digit
+macro bool @is_punct(c)  => ASCII_LOOKUP[c].punct;      // Is it "graph" but not digit or letter
+macro bool @is_blank(c)  => ASCII_LOOKUP[c].blank;      // Is it a blank space: space or tab
+macro bool @is_cntrl(c)  => ASCII_LOOKUP[c].control;    // Is it a control character: before space or 127
+macro char @to_lower(c)  => c + TO_LOWER[c];            // Convert A-Z to a-z if found
+macro char @to_upper(c)  => c - TO_UPPER[c];            // Convert a-z to A-Z if found
+
+fn bool is_lower(char c)  => @is_lower(c);  // Is a-z
+fn bool is_upper(char c)  => @is_upper(c);  // Is A-Z
+fn bool is_digit(char c)  => @is_digit(c);  // Is 0-9
+fn bool is_bdigit(char c) => @is_bdigit(c); // Is 0-1
+fn bool is_odigit(char c) => @is_odigit(c); // Is 0-7
+fn bool is_xdigit(char c) => @is_xdigit(c); // Is 0-9 or a-f or A-F
+fn bool is_alpha(char c)  => @is_alpha(c);  // Is a-z or A-Z
+fn bool is_print(char c)  => @is_print(c);  // Is a printable character (space or higher and < 127
+fn bool is_graph(char c)  => @is_graph(c);  // Does it show any graphics (printable but not space)
+fn bool is_space(char c)  => @is_space(c);  // Is it a space character: space, tab, linefeed etc
+fn bool is_alnum(char c)  => @is_alnum(c);  // Is it alpha or digit
+fn bool is_punct(char c)  => @is_punct(c);  // Is it "graph" but not digit or letter
+fn bool is_blank(char c)  => @is_blank(c);  // Is it a blank space: space or tab
+fn bool is_cntrl(char c)  => @is_cntrl(c);  // Is it a control character: before space or 127
+fn char to_lower(char c)  => @to_lower(c);  // Convert A-Z to a-z if found
+fn char to_upper(char c)  => @to_upper(c);  // Convert a-z to A-Z if found
+
+// The following methods are macro methods for the same functions
+macro bool char.is_lower(char c)  => @is_lower(c);
+macro bool char.is_upper(char c)  => @is_upper(c);
+macro bool char.is_digit(char c)  => @is_digit(c);
+macro bool char.is_bdigit(char c) => @is_bdigit(c);
+macro bool char.is_odigit(char c) => @is_odigit(c);
+macro bool char.is_xdigit(char c) => @is_xdigit(c);
+macro bool char.is_alpha(char c)  => @is_alpha(c);
+macro bool char.is_print(char c)  => @is_print(c);
+macro bool char.is_graph(char c)  => @is_graph(c);
+macro bool char.is_space(char c)  => @is_space(c);
+macro bool char.is_alnum(char c)  => @is_alnum(c);
+macro bool char.is_punct(char c)  => @is_punct(c);
+macro bool char.is_blank(char c)  => @is_blank(c);
+macro bool char.is_cntrl(char c)  => @is_cntrl(c);
+macro char char.to_lower(char c)  => @to_lower(c);
+macro char char.to_upper(char c)  => @to_upper(c);
+
+<*
+ Convert a-f/A-F/0-9 to the appropriate hex value.
+
+ @require c.is_xdigit()
+ @ensure return >= 0 && return <= 15
+*>
+macro char char.from_hex(char c) => HEX_VALUE[c];
+
+<*
+ Bitstruct containing the different properties of a character
+*>
+bitstruct CharType : ushort @private
+{
+	bool lower;
+	bool upper;
+	bool digit;
+	bool bin_digit;
+	bool hex_digit;
+	bool oct_digit;
+	bool alpha;
+	bool alphanum;
+	bool space;
+	bool printable;
+	bool blank;
+	bool punct;
+	bool control;
+	bool graph;
+}
+
+const CharType[256] ASCII_LOOKUP @private = {
+	[0..31]    = { .control },
+	[9..13]    = { .control, .space },
+	['\t']     = { .control, .space, .blank },
+	[' ']      = { .space, .printable, .blank },
+	[33..126]  = { .printable, .graph, .punct },
+	['0'..'9'] = { .printable, .graph, .alphanum, .hex_digit, .digit },
+	['2'..'7'] = { .printable, .graph, .alphanum, .hex_digit, .digit, .oct_digit },
+	['0'..'1'] = { .printable, .graph, .alphanum, .hex_digit, .digit, .oct_digit, .bin_digit },
+	['A'..'Z'] = { .printable, .graph, .alphanum, .alpha, .upper },
+	['A'..'F'] = { .printable, .graph, .alphanum, .alpha, .upper, .hex_digit },
+	['a'..'z'] = { .printable, .graph, .alphanum, .alpha, .lower },
+	['a'..'f'] = { .printable, .graph, .alphanum, .alpha, .lower, .hex_digit },
+	[127]      = { .control },
+};
+
+const char[256] HEX_VALUE = {
+	['0'] =  0, ['1'] =  1, ['2'] =  2, ['3'] =  3, ['4'] =  4,
+	['5'] =  5, ['6'] =  6, ['7'] =  7, ['8'] =  8, ['9'] =  9,
+	['A'] = 10, ['B'] = 11, ['C'] = 12, ['D'] = 13, ['E'] = 14,
+	['F'] = 15, ['a'] = 10, ['b'] = 11, ['c'] = 12, ['d'] = 13,
+	['e'] = 14, ['f'] = 15
+};
+
+const char[256] TO_UPPER @private = { ['a'..'z'] = 'a' - 'A' };
+const char[256] TO_LOWER @private  = { ['A'..'Z'] = 'a' - 'A' };
+
+typedef AsciiCharset = uint128;
+
+macro AsciiCharset @create_set(String $string) @const
+{
+	AsciiCharset $set;
+	$foreach $c : $string:
+		$set |= 1ULL << $c;
+	$endforeach
+	return $set;
+}
+
+fn AsciiCharset create_set(String string)
+{
+	AsciiCharset set;
+	foreach (c : string) set |= (AsciiCharset)1ULL << c;
+	return set;
+}
+
+macro bool AsciiCharset.@contains($set, char $c) @const => !!($c < 128) & !!($set & (AsciiCharset)(1ULL << $c));
+
+macro AsciiCharset @combine_sets(AsciiCharset $first, AsciiCharset... $sets) @const
+{
+	var $res = $first;
+	$foreach $c : $sets:
+		$res |= $c;
+	$endforeach
+	return $res;
+}
+fn AsciiCharset combine_sets(AsciiCharset first, AsciiCharset... sets)
+{
+	foreach (c : sets) first |= c;
+	return first;
+}
+
+macro bool AsciiCharset.contains(set, char c) => !!(c < 128) & !!(set & (AsciiCharset)(1ULL << c));
+
+const AsciiCharset WHITESPACE_SET = @create_set("\t\n\v\f\r ");
+const AsciiCharset NUMBER_SET = @create_set("0123456789");
+const AsciiCharset ALPHA_UPPER_SET = @create_set("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+const AsciiCharset ALPHA_LOWER_SET = @create_set("abcdefghijklmnopqrstuvwxyz");
+const AsciiCharset ALPHA_SET = @combine_sets(ALPHA_UPPER_SET, ALPHA_LOWER_SET);
+const AsciiCharset ALPHANUMERIC_SET = @combine_sets(ALPHA_SET, NUMBER_SET);

lib/std/core/bitorder.c3

@@ -1,8 +1,8 @@
-// Copyright (c) 2023 Christoffer Lerno and contributors. All rights reserved.
+// Copyright (c) 2023-2025 Christoffer Lerno and contributors. All rights reserved.
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::bitorder;
-
+import std::bits;
 // This module contains types of different endianness.
 // *BE types represent big-endian types
 // *LE types represent little-endian types.
@@ -88,93 +88,149 @@ bitstruct UInt128LE : uint128 @littleendian
 }
 
 <*
- @require is_array_or_slice_of_char(bytes) "argument must be an array, a pointer to an array or a slice of char"
- @require is_bitorder($Type) "type must be a bitorder integer"
+ @require $defined(*bytes) : "Pointer must be possible to dereference"
+ @require types::is_intlike($typeof(*bytes)) : "Type must be an integer or int vector"
 *>
-macro read(bytes, $Type)
+macro load_be(bytes)
 {
-	char[] s;
-	$switch (@typekind(bytes))
-	$case POINTER:
-		s = (*bytes)[:$Type.sizeof];
-	$default:
-		s = bytes[:$Type.sizeof];
-	$endswitch
-	return bitcast(*(char[$Type.sizeof]*)s.ptr, $Type).val;
+	$if env::BIG_ENDIAN:
+		return mem::load(bytes, $align: 1);
+	$else
+		return bswap(mem::load(bytes, $align: 1));
+	$endif
 }
 
 <*
- @require is_arrayptr_or_slice_of_char(bytes) "argument must be a pointer to an array or a slice of char"
- @require is_bitorder($Type) "type must be a bitorder integer"
+ @require $defined(*bytes) : "Pointer must be possible to dereference"
+ @require types::is_intlike($typeof(*bytes)) : "Type must be an integer or int vector"
+*>
+macro load_le(bytes)
+{
+	$if env::BIG_ENDIAN:
+		return bswap(mem::load(bytes, $align: 1));
+	$else
+		return mem::load(bytes, $align: 1);
+	$endif
+}
+
+<*
+ @require types::is_intlike($typeof(value)) : "Type must be an integer or int vector"
+*>
+macro void store_be(void* dst, value)
+{
+	$if env::BIG_ENDIAN:
+		mem::store(($typeof(value)*)dst, value, $align: 1);
+	$else
+		mem::store(($typeof(value)*)dst, bswap(value), $align: 1);
+	$endif
+}
+
+<*
+ @require types::is_intlike($typeof(value)) : "Type must be an integer or int vector"
+*>
+macro void store_le(void* dst, value)
+{
+	$if env::BIG_ENDIAN:
+		mem::store(($typeof(value)*)dst, bswap(value), $align: 1);
+	$else
+		mem::store(($typeof(value)*)dst, value, $align: 1);
+	$endif
+}
+
+<*
+ @require @is_array_or_slice_of_char(bytes) : "argument must be an array, a pointer to an array or a slice of char"
+ @require is_bitorder($Type) : "type must be a bitorder integer"
+ @require $defined(*bytes) ||| $defined(bytes[:$Type.sizeof]) : "Data is too short to contain value"
+*>
+macro read(bytes, $Type)
+{
+	char *ptr;
+	$switch $kindof(bytes):
+		$case POINTER:
+			ptr = bytes;
+		$default:
+			ptr = bytes[..].ptr;
+	$endswitch
+	return bitcast(mem::load((char[$Type.sizeof]*)ptr, $align: 1), $Type).val;
+}
+
+<*
+ @require @is_arrayptr_or_slice_of_char(bytes) : "argument must be a pointer to an array or a slice of char"
+ @require is_bitorder($Type) : "type must be a bitorder integer"
+ @require $defined(*bytes) ||| $defined(bytes[:$Type.sizeof]) : "Data is not sufficent to hold value"
 *>
 macro write(x, bytes, $Type)
 {
-	char[] s;
-	$switch (@typekind(bytes))
-	$case POINTER:
-		s = (*bytes)[:$Type.sizeof];
-	$default:
-		s = bytes[:$Type.sizeof];
+	char *ptr;
+	$switch $kindof(bytes):
+		$case POINTER:
+			ptr = bytes;
+		$default:
+			ptr = bytes[..].ptr;
 	$endswitch
-	*($typeof(x)*)s.ptr = bitcast(x, $Type).val;
+	mem::store(($typeof(x)*)ptr, bitcast(x, $Type).val, 1);
 }
 
-macro is_bitorder($Type)
+macro bool is_bitorder($Type)
 {
-	$switch ($Type)
-	$case UShortLE:
-	$case ShortLE:
-	$case UIntLE:
-	$case IntLE:
-	$case ULongLE:
-	$case LongLE:
-	$case UInt128LE:
-	$case Int128LE:
-	$case UShortBE:
-	$case ShortBE:
-	$case UIntBE:
-	$case IntBE:
-	$case ULongBE:
-	$case LongBE:
-	$case UInt128BE:
-	$case Int128BE:
-		return true;
-	$default:
-		return false;
+	$switch $Type:
+		$case UShortLE:
+		$case ShortLE:
+		$case UIntLE:
+		$case IntLE:
+		$case ULongLE:
+		$case LongLE:
+		$case UInt128LE:
+		$case Int128LE:
+		$case UShortBE:
+		$case ShortBE:
+		$case UIntBE:
+		$case IntBE:
+		$case ULongBE:
+		$case LongBE:
+		$case UInt128BE:
+		$case Int128BE:
+			return true;
+		$default:
+			return false;
 	$endswitch
 }
 
-macro bool is_array_or_slice_of_char(bytes)
+macro bool is_array_or_slice_of_char(bytes) @deprecated("Use @is_array_or_slice_of_char")
 {
-	$switch (@typekind(bytes))
-	$case POINTER:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		$if $Inner.kindof == ARRAY:
-			var $Inner2 = $typefrom($Inner.inner);
-			return $Inner2.typeid == char.typeid;
-		$endif
-	$case ARRAY:
-	$case SLICE:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		return $Inner.typeid == char.typeid;
-	$default:
-		return false;
+	return @is_array_or_slice_of_char(bytes);
+}
+
+macro bool @is_array_or_slice_of_char(#bytes) @const
+{
+    var $Type = $typeof(#bytes);
+	$switch $Type.kindof:
+		$case POINTER:
+			typeid $inner = $Type.inner;
+			return $inner.kindof == ARRAY &&& $inner.inner == char.typeid;
+		$case ARRAY:
+		$case SLICE:
+			return $Type.inner == char.typeid;
+		$default:
+			return false;
 	$endswitch
 }
 
-macro bool is_arrayptr_or_slice_of_char(bytes)
+macro bool is_arrayptr_or_slice_of_char(bytes) @deprecated("Use @is_arrayptr_or_slice_of_char")
 {
-	$switch (@typekind(bytes))
-	$case POINTER:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		$if $Inner.kindof == ARRAY:
-			var $Inner2 = $typefrom($Inner.inner);
-			return $Inner2.typeid == char.typeid;
-		$endif
-	$case SLICE:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		return $Inner.typeid == char.typeid;
-	$default:
-		return false;
+	return @is_arrayptr_or_slice_of_char(bytes);
+}
+
+macro bool @is_arrayptr_or_slice_of_char(#bytes) @const
+{
+	var $Type = $typeof(#bytes);
+	$switch $Type.kindof:
+		$case POINTER:
+			typeid $inner = $Type.inner;
+			return $inner.kindof == ARRAY &&& $inner.inner == char.typeid;
+		$case SLICE:
+			return $Type.inner == char.typeid;
+		$default:
+			return false;
 	$endswitch
-}
+}

lib/std/core/builtin.c3

@@ -4,70 +4,186 @@
 module std::core::builtin;
 import libc, std::hash, std::io, std::os::backtrace;
 
-<*
- Use `IteratorResult` when reading the end of an iterator, or accessing a result out of bounds.
-*>
-fault IteratorResult { NO_MORE_ELEMENT }
 
 <*
- Use `SearchResult` when trying to return a value from some collection but the element is missing.
+ EMPTY_MACRO_SLOT is a value used for implementing optional arguments for macros in an efficient
+ way. It relies on the fact that distinct types are not implicitly convertible.
+
+ You can use `@is_empty_macro_slot()` and `@is_valid_macro_slot()` to figure out whether
+ the argument has been used or not.
+
+ An example:
+
+```c3
+macro foo(a, #b = EMPTY_MACRO_SLOT)
+{
+	$if @is_valid_macro_slot(#b):
+		return invoke_foo2(a, #b);
+	$else
+		return invoke_foo1(a);
+	$endif
+}
 *>
-fault SearchResult { MISSING }
+const EmptySlot EMPTY_MACRO_SLOT @builtin @deprecated("Use `#arg = ...` instead.") = null;
+
+typedef EmptySlot @constinit = void*;
+macro bool @is_empty_macro_slot(#arg) @const @builtin
+		@deprecated("Use `#arg = ...` to define an optional macro slot, and `$defined(#arg)` to detect whether the argument is set.")
+	=> $typeof(#arg) == EmptySlot;
+macro bool @is_valid_macro_slot(#arg) @const @builtin
+		@deprecated("Use `#arg = ...` to define an optional macro slot, and `$defined(#arg)` to detect whether the argument is set.")
+	=> $typeof(#arg) != EmptySlot;
 
 <*
- Use `CastResult` when an attempt at conversion fails.
-*>
-fault CastResult { TYPE_MISMATCH }
+ Returns a random value at compile time.
 
-def VoidFn = fn void();
+ @ensure return >= 0.0 && return < 1.0
+ @return "A compile time random"
+*>
+macro @rnd() @const @builtin => $$rnd();
+
+/*
+ Use `NO_MORE_ELEMENT` when reading the end of an iterator, or accessing a result out of bounds.
+*/
+faultdef NO_MORE_ELEMENT @builtin;
+
+/*
+ Use `NOT_FOUND` when trying to return a value from some collection but the element is missing.
+*/
+faultdef NOT_FOUND @builtin;
+
+/*
+ Use `TYPE_MISMATCH` when an attempt at conversion fails.
+*/
+faultdef TYPE_MISMATCH @builtin;
+
+/*
+ Use `CAPACITY_EXCEEDED` when trying to add to a bounded list or similar.
+*/
+faultdef CAPACITY_EXCEEDED @builtin;
+/*
+ Use `NOT_IMPLEMENTED` when something is conditionally available.
+*/
+faultdef NOT_IMPLEMENTED @builtin;
+
+alias VoidFn = fn void();
 
 <*
  Stores a variable on the stack, then restores it at the end of the
  macro scope.
 
- @param variable `the variable to store and restore`
+ @param #variable : `the variable to store and restore`
+ @require $defined(#variable = #variable) : `Expected an actual variable`
 *>
-macro void @scope(&variable; @body) @builtin
+macro void @scope(#variable; @body) @builtin
 {
-	var temp = *variable;
-	defer *variable = temp;
+	var temp = #variable;
+	defer #variable = temp;
 	@body();
 }
 
 <*
  Swap two variables
- @require $assignable(*b, $typeof(*a)) && $assignable(*a, $typeof(*b))
+ @require $defined(#a = #b, #b = #a) : `The values must be mutually assignable`
 *>
-macro void @swap(&a, &b) @builtin
+macro void @swap(#a, #b) @builtin
 {
-	var temp = *a;
-	*a = *b;
-	*b = temp;
+	var temp = #a;
+	#a = #b;
+	#b = temp;
+}
+
+macro usz bitsizeof($Type) @builtin @const => $Type.sizeof * 8u;
+
+macro usz @bitsizeof(#expr) @builtin @const => $sizeof(#expr) * 8u;
+
+<*
+ Compile-time check for whether a set of constants contains a certain expression.
+
+ @param #needle : "The expression whose value should be located."
+*>
+macro bool @in(#needle, ...) @builtin @const
+{
+    $for var $x = 0; $x < $vacount; $x++:
+        $assert $defined(#needle == $vaconst[$x])
+            : "Index %s: types '%s' (needle) and '%s' are not equatable", $x, $typeof(#needle), $typeof($vaconst[$x]);
+        $if #needle == $vaconst[$x]: return true; $endif
+    $endfor
+    return false;
 }
 
 <*
  Convert an `any` type to a type, returning an failure if there is a type mismatch.
 
- @param v `the any to convert to the given type.`
- @param $Type `the type to convert to`
+ @param v : `the any to convert to the given type.`
+ @param $Type : `the type to convert to`
  @return `The any.ptr converted to its type.`
- @ensure @typeis(return, $Type*)
- @return! CastResult.TYPE_MISMATCH
+ @ensure $typeof(return) == $Type*
+ @return? TYPE_MISMATCH
 *>
 macro anycast(any v, $Type) @builtin
 {
-	if (v.type != $Type.typeid) return CastResult.TYPE_MISMATCH?;
+	if (v.type != $Type.typeid) return TYPE_MISMATCH~;
 	return ($Type*)v.ptr;
 }
 
-fn bool print_backtrace(String message, int backtraces_to_ignore) @if(env::NATIVE_STACKTRACE)
+<*
+  @return "The value in the pointer"
+  @return? TYPE_MISMATCH
+*>
+macro any.to(self, $Type)
 {
-	@pool()
+	if (self.type != $Type.typeid) return TYPE_MISMATCH~;
+	return *($Type*)self.ptr;
+}
+
+<*
+ @require self.type == $Type : "The 'any' contained an unexpected type."
+ @return "The value in the pointer"
+*>
+macro any.as(self, $Type)
+{
+	return *($Type*)self.ptr;
+}
+
+macro bool @assignable_to(#foo, $Type) @const @builtin @deprecated("use '$defined($Type x = #foo)'") => $defined(*&&($Type){} = #foo);
+
+macro @addr(#val) @builtin
+{
+	$if $defined(&#val):
+		return &#val;
+	$else
+		return &&#val;
+	$endif
+}
+
+macro typeid @typeid(#value) @const @builtin
+{
+	return $typeof(#value).typeid;
+}
+
+macro TypeKind @typekind(#value) @const @builtin @deprecated("Use `$kindof(#value)`.")
+{
+	return $kindof(#value);
+}
+
+macro bool @typeis(#value, $Type) @const @builtin @deprecated("Use `$typeof(#value) == $Type` instead.")
+{
+	return $typeof(#value).typeid == $Type.typeid;
+}
+
+
+fn bool print_backtrace(String message, int backtraces_to_ignore, void *added_backtrace = null) @if (env::NATIVE_STACKTRACE) => @stack_mem(0x1100; Allocator smem)
+{
+	void*[256] buffer;
+	void*[] backtraces = backtrace::capture_current(&buffer);
+	if (added_backtrace)
 	{
-		void*[256] buffer;
-		void*[] backtraces = backtrace::capture_current(&buffer);
-		backtraces_to_ignore++;
-		BacktraceList! backtrace = backtrace::symbolize_backtrace(backtraces, allocator::temp());
+		backtraces[++backtraces_to_ignore] = added_backtrace;
+	}
+	@stack_mem(4096; Allocator mem)
+	{
+		BacktraceList? backtrace = backtrace::symbolize_backtrace(mem, backtraces);
 		if (catch backtrace) return false;
 		if (backtrace.len() <= backtraces_to_ignore) return false;
 		io::eprint("\nERROR: '");
@@ -89,86 +205,93 @@ fn bool print_backtrace(String message, int backtraces_to_ignore) @if(env::NATIV
 			}
 			io::eprintfn("  in %s (source unavailable) [%s]%s", trace.function, trace.object_file, inline_suffix);
 		}
-		return true;
 	};
+	return true;
+
 }
+
 fn void default_panic(String message, String file, String function, uint line) @if(env::NATIVE_STACKTRACE)
 {
-	$if $defined(io::stderr):
-	if (!print_backtrace(message, 2))
-	{
-		io::eprintfn("\nERROR: '%s', in %s (%s:%d)", message, function, file, line);
-		return;
-	}
+	in_panic = true;
+	$if $defined(io::stderr) && env::PANIC_MSG:
+		if (!print_backtrace(message, 2))
+		{
+			io::eprintfn("\nERROR: '%s', in %s (%s:%d)", message, function, file, line);
+		}
 	$endif
 	$$trap();
 
 }
 
-macro void abort(String string = "Unrecoverable error reached", ...) @builtin @noreturn
+macro void abort(String string = "Unrecoverable error reached", ...) @format(0) @builtin @noreturn
 {
 	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
 	$$trap();
 }
 
-bool in_panic @local = false;
+bool in_panic @private = false;
 
-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)
 {
-	if (in_panic)
-	{
-		io::eprintn("Panic inside of panic.");
-		return;
-	}
-	in_panic = true;
-	$if $defined(io::stderr):
-	io::eprint("\nERROR: '");
-	io::eprint(message);
-	io::eprintfn("', in %s (%s:%d)", function, file, line);
+	$if $defined(io::stderr) && env::PANIC_MSG:
+		if (in_panic)
+		{
+			io::eprintn("Panic inside of panic.");
+			return;
+		}
+		in_panic = true;
+		$if $defined(io::stderr):
+		io::eprint("\nERROR: '");
+		io::eprint(message);
+		io::eprintfn("', in %s (%s:%d)", function, file, line);
+		$endif
+		in_panic = false;
 	$endif
-	in_panic = false;
 	$$trap();
 }
 
-def PanicFn = fn void(String message, String file, String function, uint line);
+alias PanicFn = fn void(String message, String file, String function, uint line);
 
 PanicFn panic = &default_panic;
 
 fn void panicf(String fmt, String file, String function, uint line, args...)
 {
-	if (in_panic)
-	{
-		io::eprint("Panic inside of panic: ");
-		io::eprintn(fmt);
-		return;
-	}
-	in_panic = true;
-	@stack_mem(512; Allocator allocator)
-	{
-		DString s;
-		s.new_init(allocator: allocator);
-		s.appendf(fmt, ...args);
-		in_panic = false;
-		panic(s.str_view(), file, function, line);
-	};
+	$if $defined(io::stderr) && env::PANIC_MSG:
+		if (in_panic)
+		{
+			io::eprint("Panic inside of panic: ");
+			io::eprintn(fmt);
+			return;
+		}
+		in_panic = true;
+		@stack_mem(512; Allocator allocator)
+		{
+			DString s;
+			s.init(allocator);
+			s.appendf(fmt, ...args);
+			in_panic = false;
+			panic(s.str_view(), file, function, line);
+		};
+	$endif
 }
 
 <*
  Marks the path as unreachable. This will panic in safe mode, and in fast will simply be assumed
  never happens.
- @param [in] string "The panic message or format string"
+ @param [in] string : "The panic message or format string"
 *>
 macro void unreachable(String string = "Unreachable statement reached.", ...) @builtin @noreturn
 {
 	$if env::COMPILER_SAFE_MODE:
 	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
-	$endif;
+	$else
 	$$unreachable();
+	$endif
 }
 
 <*
  Marks the path as unsupported, this is similar to unreachable.
- @param [in] string "The error message"
+ @param [in] string : "The error message"
 *>
 macro void unsupported(String string = "Unsupported function invoked") @builtin @noreturn
 {
@@ -200,11 +323,11 @@ macro any.as_inner(&self)
 }
 
 <*
- @param expr "the expression to cast"
- @param $Type "the type to cast to"
+ @param expr : "the expression to cast"
+ @param $Type : "the type to cast to"
 
- @require $sizeof(expr) == $Type.sizeof  "Cannot bitcast between types of different size."
- @ensure @typeis(return, $Type)
+ @require $sizeof(expr) == $Type.sizeof  : "Cannot bitcast between types of different size."
+ @ensure $typeof(return) == $Type*
 *>
 macro bitcast(expr, $Type) @builtin
 {
@@ -218,32 +341,49 @@ macro bitcast(expr, $Type) @builtin
 }
 
 <*
- @param $Type `The type of the enum`
- @param [in] enum_name `The name of the enum to search for`
- @require $Type.kindof == ENUM `Only enums may be used`
- @ensure @typeis(return, $Type)
- @return! SearchResult.MISSING
+ @param $Type : `The type of the enum`
+ @param [in] enum_name : `The name of the enum to search for`
+ @require $Type.kindof == ENUM : `Only enums may be used`
+ @ensure $typeof(return) == $Type*
+ @return? NOT_FOUND
 *>
 macro enum_by_name($Type, String enum_name) @builtin
 {
 	typeid x = $Type.typeid;
 	foreach (i, name : x.names)
 	{
-		if (name == enum_name) return ($Type)i;
+		if (name == enum_name) return $Type.from_ordinal(i);
 	}
-	return SearchResult.MISSING?;
+	return NOT_FOUND~;
+}
+
+<*
+ @param $Type : `The type of the enum`
+ @require $Type.kindof == ENUM : `Only enums may be used`
+ @require $defined($Type.#value) : `Expected '#value' to match an enum associated value`
+ @require $defined($typeof(($Type){}.#value) v = value) : `Expected the value to match the type of the associated value`
+ @ensure $typeof(return) == $Type*
+ @return? NOT_FOUND
+*>
+macro @enum_from_value($Type, #value, value) @builtin @deprecated("Use Enum.lookup_field and Enum.lookup")
+{
+	foreach (e : $Type.values)
+	{
+		if (e.#value == value) return e;
+	}
+	return NOT_FOUND~;
 }
 
 <*
  Mark an expression as likely to be true
 
- @param #value "expression to be marked likely"
- @param $probability "in the range 0 - 1"
+ @param #value : "expression to be marked likely"
+ @param $probability : "in the range 0 - 1"
  @require $probability >= 0 && $probability <= 1.0
 *>
 macro bool @likely(bool #value, $probability = 1.0) @builtin
 {
-	$switch
+	$switch:
 	$case env::BUILTIN_EXPECT_IS_DISABLED:
 	return #value;
 	$case $probability == 1.0:
@@ -256,13 +396,13 @@ macro bool @likely(bool #value, $probability = 1.0) @builtin
 <*
  Mark an expression as unlikely to be true
 
- @param #value "expression to be marked unlikely"
- @param $probability "in the range 0 - 1"
+ @param #value : "expression to be marked unlikely"
+ @param $probability : "in the range 0 - 1"
  @require $probability >= 0 && $probability <= 1.0
 *>
 macro bool @unlikely(bool #value, $probability = 1.0) @builtin
 {
-	$switch
+	$switch:
 	$case env::BUILTIN_EXPECT_IS_DISABLED:
 	return #value;
 	$case $probability == 1.0:
@@ -274,12 +414,12 @@ macro bool @unlikely(bool #value, $probability = 1.0) @builtin
 
 <*
  @require values::@is_int(#value) || values::@is_bool(#value)
- @require $assignable(expected, $typeof(#value))
+ @require $defined($typeof(#value) v = expected)
  @require $probability >= 0 && $probability <= 1.0
 *>
 macro @expect(#value, expected, $probability = 1.0) @builtin
 {
-	$switch
+	$switch:
 	$case env::BUILTIN_EXPECT_IS_DISABLED:
 	return #value == expected;
 	$case $probability == 1.0:
@@ -304,9 +444,9 @@ enum PrefetchLocality
 <*
  Prefetch a pointer.
 
- @param [in] ptr `Pointer to prefetch`
- @param $locality `Locality ranging from none to extremely local`
- @param $write `Prefetch for write, otherwise prefetch for read.`
+ @param [in] ptr : `Pointer to prefetch`
+ @param $locality : `Locality ranging from none to extremely local`
+ @param $write : `Prefetch for write, otherwise prefetch for read.`
 *>
 macro @prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write = false) @builtin
 {
@@ -315,32 +455,74 @@ macro @prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write =
 	$endif
 }
 
+<*
+ Shuffle a vector by its index
+
+ int[<4>] a = { 1, 2, 3, 4 };
+ assert(swizzle(a, 0, 1, 1, 3) == (int[<4>]) { 1, 2, 2, 4 });
+*>
 macro swizzle(v, ...) @builtin
 {
 	return $$swizzle(v, $vasplat);
 }
 
+
+<*
+ Shuffle two vectors by a common index from arranging the vectors sequentially in memory
+
+ int[<4>] a = { 1, 2, 3, 4 };
+ int[<4>] b = { 100, 1000, 10000, 100000 };
+ assert(swizzle2(a, b, 0, 1, 4, 6, 2) == (int[<5>]) { 1, 2, 100, 10000, 3 });
+*>
 macro swizzle2(v, v2, ...) @builtin
 {
 	return $$swizzle2(v, v2, $vasplat);
 }
+
+
+<*
+ Returns the count of leading zero bits from an integer at compile-time.
+
+ @require types::is_int($typeof($value)) : "Input value must be an integer"
+ @require $sizeof($value) * 8 <= 128 : "Input value must be 128 bits wide or lower"
+*>
+macro uint @clz($value) @builtin @const
+{
+	$if $value == 0:
+		return $sizeof($value) * 8;   // it's all leading zeroes
+	$endif
+
+	usz $n = 0;
+	uint128 $x = (uint128)$value;
+
+	$if $x <= 0x0000_0000_0000_0000_FFFF_FFFF_FFFF_FFFF: $n += 64; $x <<= 64; $endif
+	$if $x <= 0x0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 32; $x <<= 32; $endif
+	$if $x <= 0x0000_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 16; $x <<= 16; $endif
+	$if $x <= 0x00FF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 8;  $x <<= 8;  $endif
+	$if $x <= 0x0FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 4;  $x <<= 4;  $endif
+	$if $x <= 0x3FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 2;  $x <<= 2;  $endif
+	$if $x <= 0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF: $n += 1;             $endif
+
+	return $n % ($sizeof($value) * 8);   // mod by the bitsize of the input value to go back from uint128 -> it's-type
+}
+
 <*
  Return the excuse in the Optional if it is Empty, otherwise
  return a null fault.
 
- @require @typekind(#expr) == OPTIONAL : `@catch expects an Optional value`
+ @require $kindof(#expr) == OPTIONAL : `@catch expects an Optional value`
 *>
-macro anyfault @catch(#expr) @builtin
+macro fault @catch(#expr) @builtin
 {
 	if (catch f = #expr) return f;
-	return anyfault {};
+	return {};
 }
 
 <*
  Check if an Optional expression holds a value or is empty, returning true
  if it has a value.
 
- @require @typekind(#expr) == OPTIONAL : `@ok expects an Optional value`
+ @require $kindof(#expr) == OPTIONAL : `@ok expects an Optional value`
 *>
 macro bool @ok(#expr) @builtin
 {
@@ -348,36 +530,188 @@ macro bool @ok(#expr) @builtin
 	return true;
 }
 
-macro char[] @as_char_view(&value) @builtin
+<*
+ Check if an Optional expression evaluates to a fault. If so, return it;
+ else, assign the result to an expression.
+
+ @require $defined(#v = #v) : "#v must be a variable"
+ @require $defined(#expr!) : "Expected an optional expression"
+ @require $defined(#v = #expr!!)  : `Type of #expr must be an optional of #v's type`
+*>
+macro void? @try(#v, #expr) @builtin @maydiscard
 {
-	return ((char*)value)[:$sizeof(*value)];
+	var res = #expr;
+	if (catch err = res) return err~;
+	#v = res;
+}
+
+<*
+ Check if an Optional expression evaluates to a fault. If so, return true if it is the
+ expected fault, the optional if it is unexpected, or false if there was no fault and
+ the assign happened.
+
+ This can be used in like this:
+
+  while (true)
+  {
+	char[] data;
+	// Read until end of file
+	if (@try_catch(data, load_line(), io::EOF)!) break;
+	.. use data ..
+  }
+
+ In this example we read until we reach an EOF, which is expected. However, if we encounter some other
+ fault, we rethrow is. Without this macro, the code is instead written like:
+
+  while (true)
+  {
+	char[]? data;
+	data = load_line();
+	if (catch err = data)
+	{
+	  if (err = io::EOF) break;
+	  return err?
+	}
+	.. use data ..
+  }
+
+ @require $defined(#v = #v) : "#v must be a variable"
+ @require $defined(#expr!) : "Expected an optional expression"
+ @require $defined(#v = #expr!!)  : `Type of #expr must be an optional of #v's type`
+ @return "True if it was the expected fault, false if the variable was assigned, otherwise returns an optional."
+*>
+macro bool? @try_catch(#v, #expr, fault expected_fault) @builtin
+{
+	var res = #expr;
+	if (catch err = res)
+	{
+		return err == expected_fault ? true : err~;
+	}
+	#v = res;
+	return false;
+}
+
+<*
+ @require $defined(&#value, (char*)&#value) : "This must be a value that can be viewed as a char array"
+ *>
+macro char[] @as_char_view(#value) @builtin
+{
+	return ((char*)&#value)[:$sizeof(#value)];
 }
 
 macro isz @str_find(String $string, String $needle) @builtin => $$str_find($string, $needle);
 macro String @str_upper(String $str) @builtin => $$str_upper($str);
 macro String @str_lower(String $str) @builtin => $$str_lower($str);
 macro uint @str_hash(String $str) @builtin => $$str_hash($str);
+macro String @str_pascalcase(String $str) @builtin => $$str_pascalcase($str);
+macro String @str_snakecase(String $str) @builtin => $$str_snakecase($str);
+macro String @str_camelcase(String $str) @builtin => @str_capitalize($$str_pascalcase($str));
+macro String @str_constantcase(String $str) @builtin => @str_upper($$str_snakecase($str));
+macro String @str_replace(String $str, String $pattern, String $replace, uint $limit = 0) @builtin => $$str_replace($str, $pattern, $replace, $limit);
+macro String @str_capitalize(String $str) @builtin
+{
+	$switch $str.len:
+		$case 0: return $str;
+		$case 1: return $$str_upper($str);
+		$default: return $$str_upper($str[0:1]) +++ $str[1..];
+	$endswitch
+}
+macro String @str_uncapitalize(String $str) @builtin
+{
+	$switch $str.len:
+		$case 0: return $str;
+		$case 1: return $$str_lower($str);
+		$default: return $$str_lower($str[0:1]) +++ $str[1..];
+	$endswitch
+}
 
-macro uint int.hash(int i) => i;
-macro uint uint.hash(uint i) => i;
-macro uint short.hash(short s) => s;
-macro uint ushort.hash(ushort s) => s;
-macro uint char.hash(char c) => c;
-macro uint ichar.hash(ichar c) => c;
-macro uint long.hash(long i) => (uint)((i >> 32) ^ i);
-macro uint ulong.hash(ulong i) => (uint)((i >> 32) ^ i);
-macro uint int128.hash(int128 i) => (uint)((i >> 96) ^ (i >> 64) ^ (i >> 32) ^ i);
-macro uint uint128.hash(uint128 i) => (uint)((i >> 96) ^ (i >> 64) ^ (i >> 32) ^ i);
-macro uint bool.hash(bool b) => (uint)b;
-macro uint typeid.hash(typeid t) => ((ulong)(uptr)t).hash();
-macro uint String.hash(String c) => (uint)fnv32a::encode(c);
-macro uint char[].hash(char[] c) => (uint)fnv32a::encode(c);
-macro uint void*.hash(void* ptr) => ((ulong)(uptr)ptr).hash();
+macro @generic_hash_core(h, value)
+{
+	h ^= (uint)value; // insert lowest 32 bits
+	h *= 0x96f59e5b; // diffuse them up
+	h ^= h >> 16; // diffuse them down
+	return h;
+}
 
-distinct EmptySlot = void*;
-const EmptySlot EMPTY_MACRO_SLOT @builtin = null;
-macro @is_empty_macro_slot(#arg) @builtin => @typeis(#arg, EmptySlot);
-macro @is_valid_macro_slot(#arg) @builtin => !@typeis(#arg, EmptySlot);
+macro uint @generic_hash(value)
+{
+	uint h = @generic_hash_core((uint)0x3efd4391, value);
+	$for var $cnt = 4; $cnt < $sizeof(value); $cnt += 4:
+		value >>= 32; // reduce value
+		h = @generic_hash_core(h, value);
+	$endfor
+	return h;
+}
+
+
+macro uint int128.hash(self)       => @generic_hash(self);
+macro uint uint128.hash(self)      => @generic_hash(self);
+macro uint long.hash(self)         => @generic_hash(self);
+macro uint ulong.hash(self)        => @generic_hash(self);
+macro uint int.hash(self)          => @generic_hash(self);
+macro uint uint.hash(self)         => @generic_hash(self);
+macro uint short.hash(self)        => @generic_hash(self);
+macro uint ushort.hash(self)       => @generic_hash(self);
+macro uint ichar.hash(self)        => @generic_hash(self);
+macro uint char.hash(self)         => @generic_hash(self);
+macro uint bool.hash(self)         => @generic_hash(self);
+
+macro uint int128[*].hash(&self)   => hash_array(self);
+macro uint uint128[*].hash(&self)  => hash_array(self);
+macro uint long[*].hash(&self)     => hash_array(self);
+macro uint ulong[*].hash(&self)    => hash_array(self);
+macro uint int[*].hash(&self)      => hash_array(self);
+macro uint uint[*].hash(&self)     => hash_array(self);
+macro uint short[*].hash(&self)    => hash_array(self);
+macro uint ushort[*].hash(&self)   => hash_array(self);
+macro uint char[*].hash(&self)     => hash_array(self);
+macro uint ichar[*].hash(&self)    => hash_array(self);
+macro uint bool[*].hash(&self)     => hash_array(self);
+
+macro uint int128[<*>].hash(self)  => hash_vec(self);
+macro uint uint128[<*>].hash(self) => hash_vec(self);
+macro uint long[<*>].hash(self)    => hash_vec(self);
+macro uint ulong[<*>].hash(self)   => hash_vec(self);
+macro uint int[<*>].hash(self)     => hash_vec(self);
+macro uint uint[<*>].hash(self)    => hash_vec(self);
+macro uint short[<*>].hash(self)   => hash_vec(self);
+macro uint ushort[<*>].hash(self)  => hash_vec(self);
+macro uint char[<*>].hash(self)    => hash_vec(self);
+macro uint ichar[<*>].hash(self)   => hash_vec(self);
+macro uint bool[<*>].hash(self)    => hash_vec(self);
+
+macro uint typeid.hash(typeid t) => @generic_hash(((ulong)(uptr)t));
+macro uint String.hash(String c) => (uint)a5hash::hash(c);
+macro uint char[].hash(char[] c) => (uint)a5hash::hash(c);
+macro uint void*.hash(void* ptr) => @generic_hash(((ulong)(uptr)ptr));
+
+<*
+ @require $kindof(array_ptr) == POINTER &&& $kindof(*array_ptr) == ARRAY
+*>
+macro uint hash_array(array_ptr) @local
+{
+	var $len = $sizeof(*array_ptr);
+
+	$if $len > 16:
+		return (uint)komi::hash(((char*)array_ptr)[:$len]);
+	$else
+		return (uint)wyhash2::hash(((char*)array_ptr)[:$len]);
+	$endif
+}
+
+<*
+ @require $kindof(vec) == VECTOR
+*>
+macro uint hash_vec(vec) @local
+{
+	var $len = $sizeof(vec);
+
+	$if $len > 16:
+		return (uint)komi::hash(((char*)&&vec)[:$len]);
+	$else
+		return (uint)wyhash2::hash(((char*)&&vec)[:$len]);
+	$endif
+}
 
 const MAX_FRAMEADDRESS = 128;
 <*
@@ -662,58 +996,74 @@ macro void* get_returnaddress(int n)
 	}
 }
 
-module std::core::builtin @if((env::LINUX || env::DARWIN) && env::COMPILER_SAFE_MODE && env::DEBUG_SYMBOLS);
-import libc, std::io;
+module std::core::builtin @if((env::LINUX || env::ANDROID || env::DARWIN) && env::COMPILER_SAFE_MODE && env::DEBUG_SYMBOLS);
+import libc, std::io, std::os::posix;
 
 fn void sig_panic(String message)
 {
 	default_panic(message, "???", "???", 0);
 }
 
-SignalFunction old_bus_error;
-SignalFunction old_segmentation_fault;
-
-fn void sig_bus_error(CInt i)
+fn void sig_bus_error(CInt i, void* info, void* context)
 {
 	$if !env::NATIVE_STACKTRACE:
 		sig_panic("Illegal memory access.");
 	$else
 		$if $defined(io::stderr):
-			if (!print_backtrace("Illegal memory access.", 1))
+			if (!print_backtrace("Illegal memory access.", 2, posix::stack_instruction(context)))
 			{
 				io::eprintn("\nERROR: 'Illegal memory access'.");
 			}
 		$endif
 	$endif
-	$$trap();
+	os::fastexit(128 + i);
 }
 
-fn void sig_segmentation_fault(CInt i)
+fn void sig_segmentation_fault(CInt i, void* p1, void* context)
 {
 	$if !env::NATIVE_STACKTRACE:
 		sig_panic("Out of bounds memory access.");
 	$else
 		$if $defined(io::stderr):
-			if (!print_backtrace("Out of bounds memory access.", 1))
+			if (!print_backtrace("Out of bounds memory access.", 2, posix::stack_instruction(context)))
 			{
 				io::eprintn("\nERROR: Memory error without backtrace, possible stack overflow.");
 			}
 		$endif
 	$endif
-	$$trap();
+	os::fastexit(128 + i);
 }
 
-fn void install_signal_handler(CInt signal, SignalFunction func) @local
+fn void sig_illegal_instruction(CInt i, void* p1, void* context)
 {
-	SignalFunction old = libc::signal(signal, func);
-	// Restore
-	if ((iptr)old > 1024) libc::signal(signal, old);
+	if (in_panic) os::fastexit(128 + i);
+	$if !env::NATIVE_STACKTRACE:
+		sig_panic("Illegal instruction.");
+	$else
+		$if $defined(io::stderr):
+			if (!print_backtrace("Illegal instruction.", 2, posix::stack_instruction(context)))
+			{
+				io::eprintn("\nERROR: Illegal instruction.");
+			}
+		$endif
+	$endif
+	os::fastexit(128 + i);
 }
 
+char[64 * 1024] sig_stack @local @if(env::BACKTRACE && env::LINUX);
+
 // Clean this up
 fn void install_signal_handlers() @init(101) @local @if(env::BACKTRACE)
 {
-	install_signal_handler(libc::SIGBUS, &sig_bus_error);
-	install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);
-}
+	$if env::LINUX:
+		Stack_t ss = {
+			.ss_sp = &sig_stack,
+			.ss_size = sig_stack.len
+		};
+		libc::sigaltstack(&ss, null);
+	$endif
 
+	posix::install_signal_handler(libc::SIGBUS, &sig_bus_error);
+	posix::install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);
+	posix::install_signal_handler(libc::SIGILL,  &sig_illegal_instruction);
+}

lib/std/core/builtin_comparison.c3

@@ -6,9 +6,9 @@ module std::core::builtin;
 <*
  @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro less(a, b) @builtin
+macro bool less(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return a.less(b);
 	$case $defined(a.compare_to):
@@ -21,9 +21,9 @@ macro less(a, b) @builtin
 <*
  @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro less_eq(a, b) @builtin
+macro bool less_eq(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return !b.less(a);
 	$case $defined(a.compare_to):
@@ -36,9 +36,9 @@ macro less_eq(a, b) @builtin
 <*
  @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro greater(a, b) @builtin
+macro bool greater(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return b.less(a);
 	$case $defined(a.compare_to):
@@ -53,7 +53,7 @@ macro greater(a, b) @builtin
 *>
 macro int compare_to(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.compare_to):
 		return a.compare_to(b);
 	$case $defined(a.less):
@@ -65,9 +65,9 @@ macro int compare_to(a, b) @builtin
 <*
  @require types::@comparable_value(a) && types::@comparable_value(b)
 *>
-macro greater_eq(a, b) @builtin
+macro bool greater_eq(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.less):
 		return !a.less(b);
 	$case $defined(a.compare_to):
@@ -78,11 +78,11 @@ macro greater_eq(a, b) @builtin
 }
 
 <*
- @require types::@equatable_value(a) && types::@equatable_value(b) `values must be equatable`
+ @require types::@equatable_value(a) && types::@equatable_value(b) : `values must be equatable`
 *>
 macro bool equals(a, b) @builtin
 {
-	$switch
+	$switch:
 	$case $defined(a.equals, a.equals(b)):
 		return a.equals(b);
 	$case $defined(a.compare_to, a.compare_to(b)):
@@ -100,7 +100,7 @@ macro min(x, ...) @builtin
 		return less(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
-		$for (var $i = 0; $i < $vacount; $i++)
+		$for var $i = 0; $i < $vacount; $i++:
 			if (less($vaarg[$i], result))
 			{
 				 result = $vaarg[$i];
@@ -116,7 +116,7 @@ macro max(x, ...) @builtin
 		return greater(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
-		$for (var $i = 0; $i < $vacount; $i++)
+		$for var $i = 0; $i < $vacount; $i++:
 			if (greater($vaarg[$i], result))
 			{
 				 result = $vaarg[$i];
@@ -126,3 +126,36 @@ macro max(x, ...) @builtin
 	$endif
 }
 
+
+<*
+ @require types::is_numerical($typeof($a))
+*>
+macro @max($a, ...) @builtin @const
+{
+	$if $vacount == 1:
+		return $a > $vaconst[0] ? $a : $vaconst[0];
+	$else
+		var $result = $a;
+		$for var $x = 0; $x < $vacount; ++$x:
+			$if $vaconst[$x] > $result: $result = $vaconst[$x]; $endif
+		$endfor
+		return $result;
+	$endif
+}
+
+<*
+ @require types::is_numerical($typeof($a))
+*>
+macro @min($a, ...) @builtin @const
+{
+	$if $vacount == 1:
+		return $a < $vaconst[0] ? $a : $vaconst[0];
+	$else
+		var $result = $a;
+		$for var $x = 0; $x < $vacount; ++$x:
+			$if $vaconst[$x] < $result: $result = $vaconst[$x]; $endif
+		$endfor
+		return $result;
+	$endif
+}
+

lib/std/core/cinterop.c3

@@ -2,6 +2,8 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::core::cinterop;
+import std::core::env;
+
 
 const C_INT_SIZE = $$C_INT_SIZE;
 const C_LONG_SIZE = $$C_LONG_SIZE;
@@ -16,20 +18,20 @@ $assert C_SHORT_SIZE <= C_INT_SIZE;
 $assert C_INT_SIZE <= C_LONG_SIZE;
 $assert C_LONG_SIZE <= C_LONG_LONG_SIZE;
 
-def CShort = $typefrom(signed_int_from_bitsize($$C_SHORT_SIZE));
-def CUShort = $typefrom(unsigned_int_from_bitsize($$C_SHORT_SIZE));
-def CInt = $typefrom(signed_int_from_bitsize($$C_INT_SIZE));
-def CUInt = $typefrom(unsigned_int_from_bitsize($$C_INT_SIZE));
-def CLong = $typefrom(signed_int_from_bitsize($$C_LONG_SIZE));
-def CULong = $typefrom(unsigned_int_from_bitsize($$C_LONG_SIZE));
-def CLongLong = $typefrom(signed_int_from_bitsize($$C_LONG_LONG_SIZE));
-def CULongLong = $typefrom(unsigned_int_from_bitsize($$C_LONG_LONG_SIZE));
-def CSChar = ichar;
-def CUChar = char;
+alias CShort = $typefrom(signed_int_from_bitsize($$C_SHORT_SIZE));
+alias CUShort = $typefrom(unsigned_int_from_bitsize($$C_SHORT_SIZE));
+alias CInt = $typefrom(signed_int_from_bitsize($$C_INT_SIZE));
+alias CUInt = $typefrom(unsigned_int_from_bitsize($$C_INT_SIZE));
+alias CLong = $typefrom(signed_int_from_bitsize($$C_LONG_SIZE));
+alias CULong = $typefrom(unsigned_int_from_bitsize($$C_LONG_SIZE));
+alias CLongLong = $typefrom(signed_int_from_bitsize($$C_LONG_LONG_SIZE));
+alias CULongLong = $typefrom(unsigned_int_from_bitsize($$C_LONG_LONG_SIZE));
+alias CSChar = ichar;
+alias CUChar = char;
 
-def CChar = $typefrom($$C_CHAR_IS_SIGNED ? ichar.typeid : char.typeid);
+alias CChar = $typefrom($$C_CHAR_IS_SIGNED ? ichar.typeid : char.typeid);
 
-enum CBool : CInt
+enum CBool : char
 {
 	FALSE,
 	TRUE
@@ -38,7 +40,7 @@ enum CBool : CInt
 // Helper macros
 macro typeid signed_int_from_bitsize(usz $bitsize) @private
 {
-	$switch ($bitsize)
+	$switch $bitsize:
 		$case 128: return int128.typeid;
 		$case 64: return long.typeid;
 		$case 32: return int.typeid;
@@ -50,7 +52,7 @@ macro typeid signed_int_from_bitsize(usz $bitsize) @private
 
 macro typeid unsigned_int_from_bitsize(usz $bitsize) @private
 {
-	$switch ($bitsize)
+	$switch $bitsize:
 		$case 128: return uint128.typeid;
 		$case 64: return ulong.typeid;
 		$case 32: return uint.typeid;
@@ -59,3 +61,57 @@ macro typeid unsigned_int_from_bitsize(usz $bitsize) @private
 		$default: $error("Invalid bitsize");
 	$endswitch
 }
+
+const USE_STACK_VALIST = env::ARCH_32_BIT || env::WIN32 || (env::DARWIN && env::AARCH64);
+module std::core::cinterop @if(USE_STACK_VALIST);
+
+typedef CVaList = void*;
+macro CVaList.next(&self, $Type)
+{
+	void *ptr = mem::aligned_pointer((void*)*self, max($Type.alignof, 8));
+	defer *self = (CVaList)(ptr + 1);
+	return *($Type*)ptr;
+}
+
+module std::core::cinterop @if(env::X86_64 && !env::WIN32);
+
+struct CVaListData
+{
+    uint gp_offset;
+    uint fp_offset;
+    void *overflow_arg_area;
+    void *reg_save_area;
+}
+
+typedef CVaList = CVaListData*;
+
+macro CVaList.next(self, $Type)
+{
+	CVaListData* data = (CVaListData*)self;
+	$switch:
+	    $case $Type.kindof == FLOAT ||| ($Type.kindof == VECTOR && $Type.sizeof <= 16):
+	        var $LoadType = $Type.sizeof < 8 ? double : $Type;
+	        if (data.fp_offset < 6 * 8 + 8 * 16 )
+			{
+				defer data.fp_offset += (uint)mem::aligned_offset($Type.sizeof, 16);
+				return ($Type)*($LoadType*)(data.reg_save_area + data.fp_offset);
+			}
+			void* ptr = mem::aligned_pointer(data.overflow_arg_area, max(8, $Type.alignof));
+			defer data.overflow_arg_area = ptr + $Type.sizeof;
+			return ($Type)*($LoadType*)ptr;
+		$case $Type.kindof == SIGNED_INT || $Type.kindof == UNSIGNED_INT:
+	        var $LoadType = $Type.sizeof < 4 ? int : $Type;
+			if (data.gp_offset < 6 * 8 && $Type.sizeof <= 8)
+			{
+				defer data.gp_offset += (uint)mem::aligned_offset($Type.sizeof, 8);
+				return ($Type)*($LoadType*)(data.reg_save_area + data.gp_offset);
+			}
+			void* ptr = mem::aligned_pointer(data.overflow_arg_area, max(8, $Type.alignof));
+			defer data.overflow_arg_area = ptr + $Type.sizeof;
+			return ($Type)*($LoadType*)ptr;
+		$default:
+			void* ptr = mem::aligned_pointer(data.overflow_arg_area, max(8, $Type.alignof));
+			defer data.overflow_arg_area = ptr + $Type.sizeof;
+			return *($Type*)ptr;
+	$endswitch
+}

lib/std/core/conv.c3

@@ -10,30 +10,31 @@ const uint UTF16_SURROGATE_LOW_VALUE @private = 0xDC00;
 const uint UTF16_SURROGATE_HIGH_VALUE @private = 0xD800;
 
 <*
- @param c `The utf32 codepoint to convert`
- @param [out] output `the resulting buffer`
+ @param c : `The utf32 codepoint to convert`
+ @param [out] output : `the resulting buffer`
+ @return? string::CONVERSION_FAILED
 *>
-fn usz! char32_to_utf8(Char32 c, char[] output)
+fn usz? char32_to_utf8(Char32 c, char[] output)
 {
-	if (!output.len) return UnicodeResult.CONVERSION_FAILED?;
+	if (!output.len) return string::CONVERSION_FAILED~;
 	switch (true)
 	{
 		case c <= 0x7f:
 			output[0] = (char)c;
 			return 1;
 		case c <= 0x7ff:
-			if (output.len < 2) return UnicodeResult.CONVERSION_FAILED?;
+			if (output.len < 2) return string::CONVERSION_FAILED~;
 			output[0] = (char)(0xC0 | c >> 6);
 			output[1] = (char)(0x80 | (c & 0x3F));
 			return 2;
 		case c <= 0xffff:
-			if (output.len < 3) return UnicodeResult.CONVERSION_FAILED?;
+			if (output.len < 3) return string::CONVERSION_FAILED~;
 			output[0] = (char)(0xE0 | c >> 12);
 			output[1] = (char)(0x80 | (c >> 6 & 0x3F));
 			output[2] = (char)(0x80 | (c & 0x3F));
 			return 3;
 		case c <= 0x10ffff:
-			if (output.len < 4) return UnicodeResult.CONVERSION_FAILED?;
+			if (output.len < 4) return string::CONVERSION_FAILED~;
 			output[0] = (char)(0xF0 | c >> 18);
 			output[1] = (char)(0x80 | (c >> 12 & 0x3F));
 			output[2] = (char)(0x80 | (c >> 6 & 0x3F));
@@ -41,15 +42,15 @@ fn usz! char32_to_utf8(Char32 c, char[] output)
 			return 4;
 		default:
 			// 0x10FFFF and above is not defined.
-			return UnicodeResult.CONVERSION_FAILED?;
+			return string::CONVERSION_FAILED~;
 	}
 }
 
 <*
  Convert a code pointer into 1-2 UTF16 characters.
 
- @param c `The character to convert.`
- @param [inout] output `the resulting UTF16 buffer to write to.`
+ @param c : `The character to convert.`
+ @param [inout] output : `the resulting UTF16 buffer to write to.`
 *>
 fn void char32_to_utf16_unsafe(Char32 c, Char16** output)
 {
@@ -69,11 +70,11 @@ fn void char32_to_utf16_unsafe(Char32 c, Char16** output)
 <*
  Convert 1-2 UTF16 data points into UTF8.
 
- @param [in] ptr `The UTF16 data to convert.`
- @param [inout] available `amount of UTF16 data available.`
- @param [inout] output `the resulting utf8 buffer to write to.`
+ @param [in] ptr : `The UTF16 data to convert.`
+ @param [inout] available : `amount of UTF16 data available.`
+ @param [inout] output : `the resulting utf8 buffer to write to.`
 *>
-fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
+fn void? char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 {
 	Char16 high = *ptr;
 	if (high & UTF16_SURROGATE_GENERIC_MASK != UTF16_SURROGATE_GENERIC_VALUE)
@@ -83,15 +84,15 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 		return;
 	}
 	// Low surrogate first is an error
-	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return UnicodeResult.INVALID_UTF16?;
+	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return string::INVALID_UTF16~;
 
 	// Unmatched high surrogate is an error
-	if (*available == 1) return UnicodeResult.INVALID_UTF16?;
+	if (*available == 1) return string::INVALID_UTF16~;
 
 	Char16 low = ptr[1];
 
 	// Unmatched high surrogate, invalid
-	if (low & UTF16_SURROGATE_MASK != UTF16_SURROGATE_LOW_VALUE) return UnicodeResult.INVALID_UTF16?;
+	if (low & UTF16_SURROGATE_MASK != UTF16_SURROGATE_LOW_VALUE) return string::INVALID_UTF16~;
 
 	// The high bits of the codepoint are the value bits of the high surrogate
 	// The low bits of the codepoint are the value bits of the low surrogate
@@ -101,8 +102,8 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 	*available = 2;
 }
 <*
- @param c `The utf32 codepoint to convert`
- @param [inout] output `the resulting buffer`
+ @param c : `The utf32 codepoint to convert`
+ @param [inout] output : `the resulting buffer`
 *>
 fn usz char32_to_utf8_unsafe(Char32 c, char** output)
 {
@@ -130,14 +131,14 @@ fn usz char32_to_utf8_unsafe(Char32 c, char** output)
 }
 
 <*
- @param [in] ptr `pointer to the first character to parse`
- @param [inout] size `Set to max characters to read, set to characters read`
+ @param [in] ptr : `pointer to the first character to parse`
+ @param [inout] size : `Set to max characters to read, set to characters read`
  @return `the parsed 32 bit codepoint`
 *>
-fn Char32! utf8_to_char32(char* ptr, usz* size)
+fn Char32? utf8_to_char32(char* ptr, usz* size)
 {
 	usz max_size = *size;
-	if (max_size < 1) return UnicodeResult.INVALID_UTF8?;
+	if (max_size < 1) return string::INVALID_UTF8~;
 	char c = (ptr++)[0];
 
 	if ((c & 0x80) == 0)
@@ -147,45 +148,45 @@ fn Char32! utf8_to_char32(char* ptr, usz* size)
 	}
 	if ((c & 0xE0) == 0xC0)
 	{
-		if (max_size < 2) return UnicodeResult.INVALID_UTF8?;
+		if (max_size < 2) return string::INVALID_UTF8~;
 		*size = 2;
 		Char32 uc = (c & 0x1F) << 6;
 		c = *ptr;
 		// Overlong sequence or invalid second.
-		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+		if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 		return uc + c & 0x3F;
 	}
 	if ((c & 0xF0) == 0xE0)
 	{
-		if (max_size < 3) return UnicodeResult.INVALID_UTF8?;
+		if (max_size < 3) return string::INVALID_UTF8~;
 		*size = 3;
 		Char32 uc = (c & 0x0F) << 12;
 		c = ptr++[0];
-		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+		if (c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 		uc += (c & 0x3F) << 6;
 		c = ptr++[0];
 		// Overlong sequence or invalid last
-		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+		if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 		return uc + c & 0x3F;
 	}
-	if (max_size < 4) return UnicodeResult.INVALID_UTF8?;
-	if ((c & 0xF8) != 0xF0) return UnicodeResult.INVALID_UTF8?;
+	if (max_size < 4) return string::INVALID_UTF8~;
+	if ((c & 0xF8) != 0xF0) return string::INVALID_UTF8~;
 	*size = 4;
 	Char32 uc = (c & 0x07) << 18;
 	c = ptr++[0];
-	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+	if (c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 	uc += (c & 0x3F) << 12;
 	c = ptr++[0];
-	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+	if (c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 	uc += (c & 0x3F) << 6;
 	c = ptr++[0];
 	// Overlong sequence or invalid last
-	if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+	if (!uc || c & 0xC0 != 0x80) return string::INVALID_UTF8~;
 	return uc + c & 0x3F;
 }
 
 <*
- @param utf8 `An UTF-8 encoded slice of bytes`
+ @param utf8 : `An UTF-8 encoded slice of bytes`
  @return `the number of encoded code points`
 *>
 fn usz utf8_codepoints(String utf8)
@@ -200,7 +201,7 @@ fn usz utf8_codepoints(String utf8)
 
 <*
  Calculate the UTF8 length required to encode an UTF32 array.
- @param [in] utf32 `the utf32 data to calculate from`
+ @param [in] utf32 : `the utf32 data to calculate from`
  @return `the length of the resulting UTF8 array`
 *>
 fn usz utf8len_for_utf32(Char32[] utf32)
@@ -225,7 +226,7 @@ fn usz utf8len_for_utf32(Char32[] utf32)
 
 <*
  Calculate the UTF8 length required to encode an UTF16 array.
- @param [in] utf16 `the utf16 data to calculate from`
+ @param [in] utf16 : `the utf16 data to calculate from`
  @return `the length of the resulting UTF8 array`
 *>
 fn usz utf8len_for_utf16(Char16[] utf16)
@@ -257,7 +258,7 @@ fn usz utf8len_for_utf16(Char16[] utf16)
 
 <*
  Calculate the UTF16 length required to encode a UTF8 array.
- @param utf8 `the utf8 data to calculate from`
+ @param utf8 : `the utf8 data to calculate from`
  @return `the length of the resulting UTF16 array`
 *>
 fn usz utf16len_for_utf8(String utf8)
@@ -280,7 +281,7 @@ fn usz utf16len_for_utf8(String utf8)
 }
 
 <*
- @param [in] utf32 `the UTF32 array to check the length for`
+ @param [in] utf32 : `the UTF32 array to check the length for`
  @return `the required length of an UTF16 array to hold the UTF32 data.`
 *>
 fn usz utf16len_for_utf32(Char32[] utf32)
@@ -300,7 +301,7 @@ fn usz utf16len_for_utf32(Char32[] utf32)
  @param [out] utf8_buffer
  @return `the number of bytes written.`
 *>
-fn usz! utf32to8(Char32[] utf32, char[] utf8_buffer)
+fn usz? utf32to8(Char32[] utf32, char[] utf8_buffer)
 {
 	char[] buffer = utf8_buffer;
 	foreach (uc : utf32)
@@ -320,7 +321,7 @@ fn usz! utf32to8(Char32[] utf32, char[] utf8_buffer)
  @param [out] utf32_buffer
  @return `the number of Char32s written.`
 *>
-fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
+fn usz? utf8to32(String utf8, Char32[] utf32_buffer)
 {
 	usz len = utf8.len;
 	Char32* ptr = utf32_buffer.ptr;
@@ -328,7 +329,7 @@ fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
 	usz buf_len = utf32_buffer.len;
 	for (usz i = 0; i < len;)
 	{
-		if (len32 == buf_len) return UnicodeResult.CONVERSION_FAILED?;
+		if (len32 == buf_len) return string::CONVERSION_FAILED~;
 		usz width = len - i;
 		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
 		i += width;
@@ -344,10 +345,10 @@ fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
  checking. This will assume the buffer is sufficiently large to hold
  the converted data.
 
- @param [in] utf16 `The UTF16 array containing the data to convert.`
- @param [out] utf8_buffer `the (sufficiently large) buffer to hold the UTF16 data.`
+ @param [in] utf16 : `The UTF16 array containing the data to convert.`
+ @param [out] utf8_buffer : `the (sufficiently large) buffer to hold the UTF16 data.`
 *>
-fn void! utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
+fn void? utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
 {
 	usz len16 = utf16.len;
 	for (usz i = 0; i < len16;)
@@ -363,10 +364,10 @@ fn void! utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
  checking. This will assume the buffer is sufficiently large to hold
  the converted data.
 
- @param [in] utf8 `The UTF8 buffer containing the data to convert.`
- @param [out] utf32_buffer `the (sufficiently large) buffer to hold the UTF8 data.`
+ @param [in] utf8 : `The UTF8 buffer containing the data to convert.`
+ @param [out] utf32_buffer : `the (sufficiently large) buffer to hold the UTF8 data.`
 *>
-fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)
+fn void? utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 {
 	usz len = utf8.len;
 	for (usz i = 0; i < len;)
@@ -383,10 +384,10 @@ fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)
  checking. This will assume the buffer is sufficiently large to hold
  the converted data.
 
- @param [in] utf8 `The UTF8 buffer containing the data to convert.`
- @param [out] utf16_buffer `the (sufficiently large) buffer to hold the UTF8 data.`
+ @param [in] utf8 : `The UTF8 buffer containing the data to convert.`
+ @param [out] utf16_buffer : `the (sufficiently large) buffer to hold the UTF8 data.`
 *>
-fn void! utf8to16_unsafe(String utf8, Char16* utf16_buffer)
+fn void? utf8to16_unsafe(String utf8, Char16* utf16_buffer)
 {
 	usz len = utf8.len;
 	for (usz i = 0; i < len;)
@@ -403,8 +404,8 @@ fn void! utf8to16_unsafe(String utf8, Char16* utf16_buffer)
  checking. This will assume the buffer is sufficiently large to hold
  the converted data.
 
- @param [in] utf32 `The UTF32 buffer containing the data to convert.`
- @param [out] utf8_buffer `the (sufficiently large) buffer to hold the UTF8 data.`
+ @param [in] utf32 : `The UTF32 buffer containing the data to convert.`
+ @param [out] utf8_buffer : `the (sufficiently large) buffer to hold the UTF8 data.`
 *>
 fn void utf32to8_unsafe(Char32[] utf32, char* utf8_buffer)
 {

lib/std/core/dstring.c3

@@ -1,14 +1,23 @@
 module std::core::dstring;
-import std::io;
+import std::io, std::math;
 
-distinct DString (OutStream) = void*;
+<*
+ The DString offers a dynamic string builder.
+*>
+typedef DString (OutStream) = DStringOpaque*;
+typedef DStringOpaque = void;
 
 const usz MIN_CAPACITY @private = 16;
 
 <*
- @require !self.data() "String already initialized"
+ Initialize the DString with a particular allocator.
+
+ @param [&inout] allocator : "The allocator to use"
+ @param capacity : "Starting capacity, defaults to MIN_CAPACITY and cannot be smaller"
+ @return "Return the DString itself"
+ @require !self.data() : "String already initialized"
 *>
-fn DString DString.new_init(&self, usz capacity = MIN_CAPACITY, Allocator allocator = allocator::heap())
+fn DString DString.init(&self, Allocator allocator, usz capacity = MIN_CAPACITY)
 {
 	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
 	StringData* data = allocator::alloc_with_padding(allocator, StringData, capacity)!!;
@@ -19,25 +28,29 @@ fn DString DString.new_init(&self, usz capacity = MIN_CAPACITY, Allocator alloca
 }
 
 <*
- @require !self.data() "String already initialized"
+ Initialize the DString with the temp allocator. Note that if the dstring is never
+ initialized, this is the allocator it will default to.
+
+ @param capacity : "Starting capacity, defaults to MIN_CAPACITY and cannot be smaller"
+ @return "Return the DString itself"
+ @require !self.data() : "String already initialized"
 *>
-fn DString DString.temp_init(&self, usz capacity = MIN_CAPACITY)
+fn DString DString.tinit(&self, usz capacity = MIN_CAPACITY)
 {
-	self.new_init(capacity, allocator::temp()) @inline;
-	return *self;
+	return self.init(tmem, capacity) @inline;
 }
 
-fn DString new_with_capacity(usz capacity, Allocator allocator = allocator::heap())
+fn DString new_with_capacity(Allocator allocator, usz capacity)
 {
-	return DString{}.new_init(capacity, allocator);
+	return (DString){}.init(allocator, capacity);
 }
 
-fn DString temp_with_capacity(usz capacity) => new_with_capacity(capacity, allocator::temp()) @inline;
+fn DString temp_with_capacity(usz capacity) => new_with_capacity(tmem, capacity) @inline;
 
-fn DString new(String c = "", Allocator allocator = allocator::heap())
+fn DString new(Allocator allocator, String c = "")
 {
 	usz len = c.len;
-	StringData* data = (StringData*)new_with_capacity(len, allocator);
+	StringData* data = (StringData*)new_with_capacity(allocator, len);
 	if (len)
 	{
 		data.len = len;
@@ -46,7 +59,7 @@ fn DString new(String c = "", Allocator allocator = allocator::heap())
 	return (DString)data;
 }
 
-fn DString temp_new(String s = "") => new(s, allocator::temp()) @inline;
+fn DString temp(String s = "") => new(tmem, s) @inline;
 
 
 fn void DString.replace_char(self, char ch, char replacement)
@@ -69,7 +82,8 @@ fn void DString.replace(&self, String needle, String replacement)
 		self.replace_char(needle[0], replacement[0]);
 		return;
 	}
-	@pool(data.allocator) {
+	@pool()
+	{
 		String str = self.tcopy_str();
 		self.clear();
 		usz len = str.len;
@@ -81,7 +95,7 @@ fn void DString.replace(&self, String needle, String replacement)
 				match++;
 				if (match == needle_len)
 				{
-					self.append_chars(replacement);
+					self.append_string(replacement);
 					match = 0;
 					continue;
 				}
@@ -89,25 +103,25 @@ fn void DString.replace(&self, String needle, String replacement)
 			}
 			if (match > 0)
 			{
-				self.append_chars(str[i - match:match]);
+				self.append_string(str[i - match:match]);
 				match = 0;
 			}
 			self.append_char(c);
 		}
-		if (match > 0) self.append_chars(str[^match:match]);
+		if (match > 0) self.append_string(str[^match:match]);
 	};
 }
 
-fn DString DString.new_concat(self, DString b, Allocator allocator = allocator::heap())
+fn DString DString.concat(self, Allocator allocator, DString b) @nodiscard
 {
 	DString string;
-	string.new_init(self.len() + b.len(), allocator);
+	string.init(allocator, self.len() + b.len());
 	string.append(self);
 	string.append(b);
 	return string;
 }
 
-fn DString DString.temp_concat(self, DString b) => self.new_concat(b, allocator::temp());
+fn DString DString.tconcat(self, DString b) => self.concat(tmem, b);
 
 fn ZString DString.zstr_view(&self)
 {
@@ -132,7 +146,7 @@ fn usz DString.capacity(self)
 	return self.data().capacity;
 }
 
-fn usz DString.len(&self) @dynamic
+fn usz DString.len(&self) @dynamic @operator(len)
 {
 	if (!*self) return 0;
 	return self.data().len;
@@ -154,6 +168,24 @@ fn String DString.str_view(self)
 	return (String)data.chars[:data.len];
 }
 
+<*
+ @require index < self.len()
+ @require self.data() != null : "Empty string"
+*>
+fn char DString.char_at(self, usz index) @operator([])
+{
+	return self.data().chars[index];
+}
+
+<*
+ @require index < self.len()
+ @require self.data() != null  : "Empty string"
+*>
+fn char* DString.char_ref(&self, usz index) @operator(&[])
+{
+	return &self.data().chars[index];
+}
+
 fn usz DString.append_utf32(&self, Char32[] chars)
 {
 	self.reserve(chars.len);
@@ -168,7 +200,7 @@ fn usz DString.append_utf32(&self, Char32[] chars)
 <*
  @require index < self.len()
 *>
-fn void DString.set(self, usz index, char c)
+fn void DString.set(self, usz index, char c) @operator([]=)
 {
 	self.data().chars[index] = c;
 }
@@ -199,23 +231,18 @@ fn usz DString.append_char32(&self, Char32 c)
 	return n;
 }
 
-fn DString DString.tcopy(&self) => self.copy(allocator::temp());
+fn DString DString.tcopy(&self) => self.copy(tmem);
 
-fn DString DString.copy(self, Allocator allocator = null)
+fn DString DString.copy(self, Allocator allocator) @nodiscard
 {
-	if (!self)
-	{
-		if (allocator) return new_with_capacity(0, allocator);
-		return (DString)null;
-	}
+	if (!self) return new(allocator);
 	StringData* data = self.data();
-	if (!allocator) allocator = allocator::heap();
-	DString new_string = new_with_capacity(data.capacity, allocator);
+	DString new_string = new_with_capacity(allocator, data.capacity);
 	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
 	return new_string;
 }
 
-fn ZString DString.copy_zstr(self, Allocator allocator = allocator::heap())
+fn ZString DString.copy_zstr(self, Allocator allocator) @nodiscard
 {
 	usz str_len = self.len();
 	if (!str_len)
@@ -229,12 +256,12 @@ fn ZString DString.copy_zstr(self, Allocator allocator = allocator::heap())
 	return (ZString)zstr;
 }
 
-fn String DString.copy_str(self, Allocator allocator = allocator::heap())
+fn String DString.copy_str(self, Allocator allocator) @nodiscard
 {
 	return (String)self.copy_zstr(allocator)[:self.len()];
 }
 
-fn String DString.tcopy_str(self) => self.copy_str(allocator::temp()) @inline;
+fn String DString.tcopy_str(self) @nodiscard => self.copy_str(tmem) @inline;
 
 fn bool DString.equals(self, DString other_string)
 {
@@ -278,27 +305,49 @@ fn bool DString.less(self, DString other_string)
 	return true;
 }
 
-fn void DString.append_chars(&self, String str)
+fn void DString.append_chars(&self, String str) @deprecated("Use append_string")
 {
-	usz other_len = str.len;
+	self.append_bytes(str);
+}
+
+fn void DString.append_bytes(&self, char[] bytes)
+{
+	usz other_len = bytes.len;
 	if (!other_len) return;
 	if (!*self)
 	{
-		*self = new(str);
+		*self = temp((String)bytes);
 		return;
 	}
 	self.reserve(other_len);
 	StringData* data = self.data();
-	mem::copy(&data.chars[data.len], str.ptr, other_len);
+	mem::copy(&data.chars[data.len], bytes.ptr, other_len);
 	data.len += other_len;
 }
 
-fn Char32[] DString.copy_utf32(&self, Allocator allocator = allocator::heap())
+fn Char32[] DString.copy_utf32(&self, Allocator allocator)
 {
 	return self.str_view().to_utf32(allocator) @inline!!;
 }
 
-fn void DString.append_string(&self, DString str)
+<*
+ @require $defined(String s = str) ||| $typeof(str) == DString : "Expected string or DString"
+*>
+macro void DString.append_string(&self, str)
+{
+	$if $typeof(str) == DString:
+		self.append_string_deprecated(str);
+	$else
+		self.append_bytes((String)str);
+	$endif
+}
+
+macro void DString.append_string_deprecated(&self, DString str) @deprecated("Use .append_dstring()")
+{
+	self.append_dstring(str);
+}
+
+fn void DString.append_dstring(&self, DString str)
 {
 	StringData* other = str.data();
 	if (!other) return;
@@ -311,13 +360,13 @@ fn void DString.clear(self)
 	self.data().len = 0;
 }
 
-fn usz! DString.write(&self, char[] buffer) @dynamic
+fn usz? DString.write(&self, char[] buffer) @dynamic
 {
-	self.append_chars((String)buffer);
+	self.append_bytes(buffer);
 	return buffer.len;
 }
 
-fn void! DString.write_byte(&self, char c) @dynamic
+fn void? DString.write_byte(&self, char c) @dynamic
 {
 	self.append_char(c);
 }
@@ -326,7 +375,7 @@ fn void DString.append_char(&self, char c)
 {
 	if (!*self)
 	{
-		*self = new_with_capacity(MIN_CAPACITY);
+		*self = temp_with_capacity(MIN_CAPACITY);
 	}
 	self.reserve(1);
 	StringData* data = self.data();
@@ -336,7 +385,7 @@ fn void DString.append_char(&self, char c)
 <*
  @require start < self.len()
  @require end < self.len()
- @require end >= start "End must be same or equal to the start"
+ @require end >= start : "End must be same or equal to the start"
 *>
 fn void DString.delete_range(&self, usz start, usz end)
 {
@@ -368,22 +417,22 @@ fn void DString.delete(&self, usz start, usz len = 1)
 macro void DString.append(&self, value)
 {
 	var $Type = $typeof(value);
-	$switch ($Type)
+	$switch $Type:
 		$case char:
 		$case ichar:
 			self.append_char(value);
 		$case DString:
-			self.append_string(value);
+			self.append_dstring(value);
 		$case String:
-			self.append_chars(value);
+			self.append_string(value);
 		$case Char32:
 			self.append_char32(value);
 		$default:
-			$switch
+			$switch:
 				$case $defined((Char32)value):
 					self.append_char32((Char32)value);
 				$case $defined((String)value):
-					self.append_chars((String)value);
+					self.append_string((String)value);
 				$default:
 					$error "Unsupported type for append – use appendf instead.";
 			$endswitch
@@ -500,7 +549,7 @@ fn usz DString.insert_utf32_at(&self, usz index, Char32[] chars)
 macro void DString.insert_at(&self, usz index, value)
 {
 	var $Type = $typeof(value);
-	$switch ($Type)
+	$switch $Type:
 		$case char:
 		$case ichar:
 			self.insert_char_at(index, value);
@@ -511,7 +560,7 @@ macro void DString.insert_at(&self, usz index, value)
 		$case Char32:
 			self.insert_char32_at(index, value);
 		$default:
-			$switch
+			$switch:
 				$case $defined((Char32)value):
 					self.insert_char32_at(index, (Char32)value);
 				$case $defined((String)value):
@@ -522,21 +571,19 @@ macro void DString.insert_at(&self, usz index, value)
 	$endswitch
 }
 
-fn usz! DString.appendf(&self, String format, args...) @maydiscard
+import libc;
+fn usz? DString.appendf(&self, String format, args...) @maydiscard
 {
-	if (!self.data()) self.new_init(format.len + 20);
-	@pool(self.data().allocator)
-	{
-		Formatter formatter;
-		formatter.init(&out_string_append_fn, self);
-		return formatter.vprintf(format, args);
-	};
+	if (!self.data()) self.tinit(format.len + 20);
+	Formatter formatter;
+	formatter.init(&out_string_append_fn, self);
+	return formatter.vprintf(format, args);
 }
 
-fn usz! DString.appendfn(&self, String format, args...) @maydiscard
+fn usz? DString.appendfn(&self, String format, args...) @maydiscard
 {
-	if (!self.data()) self.new_init(format.len + 20);
-	@pool(self.data().allocator)
+	if (!self.data()) self.tinit(format.len + 20);
+	@pool()
 	{
 		Formatter formatter;
 		formatter.init(&out_string_append_fn, self);
@@ -546,25 +593,25 @@ fn usz! DString.appendfn(&self, String format, args...) @maydiscard
 	};
 }
 
-fn DString new_join(String[] s, String joiner, Allocator allocator = allocator::heap())
+fn DString join(Allocator allocator, String[] s, String joiner) @nodiscard
 {
-	if (!s.len) return (DString)null;
+	if (!s.len) return new(allocator);
 	usz total_size = joiner.len * s.len;
 	foreach (String* &str : s)
 	{
 		total_size += str.len;
 	}
-	DString res = new_with_capacity(total_size, allocator);
+	DString res = new_with_capacity(allocator, total_size);
 	res.append(s[0]);
-	foreach (String* &str : s[1..])
+	foreach (String str : s[1..])
 	{
 		res.append(joiner);
-		res.append(*str);
+		res.append(str);
 	}
 	return res;
 }
 
-fn void! out_string_append_fn(void* data, char c) @private
+fn void? out_string_append_fn(void* data, char c) @private
 {
 	DString* s = data;
 	s.append_char(c);
@@ -584,7 +631,7 @@ fn void DString.reverse(self)
 	}
 }
 
-fn StringData* DString.data(self) @inline @private
+fn StringData* DString.data(self) @inline
 {
 	return (StringData*)self;
 }
@@ -594,26 +641,27 @@ fn void DString.reserve(&self, usz addition)
 	StringData* data = self.data();
 	if (!data)
 	{
-		*self = dstring::new_with_capacity(addition);
+		*self = dstring::temp_with_capacity(addition);
 		return;
 	}
 	usz len = data.len + addition;
 	if (data.capacity >= len) return;
 	usz new_capacity = data.capacity * 2;
 	if (new_capacity < MIN_CAPACITY) new_capacity = MIN_CAPACITY;
-	while (new_capacity < len) new_capacity *= 2;
+	if (new_capacity < len) new_capacity = math::next_power_of_2(len);
 	data.capacity = new_capacity;
 	*self = (DString)allocator::realloc(data.allocator, data, StringData.sizeof + new_capacity);
 }
 
-fn usz! DString.read_from_stream(&self, InStream reader)
+fn usz? DString.read_from_stream(&self, InStream reader)
 {
 	if (&reader.available)
 	{
 		usz total_read = 0;
-		while (usz available = reader.available()!)
+		while (ulong available = reader.available()!)
 		{
-			self.reserve(available);
+			if (available > isz.max) available = (ulong)isz.max;
+			self.reserve((usz)available);
 			StringData* data = self.data();
 			usz len = reader.read(data.chars[data.len..(data.capacity - 1)])!;
 			total_read += len;

lib/std/core/env.c3

@@ -57,6 +57,7 @@ enum OsType
 	HURD,
 	WASI,
 	EMSCRIPTEN,
+	ANDROID,
 }
 
 enum ArchType
@@ -117,13 +118,16 @@ enum ArchType
 
 const String COMPILER_BUILD_HASH = $$BUILD_HASH;
 const String COMPILER_BUILD_DATE = $$BUILD_DATE;
-const OsType OS_TYPE = (OsType)$$OS_TYPE;
-const ArchType ARCH_TYPE = (ArchType)$$ARCH_TYPE;
+const OsType OS_TYPE = OsType.from_ordinal($$OS_TYPE);
+const ArchType ARCH_TYPE = ArchType.from_ordinal($$ARCH_TYPE);
+const usz MAX_VECTOR_SIZE = $$MAX_VECTOR_SIZE;
 const bool ARCH_32_BIT = $$REGISTER_SIZE == 32;
 const bool ARCH_64_BIT = $$REGISTER_SIZE == 64;
 const bool LIBC = $$COMPILER_LIBC_AVAILABLE;
-const bool NO_LIBC = !$$COMPILER_LIBC_AVAILABLE;
-const CompilerOptLevel COMPILER_OPT_LEVEL = (CompilerOptLevel)$$COMPILER_OPT_LEVEL;
+const bool NO_LIBC = !LIBC && !CUSTOM_LIBC;
+const bool CUSTOM_LIBC = $$CUSTOM_LIBC;
+const bool OLD_IO = $feature(OLD_IO);
+const CompilerOptLevel COMPILER_OPT_LEVEL = CompilerOptLevel.from_ordinal($$COMPILER_OPT_LEVEL);
 const bool BIG_ENDIAN = $$PLATFORM_BIG_ENDIAN;
 const bool I128_NATIVE_SUPPORT = $$PLATFORM_I128_SUPPORTED;
 const bool F16_SUPPORT = $$PLATFORM_F16_SUPPORTED;
@@ -135,12 +139,13 @@ const bool BACKTRACE = $$BACKTRACE;
 const usz LLVM_VERSION = $$LLVM_VERSION;
 const bool BENCHMARKING = $$BENCHMARKING;
 const bool TESTING = $$TESTING;
-const MemoryEnvironment MEMORY_ENV = (MemoryEnvironment)$$MEMORY_ENVIRONMENT;
+const bool PANIC_MSG = $$PANIC_MSG;
+const MemoryEnvironment MEMORY_ENV = MemoryEnvironment.from_ordinal($$MEMORY_ENVIRONMENT);
 const bool TRACK_MEMORY = DEBUG_SYMBOLS && (COMPILER_SAFE_MODE || TESTING);
 const bool X86_64 = ARCH_TYPE == X86_64;
 const bool X86 = ARCH_TYPE == X86;
 const bool AARCH64 = ARCH_TYPE == AARCH64;
-const bool NATIVE_STACKTRACE = LINUX || DARWIN || WIN32;
+const bool NATIVE_STACKTRACE = LINUX || DARWIN || OPENBSD || WIN32;
 const bool LINUX = LIBC && OS_TYPE == LINUX;
 const bool DARWIN = LIBC && os_is_darwin();
 const bool WIN32 = LIBC && OS_TYPE == WIN32;
@@ -150,15 +155,24 @@ const bool FREEBSD = LIBC && OS_TYPE == FREEBSD;
 const bool NETBSD = LIBC && OS_TYPE == NETBSD;
 const bool BSD_FAMILY = env::FREEBSD || env::OPENBSD || env::NETBSD;
 const bool WASI = LIBC && OS_TYPE == WASI;
-const bool WASM_NOLIBC @builtin = !LIBC && ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+const bool WASM = ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+const bool ANDROID = LIBC && OS_TYPE == ANDROID;
+const bool WASM_NOLIBC @builtin @deprecated("Use 'FREESTANDING_WASM' instead") = !LIBC && ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+const bool FREESTANDING_PE32 = NO_LIBC && OS_TYPE == WIN32;
+const bool FREESTANDING_MACHO = NO_LIBC && OS_TYPE == MACOS;
+const bool FREESTANDING_ELF = NO_LIBC && !env::FREESTANDING_PE32 && !env::FREESTANDING_MACHO && !env::FREESTANDING_WASM;
+const bool FREESTANDING_WASM = NO_LIBC && WASM;
+const bool FREESTANDING = env::FREESTANDING_PE32 || env::FREESTANDING_MACHO || env::FREESTANDING_ELF || env::FREESTANDING_WASM;
 const bool ADDRESS_SANITIZER = $$ADDRESS_SANITIZER;
 const bool MEMORY_SANITIZER = $$MEMORY_SANITIZER;
 const bool THREAD_SANITIZER = $$THREAD_SANITIZER;
 const bool ANY_SANITIZER = ADDRESS_SANITIZER || MEMORY_SANITIZER || THREAD_SANITIZER;
+const int LANGUAGE_DEV_VERSION = $$LANGUAGE_DEV_VERSION;
+const bool HAS_NATIVE_ERRNO = env::LINUX || env::ANDROID || env::OPENBSD || env::DARWIN || env::WIN32 || env::NETBSD;
 
 macro bool os_is_darwin() @const
 {
-	$switch (OS_TYPE)
+	$switch OS_TYPE:
 	$case IOS:
 	$case MACOS:
 	$case TVOS:
@@ -171,7 +185,7 @@ macro bool os_is_darwin() @const
 
 macro bool os_is_posix() @const
 {
-	$switch (OS_TYPE)
+	$switch OS_TYPE:
 	$case IOS:
 	$case MACOS:
 	$case NETBSD:
@@ -182,6 +196,7 @@ macro bool os_is_posix() @const
 	$case SOLARIS:
 	$case TVOS:
 	$case WATCHOS:
+	$case ANDROID:
 		return true;
 	$case WIN32:
 	$case WASI:
@@ -192,6 +207,8 @@ macro bool os_is_posix() @const
 		return false;
 	$endswitch
 }
-
+const String[] AUTHORS = $$AUTHORS;
+const String[] AUTHOR_EMAILS = $$AUTHOR_EMAILS;
+const String PROJECT_VERSION = $$PROJECT_VERSION;
 const BUILTIN_EXPECT_IS_DISABLED = $feature(DISABLE_BUILTIN_EXPECT);
 const BUILTIN_PREFETCH_IS_DISABLED = $feature(DISABLE_BUILTIN_PREFETCH);

lib/std/core/logging.c3

@@ -0,0 +1,240 @@
+module std::core::log;
+import std::io, std::thread, std::time, std::math::random;
+
+const FULL_LOG = env::COMPILER_SAFE_MODE || $feature(FULL_LOG);
+
+typedef LogCategory = inline char;
+typedef LogTag = char[12];
+
+const LogCategory CATEGORY_APPLICATION  = (LogCategory)0;
+const LogCategory CATEGORY_SYSTEM       = (LogCategory)1;
+const LogCategory CATEGORY_KERNEL       = (LogCategory)2;
+const LogCategory CATEGORY_AUDIO        = (LogCategory)3;
+const LogCategory CATEGORY_VIDEO        = (LogCategory)4;
+const LogCategory CATEGORY_RENDER       = (LogCategory)5;
+const LogCategory CATEGORY_INPUT        = (LogCategory)6;
+const LogCategory CATEGORY_NETWORK      = (LogCategory)7;
+const LogCategory CATEGORY_SOCKET       = (LogCategory)8;
+const LogCategory CATEGORY_SECURITY     = (LogCategory)9;
+const LogCategory CATEGORY_TEST         = (LogCategory)10;
+const LogCategory CATEGORY_ERROR        = (LogCategory)11;
+const LogCategory CATEGORY_ASSERT       = (LogCategory)12;
+const LogCategory CATEGORY_CRASH        = (LogCategory)13;
+const LogCategory CATEGORY_STATS        = (LogCategory)14;
+const LogCategory CATEGORY_CUSTOM_START = (LogCategory)100;
+
+tlocal LogCategory default_category = CATEGORY_APPLICATION;
+tlocal LogTag current_tag;
+
+
+enum LogPriority : int
+{
+	VERBOSE,
+	DEBUG,
+	INFO,
+	WARN,
+	ERROR,
+	CRITICAL,
+}
+
+interface Logger
+{
+	fn void log(LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args);
+}
+
+macro void verbose(String fmt, ..., LogCategory category = default_category) => call_log(VERBOSE, category, fmt, $vasplat);
+macro void debug(String fmt, ..., LogCategory category = default_category) => call_log(DEBUG, category, fmt, $vasplat);
+macro void info(String fmt, ..., LogCategory category = default_category) => call_log(INFO, category, fmt, $vasplat);
+macro void warn(String fmt, ..., LogCategory category = default_category) => call_log(WARN, category, fmt, $vasplat);
+macro void error(String fmt, ..., LogCategory category = default_category) => call_log(ERROR, category, fmt, $vasplat);
+macro void critical(String fmt, ..., LogCategory category = default_category) => call_log(CRITICAL, category, fmt, $vasplat);
+
+macro void @category_scope(LogCategory new_category; @body)
+{
+	LogCategory old = default_category;
+	default_category = new_category;
+	defer default_category = old;
+	@body();
+}
+
+<*
+ @require tag_prefix.len <= 3 : "The prefix may not exceed 3 bytes"
+*>
+macro void @tag_scope(String tag_prefix = ""; @body)
+{
+	LogTag old = current_tag;
+	push_tag(tag_prefix);
+	defer current_tag = old;
+	@body();
+}
+
+<*
+ @require tag_prefix.len <= 3 : "The prefix may not exceed 3 bytes"
+*>
+macro void push_tag(String tag_prefix = "")
+{
+	current_tag = create_tag(tag_prefix);
+}
+
+<*
+ @require tag_prefix.len <= 3 : "The prefix may not exceed 3 bytes"
+*>
+fn LogTag create_tag(String tag_prefix)
+{
+	LogTag tag @noinit;
+	int start = 0;
+	foreach (int i, c : tag_prefix)
+	{
+		if (c == 0) break;
+		tag[start++] = c;
+	}
+	if (start > 0) tag[start++] = '_';
+	for (int i = start; i < tag.len; i++)
+	{
+		tag[i] = (char)rand_in_range('a', 'z');
+	}
+	return tag;
+}
+
+fn void set_priority_for_category(LogCategory category, LogPriority new_priority)
+{
+	@atomic_store(config_priorities[category], new_priority, UNORDERED);
+}
+
+fn LogPriority get_priority_for_category(LogCategory category)
+{
+	return @atomic_load(config_priorities[category], UNORDERED);
+}
+
+fn void set_priority_all(LogPriority new_priority)
+{
+	for (int i = 0; i < config_priorities.len; i++)
+	{
+		@atomic_store(config_priorities[i], new_priority, UNORDERED);
+	}
+}
+fn void set_logger(Logger logger)
+{
+	init();
+	if (!logger_mutex.is_initialized())
+	{
+		current_logger = logger;
+		current_logfn = &logger.log;
+		return;
+	}
+	logger_mutex.@in_lock()
+	{
+		current_logger = logger;
+		current_logfn = &logger.log;
+	};
+}
+
+macro void init()
+{
+	log_init.call(fn () => (void)logger_mutex.init());
+}
+
+macro void call_log(LogPriority prio, LogCategory category, String fmt, args...)
+{
+	$if FULL_LOG:
+	call_log_internal(prio, category, $$FILE, $$FUNC, $$LINE, fmt, args);
+	$else
+	call_log_internal(prio, category, "", "", 0, fmt, args);
+	$endif
+}
+
+fn void call_log_internal(LogPriority prio, LogCategory category, String file, String func, int line, String fmt, any[] args)
+{
+	LogPriority priority = mem::@atomic_load(config_priorities[category], UNORDERED);
+	if (priority > prio) return;
+	init();
+	bool locked = logger_mutex.is_initialized();
+	if (locked) logger_mutex.lock();
+	Logger logger = current_logger;
+	LogFn logfn = current_logfn;
+	defer if (locked) logger_mutex.unlock();
+	logfn(logger.ptr, prio, category, current_tag, file, func, line, fmt, args);
+}
+
+fn String? get_category_name(LogCategory category)
+{
+	String val = category_names[category];
+	return val ?: NOT_FOUND~;
+}
+
+fn void set_category_name(LogCategory category, String name)
+{
+	category_names[category] = name;
+}
+
+struct NullLogger (Logger)
+{
+	void* dummy;
+}
+
+fn void NullLogger.log(&self, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args) @dynamic
+{}
+
+struct MultiLogger (Logger)
+{
+	Logger[] loggers;
+}
+
+fn void MultiLogger.log(&self, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args) @dynamic
+{
+	foreach (logger : self.loggers)
+	{
+		logger.log(priority, category, tag, file, function, line, fmt, args);
+	}
+}
+
+
+module std::core::log @private;
+import std::io, std::thread, std::time;
+
+struct StderrLogger (Logger) @if(env::LIBC)
+{
+	void* dummy;
+}
+
+fn void StderrLogger.log(&self, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args) @dynamic @if(env::LIBC)
+{
+	@stack_mem(256 + 64; Allocator mem)
+	{
+		DString str;
+		str.init(mem, 256);
+		str.appendf(fmt, ...args);
+		TzDateTime time = datetime::now().to_local();
+		$if FULL_LOG:
+		io::eprintfn("[%02d:%02d:%02d:%04d] %s:%d [%s] %s", time.hour, time.min, time.sec, (time.usec / 1000), file, line, priority, str);
+		$else
+		io::eprintfn("[%02d:%02d:%02d:%04d] [%s] %s", time.hour, time.min, time.sec, (time.usec / 1000), priority, str);
+		$endif
+	};
+}
+
+alias LogFn = fn void(void*, LogPriority priority, LogCategory category, LogTag tag, String file, String function, int line, String fmt, any[] args);
+LogFn current_logfn = env::LIBC ??? (LogFn)&StderrLogger.log : (LogFn)&NullLogger.log;
+OnceFlag log_init;
+Mutex logger_mutex;
+Logger current_logger = env::LIBC ??? &stderr_logger : &null_logger;
+StderrLogger stderr_logger @if (env::LIBC);
+NullLogger null_logger;
+LogPriority[256] config_priorities = { [0..255] = ERROR, [CATEGORY_APPLICATION] = INFO, [CATEGORY_TEST] = VERBOSE, [CATEGORY_ASSERT] = WARN};
+String[256] category_names = {
+	[CATEGORY_APPLICATION] = "APP",
+    [CATEGORY_SYSTEM] = "SYSTEM",
+    [CATEGORY_KERNEL] = "KERNEL",
+    [CATEGORY_AUDIO] = "AUDIO",
+    [CATEGORY_VIDEO] = "VIDEO",
+    [CATEGORY_RENDER] = "RENDER",
+    [CATEGORY_INPUT] = "INPUT",
+    [CATEGORY_NETWORK] = "NETWORD",
+    [CATEGORY_SOCKET] = "SOCKET",
+    [CATEGORY_SECURITY] = "SECURITY",
+    [CATEGORY_TEST] = "TEST",
+    [CATEGORY_ERROR] = "ERROR",
+    [CATEGORY_ASSERT] = "ASSERT",
+    [CATEGORY_CRASH] = "CRASH",
+    [CATEGORY_STATS] = "STATS"
+};

lib/std/core/mem_allocator.c3

@@ -1,4 +1,18 @@
 module std::core::mem::allocator;
+import std::math;
+
+// C3 has several different allocators available:
+//
+// Name                     Arena  Uses buffer  OOM Fallback?     Mark?   Reset?
+// ArenaAllocator             Yes          Yes             No       Yes      Yes
+// BackedArenaAllocator       Yes           No            Yes       Yes      Yes
+// DynamicArenaAllocator      Yes           No            Yes        No      Yes
+// HeapAllocator               No           No             No        No       No   *Note: Not for normal use
+// LibcAllocator               No           No             No        No       No   *Note: Wraps malloc
+// OnStackAllocator           Yes          Yes            Yes        No       No   *Note: Used by @stack_mem
+// TempAllocator              Yes           No            Yes        No*      No*  *Note: Mark/reset using @pool
+// TrackingAllocator           No           No            N/A        No       No   *Note: Wraps other heap allocator
+// Vmem                       Yes           No             No       Yes      Yes   *Note: Can be set to huge sizes
 
 const DEFAULT_SIZE_PREFIX = usz.sizeof;
 const DEFAULT_SIZE_PREFIX_ALIGNMENT = usz.alignof;
@@ -18,36 +32,40 @@ enum AllocInitType
 
 interface Allocator
 {
-	fn void reset(usz mark) @optional;
-	fn usz mark() @optional;
 	<*
-	 * @require !alignment || math::is_power_of_2(alignment)
-	 * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
-	 * @require size > 0
+	 Acquire memory from the allocator, with the given alignment and initialization type.
+
+	 @require !alignment || math::is_power_of_2(alignment)
+	 @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+	 @require size > 0 : "The size must be 1 or more"
+	 @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 	*>
-	fn void*! acquire(usz size, AllocInitType init_type, usz alignment = 0);
+	fn void*? acquire(usz size, AllocInitType init_type, usz alignment = 0);
+
 	<*
-	 * @require !alignment || math::is_power_of_2(alignment)
-	 * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
-	 * @require ptr != null
-	 * @require new_size > 0
+	 Resize acquired memory from the allocator, with the given new size and alignment.
+
+	 @require !alignment || math::is_power_of_2(alignment)
+	 @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
+	 @require ptr != null
+	 @require new_size > 0
+	 @return? mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 	*>
-	fn void*! resize(void* ptr, usz new_size, usz alignment = 0);
+	fn void*? resize(void* ptr, usz new_size, usz alignment = 0);
+
 	<*
-	 * @require ptr != null
+	 Release memory acquired using `acquire` or `resize`.
+
+	 @require ptr != null : "Empty pointers should never be released"
 	*>
 	fn void release(void* ptr, bool aligned);
 }
 
-def MemoryAllocFn = fn char[]!(usz);
+alias MemoryAllocFn = fn char[]?(usz);
 
-fault AllocationFailure
-{
-	OUT_OF_MEMORY,
-	CHUNK_TOO_LARGE,
-}
 
-fn usz alignment_for_allocation(usz alignment) @inline @private
+
+fn usz alignment_for_allocation(usz alignment) @inline
 {
 	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? mem::DEFAULT_MEM_ALIGNMENT : alignment;
 }
@@ -57,7 +75,7 @@ macro void* malloc(Allocator allocator, usz size) @nodiscard
 	return malloc_try(allocator, size)!!;
 }
 
-macro void*! malloc_try(Allocator allocator, usz size) @nodiscard
+macro void*? malloc_try(Allocator allocator, usz size) @nodiscard
 {
 	if (!size) return null;
 	$if env::TESTING:
@@ -74,7 +92,7 @@ macro void* calloc(Allocator allocator, usz size) @nodiscard
 	return calloc_try(allocator, size)!!;
 }
 
-macro void*! calloc_try(Allocator allocator, usz size) @nodiscard
+macro void*? calloc_try(Allocator allocator, usz size) @nodiscard
 {
 	if (!size) return null;
 	return allocator.acquire(size, ZERO);
@@ -85,7 +103,7 @@ macro void* realloc(Allocator allocator, void* ptr, usz new_size) @nodiscard
 	return realloc_try(allocator, ptr, new_size)!!;
 }
 
-macro void*! realloc_try(Allocator allocator, void* ptr, usz new_size) @nodiscard
+macro void*? realloc_try(Allocator allocator, void* ptr, usz new_size) @nodiscard
 {
 	if (!new_size)
 	{
@@ -105,7 +123,7 @@ macro void free(Allocator allocator, void* ptr)
 	allocator.release(ptr, false);
 }
 
-macro void*! malloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
+macro void*? malloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
 {
 	if (!size) return null;
 	$if env::TESTING:
@@ -117,13 +135,13 @@ macro void*! malloc_aligned(Allocator allocator, usz size, usz alignment) @nodis
 	$endif
 }
 
-macro void*! calloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
+macro void*? calloc_aligned(Allocator allocator, usz size, usz alignment) @nodiscard
 {
 	if (!size) return null;
 	return allocator.acquire(size, ZERO, alignment);
 }
 
-macro void*! realloc_aligned(Allocator allocator, void* ptr, usz new_size, usz alignment) @nodiscard
+macro void*? realloc_aligned(Allocator allocator, void* ptr, usz new_size, usz alignment) @nodiscard
 {
 	if (!new_size)
 	{
@@ -149,7 +167,7 @@ macro void free_aligned(Allocator allocator, void* ptr)
 <*
  @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
  @require $vacount < 2 : "Too many arguments."
- @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ @require $vacount == 0 ||| $defined($Type t = $vaexpr[0]) : "The second argument must be an initializer for the type"
 *>
 macro new(Allocator allocator, $Type, ...) @nodiscard
 {
@@ -165,7 +183,7 @@ macro new(Allocator allocator, $Type, ...) @nodiscard
 <*
  @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
  @require $vacount < 2 : "Too many arguments."
- @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ @require $vacount == 0 ||| $defined($Type t = $vaexpr[0]) : "The second argument must be an initializer for the type"
 *>
 macro new_try(Allocator allocator, $Type, ...) @nodiscard
 {
@@ -182,14 +200,14 @@ macro new_try(Allocator allocator, $Type, ...) @nodiscard
  Allocate using an aligned allocation. This is necessary for types with a default memory alignment
  exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
  @require $vacount < 2 : "Too many arguments."
- @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
+ @require $vacount == 0 ||| $defined($Type t = $vaexpr[0]) : "The second argument must be an initializer for the type"
 *>
-macro new_aligned($Type, ...) @nodiscard
+macro new_aligned(Allocator allocator, $Type, ...) @nodiscard
 {
 	$if $vacount == 0:
 		return ($Type*)calloc_aligned(allocator, $Type.sizeof, $Type.alignof);
 	$else
-		$Type* val = malloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+		$Type* val = malloc_aligned(allocator, $Type.sizeof, $Type.alignof)!;
 		*val = $vaexpr[0];
 		return val;
 	$endif
@@ -286,11 +304,75 @@ macro alloc_array_try(Allocator allocator, $Type, usz elements) @nodiscard
 	return (($Type*)malloc_try(allocator, $Type.sizeof * elements))[:elements];
 }
 
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+*>
+macro realloc_array(Allocator allocator, void* ptr, $Type, usz elements) @nodiscard
+{
+	return realloc_array_try(allocator, ptr, $Type, elements)!!;
+}
+
+<*
+ Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+*>
+macro realloc_array_aligned(Allocator allocator, void* ptr, $Type, usz elements) @nodiscard
+{
+	return (($Type*)realloc_aligned(allocator, ptr, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
+}
+
+<*
+ @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+*>
+macro realloc_array_try(Allocator allocator, void* ptr, $Type, usz elements) @nodiscard
+{
+	return (($Type*)realloc_try(allocator, ptr, $Type.sizeof * elements))[:elements];
+}
+
+<*
+ Clone a value.
+
+ @param [&inout] allocator : "The allocator to use to clone"
+ @param value : "The value to clone"
+ @return "A pointer to the cloned value"
+ @require $alignof(value) <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'clone_aligned' instead"
+*>
 macro clone(Allocator allocator, value) @nodiscard
 {
 	return new(allocator, $typeof(value), value);
 }
 
+<*
+ @param [&inout] allocator : "The allocator used to clone"
+ @param slice : "The slice to clone"
+ @return "A pointer to the cloned slice"
+
+ @require $kindof(slice) == SLICE || $kindof(slice) == ARRAY
+*>
+macro clone_slice(Allocator allocator, slice) @nodiscard
+{
+	if (!lengthof(slice)) return {};
+
+	var $Type = $typeof(slice[0]);
+
+	$Type[] new_arr = new_array(allocator, $Type, slice.len);
+	mem::copy(new_arr.ptr, &slice[0], slice.len * $Type.sizeof);
+
+	return new_arr;
+}
+
+<*
+ Clone overaligned values. Must be released using free_aligned.
+
+ @param [&inout] allocator : "The allocator to use to clone"
+ @param value : "The value to clone"
+ @return "A pointer to the cloned value"
+*>
+macro clone_aligned(Allocator allocator, value) @nodiscard
+{
+	return new_aligned(allocator, $typeof(value), value)!!;
+}
+
 fn any clone_any(Allocator allocator, any value) @nodiscard
 {
 	usz size = value.type.sizeof;
@@ -305,12 +387,12 @@ fn any clone_any(Allocator allocator, any value) @nodiscard
  @require alignment > 0
  @require bytes <= isz.max
 *>
-macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment)
+macro void*? @aligned_alloc(#alloc_fn, usz bytes, usz alignment)
 {
 	if (alignment < void*.alignof) alignment = void*.alignof;
 	usz header = AlignedBlock.sizeof + alignment;
 	usz alignsize = bytes + header;
-	$if @typekind(#alloc_fn(bytes)) == OPTIONAL:
+	$if $kindof(#alloc_fn(bytes)) == OPTIONAL:
 		void* data = #alloc_fn(alignsize)!;
 	$else
 		void* data = #alloc_fn(alignsize);
@@ -322,33 +404,65 @@ macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment)
 	return mem;
 }
 
+<*
+ @require bytes > 0
+ @require alignment > 0
+ @require bytes <= isz.max
+*>
+macro void*? @aligned_alloc_fn(context, #alloc_fn, usz bytes, usz alignment)
+{
+	if (alignment < void*.alignof) alignment = void*.alignof;
+	usz header = AlignedBlock.sizeof + alignment;
+	usz alignsize = bytes + header;
+	$if $kindof(#alloc_fn(context, bytes)) == OPTIONAL:
+		void* data = #alloc_fn(context, alignsize)!;
+	$else
+		void* data = #alloc_fn(context, alignsize);
+	$endif
+	void* mem = mem::aligned_pointer(data + AlignedBlock.sizeof, alignment);
+	AlignedBlock* desc = (AlignedBlock*)mem - 1;
+	assert(mem > data);
+	*desc = { bytes, data };
+	return mem;
+}
+
 struct AlignedBlock
 {
 	usz len;
 	void* start;
 }
 
-macro void! @aligned_free(#free_fn, void* old_pointer)
+macro void? @aligned_free(#free_fn, void* old_pointer)
 {
 	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
-	$if @typekind(#free_fn(desc.start)) == OPTIONAL:
+	$if $kindof(#free_fn(desc.start)) == OPTIONAL:
 	#free_fn(desc.start)!;
 	$else
 	#free_fn(desc.start);
 	$endif
 }
 
+macro void? @aligned_free_fn(context, #free_fn, void* old_pointer)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	$if $kindof(#free_fn(context, desc.start)) == OPTIONAL:
+	#free_fn(context, desc.start)!;
+	$else
+	#free_fn(context, desc.start);
+	$endif
+}
+
 <*
  @require bytes > 0
  @require alignment > 0
 *>
-macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
+macro void*? @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
 {
 	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
 	void* data_start = desc.start;
 	void* new_data = @aligned_alloc(#calloc_fn, bytes, alignment)!;
 	mem::copy(new_data, old_pointer, desc.len < bytes ? desc.len : bytes, 1, 1);
-	$if @typekind(#free_fn(data_start)) == OPTIONAL:
+	$if $kindof(#free_fn(data_start)) == OPTIONAL:
 	#free_fn(data_start)!;
 	$else
 	#free_fn(data_start);
@@ -356,15 +470,53 @@ macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes
 	return new_data;
 }
 
+<*
+ @require bytes > 0
+ @require alignment > 0
+*>
+macro void*? @aligned_realloc_fn(context, #calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	void* data_start = desc.start;
+	void* new_data = @aligned_alloc_fn(context, #calloc_fn, bytes, alignment)!;
+	mem::copy(new_data, old_pointer, desc.len < bytes ? desc.len : bytes, 1, 1);
+	$if $kindof(#free_fn(context, data_start)) == OPTIONAL:
+	#free_fn(context, data_start)!;
+	$else
+	#free_fn(context, data_start);
+	$endif
+	return new_data;
+}
 
 // All allocators
-
-
+alias mem @builtin = thread_allocator ;
 tlocal Allocator thread_allocator @private = base_allocator();
 Allocator temp_base_allocator @private = base_allocator();
 
-tlocal TempAllocator* thread_temp_allocator @private = null;
-tlocal TempAllocator*[2] temp_allocator_pair @private;
+typedef PoolState = TempAllocator*;
+
+const LazyTempAllocator LAZY_TEMP @private = {};
+tlocal Allocator current_temp = &LAZY_TEMP;
+tlocal TempAllocator* top_temp;
+tlocal bool auto_create_temp = false;
+
+usz temp_allocator_min_size = temp_allocator_default_min_size();
+usz temp_allocator_reserve_size = temp_allocator_default_reserve_size();
+usz temp_allocator_realloc_size = temp_allocator_default_min_size() * 4;
+
+fn PoolState push_pool(usz reserve = 0)
+{
+	Allocator old = top_temp ? current_temp : create_temp_allocator_on_demand();
+	current_temp = ((TempAllocator*)old).derive_allocator(reserve)!!;
+	return (PoolState)old.ptr;
+}
+
+fn void pop_pool(PoolState old)
+{
+	TempAllocator* temp = (TempAllocator*)old;
+	current_temp = temp;
+	temp.reset();
+}
 
 macro Allocator base_allocator() @private
 {
@@ -375,36 +527,69 @@ macro Allocator base_allocator() @private
 	$endif
 }
 
-macro TempAllocator* create_default_sized_temp_allocator(Allocator allocator) @local
+macro usz temp_allocator_size() @local
 {
-	$switch (env::MEMORY_ENV)
-	$case NORMAL:
-		return new_temp_allocator(1024 * 256, allocator)!!;
-	$case SMALL:
-		return new_temp_allocator(1024 * 16, allocator)!!;
-	$case TINY:
-		return new_temp_allocator(1024 * 2, allocator)!!;
-	$case NONE:
-		unreachable("Temp allocator must explicitly created when memory-env is set to 'none'.");
+	$switch env::MEMORY_ENV:
+		$case NORMAL: return 256 * 1024;
+		$case SMALL: return 1024 * 32;
+		$case TINY: return 1024 * 4;
+		$case NONE: return 0;
 	$endswitch
 }
 
-macro Allocator heap() => thread_allocator;
-
-macro TempAllocator* temp()
+macro usz temp_allocator_default_min_size() @local
 {
-	if (!thread_temp_allocator)
-	{
-		init_default_temp_allocators();
-	}
-	return thread_temp_allocator;
+	$switch env::MEMORY_ENV:
+		$case NORMAL: return 16 * 1024;
+		$case SMALL: return 1024 * 2;
+		$case TINY: return 256;
+		$case NONE: return 256;
+	$endswitch
 }
 
-fn void init_default_temp_allocators() @private
+macro usz temp_allocator_default_reserve_size() @local
 {
-	temp_allocator_pair[0] = create_default_sized_temp_allocator(temp_base_allocator);
-	temp_allocator_pair[1] = create_default_sized_temp_allocator(temp_base_allocator);
-	thread_temp_allocator = temp_allocator_pair[0];
+	$switch env::MEMORY_ENV:
+		$case NORMAL: return 1024;
+		$case SMALL: return 128;
+		$case TINY: return 64;
+		$case NONE: return 64;
+	$endswitch
+}
+
+macro Allocator heap() @deprecated("Use 'mem' instead.") => thread_allocator;
+
+<*
+ @require !top_temp : "This should never be called when temp already exists"
+*>
+fn Allocator create_temp_allocator_on_demand() @private
+{
+	if (!auto_create_temp)
+	{
+	    auto_create_temp = true;
+	    abort("Use '@pool_init()' to enable the temp allocator on a new thread. A temp allocator is only implicitly created on the main thread.");
+	}
+	return create_temp_allocator(temp_base_allocator, temp_allocator_size(), temp_allocator_reserve_size, temp_allocator_min_size, temp_allocator_realloc_size);
+}
+
+<*
+ @require !top_temp : "This should never be called when temp already exists"
+*>
+fn Allocator create_temp_allocator(Allocator allocator, usz size, usz reserve, usz min_size, usz realloc_size) @private
+{
+	return current_temp = top_temp = allocator::new_temp_allocator(allocator, size, reserve, min_size, realloc_size)!!;
+}
+
+macro Allocator temp() @deprecated("Use 'tmem' instead")
+{
+	return current_temp;
+}
+
+alias tmem @builtin = current_temp;
+
+fn void allow_implicit_temp_allocator_on_load_thread() @init(1) @local @if(env::LIBC || env::FREESTANDING_WASM)
+{
+	auto_create_temp = true;
 }
 
 fn void destroy_temp_allocators_after_exit() @finalizer(65535) @local @if(env::LIBC)
@@ -417,35 +602,42 @@ fn void destroy_temp_allocators_after_exit() @finalizer(65535) @local @if(env::L
 *>
 fn void destroy_temp_allocators()
 {
-	if (!thread_temp_allocator) return;
-	temp_allocator_pair[0].destroy();
-	temp_allocator_pair[1].destroy();
-	temp_allocator_pair[..] = null;
-	thread_temp_allocator = null;
+	if (!top_temp) return;
+	top_temp.free();
+	top_temp = null;
+	current_temp = &LAZY_TEMP;
 }
 
-fn TempAllocator* temp_allocator_next() @private
+import libc;
+typedef LazyTempAllocator (Allocator) @private = uptr;
+
+fn void*? LazyTempAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	if (!top_temp) create_temp_allocator_on_demand();
+	return top_temp.acquire(bytes, init_type, alignment);
+}
+
+fn void*? LazyTempAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	if (!top_temp) create_temp_allocator_on_demand();
+	return top_temp.resize(old_ptr, new_bytes, alignment);
+}
+
+fn void LazyTempAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
 {
-	if (!thread_temp_allocator)
-	{
-		init_default_temp_allocators();
-		return thread_temp_allocator;
-	}
-	usz index = thread_temp_allocator == temp_allocator_pair[0] ? 1 : 0;
-	return thread_temp_allocator = temp_allocator_pair[index];
 }
 
 const NullAllocator NULL_ALLOCATOR = {};
-distinct NullAllocator (Allocator) = uptr;
+typedef NullAllocator (Allocator) = uptr;
 
-fn void*! NullAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? NullAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
-	return AllocationFailure.OUT_OF_MEMORY?;
+	return mem::OUT_OF_MEMORY~;
 }
 
-fn void*! NullAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? NullAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
-	return AllocationFailure.OUT_OF_MEMORY?;
+	return mem::OUT_OF_MEMORY~;
 }
 
 fn void NullAllocator.release(&self, void* old_ptr, bool aligned) @dynamic

lib/std/core/mem_mempool.c3

@@ -0,0 +1,252 @@
+module std::core::mem::mempool;
+import std::core::mem, std::core::mem::allocator, std::math;
+import std::core::sanitizer::asan;
+
+const INITIAL_CAPACITY = 0;
+
+struct FixedBlockPoolNode
+{
+	void* buffer;
+	FixedBlockPoolNode *next;
+	usz capacity;
+}
+
+struct FixedBlockPoolEntry
+{
+	void *previous;
+}
+
+<*
+ Fixed blocks pool pre-allocating blocks backed by an Allocator which are then reserved for the user,
+ blocks deallocated by the user are later re-used by future blocks allocations
+
+ `grow_capacity` can be changed in order to affect how many blocks will be allocated by next pool allocation,
+ it has to be greater than 0
+ `allocated` number of allocated blocks
+ `used` number of used blocks by the user
+*>
+struct FixedBlockPool
+{
+	Allocator allocator;
+	FixedBlockPoolNode head;
+	FixedBlockPoolNode *tail;
+	void *next_free;
+	void *freelist;
+	usz block_size;
+	usz grow_capacity;
+	usz allocated;
+	usz page_size;
+	usz alignment;
+	usz used;
+	bool initialized;
+}
+
+<*
+ Initialize an block pool
+
+ @param [in] allocator : "The allocator to use"
+ @param block_size : "The block size to use"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @param alignment : "The alignment of the buffer"
+ @require !alignment || math::is_power_of_2(alignment)
+ @require !self.initialized : "The block pool must not be initialized"
+ @require block_size > 0 : "Block size must be non zero"
+ @require calculate_actual_capacity(capacity, block_size) * block_size >= block_size
+    : "Total memory would overflow"
+*>
+fn FixedBlockPool* FixedBlockPool.init(&self, Allocator allocator, usz block_size, usz capacity = INITIAL_CAPACITY, usz alignment = 0)
+{
+	self.allocator = allocator;
+	self.tail = &self.head;
+	self.head.next = null;
+	self.block_size = math::max(block_size, FixedBlockPoolEntry.sizeof);
+	capacity = calculate_actual_capacity(capacity, self.block_size);
+	self.alignment = allocator::alignment_for_allocation(alignment);
+	self.page_size = capacity * self.block_size;
+    assert(self.page_size >= self.block_size, "Total memory would overflow %d %d", block_size, capacity);
+	self.head.buffer = fixedblockpool_allocate_page(self);
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(self.head.buffer, self.page_size);
+	$endif
+	self.head.capacity = capacity;
+	self.next_free = self.head.buffer;
+	self.freelist = null;
+	self.grow_capacity = capacity;
+	self.initialized = true;
+	self.allocated = capacity;
+	self.used = 0;
+	return self;
+}
+
+<*
+ Initialize an block pool
+
+ @param [in] allocator : "The allocator to use"
+ @param $Type : "The type used for setting the block size"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @require !self.initialized : "The block pool must not be initialized"
+*>
+macro FixedBlockPool* FixedBlockPool.init_for_type(&self, Allocator allocator, $Type, usz capacity = INITIAL_CAPACITY)
+{
+	return self.init(allocator, $Type.sizeof, capacity, $Type.alignof);
+}
+
+<*
+ Initialize an block pool using Temporary allocator
+
+ @param $Type : "The type used for setting the block size"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @require !self.initialized : "The block pool must not be initialized"
+*>
+macro FixedBlockPool* FixedBlockPool.tinit_for_type(&self, $Type, usz capacity = INITIAL_CAPACITY) => self.init_for_type(tmem, $Type, capacity);
+
+<*
+ Initialize an block pool using Temporary allocator
+
+ @param block_size : "The block size to use"
+ @param capacity : "The amount of blocks to be pre-allocated"
+ @require !self.initialized : "The block pool must not be initialized"
+*>
+macro FixedBlockPool* FixedBlockPool.tinit(&self, usz block_size, usz capacity = INITIAL_CAPACITY) => self.init(tmem, block_size, capacity);
+
+<*
+ Free up the entire block pool
+
+ @require self.initialized : "The block pool must be initialized"
+*>
+fn void FixedBlockPool.free(&self)
+{
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::unpoison_memory_region(self.head.buffer, self.page_size);
+	$endif
+	fixedblockpool_free_page(self, self.head.buffer);
+	FixedBlockPoolNode* iter = self.head.next;
+
+	while (iter)
+	{
+		$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+			asan::unpoison_memory_region(iter.buffer, self.page_size);
+		$endif
+		fixedblockpool_free_page(self, iter.buffer);
+		FixedBlockPoolNode* current = iter;
+		iter = iter.next;
+		allocator::free(self.allocator, current);
+	}
+	self.initialized = false;
+	self.allocated = 0;
+	self.used = 0;
+}
+
+<*
+ Allocate an block on the block pool, re-uses previously deallocated blocks
+
+ @require self.initialized : "The block pool must be initialized"
+*>
+fn void* FixedBlockPool.alloc(&self)
+{
+	defer self.used++;
+
+	if (self.freelist)
+	{
+		FixedBlockPoolEntry* entry = self.freelist;
+		$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+			asan::unpoison_memory_region(entry, self.block_size);
+		$endif
+		self.freelist = entry.previous;
+		mem::clear(entry, self.block_size);
+		return entry;
+	}
+
+	void* end = self.tail.buffer + (self.tail.capacity * self.block_size);
+	if (self.next_free >= end) fixedblockpool_new_node(self);
+	void* ptr = self.next_free;
+	self.next_free += self.block_size;
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::unpoison_memory_region(ptr, self.block_size);
+	$endif
+
+	return ptr;
+}
+
+<*
+ Deallocate a block from the block pool
+
+ @require self.initialized : "The block pool must be initialized"
+ @require fixedblockpool_check_ptr(self, ptr) : "The pointer should be part of the pool"
+*>
+fn void FixedBlockPool.dealloc(&self, void* ptr)
+{
+	$if env::COMPILER_SAFE_MODE && !env::ADDRESS_SANITIZER:
+		mem::set(ptr, 0xAA, self.block_size);
+	$endif
+
+	FixedBlockPoolEntry* entry = ptr;
+	entry.previous = self.freelist;
+	self.freelist = entry;
+	self.used--;
+
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(ptr, self.block_size);
+	$endif
+}
+
+<*
+ @require self.initialized : "The block pool must be initialized"
+*>
+fn bool fixedblockpool_check_ptr(FixedBlockPool* self, void *ptr) @local
+{
+	FixedBlockPoolNode* iter = &self.head;
+
+	while (iter)
+	{
+		void* end = iter.buffer + (iter.capacity * self.block_size);
+		if (ptr >= iter.buffer && ptr < end) return true;
+		iter = iter.next;
+	}
+
+	return false;
+}
+
+<*
+ @require self.grow_capacity > 0 : "How many blocks will it store"
+*>
+fn void fixedblockpool_new_node(FixedBlockPool* self) @local
+{
+	FixedBlockPoolNode* node = allocator::new(self.allocator, FixedBlockPoolNode);
+	node.buffer = fixedblockpool_allocate_page(self);
+	$if env::COMPILER_SAFE_MODE && env::ADDRESS_SANITIZER:
+		asan::poison_memory_region(node.buffer, self.page_size);
+	$endif
+	node.capacity = self.grow_capacity;
+	self.tail.next = node;
+	self.tail = node;
+	self.next_free = node.buffer;
+	self.allocated += node.capacity;
+}
+
+macro void* fixedblockpool_allocate_page(FixedBlockPool* self) @private
+{
+	return self.alignment > mem::DEFAULT_MEM_ALIGNMENT
+	       ? allocator::calloc_aligned(self.allocator, self.page_size, self.alignment)!!
+           : allocator::calloc(self.allocator, self.page_size);
+}
+
+macro void fixedblockpool_free_page(FixedBlockPool* self, void* page) @private
+{
+	if (self.alignment > mem::DEFAULT_MEM_ALIGNMENT)
+	{
+		allocator::free_aligned(self.allocator, page);
+	}
+	else
+	{
+		allocator::free(self.allocator, page);
+	}
+}
+
+macro usz calculate_actual_capacity(usz capacity, usz block_size) @private
+{
+	// Assume some overhead
+	if (capacity) return capacity;
+	capacity = (mem::os_pagesize() - 128) / block_size;
+	return capacity ?: 1;
+}

lib/std/core/os/mem_vm.c3

@@ -0,0 +1,353 @@
+<*
+ The VM module holds code for working with virtual memory on supported platforms (currently Win32 and Posix)
+*>
+module std::core::mem::vm;
+import std::io, std::os::win32, std::os::posix, libc;
+
+<*
+ VirtualMemory is an abstraction for working with an allocated virtual memory area. It will invoke vm:: functions
+ but will perform more checks and track its size (required to unmap the memory on Posix)
+*>
+struct VirtualMemory
+{
+	void* ptr;
+	usz size;
+	VirtualMemoryAccess default_access;
+}
+
+faultdef RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, UNMAPPED_ACCESS, UNALIGNED_ADDRESS, RELEASE_FAILED, UPDATE_FAILED, INVALID_ARGS;
+
+enum VirtualMemoryAccess
+{
+	PROTECTED,
+	READ,
+	WRITE,
+	READWRITE,
+	EXEC,
+	EXECREAD,
+	EXECWRITE,
+	ANY
+}
+
+fn usz aligned_alloc_size(usz size)
+{
+	$if env::WIN32:
+		return size > 0 ? mem::aligned_offset(size, win32::allocation_granularity()) : win32::allocation_granularity();
+	$else
+		return size > 0 ? mem::aligned_offset(size, mem::os_pagesize()) : mem::os_pagesize();
+	$endif
+}
+
+<*
+ Allocate virtual memory, size is rounded up to platform granularity (Win32) / page size (Posix).
+
+ @param size : "The size of the memory to allocate, will be rounded up"
+ @param access : "The initial access permissions."
+ @return? mem::OUT_OF_MEMORY, RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, INVALID_ARGS
+ @return "Pointer to the allocated memory, page aligned"
+*>
+fn void*? alloc(usz size, VirtualMemoryAccess access)
+{
+	$switch:
+		$case env::POSIX:
+			void* ptr = posix::mmap(null, aligned_alloc_size(size), access.to_posix(), posix::MAP_PRIVATE | posix::MAP_ANONYMOUS, -1, 0);
+			if (ptr != posix::MAP_FAILED) return ptr;
+			switch (libc::errno())
+			{
+				case errno::ENOMEM:    return mem::OUT_OF_MEMORY~;
+				case errno::EOVERFLOW: return RANGE_OVERFLOW~;
+				case errno::EPERM:     return ACCESS_DENIED~;
+				case errno::EINVAL:    return INVALID_ARGS~;
+				default:               return UNKNOWN_ERROR~;
+			}
+		$case env::WIN32:
+			void* ptr = win32::virtualAlloc(null, aligned_alloc_size(size), MEM_RESERVE, access.to_win32());
+			if (ptr) return ptr;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_NOT_ENOUGH_MEMORY:
+				case win32::ERROR_COMMITMENT_LIMIT:  return mem::OUT_OF_MEMORY~;
+				default:                             return UNKNOWN_ERROR~;
+			}
+		$default:
+			unsupported("Virtual alloc only available on Win32 and Posix");
+	$endswitch
+}
+
+<*
+ Release memory allocated with "alloc".
+
+ @param [&inout] ptr : "Pointer to page to release, should be allocated using vm::alloc"
+ @param size : "The size of the allocated pointer"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+*>
+fn void? release(void* ptr, usz size)
+{
+	$switch:
+		$case env::POSIX:
+			if (posix::munmap(ptr, aligned_alloc_size(size)))
+			{
+				switch (libc::errno())
+				{
+					case errno::EINVAL: return INVALID_ARGS~;    // Not a valid mapping or size
+					case errno::ENOMEM: return UNMAPPED_ACCESS~; // Address not mapped
+					default:            return RELEASE_FAILED~;
+				}
+			}
+		$case env::WIN32:
+			if (win32::virtualFree(ptr, 0, MEM_RELEASE)) return;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_INVALID_ADDRESS:   return INVALID_ARGS~;
+				case win32::ERROR_NOT_ENOUGH_MEMORY: return mem::OUT_OF_MEMORY~;
+				default:                             return RELEASE_FAILED~;
+			}
+		$default:
+			unsupported("Virtual free only available on Win32 and Posix");
+	$endswitch
+}
+
+<*
+ Change the access protection of a region in memory. The region must be page aligned.
+
+ @param [&inout] ptr : "Pointer to page to update, must be page aligned"
+ @param len : "To what len to update, must be page aligned"
+ @param access : "The new access"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+ @require mem::ptr_is_page_aligned(ptr + len) : "The length must be page aligned"
+ @return? ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UPDATE_FAILED, UNMAPPED_ACCESS, INVALID_ARGS
+*>
+fn void? protect(void* ptr, usz len, VirtualMemoryAccess access)
+{
+	$switch:
+		$case env::POSIX:
+			if (!posix::mprotect(ptr, len, access.to_posix())) return;
+			switch (libc::errno())
+			{
+				case errno::EACCES:    return ACCESS_DENIED~;
+				case errno::EINVAL:    return UNALIGNED_ADDRESS~;
+				case errno::EOVERFLOW: return RANGE_OVERFLOW~;
+				case errno::ENOMEM:    return UNMAPPED_ACCESS~;
+				default:               return UPDATE_FAILED~;
+			}
+		$case env::WIN32:
+			Win32_Protect old;
+			if (win32::virtualProtect(ptr, len, access.to_win32(), &old)) return;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_INVALID_ADDRESS:   return UNALIGNED_ADDRESS~;
+				case win32::ERROR_ACCESS_DENIED:     return ACCESS_DENIED~;
+				case win32::ERROR_INVALID_PARAMETER: return INVALID_ARGS~;
+				default:                             return UPDATE_FAILED~;
+			}
+		$default:
+			unsupported("'virtual_protect' is only available on Win32 and Posix.");
+	$endswitch
+}
+
+<*
+ Makes a region of memory available that was previously retrieved using 'alloc'. This is necessary on Win32,
+ but optional on Posix.
+
+ @param [&inout] ptr : "Pointer to page to update, must be page aligned"
+ @param len : "To what len to commit, must be page aligned"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+ @require mem::ptr_is_page_aligned(ptr + len) : "The length must be page aligned"
+ @return? UNKNOWN_ERROR, mem::OUT_OF_MEMORY, ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UPDATE_FAILED, UNMAPPED_ACCESS, INVALID_ARGS
+*>
+fn void? commit(void* ptr, usz len, VirtualMemoryAccess access = READWRITE)
+{
+	$switch:
+		$case env::POSIX:
+			return protect(ptr, len, READWRITE) @inline;
+		$case env::WIN32:
+			void* result = win32::virtualAlloc(ptr, len, MEM_COMMIT, access.to_win32());
+			if (result) return;
+			switch (win32::getLastError())
+			{
+				case win32::ERROR_INVALID_ADDRESS:   return UNALIGNED_ADDRESS~;
+				case win32::ERROR_ACCESS_DENIED:     return ACCESS_DENIED~;
+				case win32::ERROR_COMMITMENT_LIMIT:
+				case win32::ERROR_NOT_ENOUGH_MEMORY: return mem::OUT_OF_MEMORY~;
+				case win32::ERROR_INVALID_PARAMETER: return INVALID_ARGS~;
+				default:                             return UNKNOWN_ERROR~;
+			}
+		$default:
+			unsupported("'virtual_commit' is only available on Win32 and Posix.");
+	$endswitch
+}
+
+<*
+ Notifies that the memory in the region can be released back to the OS. On Win32 this decommits the region,
+ whereas on Posix it tells the system that it may be reused using madvise. The "block" parameter is only
+ respected on Posix, and protects the region from read/write/exec. On Win32 this always happens.
+
+ @param [&inout] ptr : "Pointer to page to update, must be page aligned"
+ @param len : "To what len to commit, must be page aligned"
+ @param block : "Set the released memory to protected"
+ @require mem::ptr_is_page_aligned(ptr) : "The pointer should be page aligned"
+ @require mem::ptr_is_page_aligned(ptr + len) : "The length must be page aligned"
+ @return? ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UPDATE_FAILED, UNMAPPED_ACCESS, INVALID_ARGS
+*>
+fn void? decommit(void* ptr, usz len, bool block = true)
+{
+	$switch:
+		$case env::POSIX:
+			if (posix::madvise(ptr, len, posix::MADV_DONTNEED))
+			{
+				switch (libc::errno())
+				{
+					case errno::EINVAL: return UNALIGNED_ADDRESS~;
+					case errno::ENOMEM: return UNMAPPED_ACCESS~;
+					default:            return UPDATE_FAILED~;
+				}
+			}
+			if (block) (void)protect(ptr, len, PROTECTED) @inline;
+		$case env::WIN32:
+			if (!win32::virtualFree(ptr, len, MEM_DECOMMIT))
+			{
+				switch (win32::getLastError())
+				{
+					case win32::ERROR_INVALID_ADDRESS:   return UNALIGNED_ADDRESS~;
+					case win32::ERROR_INVALID_PARAMETER: return INVALID_ARGS~;
+					case win32::ERROR_ACCESS_DENIED:     return ACCESS_DENIED~;
+					default:                             return UPDATE_FAILED~;
+				}
+			}
+		$default:
+			unsupported("'virtual_decommit' is only available on Win32 and Posix.");
+	$endswitch
+}
+
+<*
+ Map a portion of an already-opened file into memory.
+
+ @param fd : "File descriptor"
+ @param size : "Number of bytes to map, will be rounded up to page size"
+ @param offset : "Byte offset in file, must be page size aligned"
+ @param access : "The initial access permissions"
+ @param shared : "if True then MAP_SHARED else MAP_PRIVATE"
+ @return? mem::OUT_OF_MEMORY, RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, INVALID_ARGS, io::NO_PERMISSION, io::FILE_NOT_VALID, io::WOULD_BLOCK, io::FILE_NOT_FOUND
+ @return "Pointer to the mapped region"
+*>
+fn void*? mmap_file(Fd fd, usz size, usz offset = 0, VirtualMemoryAccess access = READ, bool shared = false) @if (env::POSIX)
+{
+	CInt flags = shared ? posix::MAP_SHARED : posix::MAP_PRIVATE;
+	void* ptr = posix::mmap(null, aligned_alloc_size(size), access.to_posix(), flags, fd, offset);
+	if (ptr != posix::MAP_FAILED) return ptr;
+	switch (libc::errno())
+	{
+		case errno::ENOMEM:    return mem::OUT_OF_MEMORY~;
+		case errno::EOVERFLOW: return RANGE_OVERFLOW~;
+		case errno::EPERM:     return ACCESS_DENIED~;
+		case errno::EINVAL:    return INVALID_ARGS~;
+		case errno::EACCES:    return io::NO_PERMISSION~;
+		case errno::EBADF:     return io::FILE_NOT_VALID~;
+		case errno::EAGAIN:    return io::WOULD_BLOCK~;
+		case errno::ENXIO:     return io::FILE_NOT_FOUND~;
+		default:               return UNKNOWN_ERROR~;
+	}
+}
+
+<*
+ Create a VirtualMemory using
+
+ @param size : "The size of the memory to allocate."
+ @require size > 0 : "The size must be non-zero"
+ @return? mem::OUT_OF_MEMORY, RANGE_OVERFLOW, UNKNOWN_ERROR, ACCESS_DENIED, INVALID_ARGS
+*>
+fn VirtualMemory? virtual_alloc(usz size, VirtualMemoryAccess access = PROTECTED)
+{
+	size = aligned_alloc_size(size);
+	void* ptr = alloc(size, access)!;
+	return { ptr, size, access };
+}
+
+<*
+ Commits memory, using vm::commit
+
+ @param offset : "Starting from what offset to commit"
+ @param len : "To what len to commit"
+ @require mem::ptr_is_page_aligned(self.ptr + offset) : "The offset should be page aligned"
+ @require mem::ptr_is_page_aligned(self.ptr + offset + len) : "The length must be page aligned"
+ @require offset < self.size : "Offset out of range"
+ @require offset + len <= self.size : "Length out of range"
+ @return? UPDATE_FAILED, ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UNKNOWN_ERROR
+*>
+macro void? VirtualMemory.commit(self, usz offset, usz len)
+{
+	return commit(self.ptr + offset, len, self.default_access);
+}
+
+<*
+ Changes protection of a part of memory using vm::protect
+
+ @param offset : "Starting from what offset to update"
+ @param len : "To what len to update"
+ @require mem::ptr_is_page_aligned(self.ptr + offset) : "The offset should be page aligned"
+ @require mem::ptr_is_page_aligned(self.ptr + offset + len) : "The length must be page aligned"
+ @require offset < self.size : "Offset out of range"
+ @require offset + len < self.size : "Length out of range"
+ @return? UPDATE_FAILED, ACCESS_DENIED, UNALIGNED_ADDRESS, RANGE_OVERFLOW, UNKNOWN_ERROR
+*>
+macro void? VirtualMemory.protect(self, usz offset, usz len, VirtualMemoryAccess access)
+{
+	return protect(self.ptr + offset, len, access);
+}
+<*
+ Decommits a part of memory using vm::decommit
+
+ @param offset : "Starting from what offset to decommit"
+ @param len : "To what len to decommit"
+ @param block : "Should the memory be blocked from access after decommit"
+ @require mem::ptr_is_page_aligned(self.ptr + offset) : "The offset should be page aligned"
+ @require mem::ptr_is_page_aligned(self.ptr + offset + len) : "The length must be page aligned"
+ @require offset < self.size : "Offset out of range"
+ @require offset + len < self.size : "Length out of range"
+ @return? UPDATE_FAILED
+*>
+fn void? VirtualMemory.decommit(self, usz offset, usz len, bool block = true)
+{
+	return decommit(self.ptr + offset, len, block);
+}
+
+<*
+ Releases the memory region
+
+ @require self.ptr != null : "Virtual memory must be initialized to call destroy"
+*>
+fn void? VirtualMemory.destroy(&self)
+{
+	return release(self.ptr, self.size);
+}
+
+fn CInt VirtualMemoryAccess.to_posix(self) @if(env::POSIX)
+{
+	switch (self)
+	{
+		case PROTECTED: return posix::PROT_NONE;
+		case READ: return posix::PROT_READ;
+		case WRITE: return posix::PROT_WRITE;
+		case EXEC: return posix::PROT_EXEC;
+		case READWRITE: return posix::PROT_READ | posix::PROT_WRITE;
+		case EXECREAD: return posix::PROT_READ | posix::PROT_EXEC;
+		case EXECWRITE: return posix::PROT_WRITE | posix::PROT_EXEC;
+		case ANY: return posix::PROT_WRITE | posix::PROT_READ | posix::PROT_EXEC;
+	}
+}
+
+fn Win32_Protect VirtualMemoryAccess.to_win32(self) @if(env::WIN32)
+{
+	switch (self)
+	{
+		case PROTECTED: return PAGE_NOACCESS;
+		case READ: return PAGE_READONLY;
+		case WRITE: return PAGE_READWRITE;
+		case EXEC: return PAGE_EXECUTE;
+		case READWRITE: return PAGE_READWRITE;
+		case EXECWRITE: return PAGE_EXECUTE_READWRITE;
+		case EXECREAD: return PAGE_EXECUTE_READ;
+		case ANY: return PAGE_EXECUTE_READWRITE;
+	}
+}
+

lib/std/core/os/wasm/wasm_memory.c3

@@ -11,7 +11,7 @@ struct WasmMemory
 	uptr use;
 }
 
-fn char[]! WasmMemory.allocate_block(&self, usz bytes)
+fn char[]? WasmMemory.allocate_block(&self, usz bytes)
 {
 	if (!self.allocation)
 	{
@@ -25,7 +25,7 @@ fn char[]! WasmMemory.allocate_block(&self, usz bytes)
 	}
 
 	usz blocks_required = (bytes_required + WASM_BLOCK_SIZE + 1) / WASM_BLOCK_SIZE;
-	if ($$wasm_memory_grow(0, blocks_required) == -1) return AllocationFailure.OUT_OF_MEMORY?;
+	if ($$wasm_memory_grow(0, blocks_required) == -1) return mem::OUT_OF_MEMORY~;
 	self.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
 	defer self.use += bytes;
 	return ((char*)self.use)[:bytes];

lib/std/core/private/cpu_detect.c3

@@ -25,6 +25,11 @@ enum X86Feature
 {
 	ADX,
 	AES,
+	AMX_AVX512,
+	AMX_FP8,
+	AMX_MOVRS,
+	AMX_TF32,
+	AMX_TRANSPOSE,
 	AMX_BF16,
 	AMX_COMPLEX,
 	AMX_FP16,
@@ -34,6 +39,8 @@ enum X86Feature
 	AVX,
 	AVX10_1_256,
 	AVX10_1_512,
+	AVX10_2_256,
+	AVX10_2_512,
 	AVX2,
 	AVX5124FMAPS,
 	AVX5124VNNIW,
@@ -84,6 +91,7 @@ enum X86Feature
 	MOVBE,
 	MOVDIR64B,
 	MOVDIRI,
+	MOVRS,
 	MWAITX,
 	PCLMUL,
 	PCONFIG,
@@ -135,21 +143,21 @@ uint128 x86_features;
 
 fn void add_feature_if_bit(X86Feature feature, uint register, int bit)
 {
-	if (register & 1U << bit) x86_features |= 1u128 << feature.ordinal;
+	if (register & 1U << bit) x86_features |= 1ULL << feature.ordinal;
 }
 
 fn void x86_initialize_cpu_features()
 {
 	uint max_level = x86_cpuid(0).eax;
 	CpuId feat = x86_cpuid(1);
-	CpuId leaf7 = max_level >= 8 ? x86_cpuid(7) : CpuId {};
-	CpuId leaf7s1 = leaf7.eax >= 1 ? x86_cpuid(7, 1) : CpuId {};
-	CpuId ext1 = x86_cpuid(0x80000000).eax >= 0x80000001 ? x86_cpuid(0x80000001) : CpuId {};
-	CpuId ext8 = x86_cpuid(0x80000000).eax >= 0x80000008 ? x86_cpuid(0x80000008) : CpuId {};
-	CpuId leaf_d = max_level >= 0xd ? x86_cpuid(0xd, 0x1) : CpuId {};
-	CpuId leaf_14 = max_level >= 0x14 ? x86_cpuid(0x14) : CpuId {};
-	CpuId leaf_19 = max_level >= 0x19 ? x86_cpuid(0x19) : CpuId {};
-	CpuId leaf_24 = max_level >= 0x24 ? x86_cpuid(0x24) : CpuId {};
+	CpuId leaf7 = max_level >= 8 ? x86_cpuid(7) : {};
+	CpuId leaf7s1 = leaf7.eax >= 1 ? x86_cpuid(7, 1) : {};
+	CpuId ext1 = x86_cpuid(0x80000000).eax >= 0x80000001 ? x86_cpuid(0x80000001) : {};
+	CpuId ext8 = x86_cpuid(0x80000000).eax >= 0x80000008 ? x86_cpuid(0x80000008) : {};
+	CpuId leaf_d = max_level >= 0xd ? x86_cpuid(0xd, 0x1) : {};
+	CpuId leaf_14 = max_level >= 0x14 ? x86_cpuid(0x14) : {};
+	CpuId leaf_19 = max_level >= 0x19 ? x86_cpuid(0x19) : {};
+	CpuId leaf_24 = max_level >= 0x24 ? x86_cpuid(0x24) : {};
 	add_feature_if_bit(ADX, leaf7.ebx, 19);
 	add_feature_if_bit(AES, feat.ecx, 25);
 	add_feature_if_bit(AMX_BF16, leaf7.edx, 22);

lib/std/core/private/macho_runtime.c3

@@ -56,10 +56,7 @@ struct MachHeader64
 
 const LC_SEGMENT_64 = 0x19;
 
-fault MachoSearch
-{
-	NOT_FOUND
-}
+
 fn bool name_cmp(char* a, char[16]* b)
 {
 	for (usz i = 0; i < 16; i++)
@@ -70,7 +67,7 @@ fn bool name_cmp(char* a, char[16]* b)
 	return false;
 }
 
-fn SegmentCommand64*! find_segment(MachHeader* header, char* segname)
+fn SegmentCommand64*? find_segment(MachHeader* header, char* segname)
 {
 	LoadCommand* command = (void*)header + MachHeader64.sizeof;
 	for (uint i = 0; i < header.ncmds; i++)
@@ -82,9 +79,9 @@ fn SegmentCommand64*! find_segment(MachHeader* header, char* segname)
 		}
 		command = (void*)command + command.cmdsize;
 	}
-	return MachoSearch.NOT_FOUND?;
+	return NOT_FOUND~;
 }
-fn Section64*! find_section(SegmentCommand64* command, char* sectname)
+fn Section64*? find_section(SegmentCommand64* command, char* sectname)
 {
 	Section64* section = (void*)command + SegmentCommand64.sizeof;
 	for (uint i = 0; i < command.nsects; i++)
@@ -92,22 +89,22 @@ fn Section64*! find_section(SegmentCommand64* command, char* sectname)
 		if (name_cmp(sectname, &section.sectname)) return section;
 		section++;
 	}
-	return MachoSearch.NOT_FOUND?;
+	return NOT_FOUND~;
 }
 
 macro find_segment_section_body(MachHeader* header, char* segname, char* sectname, $Type)
 {
 
-	Section64*! section = find_section(find_segment(header, segname), sectname);
+	Section64*? section = find_section(find_segment(header, segname), sectname);
 	if (catch section)
 	{
-		return $Type[] {};
+		return ($Type[]){};
 	}
 	$Type* ptr = (void*)header + section.offset;
 	return ptr[:section.size / $Type.sizeof];
 }
 
-def DyldCallback = fn void (MachHeader* mh, isz vmaddr_slide);
+alias DyldCallback = fn void (MachHeader* mh, isz vmaddr_slide);
 
 extern fn void _dyld_register_func_for_add_image(DyldCallback);
 
@@ -126,7 +123,7 @@ extern fn void* realloc(void* ptr, usz size);
 extern fn void* malloc(usz size);
 extern fn void free(void* ptr);
 
-def CallbackFn = fn void();
+alias CallbackFn = fn void();
 struct Callback
 {
 	uint priority;

lib/std/core/private/main_stub.c3

@@ -7,16 +7,26 @@ macro usz _strlen(ptr) @private
 	return len;
 }
 
-macro int @main_to_err_main(#m, int, char**)
+macro int @main_no_args(#m, int, char**)
 {
-	if (catch #m()) return 1;
-	return 0;
+	$if $typeof(#m()) == void:
+		#m();
+		return 0;
+	$else
+		return #m();
+	$endif
 }
-macro int @main_to_int_main(#m, int, char**) => #m();
-macro int @main_to_void_main(#m, int, char**)
+
+macro int @main_args(#m, int argc, char** argv)
 {
-	#m();
-	return 0;
+	String[] list = args_to_strings(argc, argv);
+	defer free(list.ptr);
+	$if $typeof(#m(list)) == void:
+		#m(list);
+		return 0;
+	$else
+		return #m(list);
+	$endif
 }
 
 macro String[] args_to_strings(int argc, char** argv) @private
@@ -32,32 +42,27 @@ macro String[] args_to_strings(int argc, char** argv) @private
 }
 
 
-macro int @main_to_err_main_args(#m, int argc, char** argv)
+macro int @_main_runner(#m, int argc, char** argv)
 {
 	String[] list = args_to_strings(argc, argv);
 	defer free(list.ptr);
-	if (catch #m(list)) return 1;
-	return 0;
-}
-
-macro int @main_to_int_main_args(#m, int argc, char** argv)
-{
-	String[] list = args_to_strings(argc, argv);
-	defer free(list.ptr);
-	return #m(list);
-}
-
-macro int @main_to_void_main_args(#m, int argc, char** argv)
-{
-	String[] list = args_to_strings(argc, argv);
-	defer free(list.ptr);
-	#m(list);
-	return 0;
+	return #m(list) ? 0 : 1;
 }
 
 module std::core::main_stub @if(env::WIN32);
+import std::os::win32;
 
-extern fn Char16** _win_command_line_to_argv_w(ushort* cmd_line, int* argc_ptr) @extern("CommandLineToArgvW");
+macro win32_set_utf8_codepage() @local
+{
+	// By default windows uses an OEM codepage that differs based on locale
+	// and does not support printing utf-8 characters. This allows both
+	// printing utf-8 characters from strings and reading them from stdin.
+	win32::setConsoleCP(UTF8);
+	win32::setConsoleOutputCP(UTF8);
+}
+
+
+extern fn Char16** _win_command_line_to_argv_w(ushort* cmd_line, int* argc_ptr) @cname("CommandLineToArgvW");
 
 macro String[] win_command_line_to_strings(ushort* cmd_line) @private
 {
@@ -73,7 +78,7 @@ macro String[] wargs_strings(int argc, Char16** argv) @private
 	{
 		Char16* arg = argv[i];
 		Char16[] argstring = arg[:_strlen(arg)];
-		list[i] = string::new_from_utf16(argstring) ?? "?".copy();
+		list[i] = string::from_utf16(mem, argstring) ?? "?".copy(mem);
 	}
 	return list[:argc];
 }
@@ -84,83 +89,72 @@ macro void release_wargs(String[] list) @private
 	free(list.ptr);
 }
 
-macro int @win_to_err_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
+macro int @win_main_no_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
-	if (catch #m()) return 1;
-	return 0;
-}
-macro int @win_to_int_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd) => #m();
-macro int @win_to_void_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
-{
-	#m();
-	return 0;
+	win32_set_utf8_codepage();
+	$if $typeof(#m()) == void:
+		#m();
+		return 0;
+	$else
+		return #m();
+	$endif
 }
 
-macro int @win_to_err_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
+macro int @win_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
+	win32_set_utf8_codepage();
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	if (catch #m(args)) return 1;
-	return 0;
+	$if $typeof(#m(args)) == void:
+		#m(args);
+		return 0;
+	$else
+		return #m(args);
+	$endif
 }
 
-macro int @win_to_int_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
+macro int @win_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
+	win32_set_utf8_codepage();
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	return #m(args);
+	$if $typeof(#m(handle, prev_handle, args, show_cmd)) == void:
+		#m(handle, prev_handle, args, show_cmd);
+		return 0;
+	$else
+		return #m(handle, prev_handle, args, show_cmd);
+	$endif
 }
 
-macro int @win_to_void_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
-{
-	String[] args = win_command_line_to_strings(cmd_line);
-	defer release_wargs(args);
-	#m(args);
-	return 0;
-}
 
-macro int @win_to_err_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
-{
-	String[] args = win_command_line_to_strings(cmd_line);
-	defer release_wargs(args);
-	if (catch #m(handle, prev_handle, args, show_cmd)) return 1;
-	return 0;
-}
-
-macro int @win_to_int_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
-{
-	String[] args = win_command_line_to_strings(cmd_line);
-	defer release_wargs(args);
-	return #m(handle, prev_handle, args, show_cmd);
-}
-
-macro int @win_to_void_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
-{
-	String[] args = win_command_line_to_strings(cmd_line);
-	defer release_wargs(args);
-	#m(handle, prev_handle, args, show_cmd);
-	return 0;
-}
-
-macro int @wmain_to_err_main_args(#m, int argc, Char16** argv)
+macro int @wmain_main(#m, int argc, Char16** argv)
 {
+	win32_set_utf8_codepage();
 	String[] args = wargs_strings(argc, argv);
 	defer release_wargs(args);
-	if (catch #m(args)) return 1;
-	return 1;
+	$if $typeof(#m(args)) == void:
+		#m(args);
+		return 0;
+	$else
+		return #m(args);
+	$endif
 }
 
-macro int @wmain_to_int_main_args(#m, int argc, Char16** argv)
+macro int @wmain_main_no_args(#m, int argc, Char16** argv)
 {
-	String[] args = wargs_strings(argc, argv);
-	defer release_wargs(args);
-	return #m(args);
+	win32_set_utf8_codepage();
+	$if $typeof(#m()) == void:
+		#m();
+		return 0;
+	$else
+		return #m();
+	$endif
 }
 
-macro int @wmain_to_void_main_args(#m, int argc, Char16** argv)
+macro int @_wmain_runner(#m, int argc, Char16** argv)
 {
+	win32_set_utf8_codepage();
 	String[] args = wargs_strings(argc, argv);
 	defer release_wargs(args);
-	#m(args);
-	return 0;
+	return #m(args) ? 0 : 1;
 }

lib/std/core/refcount.c3

@@ -0,0 +1,132 @@
+<*
+ Ref provides a general *external* ref counted wrapper for a pointer. For convenience, a ref count of 0
+ means the reference is still valid.
+
+ When the rc drops to -1, it will first run the dealloc function on the underlying pointer (if it exists),
+ then free the pointer and the atomic variable assuming that they are allocated using the Allocator in the Ref.
+
+ @require !$defined(Type.dealloc) ||| $defined(Type.dealloc(&&(Type){})) : "'dealloc' must only take a pointer to the underlying type"
+ @require !$defined(Type.dealloc) ||| $typeof((Type){}.dealloc()) ==  void : "'dealloc' must return 'void'"
+*>
+module std::core::mem::ref <Type>;
+import std::thread, std::atomic;
+
+const OVERALIGNED @private = Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+
+alias DeallocFn = fn void(void*);
+
+fn Ref wrap(Type* ptr, Allocator allocator = mem)
+{
+	return { .refcount = allocator::new(allocator, Atomic{int}), .ptr = ptr, .allocator = allocator };
+}
+<*
+ @require $vacount < 2 : "Too many arguments."
+ @require $vacount == 0 ||| $defined(Type a = $vaexpr[0]) : "The first argument must be an initializer for the type"
+*>
+macro Ref new(..., Allocator allocator = mem)
+{
+
+	$switch:
+		$case OVERALIGNED && !$vacount:
+			Type* ptr = allocator::calloc_aligned(allocator, Type.sizeof, Type.alignof)!!;
+		$case OVERALIGNED:
+			Type* ptr = allocator::malloc_aligned(allocator, Type.sizeof, Type.alignof)!!;
+			*ptr = $vaexpr[0];
+		$case !$vacount:
+			Type* ptr = allocator::calloc(allocator, Type.sizeof);
+		$default:
+			Type* ptr = allocator::malloc(allocator, Type.sizeof);
+			*ptr = $vaexpr[0];
+	$endswitch
+	return { .refcount = allocator::new(allocator, Atomic{int}),
+	         .ptr = ptr,
+	         .allocator = allocator };
+}
+
+struct Ref
+{
+	Atomic{int}* refcount;
+	Type* ptr;
+	Allocator allocator;
+}
+
+fn Ref* Ref.retain(&self)
+{
+	assert(self.refcount != null, "Reference already released");
+	assert(self.refcount.load(RELAXED) >= 0, "Retaining zombie");
+	self.refcount.add(1, RELAXED);
+	return self;
+}
+
+fn void Ref.release(&self)
+{
+	assert(self.refcount != null, "Reference already released");
+    assert(self.refcount.load(RELAXED) >= 0, "Overrelease of refcount");
+	if (self.refcount.sub(1, RELAXED) == 0)
+	{
+		thread::fence(ACQUIRE);
+		$if $defined(Type.dealloc):
+			self.ptr.dealloc();
+		$endif
+		$if OVERALIGNED:
+			allocator::free_aligned(self.allocator, self.ptr);
+		$else
+			allocator::free(self.allocator, self.ptr);
+		$endif
+		allocator::free(self.allocator, self.refcount);
+		*self = {};
+	}
+}
+
+module std::core::mem::rc;
+import std::thread, std::atomic;
+
+<*
+ A RefCounted struct should be an inline base of a struct.
+ If a `dealloc` is defined, then it will be called rather than `free`
+
+ For convenience, a ref count of 0 is still valid, and the struct is
+ only freed when when ref count drops to -1.
+
+ The macros rc::retain and rc::release must be used on the full pointer,
+ not on the RefCounted substruct.
+
+ So `Foo* f = ...; RefCounted* rc = f; rc::release(rc);` will not do the right thing.
+*>
+struct RefCounted
+{
+	Atomic{int} refcount;
+}
+
+<*
+ @require $defined(RefCounted* c = refcounted) : "Expected a ref counted value"
+*>
+macro retain(refcounted)
+{
+	if (refcounted)
+	{
+		assert(refcounted.refcount.load(RELAXED) >= 0, "Retaining zombie");
+    	refcounted.refcount.add(1, RELAXED);
+	}
+	return refcounted;
+}
+
+<*
+ @require $defined(RefCounted* c = refcounted) : "Expected a ref counted value"
+ @require !$defined(refcounted.dealloc()) ||| $typeof(refcounted.dealloc()) == void
+   : "Expected refcounted type to have a valid dealloc"
+*>
+macro void release(refcounted)
+{
+	if (!refcounted) return;
+	assert(refcounted.refcount.load(RELAXED) >= 0, "Overrelease of refcount");
+	if (refcounted.refcount.sub(1, RELAXED) == 0)
+	{
+		thread::fence(ACQUIRE);
+		$if $defined(refcounted.dealloc):
+			refcounted.dealloc();
+		$else
+			free(refcounted);
+		$endif
+	}
+}

lib/std/core/runtime.c3

@@ -22,235 +22,27 @@ struct SliceRaw
 	usz len;
 }
 
-def BenchmarkFn = fn void!();
-
-struct BenchmarkUnit
+macro @enum_lookup($Type, #value, value)
 {
-	String name;
-	BenchmarkFn func;
+	$foreach $val : $Type.values:
+		if ($val.#value == value) return $val;
+	$endforeach
+	return NOT_FOUND~;
 }
 
-fn BenchmarkUnit[] benchmark_collection_create(Allocator allocator = allocator::heap())
+macro @enum_lookup_new($Type, $name, value)
 {
-	BenchmarkFn[] fns = $$BENCHMARK_FNS;
-	String[] names = $$BENCHMARK_NAMES;
-	BenchmarkUnit[] benchmarks = allocator::alloc_array(allocator, BenchmarkUnit, names.len);
-	foreach (i, benchmark : fns)
-	{
-		benchmarks[i] = { names[i], fns[i] };
-	}
-	return benchmarks;
+	$foreach $val : $Type.values:
+		if ($val.$eval($name) == value) return $val;
+	$endforeach
+	return NOT_FOUND~;
 }
 
-const DEFAULT_BENCHMARK_WARMUP_ITERATIONS = 3;
-const DEFAULT_BENCHMARK_MAX_ITERATIONS = 10000;
 
-uint benchmark_warmup_iterations @private = DEFAULT_BENCHMARK_WARMUP_ITERATIONS;
-uint benchmark_max_iterations @private = DEFAULT_BENCHMARK_MAX_ITERATIONS;
-
-fn void set_benchmark_warmup_iterations(uint value) @builtin
-{
-    benchmark_warmup_iterations = value;
-}
-
-fn void set_benchmark_max_iterations(uint value) @builtin
-{
-    assert(value > 0);
-    benchmark_max_iterations = value;
-}
-
-fn bool run_benchmarks(BenchmarkUnit[] benchmarks)
-{
-	int benchmarks_passed = 0;
-	int benchmark_count = benchmarks.len;
-	usz max_name;
-
-	foreach (&unit : benchmarks)
-	{
-		if (max_name < unit.name.len) max_name = unit.name.len;
-	}
-
-	usz len = max_name + 9;
-
-	DString name = dstring::temp_with_capacity(64);
-	name.append_repeat('-', len / 2);
-	name.append(" BENCHMARKS ");
-	name.append_repeat('-', len - len / 2);
-
-	io::printn(name);
-
-	name.clear();
-
-	long sys_clock_started;
-	long sys_clock_finished;
-	long sys_clocks;
-	Clock clock;
-	anyfault err;
-
-	foreach(unit : benchmarks)
-	{
-		defer name.clear();
-		name.appendf("Benchmarking %s ", unit.name);
-		name.append_repeat('.', max_name - unit.name.len + 2);
-		io::printf("%s ", name.str_view());
-
-		for (uint i = 0; i < benchmark_warmup_iterations; i++)
-		{
-			err = @catch(unit.func()) @inline;
-			@volatile_load(err);
-		}
-
-		clock = std::time::clock::now();
-		sys_clock_started = $$sysclock();
-
-		for (uint i = 0; i < benchmark_max_iterations; i++)
-		{
-			err = @catch(unit.func()) @inline;
-			@volatile_load(err);
-		}
-
-		sys_clock_finished = $$sysclock();
-		NanoDuration nano_seconds = clock.mark();
-		sys_clocks = sys_clock_finished - sys_clock_started;
-
-		if (err)
-		{
-			io::printfn("[failed] Failed due to: %s", err);
-			continue;
-		}
-
-		io::printfn("[ok] %.2f ns, %.2f CPU's clocks", (float)nano_seconds / benchmark_max_iterations, (float)sys_clocks / benchmark_max_iterations);
-		benchmarks_passed++;
-	}
-
-	io::printfn("\n%d benchmark%s run.\n", benchmark_count, benchmark_count > 1 ? "s" : "");
-	io::printfn("Benchmarks Result: %s. %d passed, %d failed.",
-		benchmarks_passed < benchmark_count ? "FAILED" : "ok",
-		benchmarks_passed,
-		benchmark_count - benchmarks_passed);
-
-	return benchmark_count == benchmarks_passed;
-}
-
-fn bool default_benchmark_runner()
-{
-	@pool()
-	{
-		return run_benchmarks(benchmark_collection_create(allocator::temp()));
-	};
-}
-
-def TestFn = fn void!();
-
-struct TestUnit
-{
-	String name;
-	TestFn func;
-}
-
-fn TestUnit[] test_collection_create(Allocator allocator = allocator::heap())
-{
-	TestFn[] fns = $$TEST_FNS;
-	String[] names = $$TEST_NAMES;
-	TestUnit[] tests = allocator::alloc_array(allocator, TestUnit, names.len);
-	foreach (i, test : fns)
-	{
-		tests[i] = { names[i], fns[i] };
-	}
-	return tests;
-}
-
-struct TestContext
-{
-	JmpBuf buf;
-}
-
-// Sort the tests by their name in ascending order.
-fn int cmp_test_unit(TestUnit a, TestUnit b)
-{
-	usz an = a.name.len;
-	usz bn = b.name.len;
-	if (an > bn) @swap(a, b);
-	foreach (i, ac : a.name)
-	{
-		char bc = b.name[i];
-		if (ac != bc) return an > bn ? bc - ac : ac - bc;
-	}
-	return (int)(an - bn);
-}
-
-TestContext* test_context @private;
-
-fn void test_panic(String message, String file, String function, uint line)
-{
-	io::printn("[error]");
-	io::print("\n Error: ");
-	io::print(message);
-	io::printn();
-	io::printfn("  - in %s %s:%s.\n", function, file, line);
-	libc::longjmp(&test_context.buf, 1);
-}
-
-fn bool run_tests(TestUnit[] tests)
-{
-	usz max_name;
-	foreach (&unit : tests)
-	{
-		if (max_name < unit.name.len) max_name = unit.name.len;
-	}
-	quicksort(tests, &cmp_test_unit);
-
-	TestContext context;
-	test_context = &context;
-
-	PanicFn old_panic = builtin::panic;
-	defer builtin::panic = old_panic;
-	builtin::panic = &test_panic;
-	int tests_passed = 0;
-	int test_count = tests.len;
-	DString name = dstring::temp_with_capacity(64);
-	usz len = max_name + 9;
-	name.append_repeat('-', len / 2);
-	name.append(" TESTS ");
-	name.append_repeat('-', len - len / 2);
-	io::printn(name);
-	name.clear();
-	foreach(unit : tests)
-	{
-		defer name.clear();
-		name.appendf("Testing %s ", unit.name);
-		name.append_repeat('.', max_name - unit.name.len + 2);
-		io::printf("%s ", name.str_view());
-		(void)io::stdout().flush();
-		if (libc::setjmp(&context.buf) == 0)
-		{
-			if (catch err = unit.func())
-			{
-				io::printfn("[failed] Failed due to: %s", err);
-				continue;
-			}
-			io::printn("[ok]");
-			tests_passed++;
-		}
-	}
-	io::printfn("\n%d test%s run.\n", test_count, test_count > 1 ? "s" : "");
-	io::printfn("Test Result: %s. %d passed, %d failed.",
-		tests_passed < test_count ? "FAILED" : "ok", tests_passed, test_count - tests_passed);
-	return test_count == tests_passed;
-}
-
-fn bool default_test_runner()
-{
-	@pool()
-	{
-		return run_tests(test_collection_create(allocator::temp()));
-	};
-}
-
-module std::core::runtime @if(WASM_NOLIBC);
+module std::core::runtime @if(env::FREESTANDING_WASM);
 
 extern fn void __wasm_call_ctors();
-fn void wasm_initialize() @extern("_initialize") @wasm
+fn void wasm_initialize() @cname("_initialize") @wasm
 {
 	// The linker synthesizes this to call constructors.
 	__wasm_call_ctors();

lib/std/core/runtime_benchmark.c3

@@ -0,0 +1,187 @@
+module std::core::runtime;
+import libc, std::time, std::io, std::sort, std::math, std::collections::map;
+
+alias BenchmarkFn = fn void ();
+
+HashMap { String, uint } bench_fn_iters @local;
+
+struct BenchmarkUnit
+{
+	String name;
+	BenchmarkFn func;
+}
+
+fn BenchmarkUnit[] benchmark_collection_create(Allocator allocator)
+{
+	BenchmarkFn[] fns = $$BENCHMARK_FNS;
+	String[] names = $$BENCHMARK_NAMES;
+	BenchmarkUnit[] benchmarks = allocator::alloc_array(allocator, BenchmarkUnit, names.len);
+	foreach (i, benchmark : fns)
+	{
+		benchmarks[i] = { names[i], fns[i] };
+		if (!bench_fn_iters.has_key(names[i])) bench_fn_iters[names[i]] = benchmark_max_iterations;
+	}
+	return benchmarks;
+}
+
+const DEFAULT_BENCHMARK_WARMUP_ITERATIONS = 3;
+const DEFAULT_BENCHMARK_MAX_ITERATIONS = 10000;
+
+uint benchmark_warmup_iterations @private = DEFAULT_BENCHMARK_WARMUP_ITERATIONS;
+uint benchmark_max_iterations @private = DEFAULT_BENCHMARK_MAX_ITERATIONS;
+
+fn void set_benchmark_warmup_iterations(uint value) @builtin
+{
+    benchmark_warmup_iterations = value;
+}
+
+fn void set_benchmark_max_iterations(uint value) @builtin
+{
+    assert(value > 0);
+    benchmark_max_iterations = value;
+	foreach (k : bench_fn_iters.key_iter()) bench_fn_iters[k] = value;
+}
+
+fn void set_benchmark_func_iterations(String func, uint value) @builtin
+{
+	assert(value > 0);
+	bench_fn_iters[func] = value;
+}
+
+
+Clock benchmark_clock @local;
+NanoDuration benchmark_nano_seconds @local;
+long cycle_start @local;
+long cycle_stop @local;
+DString benchmark_log @local;
+bool benchmark_warming @local;
+uint this_iteration @local;
+bool benchmark_stop @local;
+
+macro void @start_benchmark()
+{
+	benchmark_clock = clock::now();
+	cycle_start = $$sysclock();
+}
+
+macro void @end_benchmark()
+{
+	benchmark_nano_seconds = benchmark_clock.mark();
+	cycle_stop = $$sysclock();
+}
+
+macro void @kill_benchmark(String format, ...)
+{
+	@log_benchmark(format, $vasplat);
+	benchmark_stop = true;
+}
+
+macro void @log_benchmark(msg, args...) => @pool()
+{
+	if (benchmark_warming) return;
+
+	benchmark_log.appendf("%s [%d]:  ", $$FUNC, this_iteration);
+	benchmark_log.appendfn(msg, ...args);
+}
+
+fn bool run_benchmarks(BenchmarkUnit[] benchmarks)
+{
+	usz max_name;
+
+	foreach (&unit : benchmarks)
+	{
+		if (max_name < unit.name.len) max_name = unit.name.len;
+	}
+
+	usz len = max_name + 9;
+
+	DString name = dstring::temp_with_capacity(64);
+	name.append_repeat('-', len / 2);
+	name.append(" BENCHMARKS ");
+	name.append_repeat('-', len - len / 2);
+
+	io::printn(name);
+
+	name.clear();
+
+	foreach (unit : benchmarks)
+	{
+		defer name.clear();
+		name.appendf("Benchmarking %s ", unit.name);
+		name.append_repeat('.', max_name - unit.name.len + 2);
+		io::printf("%s ", name.str_view());
+
+		benchmark_warming = true;
+		for (uint i = 0; i < benchmark_warmup_iterations; i++)
+		{
+			unit.func() @inline;
+		}
+		benchmark_warming = false;
+
+		NanoDuration running_timer;
+		long total_clocks;
+
+		uint current_benchmark_iterations = bench_fn_iters[unit.name] ?? benchmark_max_iterations;
+		char[] perc_str = { [0..19] = ' ', [20] = 0 };
+		int perc = 0;
+		uint print_step = current_benchmark_iterations / 100;
+		if (print_step == 0) print_step = 1;
+
+		for (this_iteration = 0; this_iteration < current_benchmark_iterations; ++this_iteration, benchmark_nano_seconds = {})
+		{
+			if (this_iteration % print_step == 0)   // only print right about when the % will update
+			{
+				perc_str[0..(uint)math::floor((this_iteration / (float)current_benchmark_iterations) * 20)] = '#';
+				perc = (uint)math::ceil(100 * (this_iteration / (float)current_benchmark_iterations));
+
+				io::printf("\r%s [%s] %d / %d (%d%%)", name.str_view(), (ZString)perc_str, this_iteration, current_benchmark_iterations, perc);
+				io::stdout().flush()!!;
+			}
+
+			@start_benchmark();   // can be overridden by calls inside the unit's func
+
+			unit.func() @inline;
+			if (benchmark_stop) return false;
+
+			if (benchmark_nano_seconds == (NanoDuration){}) @end_benchmark();   // only mark when it wasn't already by the unit.func
+
+			total_clocks += cycle_stop - cycle_start;
+			running_timer += benchmark_nano_seconds;
+		}
+
+		float clock_cycles = (float)total_clocks / current_benchmark_iterations;
+		float measurement = (float)running_timer / current_benchmark_iterations;
+		String[] units = { "nanoseconds", "microseconds", "milliseconds", "seconds" };
+
+		float adjusted_measurement = measurement;
+		while (adjusted_measurement > 1_000) adjusted_measurement /= 1_000;
+		float adjusted_runtime_total = (float)running_timer;
+		while (adjusted_runtime_total > 1_000) adjusted_runtime_total /= 1_000;
+
+		io::printf("\r%s ", name.str_view());
+		io::printfn(
+			"[COMPLETE] %.2f %s, %.2f CPU clocks, %d iterations (runtime %.2f %s)",
+			adjusted_measurement,
+			units[math::min(3, (int)math::floor(math::log(measurement, 1_000)))],
+			clock_cycles,
+			current_benchmark_iterations,
+			adjusted_runtime_total,
+			units[math::min(3, (int)math::floor(math::log((float)running_timer, 1_000)))],
+		);
+	}
+
+	io::printfn("\n%d benchmark%s run.\n", benchmarks.len, benchmarks.len > 1 ? "s" : "");
+	return true;
+}
+
+fn bool default_benchmark_runner(String[] args) => @pool()
+{
+	benchmark_log.init(mem);
+	defer
+	{
+		if (benchmark_log.len()) io::printfn("\n---------- BENCHMARK LOG ----------\n%s\n", benchmark_log.str_view());
+		benchmark_log.free();
+	}
+
+	return run_benchmarks(benchmark_collection_create(tmem));
+}

lib/std/core/runtime_test.c3

@@ -0,0 +1,383 @@
+// Copyright (c) 2025 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::core::runtime;
+import std::core::test @public;
+import std::core::mem::allocator @public;
+import libc, std::time, std::io, std::sort, std::os;
+
+
+alias TestFn = fn void();
+
+TestContext* test_context @private;
+
+struct TestContext
+{
+	JmpBuf buf;
+	<* Allows filtering test cased or modules by substring, e.g. 'foo::', 'foo::test_add' *>
+	String test_filter;
+	<* Triggers debugger breakpoint when assert or test:: checks failed *>
+	bool breakpoint_on_assert;
+	<* Controls level of printed logs *>
+	LogPriority log_level;
+
+	// internal state
+	bool assert_print_backtrace;
+	bool has_ansi_codes;
+	bool is_in_panic;
+	bool is_quiet_mode;
+	bool is_no_capture;
+    bool sort;
+    bool check_leaks;
+	String current_test_name;
+	TestFn setup_fn;
+	TestFn teardown_fn;
+
+	char* error_buffer;
+	usz error_buffer_capacity;
+	File fake_stdout;
+	struct stored
+	{
+		File stdout;
+		File stderr;
+		Allocator allocator;
+	}
+}
+
+struct TestUnit
+{
+	String name;
+	TestFn func;
+}
+
+fn TestUnit[] test_collection_create(Allocator allocator)
+{
+	TestFn[] fns = $$TEST_FNS;
+	String[] names = $$TEST_NAMES;
+	TestUnit[] tests = allocator::alloc_array(allocator, TestUnit, names.len);
+	foreach (i, test : fns)
+	{
+		tests[i] = { names[i], fns[i] };
+	}
+	return tests;
+}
+
+// Sort the tests by their name in ascending order.
+fn int cmp_test_unit(TestUnit a, TestUnit b)
+{
+	usz an = a.name.len;
+	usz bn = b.name.len;
+	if (an > bn) @swap(a, b);
+	foreach (i, ac : a.name)
+	{
+		char bc = b.name[i];
+		if (ac != bc) return an > bn ? bc - ac : ac - bc;
+	}
+	return (int)(an - bn);
+}
+
+fn bool terminal_has_ansi_codes() @local => @pool()
+{
+
+	if (try v = env::tget_var("TERM"))
+	{
+		if (v.contains("xterm") || v.contains("vt100") || v.contains("screen")) return true;
+	}
+	$if env::WIN32 || env::NO_LIBC:
+		return false;
+	$else
+		return io::stdout().isatty();
+	$endif
+}
+
+fn void sig_bus_error(CInt i, void*, void* context) @local @if(env::POSIX)
+{
+	panic_test("Bus error", "Unknown", "Unknown", 1, posix::stack_instruction(context));
+}
+
+fn void sig_segmentation_fault(CInt i, void*, void* context) @local @if(env::POSIX)
+{
+	panic_test("Segmentation fault", "Unknown", "Unknown", 1, posix::stack_instruction(context));
+}
+
+fn void test_panic(String message, String file, String function, uint line) @local
+{
+	panic_test(message, file, function, line);
+}
+fn void panic_test(String message, String file, String function, uint line, void* extra_trace = null) @local
+{
+	if (test_context.is_in_panic) return;
+	test_context.is_in_panic = true;
+
+	unmute_output(true);
+	(void)io::stdout().flush();
+	if (test_context.assert_print_backtrace)
+	{
+		$if env::NATIVE_STACKTRACE:
+    		builtin::print_backtrace(message, extra_trace ? 3 : 0, extra_trace);
+		$endif
+	}
+	io::printf("\nTest failed ^^^ ( %s:%s ) %s\n",  file, line, message);
+	test_context.assert_print_backtrace = true;
+
+	if (test_context.breakpoint_on_assert)
+	{
+		breakpoint();
+	}
+
+	if (test_context.teardown_fn)
+	{
+		test_context.teardown_fn();
+	}
+
+	test_context.is_in_panic = false;
+	allocator::thread_allocator = test_context.stored.allocator;
+	libc::longjmp(&test_context.buf, 1);
+}
+
+fn void mute_output() @local
+{
+	if (test_context.is_no_capture || !test_context.fake_stdout.file) return;
+	File* stdout = io::stdout();
+    File* stderr = io::stderr();
+	*stderr = test_context.fake_stdout;
+	*stdout = test_context.fake_stdout;
+	(void)test_context.fake_stdout.set_cursor(0)!!;
+}
+
+fn void unmute_output(bool has_error) @local
+{
+	if (test_context.is_no_capture || !test_context.fake_stdout.file) return;
+
+	File* stdout = io::stdout();
+	File* stderr = io::stderr();
+
+	*stderr = test_context.stored.stderr;
+	*stdout = test_context.stored.stdout;
+
+	ulong log_size = test_context.fake_stdout.cursor()!!;
+	if (has_error)
+	{
+		io::printn(test_context.has_ansi_codes ? "[\e[0;31mFAIL\e[0m]" : "[FAIL]");
+	}
+
+	if (has_error && log_size > 0)
+	{
+		test_context.fake_stdout.write_byte('\n')!!;
+		test_context.fake_stdout.write_byte('\0')!!;
+		test_context.fake_stdout.set_cursor(0)!!;
+
+		io::printfn("\n========== TEST LOG ============");
+		io::printfn("%s\n", test_context.current_test_name);
+		while (try c = test_context.fake_stdout.read_byte())
+		{
+			if (@unlikely(c == '\0'))
+			{
+				// ignore junk from previous tests
+				break;
+			}
+			libc::putchar(c);
+		}
+		io::printf("========== TEST END ============");
+	}
+	(void)stdout.flush();
+}
+
+
+fn bool run_tests(String[] args, TestUnit[] tests) @private
+{
+	usz max_name;
+	if (!tests.len)
+	{
+		io::printn("There are no test units to run.");
+		return true;   // no tests == technically a pass
+	}
+$if !env::NO_LIBC && env::POSIX:
+	posix::install_signal_handler(libc::SIGBUS, &sig_bus_error);
+	posix::install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);
+$endif
+	foreach (&unit : tests)
+	{
+		if (max_name < unit.name.len) max_name = unit.name.len;
+	}
+	TestContext context =
+	{
+		.assert_print_backtrace = true,
+		.breakpoint_on_assert = false,
+        .sort = true,
+        .check_leaks = true,
+		.log_level = LogPriority.ERROR,
+		.test_filter = "",
+		.has_ansi_codes = terminal_has_ansi_codes(),
+		.stored.allocator = mem,
+		.stored.stderr = *io::stderr(),
+		.stored.stdout = *io::stdout(),
+	};
+	for (int i = 1; i < args.len; i++)
+	{
+		switch (args[i])
+		{
+			case "--test-breakpoint":
+				context.breakpoint_on_assert = true;
+			case "--test-nosort":
+				context.sort = false;
+			case "--test-noleak":
+				context.check_leaks = false;
+			case "--test-nocapture":
+			case "--test-show-output":
+				context.is_no_capture = true;
+			case "--noansi":
+				context.has_ansi_codes = false;
+			case "--useansi":
+				context.has_ansi_codes = true;
+			case "--test-quiet":
+				context.is_quiet_mode = true;
+			case "--test-filter":
+				if (i == args.len - 1)
+				{
+					io::printn("Invalid arguments to test runner.");
+					return false;
+				}
+				context.test_filter = args[i + 1];
+				i++;
+			case "--test-log-level":
+				if (i == args.len - 1)
+				{
+					io::printn("Missing log level for argument `--test-log-level`.");
+					return false;
+				}
+				@pool()
+				{
+					String upper = args[i + 1].to_upper_copy(tmem);
+					if (catch @try(context.log_level, enum_by_name(LogPriority, upper)))
+					{
+						io::printn("Log level given to `--test-log-level` is not one of verbose, debug, info, warn, error or critical.");
+						return false;
+					}
+				};
+				i++;
+			default:
+				io::printfn("Unknown argument: %s", args[i]);
+		}
+	}
+	test_context = &context;
+	log::set_priority_all(test_context.log_level);
+
+	if (context.sort)
+	{
+		quicksort(tests, &cmp_test_unit);
+	}
+
+	// Buffer for hijacking the output
+	$if (!env::NO_LIBC):
+		context.fake_stdout.file = libc::tmpfile();
+	$endif
+	if (context.fake_stdout.file == null)
+	{
+		io::print("Failed to hijack stdout, tests will print everything");
+	}
+
+	PanicFn old_panic = builtin::panic;
+	defer builtin::panic = old_panic;
+	builtin::panic = &test_panic;
+	int tests_passed = 0;
+	int tests_skipped = 0;
+	int test_count = tests.len;
+	DString name = dstring::temp_with_capacity(64);
+	usz len = max_name + 9;
+	name.append_repeat('-', len / 2);
+	name.append(" TESTS ");
+	name.append_repeat('-', len - len / 2);
+	if (!context.is_quiet_mode) io::printn(name);
+	name.clear();
+	PoolState temp_state = mem::temp_push();
+	defer mem::temp_pop(temp_state);
+	foreach(unit : tests)
+	{
+		mem::temp_pop(temp_state);
+		if (context.test_filter && !unit.name.contains(context.test_filter))
+		{
+			tests_skipped++;
+			continue;
+		}
+		context.setup_fn = null;
+		context.teardown_fn = null;
+		context.current_test_name = unit.name;
+
+		defer name.clear();
+		name.appendf("Testing %s ", unit.name);
+		name.append_repeat('.', max_name - unit.name.len + 2);
+		if (context.is_quiet_mode)
+		{
+			io::print(".");
+		}
+		else
+		{
+			io::printf("%s ", name.str_view());
+		}
+		(void)io::stdout().flush();
+		TrackingAllocator mem;
+
+		mem.init(context.stored.allocator);
+		if (libc::setjmp(&context.buf) == 0)
+		{
+			mute_output();
+			mem.clear();
+			if (context.check_leaks) allocator::thread_allocator = &mem;
+			@pool()
+            {
+                unit.func();
+            };
+			// track cleanup that may take place in teardown_fn
+			if (context.teardown_fn)
+			{
+				context.teardown_fn();
+			}
+			if (context.check_leaks) allocator::thread_allocator = context.stored.allocator;
+
+			unmute_output(false); // all good, discard output
+			if (mem.has_leaks())
+			{
+				if (context.is_quiet_mode) io::printf("\n%s ", context.current_test_name);
+				io::print(context.has_ansi_codes ? "[\e[0;31mFAIL\e[0m]" : "[FAIL]");
+				io::printn(" LEAKS DETECTED!");
+				mem.print_report();
+			}
+			else
+			{
+				if (!context.is_quiet_mode)
+				{
+					io::printfn(context.has_ansi_codes ? "[\e[0;32mPASS\e[0m]" : "[PASS]");
+				}
+				tests_passed++;
+			}
+		}
+		mem.free();
+	}
+	io::printfn("\n%d test%s run.\n", test_count-tests_skipped, test_count != 1 ? "s" : "");
+
+	int n_failed = test_count - tests_passed - tests_skipped;
+	io::printf("Test Result: %s%s%s: ",
+				context.has_ansi_codes ? (n_failed ? "\e[0;31m" : "\e[0;32m") : "",
+				n_failed ? "FAILED" : "PASSED",
+				context.has_ansi_codes ? "\e[0m" : "",
+				);
+
+	io::printfn("%d passed, %d failed, %d skipped.",
+				tests_passed,
+				n_failed,
+				tests_skipped);
+
+	// cleanup fake_stdout file
+	if (context.fake_stdout.file) libc::fclose(context.fake_stdout.file);
+	context.fake_stdout.file = null;
+
+	return n_failed == 0;
+}
+
+fn bool default_test_runner(String[] args) => @pool()
+{
+	assert(test_context == null, "test suite is already running");
+	return run_tests(args, test_collection_create(tmem));
+}
+

lib/std/core/sanitizer/asan.c3

@@ -12,7 +12,7 @@
 
 module std::core::sanitizer::asan;
 
-def ErrorCallback = fn void (ZString);
+alias ErrorCallback = fn void (ZString);
 
 <*
  Marks a memory region ([addr, addr+size)) as unaddressable.
@@ -26,14 +26,14 @@ def ErrorCallback = fn void (ZString);
  NOTE This function is not thread-safe because no two threads can poison or
  unpoison memory in the same memory region simultaneously.
 
- @param addr "Start of memory region."
- @param size "Size of memory region."
+ @param addr : "Start of memory region."
+ @param size : "Size of memory region."
 *>
-macro poison_memory_region(void* addr, usz size)
+macro void poison_memory_region(void* addr, usz size)
 {
-	$if env::ADDRESS_SANITIZER: 
+	$if env::ADDRESS_SANITIZER:
 		__asan_poison_memory_region(addr, size);
-	$endif 
+	$endif
 }
 
 <*
@@ -47,20 +47,20 @@ macro poison_memory_region(void* addr, usz size)
  NOTE This function is not thread-safe because no two threads can
  poison or unpoison memory in the same memory region simultaneously.
 
- @param addr "Start of memory region."
- @param size "Size of memory region."
+ @param addr : "Start of memory region."
+ @param size : "Size of memory region."
 *>
-macro unpoison_memory_region(void* addr, usz size)
+macro void unpoison_memory_region(void* addr, usz size)
 {
-	$if env::ADDRESS_SANITIZER: 
+	$if env::ADDRESS_SANITIZER:
 		__asan_unpoison_memory_region(addr, size);
-	$endif 
+	$endif
 }
 
 <*
  Checks if an address is poisoned.
  @return "True if 'addr' is poisoned (that is, 1-byte read/write access to this address would result in an error report from ASan). Otherwise returns false."
- @param addr "Address to check."
+ @param addr : "Address to check."
 *>
 macro bool address_is_poisoned(void* addr)
 {
@@ -77,14 +77,14 @@ macro bool address_is_poisoned(void* addr)
  If at least one byte in [beg, beg+size) is poisoned, returns the
  address of the first such byte. Otherwise returns 0.
 
- @param beg "Start of memory region."
- @param size "Start of memory region."
+ @param beg : "Start of memory region."
+ @param size : "Start of memory region."
  @return "Address of first poisoned byte."
 *>
 macro void* region_is_poisoned(void* beg, usz size)
 {
 	$if env::ADDRESS_SANITIZER:
-		return __asan_region_is_poisoned(addr);
+		return __asan_region_is_poisoned(beg, size);
 	$else
 		return null;
 	$endif

lib/std/core/sanitizer/tsan.c3

@@ -1,17 +1,17 @@
 module std::core::sanitizer::tsan;
 
-distinct MutexFlags = inline CUInt;
+typedef MutexFlags = inline CUInt;
 
-const MutexFlags MUTEX_LINKER_INIT      = 1 << 0;
-const MutexFlags MUTEX_WRITE_REENTRANT  = 1 << 1;
-const MutexFlags MUTEX_READ_REENTRANT   = 1 << 2;
-const MutexFlags MUTEX_NOT_STATIC       = 1 << 8;
-const MutexFlags MUTEX_READ_LOCK        = 1 << 3;
-const MutexFlags MUTEX_TRY_LOCK         = 1 << 4;
-const MutexFlags MUTEX_TRY_LOCK_FAILED  = 1 << 5;
-const MutexFlags MUTEX_RECURSIVE_LOCK   = 1 << 6;
-const MutexFlags MUTEX_RECURSIVE_UNLOCK = 1 << 7;
-const MutexFlags MUTEX_TRY_READ_LOCK = MUTEX_READ_LOCK | MUTEX_TRY_LOCK;
+const MutexFlags MUTEX_LINKER_INIT          = (MutexFlags)1 << 0;
+const MutexFlags MUTEX_WRITE_REENTRANT      = (MutexFlags)1 << 1;
+const MutexFlags MUTEX_READ_REENTRANT       = (MutexFlags)1 << 2;
+const MutexFlags MUTEX_NOT_STATIC           = (MutexFlags)1 << 8;
+const MutexFlags MUTEX_READ_LOCK            = (MutexFlags)1 << 3;
+const MutexFlags MUTEX_TRY_LOCK             = (MutexFlags)1 << 4;
+const MutexFlags MUTEX_TRY_LOCK_FAILED      = (MutexFlags)1 << 5;
+const MutexFlags MUTEX_RECURSIVE_LOCK       = (MutexFlags)1 << 6;
+const MutexFlags MUTEX_RECURSIVE_UNLOCK     = (MutexFlags)1 << 7;
+const MutexFlags MUTEX_TRY_READ_LOCK        = MUTEX_READ_LOCK | MUTEX_TRY_LOCK;
 const MutexFlags MUTEX_TRY_READ_LOCK_FAILED = MUTEX_TRY_READ_LOCK | MUTEX_TRY_LOCK_FAILED;
 
 macro void mutex_create(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_create(addr, flags); $endif }

lib/std/core/slice2d.c3

@@ -0,0 +1,169 @@
+module std::core::array;
+
+<*
+ A slice2d allows slicing an array like int[10][10] into an arbitrary "int[][]"-like counterpart
+ Typically you'd use array::slice2d(...) to create one.
+*>
+struct Slice2d <Type>
+{
+	Type* ptr;
+	usz inner_len;
+	usz ystart;
+	usz ylen;
+	usz xstart;
+	usz xlen;
+}
+
+<*
+ @return `The length of the "outer" slice`
+*>
+fn usz Slice2d.len(&self) @operator(len)
+{
+	return self.ylen;
+}
+
+<*
+ @return `The total number of elements.`
+*>
+fn usz Slice2d.count(&self)
+{
+	return self.ylen * self.xlen;
+}
+
+<*
+ Step through each element of the slice.
+*>
+macro void Slice2d.@each(&self; @body(usz[<2>], Type))
+{
+	foreach (y, line : *self)
+	{
+		foreach (x, val : line)
+		{
+			@body({ x, y }, val);
+		}
+	}
+}
+
+<*
+ Step through each element of the slice *by reference*
+*>
+macro void Slice2d.@each_ref(&self; @body(usz[<2>], Type*))
+{
+	foreach (y, line : *self)
+	{
+		foreach (x, &val : line)
+		{
+			@body({ x, y }, val);
+		}
+	}
+}
+
+<*
+ Return a row as a slice.
+
+ @param idy : "The row to return"
+ @return "The slice for the particular row"
+ @require idy >= 0 && idy < self.ylen
+*>
+macro Type[] Slice2d.get_row(self, usz idy) @operator([])
+{
+	return (self.ptr + self.inner_len * (idy + self.ystart))[self.xstart:self.xlen];
+}
+
+<*
+ Get the value at a particular x/y position in the slice.
+
+ @param coord : "The xy coordinate"
+ @return "The value at that coordinate"
+ @require coord.y >= 0 && coord.y < self.ylen : "y value out of range"
+ @require coord.x >= 0 && coord.x < self.xlen : "x value out of range"
+*>
+macro Type Slice2d.get_coord(self, usz[<2>] coord)
+{
+	return *self.get_coord_ref(coord);
+}
+
+<*
+ Get a pointer to the value at a particular x/y position in the slice.
+
+ @param coord : "The xy coordinate"
+ @return "A pointer to the value at that coordinate"
+ @require coord.y >= 0 && coord.y < self.ylen : "y value out of range"
+ @require coord.x >= 0 && coord.x < self.xlen : "x value out of range"
+*>
+macro Type* Slice2d.get_coord_ref(self, usz[<2>] coord)
+{
+	return self.get_xy_ref(coord.x, coord.y);
+}
+
+<*
+ Get the value at a particular x/y position in the slice.
+
+ @param x : "The x coordinate"
+ @param y : "The x coordinate"
+ @return "The value at that coordinate"
+ @require y >= 0 && y < self.ylen : "y value out of range"
+ @require x >= 0 && x < self.xlen : "x value out of range"
+*>
+macro Type Slice2d.get_xy(self, x, y)
+{
+	return *self.get_xy_ref(x, y);
+}
+
+<*
+ Get the value at a particular x/y position in the slice by reference.
+
+ @param x : "The x coordinate"
+ @param y : "The y coordinate"
+ @return "A pointer to the value at that coordinate"
+ @require y >= 0 && y < self.ylen : "y value out of range"
+ @require x >= 0 && x < self.xlen : "x value out of range"
+*>
+macro Type* Slice2d.get_xy_ref(self, x, y)
+{
+	return self.ptr + self.inner_len * (y + self.ystart) + self.xstart + x;
+}
+
+<*
+ Set the ´value at a particular x/y position in the slice.
+
+ @param coord : "The xy coordinate"
+ @param value : "The new value"
+ @require coord.y >= 0 && coord.y < self.ylen : "y value out of range"
+ @require coord.x >= 0 && coord.x < self.xlen : "x value out of range"
+*>
+macro void Slice2d.set_coord(self, usz[<2>] coord, Type value)
+{
+	*self.get_coord_ref(coord) = value;
+}
+
+<*
+ Set the value at a particular x/y position in the slice.
+
+ @param x : "The x coordinate"
+ @param y : "The y coordinate"
+ @param value : "The new value"
+ @require y >= 0 && y < self.ylen : "y value out of range"
+ @require x >= 0 && x < self.xlen : "x value out of range"
+*>
+macro void Slice2d.set_xy(self, x, y, Type value)
+{
+	*self.get_xy_ref(x, y) = value;
+}
+
+<*
+ Reslice a slice2d returning a new slice.
+
+ @param x : "The starting x"
+ @param xlen : "The length along x"
+ @param y : "The starting y"
+ @param ylen : "The length along y"
+ @require y >= 0 && y < self.ylen
+ @require x >= 0 && x < self.xlen
+*>
+fn Slice2d Slice2d.slice(&self, isz x = 0, isz xlen = 0, isz y = 0, isz ylen = 0)
+{
+	if (xlen < 1) xlen = self.xlen + xlen;
+	if (ylen < 1) ylen = self.ylen + ylen;
+	return { self.ptr, self.inner_len, y + self.ystart, ylen, x + self.xstart, xlen };
+}

lib/std/core/string_escape.c3

@@ -0,0 +1,261 @@
+// Copyright (c) 2024-2025 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+
+<*
+ This module provides functionality for escaping and unescaping strings
+ with standard C-style escape sequences, similar to what's used in JSON
+ and other string literals.
+*>
+module std::core::string;
+import std::io;
+
+faultdef INVALID_ESCAPE_SEQUENCE, UNTERMINATED_STRING, INVALID_HEX_ESCAPE, INVALID_UNICODE_ESCAPE;
+
+<*
+ Escape a string by adding quotes and converting special characters to escape sequences.
+
+ @param allocator : "The allocator to use for the result"
+ @param s : "The string to escape"
+ @param strip_quotes : "Do not include beginning and end quotes, defaults to false"
+ @return "The escaped string with surrounding quotes, can safely be cast to ZString"
+*>
+fn String String.escape(String s, Allocator allocator, bool strip_quotes = true)
+{
+	// Conservative allocation: most strings need minimal escaping
+	usz initial_capacity = s.len + s.len / 5 + 2; // ~1.2x + quotes
+
+	if (allocator == tmem)
+	{
+		DString result = dstring::new_with_capacity(tmem, initial_capacity);
+		escape_dstring(s, result, strip_quotes);
+		return result.str_view();
+	}
+	@pool()
+	{
+		DString result = dstring::temp_with_capacity(initial_capacity);
+		escape_dstring(s, result, strip_quotes);
+		return result.copy_str(allocator);
+	};
+}
+
+fn void escape_dstring(String s, DString result, bool strip_quotes) @private
+{
+	if (!strip_quotes) result.append_char('"');
+
+	foreach (char c : s)
+	{
+		switch (c)
+		{
+			case '"':  result.append(`\"`);
+			case '\\': result.append(`\\`);
+			case '\b': result.append(`\b`);
+			case '\f': result.append(`\f`);
+			case '\n': result.append(`\n`);
+			case '\r': result.append(`\r`);
+			case '\t': result.append(`\t`);
+			case '\v': result.append(`\v`);
+			case '\0': result.append(`\0`);
+			default:
+				if (c >= 32 && c <= 126)
+				{
+					// Printable ASCII
+					result.append_char(c);
+				}
+				else
+				{
+					// Non-printable, use hex escape
+					result.appendf("\\x%02x", (uint)c);
+				}
+		}
+	}
+
+	if (!strip_quotes) result.append_char('"');
+
+}
+<*
+ Escape a string using the temp allocator.
+
+ @param s : "The string to escape"
+ @param strip_quotes : "Do not include beginning and end quotes, defaults to false"
+ @return "The escaped string with surrounding quotes"
+*>
+fn String String.tescape(String s, bool strip_quotes = false) => s.escape(tmem, strip_quotes);
+
+<*
+ Calculate the length needed for an escaped string (including quotes).
+
+ @param s : "The string to check"
+ @return "The length needed for the escaped version"
+*>
+fn usz escape_len(String s)
+{
+	usz len = 2; // For quotes
+	foreach (char c : s)
+	{
+		switch (c)
+		{
+			case '"':
+			case '\\':
+			case '\b':
+			case '\f':
+			case '\n':
+			case '\r':
+			case '\t':
+			case '\v':
+			case '\0':
+				len += 2; // \X
+			default:
+				if (c >= 32 && c <= 126)
+				{
+					len += 1;
+				}
+				else
+				{
+					len += 4; // \xHH
+				}
+		}
+	}
+	return len;
+}
+
+<*
+ Unescape a quoted string by parsing escape sequences.
+
+ @param allocator : "The allocator to use for the result"
+ @param s : "The quoted string to unescape"
+ @param allow_unquoted : "Set to true to unescape strings not surrounded by quotes, defaults to false"
+ @param lenient : "Be lenient with escapes, resolving unknown sequences to the escape character, defaults to false"
+ @return "The unescaped string without quotes, safe to convert to ZString"
+ @return? UNTERMINATED_STRING, INVALID_ESCAPE_SEQUENCE, INVALID_HEX_ESCAPE, INVALID_UNICODE_ESCAPE
+*>
+fn String? String.unescape(String s, Allocator allocator, bool allow_unquoted = false, bool lenient = false)
+{
+	if (s.len >= 2 && s[0] == '"' && s[^1] == '"')
+	{
+		// Remove quotes.
+		s = s[1:^2];
+	}
+	else if (!allow_unquoted) return UNTERMINATED_STRING~;
+
+	// Handle empty string case
+	if (!s.len)
+	{
+		return "".copy(allocator);
+	}
+	if (allocator == tmem)
+	{
+		DString result = dstring::new_with_capacity(tmem, s.len);
+		unescape_dstring(s, result, allow_unquoted, lenient)!;
+		return result.str_view();
+	}
+	@pool()
+	{
+		DString result = dstring::temp_with_capacity(s.len);
+		unescape_dstring(s, result, allow_unquoted, lenient)!;
+		return result.copy_str(allocator);
+	};
+}
+
+fn void? unescape_dstring(String s, DString result, bool allow_unquoted = false, bool lenient = false) @private
+{
+	usz len = s.len;
+	for (usz i = 0; i < len; i++)
+	{
+		char c = s[i];
+		if (c != '\\')
+		{
+			result.append_char(c);
+			continue;
+		}
+
+		// Handle escape sequence
+		if (i + 1 >= len) return INVALID_ESCAPE_SEQUENCE~;
+
+		char escape_char = s[++i];
+		switch (escape_char)
+		{
+			case '"':  result.append_char('"');
+			case '\\': result.append_char('\\');
+			case '/':  result.append_char('/');
+			case 'b':  result.append_char('\b');
+			case 'f':  result.append_char('\f');
+			case 'n':  result.append_char('\n');
+			case 'r':  result.append_char('\r');
+			case 't':  result.append_char('\t');
+			case 'v':  result.append_char('\v');
+			case '0':  result.append_char('\0');
+			case 'x':
+				// Hex escape \xHH
+				if (i + 2 >= len) return INVALID_HEX_ESCAPE~;
+				char h1 = s[++i];
+				char h2 = s[++i];
+				if (!h1.is_xdigit() || !h2.is_xdigit()) return INVALID_HEX_ESCAPE~;
+				uint val = h1 > '9' ? (h1 | 32) - 'a' + 10 : h1 - '0';
+				val = val << 4;
+				val += h2 > '9' ? (h2 | 32) - 'a' + 10 : h2 - '0';
+				result.append_char((char)val);
+			case 'u':
+				// Unicode escape \uHHHH
+				if (i + 4 >= len) return INVALID_UNICODE_ESCAPE~;
+				uint val;
+				for (int j = 0; j < 4; j++)
+				{
+					char hex_char = s[++i];
+					if (!hex_char.is_xdigit()) return INVALID_UNICODE_ESCAPE~;
+					val = val << 4 + (hex_char > '9' ? (hex_char | 32) - 'a' + 10 : hex_char - '0');
+				}
+				result.append_char32(val);
+			case 'U':
+				// Unicode escape \UHHHHHHHH
+				if (i + 8 >= len) return INVALID_UNICODE_ESCAPE~;
+				uint val;
+				for (int j = 0; j < 8; j++)
+				{
+					char hex_char = s[++i];
+					if (!hex_char.is_xdigit()) return INVALID_UNICODE_ESCAPE~;
+					val = val << 4 + (hex_char > '9' ? (hex_char | 32) - 'a' + 10 : hex_char - '0');
+				}
+				result.append_char32(val);
+			default:
+				if (!lenient) return INVALID_ESCAPE_SEQUENCE~;
+				result.append_char(escape_char);
+		}
+	}
+}
+
+<*
+ Unescape a quoted string using the temp allocator.
+
+ @param s : "The quoted string to unescape"
+ @param allow_unquoted : "Set to true to unescape strings not surrounded by quotes, defaults to false"
+ @param lenient : "Be lenient with escapes, resolving unknown sequences to the escape character, defaults to false"
+ @return "The unescaped string without quotes"
+ @return? UNTERMINATED_STRING, INVALID_ESCAPE_SEQUENCE, INVALID_HEX_ESCAPE, INVALID_UNICODE_ESCAPE
+*>
+fn String? String.tunescape(String s, bool allow_unquoted = false, bool lenient = false) => s.unescape(tmem, allow_unquoted, lenient);
+
+<*
+ Check if a character needs to be escaped in a string literal.
+
+ @param c : "The character to check"
+ @return "True if the character needs escaping"
+*>
+fn bool needs_escape(char c)
+{
+	switch (c)
+	{
+		case '"':
+		case '\\':
+		case '\b':
+		case '\f':
+		case '\n':
+		case '\r':
+		case '\t':
+		case '\v':
+		case '\0':
+			return true;
+		default:
+			return c < 32 || c > 126;
+	}
+}

lib/std/core/string_iterator.c3

@@ -11,22 +11,22 @@ fn void StringIterator.reset(&self)
 	self.current = 0;
 }
 
-fn Char32! StringIterator.next(&self)
+fn Char32? StringIterator.next(&self)
 {
     usz len = self.utf8.len;
     usz current = self.current;
-    if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    if (current >= len) return NO_MORE_ELEMENT~;
     usz read = (len - current < 4 ? len - current : 4);
     Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
     self.current += read;
     return res;
 }
 
-fn Char32! StringIterator.peek(&self)
+fn Char32? StringIterator.peek(&self)
 {
     usz len = self.utf8.len;
     usz current = self.current;
-    if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    if (current >= len) return NO_MORE_ELEMENT~;
     usz read = (len - current < 4 ? len - current : 4);
     Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
     return res;
@@ -37,13 +37,13 @@ fn bool StringIterator.has_next(&self)
     return self.current < self.utf8.len;
 }
 
-fn Char32! StringIterator.get(&self)
+fn Char32? StringIterator.get(&self)
 {
     usz len = self.utf8.len;
     usz current = self.current;
     usz read = (len - current < 4 ? len - current : 4);
     usz index = current > read ? current - read : 0;
-    if (index >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    if (index >= len) return NO_MORE_ELEMENT~;
     Char32 res = conv::utf8_to_char32(&self.utf8[index], &read)!;
     return res;
 }