Add numeric library

This is because some compiler stuff and diagnostics tools rely on those
symboles being what they are.

.bazelrc

@@ -1,6 +1,7 @@
 startup --windows_enable_symlinks
 build:windows --enable_runfiles=true
 
+build --enable_platform_specific_config
 build --build_python_zip=false
 
 build:windows  --extra_execution_platforms=//:x64_windows-clang-cl
@@ -24,14 +25,15 @@ build --cxxopt=-Wno-extra-semi
 build --cxxopt=-Wno-global-constructors
 build --cxxopt=-Wno-unsafe-buffer-usage
 build --cxxopt=-Wno-covered-switch-default
+build --cxxopt=-Wno-unused-command-line-argument
 
 build:windows_san --config=windows
 build:windows_san --copt=-fno-sanitize-ignorelist
 build:windows_san --copt=-fsanitize=address
 build:windows_san --copt=-fsanitize=undefined
 build:windows_san --copt=-fno-sanitize-recover=all
-build:windows_san --linkopt=clang_rt.asan-x86_64.lib
+build:windows_san --linkopt=clang_rt.asan_dynamic-x86_64.lib
-build:windows_san --copt=/MT
+build:windows_san --linkopt=clang_rt.asan_dynamic_runtime_thunk-x86_64.lib
 
 build:linux_san --config=linux
 build:linux_san --copt=-fsanitize=address

.clang-tidy

@@ -1,34 +1,23 @@
 Checks:
-  - "hicpp-*"
+  - "*"
-  - "cppcoreguidelines-*"
+  - "-llvm*"
-  - "misc-*"
+  - "-altera*"
-  - "clang-analyzer-*"
+  - "-fuchsia*"
-  - "-misc-include-cleaner"
+  - "-*-use-trailing-return-type"
-  - "performance-*"
+  - "-readability-identifier-length"
-  - "readability-*"
+  - "-cppcoreguidelines-macro-usage"
-  - "-*-named-parameter"
-  - "-*-avoid-do-while"
-  - "-*-magic-numbers"
-  - "-*-identifier-length"
-  - "-*-union-access"
-  - "-*-vararg"
-  - "-*-macro-usage"
-  - "-*-non-private-member-variables-in-classes"
-  - "-*-avoid-non-const-global-variables"
-  - "-*-missing-std-forward"
-  - "-*-owning-memory"
-  - "-*-no-malloc"
   - "-*-avoid-c-arrays"
+  - "-*-non-private-member-variables-in-classes"
   - "-*-use-anonymous-namespace"
-  - "-*-reinterpret-cast"
+  - "-cert-err58-cpp"
-  - "-*-noexcept-swap"
+  - "-*noexcept*"
-  - "-*-noexcept-move"
+  - "-*-magic-numbers"
-  - "-*-noexcept-move-constructor"
+  - "-*-named-parameter"
-  - "-*-noexcept-move-operations"
+  - "-misc-include-cleaner"
-  - "-*-bounds-array-to-pointer-decay"
+  - "-google-runtime-int"
-  - "-*-no-array-decay"
+  - "-bugprone-easily-swappable-parameters"
   - "-*-signed-bitwise"
-  - "-readability-use-anyofallof"
+  - "-*-avoid-do-while"
-  - "-readability-function-cognitive-complexity"
+  - "-cppcoreguidelines-pro-type-union-access"
-  - "-readability-math-missing-parentheses"
+  - "-*-copy-assignment-signature"
-  - "-*-rvalue-reference-param-not-moved"
+  - "-*-unconventional-assign-operator"

.clangd

@@ -0,0 +1,7 @@
+---
+CompilerFlags:
+  Add:
+    - "-Wall"
+Diagnostics:
+  ClangTidy:
+    FastCheckFilter: None

asl/base/BUILD.bazel

@@ -11,12 +11,14 @@ cc_library(
     hdrs = [
         "annotations.hpp",
         "assert.hpp",
+        "bit.hpp",
         "config.hpp",
         "defer.hpp",
         "float.hpp",
         "functional.hpp",
         "integers.hpp",
         "meta.hpp",
+        "numeric.hpp",
         "utility.hpp",
     ],
     srcs = [
@@ -37,10 +39,12 @@ cc_library(
         "//asl/types:box",
     ],
 ) for name in [
+    "bit",
     "defer",
     "float",
     "functional",
     "integers",
     "meta",
+    "numeric",
     "utility",
 ]]

asl/base/assert.cpp

@@ -4,7 +4,12 @@
 
 #include "asl/base/assert.hpp"
 
+#include "asl/base/meta.hpp"
+
+// NOLINTNEXTLINE(*-non-const-global-variables)
 static asl::AssertFailureHandler* s_handler = nullptr;
+
+// NOLINTNEXTLINE(*-non-const-global-variables)
 static void* s_user = nullptr;
 
 void asl::set_assert_failure_handler(AssertFailureHandler handler, void* user)

asl/base/bit.hpp

@@ -0,0 +1,166 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+#include "asl/base/integers.hpp"
+#include "asl/base/meta.hpp"
+
+namespace asl
+{
+
+constexpr bool has_single_bit(is_unsigned_integer auto x)
+{
+    return x != 0 && ((x - 1) & x) == 0;
+}
+
+constexpr int popcount(uint8_t v)
+{
+    v = v - ((v >> 1) & 0x55);
+    v = (v & 0x33) + ((v >> 2) & 0x33);
+    return (v + (v >> 4)) & 0x0F;
+}
+
+constexpr int popcount(uint16_t v)
+{
+    v = v - ((v >> 1) & 0x5555);
+    v = (v & 0x3333) + ((v >> 2) & 0x3333);
+    return static_cast<uint16_t>((v + (v >> 4) & 0x0F0F) * uint16_t{0x0101}) >> 8;
+}
+
+constexpr int popcount(uint32_t v)
+{
+    v = v - ((v >> 1) & 0x5555'5555);
+    v = (v & 0x3333'3333) + ((v >> 2) & 0x3333'3333);
+    return static_cast<int>(((v + (v >> 4) & 0x0F0F'0F0F) * 0x0101'0101) >> 24);
+}
+
+constexpr int popcount(uint64_t v)
+{
+    v = v - ((v >> 1) & 0x5555'5555'5555'5555);
+    v = (v & 0x3333'3333'3333'3333) + ((v >> 2) & 0x3333'3333'3333'3333);
+    return static_cast<int>(((v + (v >> 4) & 0x0F0F'0F0F'0F0F'0F0F) * 0x0101'0101'0101'0101) >> 56);
+}
+
+constexpr uint8_t propagate_right_one(uint8_t v)
+{
+    v = v | (v >> 1);
+    v = v | (v >> 2);
+    v = v | (v >> 4);
+    return v;
+}
+
+constexpr uint16_t propagate_right_one(uint16_t v)
+{
+    v = v | (v >> 1);
+    v = v | (v >> 2);
+    v = v | (v >> 4);
+    v = v | (v >> 8);
+    return v;
+}
+
+constexpr uint32_t propagate_right_one(uint32_t v)
+{
+    v = v | (v >> 1);
+    v = v | (v >> 2);
+    v = v | (v >> 4);
+    v = v | (v >> 8);
+    v = v | (v >> 16);
+    return v;
+}
+
+constexpr uint64_t propagate_right_one(uint64_t v)
+{
+    v = v | (v >> 1);
+    v = v | (v >> 2);
+    v = v | (v >> 4);
+    v = v | (v >> 8);
+    v = v | (v >> 16);
+    v = v | (v >> 32);
+    return v;
+}
+
+constexpr int countr_zero(is_unsigned_integer auto v)
+{
+    v = ~v & (v - 1);
+    return popcount(v);
+}
+
+constexpr int countr_one(is_unsigned_integer auto v)
+{
+    v = v & (~v - 1);
+    return popcount(v);
+}
+
+constexpr int countl_zero(is_unsigned_integer auto v)
+{
+    v = ~propagate_right_one(v);
+    return popcount(v);
+}
+
+constexpr int countl_one(is_unsigned_integer auto v)
+{
+    v = ~v;
+    v = ~propagate_right_one(v);
+    return popcount(v);
+}
+
+template<is_unsigned_integer T>
+constexpr T rotr(T v, int s);
+
+template<is_unsigned_integer T>
+constexpr T rotl(T v, int s) // NOLINT(*-no-recursion)
+{
+    static constexpr int N = sizeof(decltype(v)) * 8;
+    s = s % N;
+    return (s >= 0) ? (v << s) | (v >> (N - s)) : rotr(v, -s);
+}
+
+template<is_unsigned_integer T>
+constexpr T rotr(T v, int s) // NOLINT(*-no-recursion)
+{
+    static constexpr int N = sizeof(decltype(v)) * 8;
+    s = s % N;
+    return (s >= 0) ? (v >> s) | (v << (N - s)) : rotl(v, -s);
+}
+
+constexpr uint16_t byteswap(uint16_t v)
+{
+    return static_cast<uint16_t>((v << 8U) | (v >> 8U));
+}
+
+constexpr uint32_t byteswap(uint32_t v)
+{
+    return rotr(v & 0x00ff'00ff, 8) | rotl(v & 0xff00'ff00, 8);
+}
+
+constexpr uint64_t byteswap(uint64_t v)
+{
+    return (uint64_t{byteswap(static_cast<uint32_t>(v))} << 32)
+        | uint64_t{byteswap(static_cast<uint32_t>(v >> 32))};
+}
+
+constexpr auto bit_ceil(is_unsigned_integer auto v)
+{
+    v -= 1;
+    v = propagate_right_one(v);
+    v += 1;
+    return v;
+}
+
+constexpr auto bit_floor(is_unsigned_integer auto v)
+{
+    v = propagate_right_one(v);
+    v = v - (v >> 1);
+    return v;
+}
+
+constexpr int bit_width(is_unsigned_integer auto v)
+{
+    static constexpr int N = sizeof(decltype(v)) * 8;
+    return N - countl_zero(v);
+}
+
+} // namespace asl
+

asl/base/bit_tests.cpp

@@ -0,0 +1,194 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "asl/base/bit.hpp"
+
+#include "asl/testing/testing.hpp"
+
+ASL_TEST(has_single_bit)
+{
+    ASL_TEST_EXPECT(asl::has_single_bit(4U));
+    ASL_TEST_EXPECT(asl::has_single_bit(1024U));
+    ASL_TEST_EXPECT(asl::has_single_bit(0x8000'0000U));
+    ASL_TEST_EXPECT(asl::has_single_bit(0x0000'8000'0000'0000ULL));
+    ASL_TEST_EXPECT(!asl::has_single_bit(0U));
+    ASL_TEST_EXPECT(!asl::has_single_bit(3U));
+    ASL_TEST_EXPECT(!asl::has_single_bit(341U));
+}
+
+ASL_TEST(popcount) // NOLINT(*-cognitive-complexity)
+{
+    ASL_TEST_EXPECT(asl::popcount(uint8_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::popcount(uint8_t{255}) == 8);
+    ASL_TEST_EXPECT(asl::popcount(uint8_t{46}) == 4);
+    ASL_TEST_EXPECT(asl::popcount(uint16_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::popcount(uint16_t{255}) == 8);
+    ASL_TEST_EXPECT(asl::popcount(uint16_t{65535}) == 16);
+    ASL_TEST_EXPECT(asl::popcount(uint16_t{46}) == 4);
+    ASL_TEST_EXPECT(asl::popcount(uint32_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::popcount(uint32_t{255}) == 8);
+    ASL_TEST_EXPECT(asl::popcount(uint32_t{65535}) == 16);
+    ASL_TEST_EXPECT(asl::popcount(uint32_t{65536}) == 1);
+    ASL_TEST_EXPECT(asl::popcount(uint32_t{46}) == 4);
+    ASL_TEST_EXPECT(asl::popcount(uint32_t{0xffff'ffff}) == 32);
+    ASL_TEST_EXPECT(asl::popcount(0x8421'1248'8421'1248) == 16);
+    ASL_TEST_EXPECT(asl::popcount(0xffff'ffff'ffff'ffff) == 64);
+}
+
+ASL_TEST(countr_zero)
+{
+    ASL_TEST_EXPECT(asl::countr_zero(uint8_t{0}) == 8);
+    ASL_TEST_EXPECT(asl::countr_zero(uint8_t{255}) == 0);
+    ASL_TEST_EXPECT(asl::countr_zero(uint8_t{0b00011100}) == 2);
+    ASL_TEST_EXPECT(asl::countr_zero(uint8_t{0b10101010}) == 1);
+    ASL_TEST_EXPECT(asl::countr_zero(uint8_t{0b10101001}) == 0);
+}
+
+ASL_TEST(countr_one)
+{
+    ASL_TEST_EXPECT(asl::countr_one(uint8_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::countr_one(uint8_t{255}) == 8);
+    ASL_TEST_EXPECT(asl::countr_one(uint8_t{0b00011100}) == 0);
+    ASL_TEST_EXPECT(asl::countr_one(uint8_t{0b10101011}) == 2);
+    ASL_TEST_EXPECT(asl::countr_one(uint8_t{0b10101001}) == 1);
+}
+
+ASL_TEST(countl_zero)
+{
+    ASL_TEST_EXPECT(asl::countl_zero(uint8_t{0}) == 8);
+    ASL_TEST_EXPECT(asl::countl_zero(uint8_t{255}) == 0);
+    ASL_TEST_EXPECT(asl::countl_zero(uint8_t{0b00011100}) == 3);
+    ASL_TEST_EXPECT(asl::countl_zero(uint8_t{0b10101010}) == 0);
+    ASL_TEST_EXPECT(asl::countl_zero(uint8_t{0b00001001}) == 4);
+}
+
+ASL_TEST(countl_one)
+{
+    ASL_TEST_EXPECT(asl::countl_one(uint8_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::countl_one(uint8_t{255}) == 8);
+    ASL_TEST_EXPECT(asl::countl_one(uint8_t{0b00011100}) == 0);
+    ASL_TEST_EXPECT(asl::countl_one(uint8_t{0b10101010}) == 1);
+    ASL_TEST_EXPECT(asl::countl_one(uint8_t{0b11101001}) == 3);
+}
+
+ASL_TEST(rotl)
+{
+    ASL_TEST_EXPECT(asl::rotl(uint32_t{0x4000'0100}, 1) == 0x8000'0200);
+    ASL_TEST_EXPECT(asl::rotl(uint32_t{0x4000'0100}, 3) == 0x0000'0802);
+    ASL_TEST_EXPECT(asl::rotl(uint32_t{0x4000'0100}, 0) == 0x4000'0100);
+    ASL_TEST_EXPECT(asl::rotl(uint32_t{0x4000'0100}, -1) == 0x2000'0080);
+    ASL_TEST_EXPECT(asl::rotl(uint32_t{0x4000'0100}, -12) == 0x1004'0000);
+}
+
+ASL_TEST(rotr)
+{
+    ASL_TEST_EXPECT(asl::rotr(uint32_t{0x4000'0100}, -1) == 0x8000'0200);
+    ASL_TEST_EXPECT(asl::rotr(uint32_t{0x4000'0100}, -3) == 0x0000'0802);
+    ASL_TEST_EXPECT(asl::rotr(uint32_t{0x4000'0100}, 0) == 0x4000'0100);
+    ASL_TEST_EXPECT(asl::rotr(uint32_t{0x4000'0100}, 1) == 0x2000'0080);
+    ASL_TEST_EXPECT(asl::rotr(uint32_t{0x4000'0100}, 12) == 0x1004'0000);
+}
+
+ASL_TEST(byteswap)
+{
+    ASL_TEST_EXPECT(asl::byteswap(uint32_t{0x1234'5678}) == 0x7856'3412);
+    ASL_TEST_EXPECT(asl::byteswap(uint16_t{0x1234}) == 0x3412);
+    ASL_TEST_EXPECT(asl::byteswap(uint64_t{0x0123'4567'89ab'cdef}) == 0xefcd'ab89'6745'2301);
+}
+
+ASL_TEST(bit_ceil) // NOLINT(*-cognitive-complexity)
+{
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{3}) == 4);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{4}) == 4);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{5}) == 8);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{6}) == 8);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{127}) == 128);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{128}) == 128);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{254}) == 0);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint8_t{255}) == 0);
+
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{3}) == 4);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{4}) == 4);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{5}) == 8);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{6}) == 8);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{32000}) == 32768);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{32768}) == 32768);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{35000}) == 0);
+    ASL_TEST_EXPECT(asl::bit_ceil(uint16_t{65535}) == 0);
+}
+
+ASL_TEST(bit_floor) // NOLINT(*-cognitive-complexity)
+{
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{3}) == 2);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{4}) == 4);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{5}) == 4);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{6}) == 4);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{127}) == 64);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{128}) == 128);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{254}) == 128);
+    ASL_TEST_EXPECT(asl::bit_floor(uint8_t{255}) == 128);
+
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{3}) == 2);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{4}) == 4);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{5}) == 4);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{6}) == 4);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{32000}) == 16384);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{32768}) == 32768);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{35000}) == 32768);
+    ASL_TEST_EXPECT(asl::bit_floor(uint16_t{65535}) == 32768);
+}
+
+ASL_TEST(bit_width) // NOLINT(*-cognitive-complexity)
+{
+    ASL_TEST_EXPECT(asl::bit_width(uint8_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_width(uint8_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_width(uint8_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint8_t{3}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint8_t{4}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint8_t{5}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint8_t{6}) == 3);
+
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{3}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{4}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{5}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{6}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint16_t{65535}) == 16);
+
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{3}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{4}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{5}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{6}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{65535}) == 16);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{65536}) == 17);
+    ASL_TEST_EXPECT(asl::bit_width(uint32_t{0xffff'ffff}) == 32);
+
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{0}) == 0);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{1}) == 1);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{2}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{3}) == 2);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{4}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{5}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{6}) == 3);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{65535}) == 16);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{65536}) == 17);
+    ASL_TEST_EXPECT(asl::bit_width(uint64_t{0xffff'ffff}) == 32);
+}

asl/base/config.hpp

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
+// NOLINTBEGIN(*-macro-to-enum)
+
 #pragma once
 
 #if defined(_WIN32)
@@ -19,3 +21,6 @@
 #else
     #error Unknown compiler
 #endif
+
+// NOLINTEND(*-macro-to-enum)
+

asl/base/defer.hpp

@@ -18,14 +18,16 @@ class DeferCallback
 
 public:
     template<typename T>
-    explicit DeferCallback(T&& callback) : m_callback(ASL_FWD(callback))
+    explicit DeferCallback(T&& callback)
+        requires (!same_as<un_cvref_t<T>, DeferCallback>)
+        : m_callback(std::forward<T>(callback))
     {
     }
 
     ASL_DELETE_COPY(DeferCallback);
 
     DeferCallback(DeferCallback&& other) :
-        m_callback(ASL_MOVE(other.m_callback)), m_moved(exchange(other.m_moved, true))
+        m_callback(std::move(other.m_callback)), m_moved(exchange(other.m_moved, true))
     {
     }
 
@@ -42,7 +44,7 @@ struct DeferFactory
     template<invocable Callback>
     DeferCallback<Callback> operator<<(Callback&& callback) const
     {
-        return DeferCallback<Callback>(ASL_FWD(callback));
+        return DeferCallback<Callback>(std::forward<Callback>(callback));
     }
 };
 

asl/base/defer_tests.cpp

@@ -10,25 +10,25 @@ ASL_TEST(defer)
     uint32_t a = 0;
 
     {
-        ASL_DEFER [&a]() { a |= 1; };
+        ASL_DEFER [&a]() { a |= 1U; };
         ASL_TEST_EXPECT(a == 0);
 
         {
-            ASL_DEFER [&a]() { a |= 2; };
+            ASL_DEFER [&a]() { a |= 2U; };
-            ASL_DEFER [&a]() { a |= 4; };
+            ASL_DEFER [&a]() { a |= 4U; };
             ASL_TEST_EXPECT(a == 0);
         }
 
         ASL_TEST_EXPECT(a == 6);
 
         {
-            ASL_DEFER [&a]() { a |= 8; };
+            ASL_DEFER [&a]() { a |= 8U; };
             ASL_TEST_EXPECT(a == 6);
         }
 
         ASL_TEST_EXPECT(a == 14);
 
-        ASL_DEFER [&a]() { a |= 16; };
+        ASL_DEFER [&a]() { a |= 16U; };
         ASL_TEST_EXPECT(a == 14);
     }
 

asl/base/float.hpp

@@ -6,6 +6,9 @@
 
 #include "asl/base/meta.hpp"
 
+using float32_t = float;
+using float64_t = double;
+
 namespace asl
 {
 

asl/base/functional.hpp

@@ -9,56 +9,62 @@
 
 namespace asl {
 
-template<typename... Args, typename C>
+template<typename F, typename... Args>
+constexpr auto invoke(F&& f, Args&&... args)
+    -> decltype(std::forward<F>(f)(std::forward<Args>(args)...))
+    requires (!is_member_ptr<un_cvref_t<F>>) && requires {
+        f(std::forward<Args>(args)...);
+    }
+{
+    return std::forward<F>(f)(std::forward<Args>(args)...);
+}
+
+template<typename C>
+constexpr auto&& invoke(auto C::* f, same_or_derived_from<C> auto&& arg)
+{
+    return std::forward<decltype(arg)>(arg).*f;
+}
+
+template<typename C>
+constexpr auto&& invoke(auto C::* f, auto&& arg)
+    requires (
+        !same_or_derived_from<decltype(arg), C>
+        && requires { (*arg).*f; }
+    )
+{
+    return (*std::forward<decltype(arg)>(arg)).*f;
+}
+
+template<typename C, typename... Args>
+constexpr auto invoke(is_func auto C::* f, same_or_derived_from<C> auto&& self, Args&&... args)
+    -> decltype((std::forward<decltype(self)>(self).*f)(std::forward<Args>(args)...))
+    requires requires { (self.*f)(std::forward<Args>(args)...); }
+{
+    return (std::forward<decltype(self)>(self).*f)(std::forward<Args>(args)...);
+}
+
+template<typename C, typename... Args>
 constexpr auto invoke(is_func auto C::* f, auto&& self, Args&&... args)
-    -> decltype((self.*f)(ASL_FWD(args)...))
+    -> decltype(((*std::forward<decltype(self)>(self)).*f)(std::forward<Args>(args)...))
-    requires requires {
-        (self.*f)(ASL_FWD(args)...);
-    }
-{
-    return (ASL_FWD(self).*f)(ASL_FWD(args)...);
-}
-
-template<typename... Args, typename C>
-constexpr auto invoke(is_func auto C::* f, auto* self, Args&&... args)
-    -> decltype((self->*f)(ASL_FWD(args)...))
-    requires requires {
-        (self->*f)(ASL_FWD(args)...);
-    }
-{
-    return (self->*f)(ASL_FWD(args)...);
-}
-
-template<typename... Args, typename C>
-constexpr auto invoke(is_object auto C::* m, auto&& self, Args&&...)
-    -> decltype(self.*m)
     requires (
-        sizeof...(Args) == 0 &&
+        !same_or_derived_from<decltype(self), C>
-        requires { self.*m; }
+        && requires { ((*self).*f)(std::forward<Args>(args)...); }
     )
 {
-    return ASL_FWD(self).*m;
+    return ((*std::forward<decltype(self)>(self)).*f)(std::forward<Args>(args)...);
 }
 
-template<typename... Args, typename C>
+template<typename R, typename F, typename... Args>
-constexpr auto invoke(is_object auto C::* m, auto* self, Args&&...)
+constexpr R invoke_r(F&& f, Args&&... args)
-    -> decltype(self->*m)
-    requires (
-        sizeof...(Args) == 0 &&
-        requires { self->*m; }
-    )
 {
-    return self->*m;
+    if constexpr (is_void<R>)
-}
+    {
-
+        static_cast<void>(invoke(std::forward<F>(f), std::forward<Args>(args)...));
-template<typename... Args>
+    }
-constexpr auto invoke(auto&& f, Args&&... args)
+    else
-    -> decltype(f(ASL_FWD(args)...))
+    {
-    requires requires {
+        return invoke(std::forward<F>(f), std::forward<Args>(args)...);
-        f(ASL_FWD(args)...);
     }
-{
-    return ASL_FWD(f)(ASL_FWD(args)...);
 }
 
 template<typename Void, typename F, typename... Args>
@@ -76,7 +82,11 @@ using invoke_result_t = _invoke_result_helper<void, F, Args...>::type;
 template<typename F, typename... Args>
 concept invocable = requires (F&& f, Args&&... args)
 {
-    invoke(ASL_FWD(f), ASL_FWD(args)...);
+    invoke(std::forward<F>(f), std::forward<Args>(args)...);
 };
 
+template<typename R, typename F, typename... Args>
+concept invocable_r = invocable<F, Args...>
+    && (is_void<R> || convertible_to<invoke_result_t<F, Args...>, R>);
+
 } // namespace asl

asl/base/functional_tests.cpp

@@ -7,9 +7,12 @@
 
 struct HasFunction
 {
-    void do_something(int, float) {}
+    void do_something(int, float) const {}
+    int& do_something2(int, float) &;
 };
 
+struct HasFunction2 : public HasFunction {};
+
 struct HasMember
 {
     int member{};
@@ -17,6 +20,8 @@ struct HasMember
     void (*member_fn)(){};
 };
 
+struct HasMember2 : public HasMember {};
+
 struct Functor
 {
     int64_t operator()() { return 35; }
@@ -34,7 +39,13 @@ static_assert(asl::same_as<asl::invoke_result_t<Functor>, int64_t>);
 static_assert(asl::same_as<asl::invoke_result_t<Functor, int>, int>);
 static_assert(asl::same_as<asl::invoke_result_t<decltype(static_cast<float(*)(float)>(some_func1)), float>, float>);
 static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasFunction::do_something), HasFunction, int, float>, void>);
-static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasMember::member), const HasMember>, const int&>);
+static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasFunction::do_something), const HasFunction2&, int, float>, void>);
+static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasFunction::do_something), HasFunction*, int, float>, void>);
+static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasFunction::do_something2), HasFunction2&, int, float>, int&>);
+static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasFunction::do_something2), HasFunction*, int, float>, int&>);
+static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasMember::member), HasMember>, int&&>);
+static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasMember::member), const HasMember&>, const int&>);
+static_assert(asl::same_as<asl::invoke_result_t<decltype(&HasMember::member), const HasMember2*>, const int&>);
 
 static_assert(asl::invocable<int()>);
 static_assert(!asl::invocable<int(), int>);
@@ -45,8 +56,20 @@ static_assert(asl::invocable<Functor, int>);
 static_assert(!asl::invocable<Functor, void*>);
 static_assert(asl::invocable<decltype(static_cast<float(*)(float)>(some_func1)), float>);
 static_assert(asl::invocable<decltype(&HasFunction::do_something), HasFunction, int, float>);
+static_assert(asl::invocable<decltype(&HasFunction::do_something), const HasFunction2&, int, float>);
+static_assert(asl::invocable<decltype(&HasFunction::do_something), HasFunction*, int, float>);
 static_assert(!asl::invocable<decltype(&HasFunction::do_something), HasFunction, int, int*>);
-static_assert(asl::invocable<decltype(&HasMember::member), const HasMember>);
+static_assert(!asl::invocable<decltype(&HasFunction::do_something2), HasFunction, int, float>);
+static_assert(!asl::invocable<decltype(&HasFunction::do_something2), const HasFunction2&, int, float>);
+static_assert(asl::invocable<decltype(&HasFunction::do_something2), HasFunction2&, int, float>);
+static_assert(asl::invocable<decltype(&HasFunction::do_something2), HasFunction*, int, float>);
+static_assert(!asl::invocable<decltype(&HasFunction::do_something2), HasFunction, int, int*>);
+static_assert(asl::invocable<decltype(&HasMember::member), const HasMember2>);
+static_assert(asl::invocable<decltype(&HasMember::member), const HasMember&>);
+static_assert(asl::invocable<decltype(&HasMember::member), const HasMember2*>);
+
+static_assert(asl::invocable_r<void*, int*()>);
+static_assert(!asl::invocable_r<int*, void*()>);
 
 ASL_TEST(invoke_member_function)
 {
@@ -89,3 +112,9 @@ ASL_TEST(invoke_lambda)
     ASL_TEST_EXPECT(asl::invoke([](){ return 35; }) == 35);
     ASL_TEST_EXPECT(asl::invoke([](int x){ return x + 2; }, 6) == 8);
 }
+
+ASL_TEST(invoke_r)
+{
+    ASL_TEST_EXPECT(asl::invoke_r<int>([]() { return 1ULL; }) == 1);
+    asl::invoke_r<void>([]() { return 1ULL; });
+}

asl/base/meta.hpp

@@ -25,6 +25,9 @@ struct empty {};
 
 template<typename T> struct id { using type = T; };
 
+struct in_place_t {};
+static constexpr in_place_t in_place{};
+
 template<typename... Args> static constexpr isize_t types_count = sizeof...(Args);
 
 template<typename T, T kValue> struct integral_constant { static constexpr T value = kValue; };
@@ -54,6 +57,11 @@ template<typename T> using as_rref_t = decltype(_as_rref_helper<T>(0))::type;
 
 template<typename T> consteval as_rref_t<T> declval() {}
 
+template<typename T> auto _as_ptr_helper(int) -> id<T*>;
+template<typename T> auto _as_ptr_helper(...) -> id<T>;
+
+template<typename T> using as_ptr_t = decltype(_as_ptr_helper<T>(0))::type;
+
 template<typename T> struct _un_ref_t      { using type = T; };
 template<typename T> struct _un_ref_t<T&>  { using type = T; };
 template<typename T> struct _un_ref_t<T&&> { using type = T; };
@@ -87,12 +95,6 @@ template<typename T> concept trivially_destructible = __is_trivially_destructibl
 template<typename T> concept copyable = copy_constructible<T> && copy_assignable<T>;
 template<typename T> concept moveable = move_constructible<T> && move_assignable<T>;
 
-template<typename To, typename From>
-concept convertible_from = __is_convertible(From, To);
-
-template<typename Derived, class Base>
-concept derived_from = __is_class(Derived) && __is_class(Base) && convertible_from<const volatile Base*, const volatile Derived*>;
-
 using nullptr_t = decltype(nullptr);
 
 template<typename T> struct _un_const_helper          { using type = T; };
@@ -149,11 +151,20 @@ template<typename T> struct _is_ptr_helper<T*> : true_type {};
 
 template<typename T> concept is_ptr = _is_ptr_helper<un_cv_t<T>>::value;
 
+template<typename From, typename To>
+concept convertible_to = __is_convertible(From, To);
+
+template<typename Derived, typename Base>
+concept derived_from = __is_class(Derived) && __is_class(Base) && convertible_to<const volatile Derived*, const volatile Base*>;
+
+template<typename Derived, typename Base>
+concept same_or_derived_from = same_as<un_cvref_t<Derived>, Base> || derived_from<un_cvref_t<Derived>, Base>;
+
 template<typename T> struct _tame_helper { using type = T; };
 
 #define TAME_HELPER_IMPL(TRAILING)                                  \
     template<typename R, typename... Args>                          \
-    struct _tame_helper<R(Args...) TRAILING> { using type = R(Args...); }
+    struct _tame_helper<R(Args...) TRAILING> { using type = R(Args...); } // NOLINT(*-parentheses)
 
 TAME_HELPER_IMPL();
 TAME_HELPER_IMPL(&);
@@ -189,13 +200,36 @@ template<typename R, typename... Args> struct _is_func_helper<R(Args...)> : true
 
 template<typename T> concept is_func = _is_func_helper<tame_t<T>>::value;
 
+template<typename T>             struct _is_member_ptr_helper         : false_type {};
+template<typename C, typename T> struct _is_member_ptr_helper<T C::*> : true_type
+{
+    static constexpr bool kIsFunc = is_func<T>;
+};
+
+template<typename T> concept is_member_ptr = _is_member_ptr_helper<un_cv_t<T>>::value;
+
+template<typename T> concept is_member_func_ptr = is_member_ptr<T> && _is_member_ptr_helper<un_cv_t<T>>::kIsFunc;
+template<typename T> concept is_member_data_ptr = is_member_ptr<T> && !_is_member_ptr_helper<un_cv_t<T>>::kIsFunc;
+
 template<typename T> concept is_object = !is_void<T> && !is_ref<T> && !is_func<T>;
 
-template<typename T>        struct _is_array_helper       : false_type {};
+template<typename T>        struct _array_helper       : false_type { using type = T; };
-template<typename T>        struct _is_array_helper<T[]>  : true_type  {};
+template<typename T>        struct _array_helper<T[]>  : true_type  { using type = T; };
-template<typename T, int N> struct _is_array_helper<T[N]> : true_type  {};
+template<typename T, int N> struct _array_helper<T[N]> : true_type  { using type = T; };
 
-template<typename T> concept is_array = _is_array_helper<T>::value;
+template<typename T> concept is_array = _array_helper<T>::value;
+
+template<typename T> using remove_extent_t = _array_helper<T>::type;
+
+template<typename T>
+using decay_t =
+    select_t<
+        is_array<un_ref_t<T>>,
+        as_ptr_t<remove_extent_t<un_ref_t<T>>>,
+        select_t<
+            is_func<un_ref_t<T>>,
+            as_ptr_t<un_ref_t<T>>,
+            un_cv_t<un_ref_t<T>>>>;
 
 template<typename T> struct _is_floating_point_helper         : false_type {};
 template<>           struct _is_floating_point_helper<float>  : true_type  {};
@@ -203,17 +237,75 @@ template<>           struct _is_floating_point_helper<double> : true_type  {};
 
 template<typename T> concept is_floating_point = _is_floating_point_helper<un_cv_t<T>>::value;
 
-template<typename T> struct _is_integer_helper           : false_type {};
+template<typename T> struct _integer_traits
-template<>           struct _is_integer_helper<int8_t>   : true_type  {};
+{
-template<>           struct _is_integer_helper<int16_t>  : true_type  {};
+    static constexpr bool kSigned = false;
-template<>           struct _is_integer_helper<int32_t>  : true_type  {};
+    static constexpr bool kUnsigned = false;
-template<>           struct _is_integer_helper<int64_t>  : true_type  {};
+};
-template<>           struct _is_integer_helper<uint8_t>  : true_type  {};
-template<>           struct _is_integer_helper<uint16_t> : true_type  {};
-template<>           struct _is_integer_helper<uint32_t> : true_type  {};
-template<>           struct _is_integer_helper<uint64_t> : true_type  {};
 
-template<typename T> concept is_integer = _is_integer_helper<un_cv_t<T>>::value;
+template<> struct _integer_traits<uint8_t>
+{
+    static constexpr bool kSigned = false;
+    static constexpr bool kUnsigned = true;
+    using as_signed = int8_t;
+};
+
+template<> struct _integer_traits<uint16_t>
+{
+    static constexpr bool kSigned = false;
+    static constexpr bool kUnsigned = true;
+    using as_signed = int16_t;
+};
+
+template<> struct _integer_traits<uint32_t>
+{
+    static constexpr bool kSigned = false;
+    static constexpr bool kUnsigned = true;
+    using as_signed = int32_t;
+};
+
+template<> struct _integer_traits<uint64_t>
+{
+    static constexpr bool kSigned = false;
+    static constexpr bool kUnsigned = true;
+    using as_signed = int64_t;
+};
+
+template<> struct _integer_traits<int8_t>
+{
+    static constexpr bool kSigned = true;
+    static constexpr bool kUnsigned = false;
+    using as_unsigned = uint8_t;
+};
+
+template<> struct _integer_traits<int16_t>
+{
+    static constexpr bool kSigned = true;
+    static constexpr bool kUnsigned = false;
+    using as_unsigned = uint16_t;
+};
+
+template<> struct _integer_traits<int32_t>
+{
+    static constexpr bool kSigned = true;
+    static constexpr bool kUnsigned = false;
+    using as_unsigned = uint32_t;
+};
+
+template<> struct _integer_traits<int64_t>
+{
+    static constexpr bool kSigned = true;
+    static constexpr bool kUnsigned = false;
+    using as_unsigned = uint64_t;
+};
+
+template<typename T> concept is_signed_integer   = _integer_traits<T>::kSigned;
+template<typename T> concept is_unsigned_integer = _integer_traits<T>::kUnsigned;
+
+template<typename T> concept is_integer = is_signed_integer<T> || is_unsigned_integer<T>;
+
+template<is_signed_integer T>   using as_unsigned_integer = _integer_traits<T>::as_unsigned;
+template<is_unsigned_integer T> using as_signed_integer   = _integer_traits<T>::as_signed;
 
 template<typename T> concept is_enum = __is_enum(T);
 
@@ -244,29 +336,28 @@ concept has_niche = constructible_from<T, niche_t> && equality_comparable_with<T
 template<typename T>
 concept is_niche = same_as<un_cvref_t<T>, niche_t>;
 
-template<typename T, typename U>
+template<typename From, typename To>
-concept _derefs_with_indirection_as = requires(T& t)
+concept _dereferenceable_as_convertible = requires(From& t)
 {
-    *t;
+    { *t } -> convertible_to<To&>;
-    requires convertible_from<U&, decltype(*t)>;
 };
 
-template<typename T, typename U>
+template<typename From, typename To>
-concept _derefs_reference_as = is_ref<T> && convertible_from<U&, T>;
+concept derefs_as = is_object<To> &&
+    (convertible_to<un_ref_t<From>&, To&> || _dereferenceable_as_convertible<un_ref_t<From>, To>);
 
-template<typename T, typename U>
+template<typename To, derefs_as<To> From>
-concept _derefs_value_as = !is_ref<T> && convertible_from<U&, T&>;
+constexpr auto&& deref(From&& from) // NOLINT(*-missing-std-forward)
-
+{
-template<typename U, _derefs_with_indirection_as<U> T>
+    if constexpr (_dereferenceable_as_convertible<From, To>)
-constexpr U& deref(T&& t) { return static_cast<U&>(*t); }
+    {
-
+        using deref_type = decltype(*declval<From&&>());
-template<typename U, _derefs_reference_as<U> T>
+        return static_cast<copy_cref_t<deref_type, To>>(*static_cast<From&&>(from));
-constexpr U& deref(T&& t) { return static_cast<U&>(t); }
+    }
-
+    else
-template<typename U, _derefs_value_as<U> T>
+    {
-constexpr U& deref(T&& t) { return static_cast<U&>(t); }
+        return static_cast<copy_cref_t<From&&, To>>(from);
-
+    }
-template<typename T, typename U>
+}
-concept derefs_as = _derefs_with_indirection_as<T, U> || _derefs_reference_as<T, U> || _derefs_value_as<T, U>;
 
 } // namespace asl

asl/base/meta_tests.cpp

@@ -135,6 +135,12 @@ static_assert(!asl::is_ref<void>);
 static_assert(!asl::is_ref<void()>);
 static_assert(!asl::is_ref<void() const &&>);
 
+struct MyClass
+{
+    int data;
+    int fn(int x) { return x; } // NOLINT
+};
+
 static_assert(asl::is_ptr<int*>);
 static_assert(asl::is_ptr<const int* const>);
 static_assert(asl::is_ptr<const volatile int*>);
@@ -142,6 +148,28 @@ static_assert(!asl::is_ptr<int>);
 static_assert(!asl::is_ptr<void>);
 static_assert(!asl::is_ptr<void()>);
 static_assert(!asl::is_ptr<void() const &&>);
+static_assert(!asl::is_ptr<int MyClass::*>);
+static_assert(!asl::is_ptr<int (MyClass::*)(int)>);
+
+static_assert(!asl::is_member_ptr<int*>);
+static_assert(!asl::is_member_ptr<void()>);
+static_assert(!asl::is_member_ptr<void() const &&>);
+static_assert(asl::is_member_ptr<int MyClass::*>);
+static_assert(asl::is_member_ptr<int (MyClass::*)(int)>);
+
+static_assert(!asl::is_member_data_ptr<int*>);
+static_assert(!asl::is_member_data_ptr<void()>);
+static_assert(!asl::is_member_data_ptr<void() const &&>);
+static_assert(asl::is_member_data_ptr<int MyClass::*>);
+static_assert(!asl::is_member_data_ptr<int (MyClass::*)(int)>);
+
+static_assert(!asl::is_member_func_ptr<int*>);
+static_assert(!asl::is_member_func_ptr<void()>);
+static_assert(!asl::is_member_func_ptr<void() const &&>);
+static_assert(!asl::is_member_func_ptr<int MyClass::*>);
+static_assert(asl::is_member_func_ptr<int (MyClass::*)(int)>);
+static_assert(asl::is_member_func_ptr<int (MyClass::*)(int) const>);
+static_assert(asl::is_member_func_ptr<int (MyClass::*)(int) volatile &&>);
 
 static_assert(asl::same_as<int, asl::tame_t<int>>);
 static_assert(asl::same_as<int(), asl::tame_t<int()>>);
@@ -189,6 +217,10 @@ static_assert(!asl::is_array<void>);
 static_assert(!asl::is_array<void(int)>);
 static_assert(!asl::is_array<int(float) const && noexcept>);
 
+static_assert(asl::same_as<int, asl::remove_extent_t<int>>);
+static_assert(asl::same_as<int, asl::remove_extent_t<int[]>>);
+static_assert(asl::same_as<int, asl::remove_extent_t<int[67]>>);
+
 static_assert(asl::same_as<int, asl::un_ref_t<int>>);
 static_assert(asl::same_as<int, asl::un_ref_t<int&>>);
 static_assert(asl::same_as<int, asl::un_ref_t<int&&>>);
@@ -205,21 +237,23 @@ class C {};
 class D { public: operator C() { return c; } C c; }; // NOLINT
 class E { public: template<class T> E(T&&) {} }; // NOLINT
 
-static_assert(asl::convertible_from<Base*, Derived*>);
+static_assert(asl::convertible_to<Derived*, Base*>);
-static_assert(!asl::convertible_from<Derived*, Base*>);
+static_assert(!asl::convertible_to<Base*, Derived*>);
-static_assert(asl::convertible_from<C, D>);
+static_assert(asl::convertible_to<D, C>);
-static_assert(!asl::convertible_from<C*, Derived*>);
+static_assert(!asl::convertible_to<Derived*, C*>);
-static_assert(asl::convertible_from<E, Base>);
+static_assert(asl::convertible_to<Base, E>);
 
-static_assert(!asl::convertible_from<int16_t(&)[], int32_t(&)[]>);
+static_assert(!asl::convertible_to<int32_t(&)[], int16_t(&)[]>);
-static_assert(asl::convertible_from<const int16_t(&)[], int16_t(&)[]>);
+static_assert(asl::convertible_to<int16_t(&)[], const int16_t(&)[]>);
-static_assert(asl::convertible_from<const int16_t(&)[], const int16_t(&)[]>);
+static_assert(asl::convertible_to<const int16_t(&)[], const int16_t(&)[]>);
-static_assert(asl::convertible_from<int16_t(&)[], int16_t(&)[]>);
+static_assert(asl::convertible_to<int16_t(&)[], int16_t(&)[]>);
-static_assert(!asl::convertible_from<int32_t(&)[], int16_t(&)[]>);
+static_assert(!asl::convertible_to<int16_t(&)[], int32_t(&)[]>);
-static_assert(!asl::convertible_from<int16_t(&)[], const int16_t(&)[]>);
+static_assert(!asl::convertible_to<const int16_t(&)[], int16_t(&)[]>);
-static_assert(!asl::convertible_from<C(&)[], D(&)[]>);
+static_assert(!asl::convertible_to<D(&)[], C(&)[]>);
 
 static_assert(asl::derived_from<Derived, Base>);
+static_assert(asl::derived_from<Derived, Derived>);
+static_assert(asl::derived_from<Base, Base>);
 static_assert(!asl::derived_from<Base, Derived>);
 static_assert(!asl::derived_from<D, C>);
 static_assert(!asl::derived_from<C, D>);
@@ -227,6 +261,16 @@ static_assert(!asl::derived_from<uint8_t, uint16_t>);
 static_assert(!asl::derived_from<uint16_t, uint8_t>);
 static_assert(!asl::derived_from<int, int>);
 
+static_assert(asl::same_or_derived_from<Derived, Base>);
+static_assert(asl::same_or_derived_from<Derived, Derived>);
+static_assert(asl::same_or_derived_from<Base, Base>);
+static_assert(!asl::same_or_derived_from<Base, Derived>);
+static_assert(!asl::same_or_derived_from<D, C>);
+static_assert(!asl::same_or_derived_from<C, D>);
+static_assert(!asl::same_or_derived_from<uint8_t, uint16_t>);
+static_assert(!asl::same_or_derived_from<uint16_t, uint8_t>);
+static_assert(asl::same_or_derived_from<int, int>);
+
 static_assert(!asl::is_const<int>);
 static_assert(asl::is_const<const int>);
 static_assert(!asl::is_const<const int*>);
@@ -255,16 +299,22 @@ static_assert(asl::is_enum<Enum2>);
 
 static_assert(asl::derefs_as<int, int>);
 static_assert(asl::derefs_as<int*, int>);
+static_assert(!asl::derefs_as<const int*, int>);
 static_assert(asl::derefs_as<int&, int>);
+static_assert(!asl::derefs_as<const int&, int>);
 static_assert(asl::derefs_as<asl::box<int>, int>);
 
 static_assert(asl::derefs_as<Derived, Base>);
+static_assert(!asl::derefs_as<Base, Derived>);
 static_assert(asl::derefs_as<Derived*, Base>);
 static_assert(asl::derefs_as<Derived&, Base>);
+static_assert(!asl::derefs_as<Base&, Derived>);
 static_assert(asl::derefs_as<asl::box<Derived>, Base>);
+static_assert(asl::derefs_as<asl::box<Derived>, Derived>);
+static_assert(asl::derefs_as<asl::box<Base>, Base>);
 
 static void wants_int(int) {}
-static void wants_base(Base&) {}
+static void wants_base(const Base&) {}
 static void wants_base_ptr(Base*) {}
 
 ASL_TEST(deref)
@@ -285,10 +335,11 @@ ASL_TEST(deref)
     wants_base(asl::deref<Base>(&c));
     wants_base(asl::deref<Base>(d));
 
-    wants_base_ptr(&asl::deref<Base>(Derived{}));
     wants_base_ptr(&asl::deref<Base>(c));
     wants_base_ptr(&asl::deref<Base>(&c));
     wants_base_ptr(&asl::deref<Base>(d));
+
+    wants_base(asl::deref<Base>(std::move(d)));
 }
 
 static_assert(asl::same_as<asl::copy_cref_t<int, float>, float>);
@@ -311,3 +362,13 @@ static_assert(asl::same_as<asl::copy_cref_t<const int&, const float>, const floa
 static_assert(asl::same_as<asl::copy_cref_t<const int&, float&&>, const float&>);
 static_assert(asl::same_as<asl::copy_cref_t<const int&, const float&>, const float&>);
 
+static_assert(asl::same_as<asl::decay_t<int>, int>);
+static_assert(!asl::same_as<asl::decay_t<int>, float>);
+static_assert(asl::same_as<asl::decay_t<int&>, int>);
+static_assert(asl::same_as<asl::decay_t<int&&>, int>);
+static_assert(asl::same_as<asl::decay_t<const int&>, int>);
+static_assert(asl::same_as<asl::decay_t<int[2]>, int*>);
+static_assert(!asl::same_as<asl::decay_t<int[4][2]>, int*>);
+static_assert(!asl::same_as<asl::decay_t<int[4][2]>, int**>);
+static_assert(asl::same_as<asl::decay_t<int[4][2]>, int(*)[2]>);
+static_assert(asl::same_as<asl::decay_t<int(int)>, int(*)(int)>);

asl/base/numeric.hpp

@@ -0,0 +1,43 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+#include "asl/base/integers.hpp"
+#include "asl/base/bit.hpp"
+#include "asl/base/meta.hpp"
+
+namespace asl
+{
+
+template<is_integer T>
+constexpr bool is_pow2(T x)
+{
+    using unsigned_type = select_t<is_unsigned_integer<T>, T, as_unsigned_integer<T>>;
+    return x > 0 && has_single_bit(static_cast<unsigned_type>(x));
+}
+
+template<typename T>
+concept is_numeric = is_integer<T> || is_floating_point<T>;
+
+template<is_numeric T>
+constexpr T min(T a, T b)
+{
+    return (a <= b) ? a : b;
+}
+
+template<is_numeric T>
+constexpr T max(T a, T b)
+{
+    return (a >= b) ? a : b;
+}
+
+template<is_numeric T>
+constexpr T clamp(T x, T a, T b)
+{
+    return min(max(x, a), b);
+}
+
+} // namespace asl
+

asl/base/numeric_tests.cpp

@@ -0,0 +1,16 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "asl/base/numeric.hpp"
+
+#include "asl/testing/testing.hpp"
+
+ASL_TEST(is_pow2)
+{
+    ASL_TEST_EXPECT(asl::is_pow2(4));
+    ASL_TEST_EXPECT(asl::is_pow2(65536));
+    ASL_TEST_EXPECT(!asl::is_pow2(6));
+    ASL_TEST_EXPECT(!asl::is_pow2(1978));
+    ASL_TEST_EXPECT(!asl::is_pow2(0));
+}

asl/base/utility.hpp

@@ -7,31 +7,59 @@
 #include "asl/base/meta.hpp"
 #include "asl/base/assert.hpp"
 
-#define ASL_MOVE(...) (static_cast<::asl::un_ref_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__))
+namespace std
+{
 
-#define ASL_FWD(expr_) (static_cast<decltype(expr_)&&>(expr_))
+template<typename T>
+[[nodiscard]] constexpr asl::un_ref_t<T>&& move(T&& t) noexcept // NOLINT
+{
+    return static_cast<asl::un_ref_t<T>&&>(t);
+}
 
-#define ASL_FWD_LIKE(ref_, expr_) (static_cast<::asl::copy_cref_t<ref_, decltype(expr_)&&>>(expr_))
+template<typename T>
+[[nodiscard]] constexpr T&& forward(asl::un_ref_t<T>& t) noexcept // NOLINT
+{
+    return static_cast<T&&>(t);
+}
+
+template< class T >
+[[nodiscard]] constexpr T&& forward(asl::un_ref_t<T>&& t) noexcept // NOLINT
+{
+    return static_cast<T&&>(t);
+}
+
+template<typename T, typename U>
+[[nodiscard]] constexpr auto forward_like(U&& x) noexcept -> asl::copy_cref_t<T, U> // NOLINT
+{
+    using return_type = asl::copy_cref_t<T, U&&>;
+    return static_cast<return_type>(x);
+}
+
+template<typename T>
+[[nodiscard]] constexpr T* launder(T* ptr) noexcept // NOLINT
+    requires (!asl::is_func<T> && !asl::is_void<T>)
+{
+    return __builtin_launder(ptr);
+}
+
+} // namespace std
 
 namespace asl
 {
 
-struct in_place_t {};
-static constexpr in_place_t in_place{};
-
 template<moveable T>
 constexpr void swap(T& a, T& b)
 {
-    T tmp{ASL_MOVE(a)};
+    T tmp{std::move(a)};
-    a = ASL_MOVE(b);
+    a = std::move(b);
-    b = ASL_MOVE(tmp);
+    b = std::move(tmp);
 }
 
 template<typename T, typename U>
 T exchange(T& obj, U&& new_value)
 {
-    T old_value = ASL_MOVE(obj);
+    T old_value = std::move(obj);
-    obj = ASL_FWD(new_value);
+    obj = std::forward<U>(new_value);
     return old_value;
 }
 
@@ -41,62 +69,31 @@ constexpr U bit_cast(T value) requires (sizeof(T) == sizeof(U))
     return __builtin_bit_cast(U, value);
 }
 
-template<typename T>
+// NOLINTBEGIN(*-macro-parentheses)
-constexpr T min(T a, T b)
-{
-    return (a <= b) ? a : b;
-}
-
-template<typename T>
-constexpr T max(T a, T b)
-{
-    return (a >= b) ? a : b;
-}
-
-constexpr uint64_t round_up_pow2(uint64_t v)
-{
-    ASL_ASSERT(v <= 0x8000'0000'0000'0000);
-
-    v -= 1;
-
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    v |= v >> 32;
-
-    return v + 1;
-}
-
-constexpr bool is_pow2(isize_t v)
-{
-    return v > 0 && ((v - 1) & v) == 0;
-}
-
 #define ASL_DELETE_COPY(T)                         \
     T(const T&) = delete;                          \
-    T& operator=(const T&) = delete;
+    T& operator=(const T&) = delete
 
 #define ASL_DELETE_MOVE(T)                         \
     T(T&&) = delete;                               \
-    T& operator=(T&&) = delete;
+    T& operator=(T&&) = delete
 
 #define ASL_DELETE_COPY_MOVE(T)                    \
-    ASL_DELETE_COPY(T)                             \
+    ASL_DELETE_COPY(T);                            \
     ASL_DELETE_MOVE(T)
 
 #define ASL_DEFAULT_COPY(T)                         \
     T(const T&) = default;                          \
-    T& operator=(const T&) = default;
+    T& operator=(const T&) = default
 
 #define ASL_DEFAULT_MOVE(T)                         \
     T(T&&) = default;                               \
-    T& operator=(T&&) = default;
+    T& operator=(T&&) = default
 
 #define ASL_DEFAULT_COPY_MOVE(T)                    \
-    ASL_DEFAULT_COPY(T)                             \
+    ASL_DEFAULT_COPY(T);                            \
     ASL_DEFAULT_MOVE(T)
+// NOLINTEND(*-macro-parentheses)
 
 #define ASL_CONCAT2(A, B) A##B
 #define ASL_CONCAT(A, B) ASL_CONCAT2(A, B)

asl/base/utility_tests.cpp

@@ -12,28 +12,28 @@ template<typename T> static constexpr int identify(T&&)       { return 4; }
 
 struct IdentifySelf
 {
-    constexpr int get(this auto&& self) { return identify(ASL_FWD(self)); }
+    constexpr int get(this auto&& self) { return identify(std::forward<decltype(self)>(self)); }
 };
 
-static int get_const_lref(const IdentifySelf& i)  { return ASL_FWD(i).get(); }
+static int get_const_lref(const IdentifySelf& i)  { return i.get(); }
-static int get_const_rref(const IdentifySelf&& i) { return ASL_FWD(i).get(); }
+static int get_const_rref(const IdentifySelf&& i) { return std::move(i).get(); } // NOLINT
-static int get_lref(IdentifySelf& i)              { return ASL_FWD(i).get(); }
+static int get_lref(IdentifySelf& i)              { return i.get(); }
-static int get_rref(IdentifySelf&& i)             { return ASL_FWD(i).get(); }
+static int get_rref(IdentifySelf&& i)             { return std::move(i).get(); } // NOLINT
 
 ASL_TEST(forward)
 {
-    IdentifySelf id;
+    IdentifySelf id{};
-    ASL_TEST_EXPECT(get_const_lref(id) == 1);
+    ASL_TEST_EXPECT(get_const_lref(IdentifySelf{}) == 1);
     ASL_TEST_EXPECT(get_lref(id) == 3);
-    ASL_TEST_EXPECT(get_const_rref(ASL_MOVE(id)) == 2);
+    ASL_TEST_EXPECT(get_const_rref(IdentifySelf{}) == 2);
-    ASL_TEST_EXPECT(get_rref(ASL_MOVE(id)) == 4);
+    ASL_TEST_EXPECT(get_rref(IdentifySelf{}) == 4);
 }
 
 ASL_TEST(move)
 {
     IdentifySelf id;
     ASL_TEST_EXPECT(id.get() == 3);
-    ASL_TEST_EXPECT(ASL_MOVE(id).get() == 4);
+    ASL_TEST_EXPECT(IdentifySelf{}.get() == 4);
 }
 
 struct Level1
@@ -51,33 +51,33 @@ struct Level3
     Level2 deeper;
 };
 
-static int get_const_lref(const Level3& i)  { return ASL_FWD(i).deeper.deeper.id.get(); }
+static int get_const_lref(const Level3& i)  { return i.deeper.deeper.id.get(); }
-static int get_const_rref(const Level3&& i) { return ASL_FWD(i).deeper.deeper.id.get(); }
+static int get_const_rref(const Level3&& i) { return std::move(i).deeper.deeper.id.get(); }
-static int get_lref(Level3& i)              { return ASL_FWD(i).deeper.deeper.id.get(); }
+static int get_lref(Level3& i)              { return i.deeper.deeper.id.get(); }
-static int get_rref(Level3&& i)             { return ASL_FWD(i).deeper.deeper.id.get(); }
+static int get_rref(Level3&& i)             { return std::move(i).deeper.deeper.id.get(); }
 
 ASL_TEST(forward2)
 {
     Level3 id{};
     ASL_TEST_EXPECT(get_const_lref(id) == 1);
     ASL_TEST_EXPECT(get_lref(id) == 3);
-    ASL_TEST_EXPECT(get_const_rref(ASL_MOVE(id)) == 2);
+    ASL_TEST_EXPECT(get_const_rref(Level3{}) == 2);
-    ASL_TEST_EXPECT(get_rref(ASL_MOVE(id)) == 4);
+    ASL_TEST_EXPECT(get_rref(Level3{}) == 4);
 }
 
 template<typename T>
-static int test_fwd_like(T&& t)
+static int test_fwd_like(T) // NOLINT
 {
-    IdentifySelf id;
+    const IdentifySelf id;
-    return ASL_FWD_LIKE(decltype(t), id).get();
+    return std::forward_like<T>(id).get();
 }
 
 ASL_TEST(forward_like)
 {
     int x{};
-    ASL_TEST_EXPECT(test_fwd_like<const int&>(x) == 1);
+    ASL_TEST_EXPECT(test_fwd_like<const int&>(7) == 1);
     ASL_TEST_EXPECT(test_fwd_like<int&>(x) == 3);
-    ASL_TEST_EXPECT(test_fwd_like<const int&&>(ASL_MOVE(x)) == 2);
+    ASL_TEST_EXPECT(test_fwd_like<const int&&>(8) == 2);
-    ASL_TEST_EXPECT(test_fwd_like<int&&>(ASL_MOVE(x)) == 4);
+    ASL_TEST_EXPECT(test_fwd_like<int&&>(9) == 4);
 }
 

asl/containers/BUILD.bazel

@@ -13,6 +13,7 @@ cc_library(
     ],
     deps = [
         "//asl/memory",
+        "//asl/memory:allocator",
         "//asl/base",
         "//asl/types:span",
         "//asl/hashing",
@@ -28,6 +29,7 @@ cc_library(
     deps = [
         "//asl/base",
         "//asl/memory",
+        "//asl/memory:allocator",
         "//asl/types:maybe_uninit",
         "//asl/hashing",
     ],
@@ -42,6 +44,7 @@ cc_library(
     deps = [
         "//asl/base",
         "//asl/memory",
+        "//asl/memory:allocator",
         "//asl/hashing",
         ":hash_set",
     ],

asl/containers/buffer.hpp

@@ -9,6 +9,7 @@
 #include "asl/memory/memory.hpp"
 #include "asl/base/annotations.hpp"
 #include "asl/base/assert.hpp"
+#include "asl/base/bit.hpp"
 #include "asl/types/span.hpp"
 #include "asl/hashing/hash.hpp"
 
@@ -46,7 +47,7 @@ private:
     static_assert(align_of<T*> == align_of<isize_t>);
     static_assert(align_of<T*> == align_of<size_t>);
 
-    constexpr size_t load_size_encoded() const
+    [[nodiscard]] constexpr size_t load_size_encoded() const
     {
         size_t s{};
         asl::memcpy(&s, &m_size_encoded_, sizeof(size_t));
@@ -80,25 +81,25 @@ private:
         {
             return is_on_heap(size_encoded)
                 ? static_cast<isize_t>(size_encoded & (~kOnHeapMask))
-                : static_cast<isize_t>(size_encoded >> 56);
+                : static_cast<isize_t>(size_encoded >> 56U);
         }
     }
 
-    constexpr bool is_on_heap() const
+    [[nodiscard]] constexpr bool is_on_heap() const
     {
         return is_on_heap(load_size_encoded());
     }
 
     constexpr T* push_uninit()
     {
-        isize_t sz = size();
+        const isize_t sz = size();
         resize_uninit_inner(sz + 1);
         return data() + sz;
     }
 
     constexpr void resize_uninit_inner(isize_t new_size)
     {
-        isize_t old_size = size();
+        const isize_t old_size = size();
         if (!trivially_destructible<T> && new_size < old_size)
         {
             destroy_n(data() + new_size, old_size - new_size);
@@ -110,7 +111,9 @@ private:
     constexpr void set_size_inline(isize_t new_size)
     {
         ASL_ASSERT(new_size >= 0 && new_size <= kInlineCapacity);
-        size_t size_encoded = (load_size_encoded() & size_t{0x00ff'ffff'ffff'ffff}) | (bit_cast<size_t>(new_size) << 56);
+        const size_t size_encoded =
+            (load_size_encoded() & size_t{0x00ff'ffff'ffff'ffff})
+            | (bit_cast<size_t>(new_size) << 56U);
         store_size_encoded(size_encoded);
     }
 
@@ -144,8 +147,8 @@ private:
         }
         else if (!assign || m_allocator == other.m_allocator)
         {
-            isize_t other_n = other.size();
+            const isize_t other_n = other.size();
-            isize_t this_n = size();
+            const isize_t this_n = size();
             resize_uninit_inner(other_n);
             if (other_n <= this_n)
             {
@@ -160,7 +163,7 @@ private:
         else
         {
             destroy();
-            isize_t n = other.size();
+            const isize_t n = other.size();
             ASL_ASSERT(n <= kInlineCapacity);
             relocate_uninit_n(data(), other.data(), n);
             set_size_inline(n);
@@ -170,14 +173,14 @@ private:
 
         if (assign)
         {
-            m_allocator = ASL_MOVE(other.m_allocator);
+            m_allocator = std::move(other.m_allocator);
         }
     }
 
     void copy_range(span<const T> to_copy)
     {
-        isize_t this_size = size();
+        const isize_t this_size = size();
-        isize_t new_size = to_copy.size();
+        const isize_t new_size = to_copy.size();
 
         resize_uninit_inner(to_copy.size());
         ASL_ASSERT(capacity() >= new_size);
@@ -209,7 +212,7 @@ private:
         // NOLINTNEXTLINE(*-pointer-arithmetic)
         for (T* it = data_ptr + old_size; it < end; ++it)
         {
-            construct_at<T>(it, ASL_FWD(args)...);
+            construct_at<T>(it, std::forward<Args>(args)...);
         }
     }
 
@@ -224,11 +227,11 @@ public:
     }
 
     explicit constexpr buffer(Allocator allocator)
-        : m_allocator{ASL_MOVE(allocator)}
+        : m_allocator{std::move(allocator)}
     {}
 
     explicit constexpr buffer(span<const T> s, Allocator allocator)
-        : m_allocator{ASL_MOVE(allocator)}
+        : m_allocator{std::move(allocator)}
     {
         copy_range(s);
     }
@@ -242,9 +245,9 @@ public:
 
     constexpr buffer(buffer&& other)
         requires moveable<T>
-        : buffer(ASL_MOVE(other.m_allocator))
+        : buffer(std::move(other.m_allocator))
     {
-        move_from_other(ASL_MOVE(other), false);
+        move_from_other(std::move(other), false);
     }
 
     constexpr buffer& operator=(const buffer& other)
@@ -259,7 +262,7 @@ public:
         requires moveable<T>
     {
         if (&other == this) { return *this; }
-        move_from_other(ASL_MOVE(other), true);
+        move_from_other(std::move(other), true);
         return *this;
     }
 
@@ -268,12 +271,14 @@ public:
         destroy();
     }
 
-    constexpr isize_t size() const
+    [[nodiscard]] constexpr isize_t size() const
     {
         return decode_size(load_size_encoded());
     }
 
-    constexpr isize_t capacity() const
+    [[nodiscard]] constexpr bool is_empty() const { return size() == 0; }
+
+    [[nodiscard]] constexpr isize_t capacity() const
     {
         if constexpr (kInlineCapacity == 0)
         {
@@ -287,7 +292,7 @@ public:
 
     void clear()
     {
-        isize_t current_size = size();
+        const isize_t current_size = size();
         if (current_size == 0) { return; }
 
         destroy_n(data(), current_size);
@@ -316,7 +321,7 @@ public:
         if (new_capacity <= capacity()) { return; }
         ASL_ASSERT(new_capacity > kInlineCapacity);
 
-        new_capacity = static_cast<isize_t>(round_up_pow2(static_cast<uint64_t>(new_capacity)));
+        new_capacity = static_cast<isize_t>(bit_ceil(static_cast<uint64_t>(new_capacity)));
 
         T* old_data = data();
         const isize_t old_capacity = capacity();
@@ -328,12 +333,12 @@ public:
 
         if (currently_on_heap && trivially_move_constructible<T>)
         {
-            m_data = reinterpret_cast<T*>(m_allocator.realloc(m_data, old_layout, new_layout));
+            m_data = static_cast<T*>(m_allocator.realloc(m_data, old_layout, new_layout));
             m_capacity = new_capacity;
             return;
         }
 
-        T* new_data = reinterpret_cast<T*>(m_allocator.alloc(new_layout));
+        T* new_data = static_cast<T*>(m_allocator.alloc(new_layout));
 
         relocate_uninit_n(new_data, old_data, current_size);
 
@@ -357,7 +362,7 @@ public:
     constexpr void resize_zero(isize_t new_size)
         requires trivially_default_constructible<T> && trivially_destructible<T>
     {
-        isize_t old_size = size();
+        const isize_t old_size = size();
         resize_uninit(new_size);
 
         if (new_size > old_size)
@@ -381,20 +386,25 @@ public:
         requires constructible_from<T, decltype(args)&&...>
     {
         T* uninit = push_uninit();
-        T* init = construct_at<T>(uninit, ASL_FWD(args)...);
+        T* init = construct_at<T>(uninit, std::forward<decltype(args)>(args)...);
         return *init;
     }
 
     auto data(this auto&& self)
     {
         using return_type = un_ref_t<copy_cref_t<decltype(self), T>>*;
+        // NOLINTNEXTLINE(*-reinterpret-cast)
+        auto&& buffer = reinterpret_cast<copy_cref_t<decltype(self), class buffer>>(self);
         if constexpr (kInlineCapacity == 0)
         {
-            return return_type{ self.m_data };
+            return return_type{ buffer.m_data };
         }
         else
         {
-            return self.is_on_heap() ? return_type{ self.m_data } : reinterpret_cast<return_type>(&self);
+            return buffer.is_on_heap()
+                ? return_type{ buffer.m_data }
+                // NOLINTNEXTLINE(*-reinterpret-cast)
+                : std::launder(reinterpret_cast<return_type>(&buffer));
         }
     }
 
@@ -410,12 +420,12 @@ public:
         return contiguous_iterator<type>{self.data() + self.size()};
     }
 
-    constexpr operator span<const T>() const // NOLINT(*-explicit-conversions)
+    constexpr operator span<const T>() const // NOLINT(*explicit*)
     {
         return as_span();
     }
 
-    constexpr operator span<T>() // NOLINT(*-explicit-conversions)
+    constexpr operator span<T>() // NOLINT(*explicit*)
     {
         return as_span();
     }
@@ -429,14 +439,14 @@ public:
     constexpr auto&& operator[](this auto&& self, isize_t i)
     {
         ASL_ASSERT(i >= 0 && i <= self.size());
-        return ASL_FWD_LIKE(decltype(self), ASL_FWD(self).data()[i]);
+        return std::forward_like<decltype(self)>(std::forward<decltype(self)>(self).data()[i]);
     }
 
     template<typename H>
     requires hashable<T>
     friend H AslHashValue(H h, const buffer& b)
     {
-        return H::combine_contiguous(ASL_MOVE(h), b.as_span());
+        return H::combine_contiguous(std::move(h), b.as_span());
     }
 };
 

asl/containers/buffer_tests.cpp

@@ -24,7 +24,7 @@ ASL_TEST(default_size)
     ASL_TEST_EXPECT(b1.capacity() == 5);
     ASL_TEST_EXPECT(static_cast<const void*>(b1.data()) == &b1);
 
-    asl::buffer<Big> b2;
+    const asl::buffer<Big> b2;
     ASL_TEST_EXPECT(b2.size() == 0);
     ASL_TEST_EXPECT(b2.capacity() == 0);
     ASL_TEST_EXPECT(b2.data() == nullptr);
@@ -34,6 +34,7 @@ struct CounterAllocator
 {
     isize_t* count;
 
+    [[nodiscard]]
     void* alloc(const asl::layout& layout) const
     {
         *count += 1;
@@ -76,6 +77,7 @@ struct IncompatibleAllocator
 };
 static_assert(asl::allocator<IncompatibleAllocator>);
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(reserve_capacity)
 {
     isize_t count = 0;
@@ -105,6 +107,7 @@ ASL_TEST(reserve_capacity)
     ASL_TEST_EXPECT(count == 2);
 }
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(push)
 {
     asl::buffer<int32_t> b;
@@ -137,7 +140,7 @@ ASL_TEST(push)
 
 ASL_TEST(from_span)
 {
-    int data[] = {1, 2, 4, 8};
+    const int data[] = {1, 2, 4, 8};
     asl::buffer<int> b{data};
 
     ASL_TEST_EXPECT(b.size() == 4);
@@ -157,12 +160,14 @@ struct MoveableType
     MoveableType(MoveableType&& other)  : moved{other.moved + 1}, value{other.value} {}
     MoveableType& operator=(const MoveableType&) = delete;
     MoveableType& operator=(MoveableType&&) = delete;
+    ~MoveableType() = default;
 };
 static_assert(!asl::trivially_copy_constructible<MoveableType>);
 static_assert(!asl::trivially_move_constructible<MoveableType>);
 static_assert(!asl::copyable<MoveableType>);
 static_assert(asl::move_constructible<MoveableType>);
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(push_move)
 {
     asl::buffer<MoveableType> b;
@@ -275,14 +280,13 @@ ASL_TEST(move_construct_from_heap)
     buf.push(&d[2]);
 
     {
-        asl::buffer<DestructorObserver> buf2(ASL_MOVE(buf));
+        const asl::buffer<DestructorObserver> buf2(std::move(buf));
         ASL_TEST_EXPECT(buf2.size() == 3);
         ASL_TEST_EXPECT(d[0] == false);
         ASL_TEST_EXPECT(d[1] == false);
         ASL_TEST_EXPECT(d[2] == false);
     }
 
-    ASL_TEST_EXPECT(buf.size() == 0);
     ASL_TEST_EXPECT(d[0] == true);
     ASL_TEST_EXPECT(d[1] == true);
     ASL_TEST_EXPECT(d[2] == true);
@@ -294,12 +298,11 @@ ASL_TEST(move_construct_inline_trivial)
     buf.push(1U);
     buf.push(2U);
 
-    asl::buffer<uint64_t> buf2(ASL_MOVE(buf));
+    asl::buffer<uint64_t> buf2(std::move(buf));
     ASL_TEST_EXPECT(buf2[0] == 1U);
     ASL_TEST_EXPECT(buf2[1] == 2U);
 
     ASL_TEST_EXPECT(buf2.size() == 2);
-    ASL_TEST_EXPECT(buf.size() == 0);
 }
 
 ASL_TEST(move_construct_from_inline_non_trivial)
@@ -310,17 +313,17 @@ ASL_TEST(move_construct_from_inline_non_trivial)
     buf.push(&d[1]);
 
     {
-        asl::buffer<DestructorObserver> buf2(ASL_MOVE(buf));
+        const asl::buffer<DestructorObserver> buf2(std::move(buf));
         ASL_TEST_EXPECT(buf2.size() == 2);
         ASL_TEST_EXPECT(d[0] == false);
         ASL_TEST_EXPECT(d[1] == false);
     }
 
-    ASL_TEST_EXPECT(buf.size() == 0);
     ASL_TEST_EXPECT(d[0] == true);
     ASL_TEST_EXPECT(d[1] == true);
 }
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(move_assign_from_heap)
 {
     bool d[6]{};
@@ -344,9 +347,8 @@ ASL_TEST(move_assign_from_heap)
         ASL_TEST_EXPECT(d[4] == false);
         ASL_TEST_EXPECT(d[5] == false);
 
-        buf2 = ASL_MOVE(buf);
+        buf2 = std::move(buf);
 
-        ASL_TEST_EXPECT(buf.size() == 0);
         ASL_TEST_EXPECT(buf2.size() == 3);
 
         ASL_TEST_EXPECT(d[0] == false);
@@ -380,11 +382,10 @@ ASL_TEST(move_assign_trivial_heap_to_inline)
     buf2.push(5);
     ASL_TEST_EXPECT(alloc_count == 1);
 
-    buf = ASL_MOVE(buf2);
+    buf = std::move(buf2);
     ASL_TEST_EXPECT(alloc_count == 1);
 
     ASL_TEST_EXPECT(buf.size() == 3);
-    ASL_TEST_EXPECT(buf2.size() == 0);
     ASL_TEST_EXPECT(buf[0] == 3);
     ASL_TEST_EXPECT(buf[1] == 4);
     ASL_TEST_EXPECT(buf[2] == 5);
@@ -405,15 +406,15 @@ ASL_TEST(move_assign_trivial_inline_to_heap)
     buf2.push(5);
     ASL_TEST_EXPECT(alloc_count == 1);
 
-    buf2 = ASL_MOVE(buf);
+    buf2 = std::move(buf);
     ASL_TEST_EXPECT(alloc_count == 1);
 
-    ASL_TEST_EXPECT(buf.size() == 0);
     ASL_TEST_EXPECT(buf2.size() == 2);
     ASL_TEST_EXPECT(buf2[0] == 1);
     ASL_TEST_EXPECT(buf2[1] == 2);
 }
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(move_assign_inline_to_heap)
 {
     bool d[6]{};
@@ -430,9 +431,8 @@ ASL_TEST(move_assign_inline_to_heap)
         buf2.push(&d[4]);
         buf2.push(&d[5]);
 
-        buf2 = ASL_MOVE(buf);
+        buf2 = std::move(buf);
 
-        ASL_TEST_EXPECT(buf.size() == 0);
         ASL_TEST_EXPECT(buf2.size() == 2);
         ASL_TEST_EXPECT(d[0] == false);
         ASL_TEST_EXPECT(d[1] == false);
@@ -450,6 +450,7 @@ ASL_TEST(move_assign_inline_to_heap)
     ASL_TEST_EXPECT(d[5] == true);
 }
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(move_assign_from_inline_incompatible_allocator)
 {
     bool d[6]{};
@@ -466,9 +467,8 @@ ASL_TEST(move_assign_from_inline_incompatible_allocator)
         buf2.push(&d[4]);
         buf2.push(&d[5]);
 
-        buf2 = ASL_MOVE(buf);
+        buf2 = std::move(buf);
 
-        ASL_TEST_EXPECT(buf.size() == 0);
         ASL_TEST_EXPECT(buf2.size() == 2);
         ASL_TEST_EXPECT(d[0] == false);
         ASL_TEST_EXPECT(d[1] == false);

asl/containers/hash_map.hpp

@@ -77,25 +77,17 @@ public:
     constexpr hash_map() requires default_constructible<Allocator> = default;
 
     explicit constexpr hash_map(Allocator allocator)
-        : Base{ASL_MOVE(allocator)}
+        : Base{std::move(allocator)}
     {}
 
-    hash_map(const hash_map&) requires copyable<K> && copyable<V> = default;
-
-    hash_map& operator=(const hash_map&) requires copyable<K> && copyable<V> = default;
-
-    hash_map(hash_map&&) = default;
-
-    hash_map& operator=(hash_map&&) = default;
-
-    ~hash_map() = default;
-
     using Base::destroy;
 
     using Base::clear;
 
     using Base::size;
 
+    using Base::is_empty;
+
     using Base::remove;
 
     using Base::contains;
@@ -122,7 +114,7 @@ public:
             {
                 ASL_ASSERT((Base::m_tags[result.first_available_index] & Base::kHasValue) == 0);
 
-                Base::m_values[result.first_available_index].construct_unsafe(ASL_MOVE(Base::m_values[result.already_present_index].as_init_unsafe()));
+                Base::m_values[result.first_available_index].construct_unsafe(std::move(Base::m_values[result.already_present_index].as_init_unsafe()));
                 Base::m_values[result.already_present_index].destroy_unsafe();
 
                 Base::m_tags[result.first_available_index] = result.tag;
@@ -133,17 +125,17 @@ public:
 
             if constexpr (sizeof...(Args1) == 0 && assignable_from<V&, Arg0&&>)
             {
-                Base::m_values[result.first_available_index].as_init_unsafe().value = ASL_FWD(arg0);
+                Base::m_values[result.first_available_index].as_init_unsafe().value = std::forward<Arg0>(arg0);
             }
             else
             {
-                Base::m_values[result.first_available_index].as_init_unsafe().value = ASL_MOVE(V{ASL_FWD(arg0), ASL_FWD(args1)...});
+                Base::m_values[result.first_available_index].as_init_unsafe().value = std::move(V{std::forward<Arg0>(arg0), std::forward<Args1>(args1)...});
             }
         }
         else
         {
             ASL_ASSERT((Base::m_tags[result.first_available_index] & Base::kHasValue) == 0);
-            Base::m_values[result.first_available_index].construct_unsafe(ASL_FWD(key), V{ASL_FWD(arg0), ASL_FWD(args1)...});
+            Base::m_values[result.first_available_index].construct_unsafe(std::forward<U>(key), V{std::forward<Arg0>(arg0), std::forward<Args1>(args1)...});
             Base::m_tags[result.first_available_index] = result.tag;
             Base::m_size += 1;
         }

asl/containers/hash_map_tests.cpp

@@ -5,6 +5,7 @@
 #include "asl/testing/testing.hpp"
 #include "asl/containers/hash_map.hpp"
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(default)
 {
     asl::hash_map<int, int> map;

asl/containers/hash_set.hpp

@@ -7,6 +7,8 @@
 #include "asl/base/annotations.hpp"
 #include "asl/base/utility.hpp"
 #include "asl/base/meta.hpp"
+#include "asl/base/bit.hpp"
+#include "asl/base/numeric.hpp"
 #include "asl/memory/allocator.hpp"
 #include "asl/memory/memory.hpp"
 #include "asl/types/maybe_uninit.hpp"
@@ -72,10 +74,10 @@ protected:
 
     ASL_NO_UNIQUE_ADDRESS Allocator m_allocator;
 
-    constexpr isize_t max_size() const
+    [[nodiscard]] constexpr isize_t max_size() const
     {
         // Max load factor is 75%
-        return (m_capacity >> 1) + (m_capacity >> 2);
+        return (m_capacity >> 1) + (m_capacity >> 2); // NOLINT(*-signed-bitwise)
     }
 
     static isize_t size_to_capacity(isize_t size)
@@ -83,7 +85,7 @@ protected:
         ASL_ASSERT(size > 0);
         return max<isize_t>(
             kMinCapacity,
-            static_cast<isize_t>(round_up_pow2((static_cast<uint64_t>(size) * 4 + 2) / 3)));
+            static_cast<isize_t>(bit_ceil((static_cast<uint64_t>(size) * 4 + 2) / 3)));
     }
 
     static void insert_inner(
@@ -115,7 +117,7 @@ protected:
                 *size += 1;
             }
 
-            values[result.first_available_index].construct_unsafe(ASL_MOVE(value));
+            values[result.first_available_index].construct_unsafe(std::move(value));
             tags[result.first_available_index] = result.tag;
         }
 
@@ -131,8 +133,8 @@ protected:
     {
         ASL_ASSERT(new_capacity >= kMinCapacity && is_pow2(new_capacity) && new_capacity > m_capacity);
 
-        auto* new_tags = reinterpret_cast<uint8_t*>(m_allocator.alloc(layout::array<uint8_t>(new_capacity)));
+        auto* new_tags = static_cast<uint8_t*>(m_allocator.alloc(layout::array<uint8_t>(new_capacity)));
-        auto* new_values = reinterpret_cast<maybe_uninit<T>*>(m_allocator.alloc(layout::array<maybe_uninit<T>>(new_capacity)));
+        auto* new_values = static_cast<maybe_uninit<T>*>(m_allocator.alloc(layout::array<maybe_uninit<T>>(new_capacity)));
         asl::memzero(new_tags, new_capacity);
 
         isize_t new_size = 0;
@@ -144,7 +146,7 @@ protected:
             {
                 if ((m_tags[i] & kHasValue) == 0) { continue; }
 
-                insert_inner(ASL_MOVE(m_values[i].as_init_unsafe()), new_tags, new_values, new_capacity, &new_size);
+                insert_inner(std::move(m_values[i].as_init_unsafe()), new_tags, new_values, new_capacity, &new_size);
 
                 // Destroy now so that destroy() has less things to do
                 m_values[i].destroy_unsafe();
@@ -228,7 +230,6 @@ protected:
         result.tag = static_cast<uint8_t>(hash & kHashMask) | kHasValue;
 
         // NOLINTBEGIN(*-pointer-arithmetic)
-
         for (
             isize_t i = starting_index;
             i != starting_index || result.first_available_index < 0;
@@ -312,7 +313,7 @@ public:
     {}
 
     explicit constexpr hash_set(Allocator allocator)
-        : m_allocator{ASL_MOVE(allocator)}
+        : m_allocator{std::move(allocator)}
     {}
 
     hash_set(const hash_set& other)
@@ -339,7 +340,7 @@ public:
         , m_values{exchange(other.m_values, nullptr)}
         , m_capacity{exchange(other.m_capacity, 0)}
         , m_size{exchange(other.m_size, 0)}
-        , m_allocator{ASL_MOVE(other.m_allocator)}
+        , m_allocator{std::move(other.m_allocator)}
     {}
 
     hash_set& operator=(hash_set&& other)
@@ -351,7 +352,7 @@ public:
             m_values = exchange(other.m_values, nullptr);
             m_capacity = exchange(other.m_capacity, 0);
             m_size = exchange(other.m_size, 0);
-            m_allocator = ASL_MOVE(other.m_allocator);
+            m_allocator = std::move(other.m_allocator);
         }
         return *this;
     }
@@ -385,7 +386,9 @@ public:
         }
     }
 
-    constexpr isize_t size() const { return m_size; }
+    [[nodiscard]] constexpr isize_t size() const { return m_size; }
+
+    [[nodiscard]] constexpr bool is_empty() const { return m_size == 0; }
 
     template<typename... Args>
     void insert(Args&&... args)
@@ -393,7 +396,7 @@ public:
     {
         maybe_grow_to_fit_one_more();
         ASL_ASSERT(m_size < max_size());
-        insert_inner(ASL_MOVE(T{ASL_FWD(args)...}), m_tags, m_values, m_capacity, &m_size);
+        insert_inner(T{std::forward<Args>(args)...}, m_tags, m_values, m_capacity, &m_size);
     }
 
     template<typename U>

asl/containers/hash_set_tests.cpp

@@ -10,7 +10,7 @@
 
 ASL_TEST(empty)
 {
-    asl::hash_set<int> set;
+    const asl::hash_set<int> set;
 
     ASL_TEST_EXPECT(set.size() == 0);
 
@@ -42,7 +42,7 @@ ASL_TEST(a_bunch_of_ints)
 {
     asl::hash_set<int> set;
 
-    int count = 3000;
+    const int count = 3000;
 
     for (int i = 0; i < count; ++i)
     {
@@ -98,6 +98,7 @@ struct CustomHasher
     }
 };
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(destructor_and_remove)
 {
     static constexpr int kCount = 200;
@@ -113,9 +114,9 @@ ASL_TEST(destructor_and_remove)
 
         ASL_TEST_EXPECT(set.size() == kCount);
 
-        for (int i = 0; i < kCount; ++i)
+        for (const bool i : destroyed)
         {
-            ASL_TEST_EXPECT(!destroyed[i]); // NOLINT
+            ASL_TEST_EXPECT(!i); // NOLINT
         }
 
         for (int i = 0; i < kCount; i += 2)
@@ -132,9 +133,9 @@ ASL_TEST(destructor_and_remove)
         }
     }
 
-    for (int i = 0; i < kCount; ++i)
+    for (const bool i : destroyed)
     {
-        ASL_TEST_EXPECT(destroyed[i]); // NOLINT
+        ASL_TEST_EXPECT(i); // NOLINT
     }
 }
 
@@ -147,7 +148,7 @@ ASL_TEST(copy)
         set1.insert(i);
     }
 
-    asl::hash_set<int> set2 = set1;
+    const asl::hash_set<int> set2 = set1;
     asl::hash_set<int> set3;
     set3 = set1;
 
@@ -170,7 +171,7 @@ ASL_TEST(move)
         set1.insert(i);
     }
 
-    asl::hash_set<int> set2 = ASL_MOVE(set1);
+    asl::hash_set<int> set2 = std::move(set1);
 
     ASL_TEST_EXPECT(set2.size() == 100);
     for (int i = 0; i < 100; ++i)
@@ -178,7 +179,7 @@ ASL_TEST(move)
         ASL_TEST_EXPECT(set2.contains(i));
     }
 
-    set1 = ASL_MOVE(set2);
+    set1 = std::move(set2);
 
     ASL_TEST_EXPECT(set1.size() == 100);
     for (int i = 0; i < 100; ++i)

asl/containers/intrusive_list.hpp

@@ -19,7 +19,7 @@ struct intrusive_list_node
 };
 
 template<typename T>
-concept is_intrusive_list_node = convertible_from<intrusive_list_node<T>*, T*>;
+concept is_intrusive_list_node = derived_from<T, intrusive_list_node<T>>;
 
 template<is_intrusive_list_node T>
 class IntrusiveList
@@ -43,11 +43,11 @@ public:
         push_front(head);
     }
 
-    ASL_DELETE_COPY(IntrusiveList)
+    ASL_DELETE_COPY(IntrusiveList);
-    ASL_DEFAULT_MOVE(IntrusiveList)
+    ASL_DEFAULT_MOVE(IntrusiveList);
     ~IntrusiveList() = default;
 
-    constexpr bool is_empty() const { return m_head == nullptr; }
+    [[nodiscard]] constexpr bool is_empty() const { return m_head == nullptr; }
 
     void push_front(T* node)
     {
@@ -151,7 +151,7 @@ public:
             , m_advanced{end}
         {}
 
-        constexpr bool operator==(const generic_iterator& other) const = default;
+        constexpr bool operator==(this generic_iterator, generic_iterator other) = default;
 
         constexpr generic_iterator& operator++()
         {
@@ -167,9 +167,9 @@ public:
             };
         }
 
-        constexpr TT& operator*() const { return *m_node; }
+        constexpr TT& operator*(this generic_iterator self) { return *self.m_node; }
 
-        constexpr TT* operator->() const { return m_node; }
+        constexpr TT* operator->(this generic_iterator self) { return self.m_node; }
     };
 
     using iterator = generic_iterator<T>;
@@ -188,5 +188,5 @@ public:
     }
 };
 
-}
+}  // namespace asl
 

asl/containers/intrusive_list_tests.cpp

@@ -23,6 +23,7 @@ ASL_TEST(empty_list)
     ASL_TEST_EXPECT(list.back() == nullptr);
 }
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(push_front)
 {
     IntNode one{1};
@@ -75,6 +76,7 @@ ASL_TEST(push_front)
     ASL_TEST_ASSERT(it == end);
 }
 
+// NOLINTNEXTLINE(*-complexity)
 ASL_TEST(push_back)
 {
     IntNode one{1};

asl/formatting/format.cpp

@@ -151,7 +151,7 @@ asl::string_view asl::format_uint64(uint64_t v, asl::span<char, kMaxUint64Digits
 
     while (v >= 100)
     {
-        uint64_t x = v % 100;
+        const uint64_t x = v % 100;
         v /= 100;
         write_two(s_pairs.subspan(static_cast<isize_t>(x * 2)).first<2>());
     }
@@ -195,7 +195,7 @@ void asl::AslFormat(Formatter& f, int64_t v)
     if (v < 0)
     {
         f.write("-");
-        uint64_t absolute_value = ~(bit_cast<uint64_t>(v) - 1);
+        const uint64_t absolute_value = ~(bit_cast<uint64_t>(v) - 1);
         AslFormat(f, absolute_value);
     }
     else

asl/formatting/format.hpp

@@ -32,7 +32,7 @@ struct type_erased_arg
     template<formattable T>
     static constexpr void erased_fn(Formatter& f, const void* data)
     {
-        AslFormat(f, *reinterpret_cast<const T*>(data));
+        AslFormat(f, *static_cast<const T*>(data));
     }
 
     template<formattable T>
@@ -44,7 +44,7 @@ struct type_erased_arg
 
 void format(Writer*, string_view fmt, span<const type_erased_arg> args);
 
-} // namespace internals
+}  // namespace format_internals
 
 class Formatter
 {
@@ -60,7 +60,7 @@ public:
         m_writer->write(as_bytes(s.as_span()));
     }
 
-    constexpr Writer* writer() const { return m_writer; }
+    [[nodiscard]] constexpr Writer* writer() const { return m_writer; }
 };
 
 template<formattable... Args>
@@ -68,7 +68,7 @@ void format(Writer* w, string_view fmt, const Args&... args)
 {
     if constexpr (types_count<Args...> > 0)
     {
-        format_internals::type_erased_arg type_erased_args[] = {
+        const format_internals::type_erased_arg type_erased_args[] = {
             format_internals::type_erased_arg(args)...
         };
 

asl/formatting/format_float.cpp

@@ -4,6 +4,7 @@
 
 #include "asl/formatting/format.hpp"
 #include "asl/base/float.hpp"
+#include "asl/base/numeric.hpp"
 
 #define JKJ_STD_REPLACEMENT_NAMESPACE_DEFINED 0
 #define JKJ_STATIC_DATA_SECTION_DEFINED 0
@@ -25,12 +26,12 @@ static constexpr char kZeros[kZeroCount] = {
 
 static constexpr bool is_zero(float x)
 {
-    return (asl::bit_cast<uint32_t>(x) & 0x7fff'ffff) == 0;
+    return (asl::bit_cast<uint32_t>(x) & 0x7fff'ffffU) == 0;
 }
 
 static constexpr bool is_zero(double x)
 {
-    return (asl::bit_cast<uint64_t>(x) & 0x7fff'ffff'ffff'ffff) == 0;
+    return (asl::bit_cast<uint64_t>(x) & 0x7fff'ffff'ffff'ffffULL) == 0;
 }
 
 template<asl::is_floating_point T>
@@ -66,15 +67,15 @@ static void format_float(asl::Formatter& f, T value)
     if (decimal.is_negative) { f.write("-"); }
 
     char buffer[20];
-    asl::string_view digits = asl::format_uint64(decimal.significand, buffer);
+    const asl::string_view digits = asl::format_uint64(decimal.significand, buffer);
 
     if (decimal.exponent >= 0)
     {
         f.write(digits);
         while (decimal.exponent > 0)
         {
-            isize_t to_write = asl::min(static_cast<isize_t>(decimal.exponent), kZeroCount);
+            const isize_t to_write = asl::min(static_cast<isize_t>(decimal.exponent), kZeroCount);
-            f.write(asl::string_view(kZeros, to_write));
+            f.write(asl::string_view(static_cast<const char*>(kZeros), to_write));
             decimal.exponent -= to_write;
         }
     }
@@ -86,8 +87,8 @@ static void format_float(asl::Formatter& f, T value)
             decimal.exponent = -decimal.exponent - static_cast<int>(digits.size());
             while (decimal.exponent > 0)
             {
-                isize_t to_write = asl::min(static_cast<isize_t>(decimal.exponent), kZeroCount);
+                const isize_t to_write = asl::min(static_cast<isize_t>(decimal.exponent), kZeroCount);
-                f.write(asl::string_view(kZeros, to_write));
+                f.write(asl::string_view(static_cast<const char*>(kZeros), to_write));
                 decimal.exponent -= to_write;
             }
             f.write(digits);

asl/hashing/hash.hpp

@@ -80,7 +80,7 @@ struct HashState
         {
             auto bytes = as_bytes(s);
             auto hashed = city_hash::CityHash128WithSeed(
-                reinterpret_cast<const char*>(bytes.data()),
+                reinterpret_cast<const char*>(bytes.data()), // NOLINT(*-reinterpret-cast)
                 static_cast<size_t>(bytes.size()),
                 h.state);
             return HashState{hashed};
@@ -89,7 +89,7 @@ struct HashState
         {
             for (const auto& value: s)
             {
-                h = AslHashValue(ASL_MOVE(h), value);
+                h = AslHashValue(std::move(h), value);
             }
             return h;
         }
@@ -103,7 +103,7 @@ struct HashState
     template<hashable_generic<HashState> Arg, hashable_generic<HashState>... Remaining>
     static constexpr HashState combine(HashState h, const Arg& arg, const Remaining&... remaining)
     {
-        return combine(AslHashValue(ASL_MOVE(h), arg), remaining...);
+        return combine(AslHashValue(std::move(h), arg), remaining...);
     }
 };
 
@@ -113,13 +113,13 @@ concept hashable = hashable_generic<T, HashState>;
 template<typename H, uniquely_represented T>
 constexpr H AslHashValue(H h, const T& value)
 {
-    return H::combine_contiguous(ASL_MOVE(h), span<const T>{&value, 1});
+    return H::combine_contiguous(std::move(h), span<const T>{&value, 1});
 }
 
 template<typename H>
 constexpr H AslHashValue(H h, bool value)
 {
-    return AslHashValue(ASL_MOVE(h), value ? 1 : 0);
+    return AslHashValue(std::move(h), value ? 1 : 0);
 }
 
 template<typename H, typename T>
@@ -128,7 +128,7 @@ constexpr void AslHashValue(H h, T*); // Don't hash pointers
 template<typename H, hashable T>
 constexpr H AslHashValue(H h, const span<T>& s)
 {
-    return H::combine_contiguous(ASL_MOVE(h), span<const T>{s.data(), s.size()});
+    return H::combine_contiguous(std::move(h), span<const T>{s.data(), s.size()});
 }
 
 template<hashable T>

asl/hashing/hash_tests.cpp

@@ -29,10 +29,10 @@ static_assert(asl::hashable<int64_t>);
 
 ASL_TEST(integers)
 {
-    uint64_t a = asl::hash_value<uint16_t>(45);
+    const uint64_t a = asl::hash_value<uint16_t>(45);
-    uint64_t b = asl::hash_value<uint16_t>(45);
+    const uint64_t b = asl::hash_value<uint16_t>(45);
-    uint64_t c = asl::hash_value<uint16_t>(46);
+    const uint64_t c = asl::hash_value<uint16_t>(46);
-    uint64_t d = asl::hash_value<uint32_t>(45);
+    const uint64_t d = asl::hash_value<uint32_t>(45);
 
     ASL_TEST_EXPECT(a == b);
     ASL_TEST_EXPECT(a != c);
@@ -187,19 +187,19 @@ static_assert(asl::uniquely_represented<asl::option<NonZero>>);
 
 ASL_TEST(option)
 {
-    asl::option<int> int1 = 0;
+    const asl::option<int> int1 = 0;
-    asl::option<int> int2 = 0;
+    const asl::option<int> int2 = 0;
-    asl::option<int> int3 = 1;
+    const asl::option<int> int3 = 1;
-    asl::option<int> int4 = asl::nullopt;
+    const asl::option<int> int4 = asl::nullopt;
 
     ASL_TEST_EXPECT(asl::hash_value(int1) == asl::hash_value(int2));
     ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int3));
     ASL_TEST_EXPECT(asl::hash_value(int1) != asl::hash_value(int4));
 
-    asl::option<NonZero> noz1{8};
+    const asl::option<NonZero> noz1{8};
-    asl::option<NonZero> noz2{8};
+    const asl::option<NonZero> noz2{8};
-    asl::option<NonZero> noz3{9};
+    const asl::option<NonZero> noz3{9};
-    asl::option<NonZero> noz4 = asl::nullopt;
+    const asl::option<NonZero> noz4 = asl::nullopt;
 
     ASL_TEST_EXPECT(asl::hash_value(noz1) == asl::hash_value(noz2));
     ASL_TEST_EXPECT(asl::hash_value(noz1) != asl::hash_value(noz3));
@@ -208,17 +208,18 @@ ASL_TEST(option)
 
 static_assert(asl::hashable<asl::status>);
 
+// NOLINTNEXTLINE(*-cognitive-complexity)
 ASL_TEST(status)
 {
-    asl::status s1 = asl::ok();
+    const asl::status s1 = asl::ok();
-    asl::status s2 = asl::ok();
+    const asl::status s2 = asl::ok();
-    asl::status s3 = asl::internal_error();
+    const asl::status s3 = asl::internal_error();
-    asl::status s4 = asl::internal_error();
+    const asl::status s4 = asl::internal_error();
-    asl::status s5 = asl::runtime_error();
+    const asl::status s5 = asl::runtime_error();
-    asl::status s6 = asl::internal_error("Oh, no!");
+    const asl::status s6 = asl::internal_error("Oh, no!");
-    asl::status s7 = asl::internal_error("Oh, no!");
+    const asl::status s7 = asl::internal_error("Oh, no!");
-    asl::status s8 = asl::internal_error("Oh, no");
+    const asl::status s8 = asl::internal_error("Oh, no");
-    asl::status s9 = asl::runtime_error("Oh, no!");
+    const asl::status s9 = asl::runtime_error("Oh, no!");
 
     ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));
     ASL_TEST_EXPECT(asl::hash_value(s3) == asl::hash_value(s4));
@@ -244,13 +245,13 @@ static_assert(!asl::hashable<asl::status_or<int*>>);
 
 ASL_TEST(status_or)
 {
-    asl::status_or<int> s1 = 42;
+    const asl::status_or<int> s1 = 42;
-    asl::status_or<int> s2 = 42;
+    const asl::status_or<int> s2 = 42;
-    asl::status_or<int> s3 = 43;
+    const asl::status_or<int> s3 = 43;
-    asl::status_or<int> s4 = asl::runtime_error();
+    const asl::status_or<int> s4 = asl::runtime_error();
-    asl::status_or<int> s5 = asl::runtime_error();
+    const asl::status_or<int> s5 = asl::runtime_error();
-    asl::status_or<int> s6 = asl::runtime_error("Hello");
+    const asl::status_or<int> s6 = asl::runtime_error("Hello");
-    asl::status_or<int> s7 = asl::runtime_error("Hello");
+    const asl::status_or<int> s7 = asl::runtime_error("Hello");
 
     ASL_TEST_EXPECT(asl::hash_value(s1) == asl::hash_value(s2));
     ASL_TEST_EXPECT(asl::hash_value(s4) == asl::hash_value(s5));

asl/io/print.cpp

@@ -18,7 +18,7 @@ public:
 
     void write(asl::span<const asl::byte> s) override
     {
-        fwrite(s.data(), 1, static_cast<size_t>(s.size()), m_handle);
+        (void)fwrite(s.data(), 1, static_cast<size_t>(s.size()), m_handle);
     }
 };
 

asl/logging/logging.cpp

@@ -3,14 +3,22 @@
 // SPDX-License-Identifier: BSD-3-Clause
 
 #include "asl/logging/logging.hpp"
+
+#include "asl/containers/intrusive_list.hpp"
+#include "asl/formatting/format.hpp"
 #include "asl/io/print.hpp"
+#include "asl/io/writer.hpp"
 #include "asl/strings/string_builder.hpp"
+#include "asl/strings/string_view.hpp"
+#include "asl/types/span.hpp"
 
 // @Todo Don't use internal get_stdout_writer, make console module
 
+// NOLINTNEXTLINE(*-avoid-non-const-global-variables)
 static asl::log::DefaultLogger<asl::Writer*> g_default_logger{asl::print_internals::get_stdout_writer()};
 
 // @Todo Protect the loggers list being a mutex
+// NOLINTNEXTLINE(*-avoid-non-const-global-variables)
 static asl::IntrusiveList<asl::log::Logger> g_loggers(&g_default_logger);
 
 void asl::log::register_logger(Logger* logger)
@@ -56,7 +64,7 @@ void asl::log::log_inner(
     StringWriter msg_writer{};
     asl::format_internals::format(&msg_writer, fmt, args);
 
-    message m{
+    const message m{
         .level = l,
         .message = msg_writer.as_string_view(),
         .location = sl,

asl/logging/logging.hpp

@@ -48,7 +48,11 @@ class DefaultLogger : public DefaultLoggerBase
     W m_writer;
 
 public:
-    explicit constexpr DefaultLogger(W&& writer) : m_writer{ASL_FWD(writer)} {}
+    template<typename U>
+    explicit constexpr DefaultLogger(U&& writer)
+        requires constructible_from<W, U&&>
+        : m_writer{std::forward<U>(writer)}
+    {}
 
     constexpr void log(const message& m) override
     {
@@ -74,7 +78,7 @@ void log(level l, const source_location& sl, string_view fmt, const Args&... arg
     }
     else
     {
-        format_internals::type_erased_arg type_erased_args[] = {
+        const format_internals::type_erased_arg type_erased_args[] = {
             format_internals::type_erased_arg(args)...
         };
         log_inner(l, fmt, type_erased_args, sl);

asl/logging/logging_tests.cpp

@@ -2,10 +2,11 @@
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
-#include "asl/logging/logging.hpp"
-#include "asl/testing/testing.hpp"
-#include "asl/strings/string_builder.hpp"
 #include "asl/base/defer.hpp"
+#include "asl/logging/logging.hpp"
+#include "asl/strings/string_builder.hpp"
+#include "asl/strings/string_view.hpp"
+#include "asl/testing/testing.hpp"
 
 ASL_TEST(log)
 {
@@ -27,6 +28,6 @@ ASL_TEST(custom_writer)
     ASL_LOG_INFO("Hello");
     auto sv = string_writer.as_string_view();
 
-    ASL_TEST_EXPECT(sv == "[  INFO   ] asl/logging/logging_tests.cpp:27: Hello\n");
+    ASL_TEST_EXPECT(sv == "[  INFO   ] asl/logging/logging_tests.cpp:28: Hello\n");
 }
 

asl/memory/BUILD.bazel

@@ -9,16 +9,27 @@ package(
 cc_library(
     name = "memory",
     hdrs = [
-        "allocator.hpp",
         "layout.hpp",
         "memory.hpp",
     ],
-    srcs = [
-        "allocator.cpp",
-    ],
     deps = [
         "//asl/base",
     ],
     visibility = ["//visibility:public"],
 )
 
+cc_library(
+    name = "allocator",
+    hdrs = [
+        "allocator.hpp",
+    ],
+    srcs = [
+        "allocator.cpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/memory",
+    ],
+    visibility = ["//visibility:public"],
+)
+

asl/memory/allocator.hpp

@@ -37,7 +37,7 @@ template<typename T>
 T* alloc_new(allocator auto& a, auto&&... args)
 {
     void* ptr = a.alloc(layout::of<T>());
-    return construct_at<T>(ptr, ASL_FWD(args)...);
+    return construct_at<T>(ptr, std::forward<decltype(args)>(args)...);
 }
 
 template<typename T>
@@ -50,13 +50,15 @@ void alloc_delete(allocator auto& a, T* ptr)
 template<typename T>
 constexpr T* alloc_new_default(auto&&... args)
 {
-    return alloc_new<T>(DefaultAllocator{}, ASL_FWD(args)...);
+    DefaultAllocator allocator{};
+    return alloc_new<T>(allocator, std::forward<decltype(args)>(args)...);
 }
 
 template<typename T>
 void alloc_delete_default(T* ptr)
 {
-    alloc_delete(DefaultAllocator{}, ptr);
+    DefaultAllocator allocator{};
+    alloc_delete(allocator, ptr);
 }
 
 } // namespace asl

asl/memory/memory.hpp

@@ -9,7 +9,7 @@
 #include "asl/base/utility.hpp"
 #include "asl/memory/layout.hpp"
 
-constexpr void* operator new(size_t, void* ptr)
+constexpr void* operator new(size_t, void* ptr) noexcept
 {
     return ptr;
 }
@@ -17,6 +17,17 @@ constexpr void* operator new(size_t, void* ptr)
 namespace asl
 {
 
+template<typename T>
+[[nodiscard]]
+constexpr T* address_of(T& obj)
+{
+    return __builtin_addressof(obj);
+}
+
+template<typename T>
+void address_of(const T&& obj) = delete;
+
+[[nodiscard]]
 constexpr isize_t memcmp(const void* a, const void* b, isize_t size)
 {
     return __builtin_memcmp(a, b, static_cast<size_t>(size));
@@ -41,7 +52,7 @@ template<typename T, typename... Args>
 constexpr T* construct_at(void* ptr, Args&&... args)
     requires constructible_from<T, Args&&...>
 {
-    return new (ptr) T{ ASL_FWD(args)... };
+    return new (ptr) T{ std::forward<Args>(args)... }; // NOLINT(*-owning-memory)
 }
 
 template<typename T>
@@ -112,7 +123,7 @@ constexpr void relocate_uninit_n(T* to, T* from, isize_t n)
         for (isize_t i = 0; i < n; ++i)
         {
             // NOLINTNEXTLINE(*-pointer-arithmetic)
-            construct_at<T>(to + i, ASL_MOVE(from[i]));
+            construct_at<T>(to + i, std::move(from[i]));
         }
         destroy_n(from, n);
     }
@@ -131,7 +142,7 @@ constexpr void relocate_assign_n(T* to, T* from, isize_t n)
         for (isize_t i = 0; i < n; ++i)
         {
             // NOLINTNEXTLINE(*-pointer-arithmetic)
-            to[i] = ASL_MOVE(from[i]);
+            to[i] = std::move(from[i]);
         }
         destroy_n(from, n);
     }

asl/strings/string.hpp

@@ -11,12 +11,12 @@ namespace asl
 {
 
 template<allocator Allocator = DefaultAllocator>
-class string
+class string : protected buffer<char, Allocator>
 {
-    buffer<char, Allocator> m_buffer;
+    using Base = buffer<char, Allocator>;
 
-    explicit constexpr string(buffer<char, Allocator>&& buffer) :
+    explicit constexpr string(buffer<char, Allocator>&& b) :
-        m_buffer{ASL_MOVE(buffer)}
+        Base{std::move(b)}
     {}
 
     template<allocator A>
@@ -24,38 +24,36 @@ class string
 
 public:
     constexpr string() requires default_constructible<Allocator> = default;
-    explicit constexpr string(Allocator allocator) : m_buffer{ASL_MOVE(allocator)} {}
 
-    // NOLINTNEXTLINE(*-explicit-conversions)
+    explicit constexpr string(Allocator allocator)
+        : Base{std::move(allocator)}
+    {}
+
+    // NOLINTNEXTLINE(*explicit*)
     constexpr string(string_view sv)
         requires default_constructible<Allocator>
-        : m_buffer{sv.as_span()}
+        : Base{sv.as_span()}
     {}
 
     constexpr string(string_view sv, Allocator allocator)
-        : m_buffer{sv.as_span(), ASL_MOVE(allocator)}
+        : Base{sv.as_span(), std::move(allocator)}
     {}
 
-    constexpr ~string() = default;
+    using Base::size;
 
-    constexpr string(const string&) requires copy_constructible<Allocator> = default;
+    using Base::is_empty;
-    constexpr string(string&&) = default;
 
-    constexpr string& operator=(const string&) requires copy_assignable<Allocator> = default;
+    [[nodiscard]] constexpr const char* data() const { return Base::data(); }
-    constexpr string& operator=(string&&) = default;
 
-    constexpr isize_t size() const { return m_buffer.size(); }
+    // NOLINTNEXTLINE(*explicit*)
-    constexpr const char* data() const { return m_buffer.data(); }
-
-    // NOLINTNEXTLINE(*-explicit-conversions)
     constexpr operator string_view() const
     {
         return as_string_view();
     }
 
-    constexpr string_view as_string_view() const
+    [[nodiscard]] constexpr string_view as_string_view() const
     {
-        auto span = m_buffer.as_span();
+        auto span = Base::as_span();
         return string_view{span.data(), span.size()};
     }
 

asl/strings/string_builder.hpp

@@ -20,7 +20,7 @@ class StringBuilder
 
 public:
     constexpr StringBuilder() requires default_constructible<Allocator> = default;
-    explicit constexpr StringBuilder(Allocator allocator) : m_buffer{ASL_MOVE(allocator)} {}
+    explicit constexpr StringBuilder(Allocator allocator) : m_buffer{std::move(allocator)} {}
 
     constexpr ~StringBuilder() = default;
 
@@ -30,7 +30,7 @@ public:
     constexpr StringBuilder& operator=(const StringBuilder&) requires copy_assignable<Allocator> = default;
     constexpr StringBuilder& operator=(StringBuilder&&) = default;
 
-    constexpr string_view as_string_view() const
+    [[nodiscard]] constexpr string_view as_string_view() const
     {
         auto span = m_buffer.as_span();
         return string_view{span.data(), span.size()};
@@ -44,23 +44,23 @@ public:
     auto push(this auto&& self, string_view sv) -> decltype(self)
         requires (!is_const<un_ref_t<decltype(self)>>)
     {
-        isize_t old_size = self.m_buffer.size();
+        const isize_t old_size = self.m_buffer.size();
-        self.m_buffer.resize_zero(old_size + sv.size());
+        self.m_buffer.resize_uninit(old_size + sv.size());
         // NOLINTNEXTLINE(*-pointer-arithmetic)
         asl::memcpy(self.m_buffer.data() + old_size, sv.data(), sv.size());
-        return ASL_FWD(self);
+        return std::forward<decltype(self)>(self);
     }
 
     auto push(this auto&& self, char c) -> decltype(self)
         requires (!is_const<un_ref_t<decltype(self)>>)
     {
         self.m_buffer.push(c);
-        return ASL_FWD(self);
+        return std::forward<decltype(self)>(self);
     }
 
     string<Allocator> finish() &&
     {
-        return string<Allocator>{ASL_MOVE(m_buffer)};
+        return string<Allocator>{std::move(m_buffer)};
     }
 
     template<allocator StringAllocator = Allocator>
@@ -73,7 +73,7 @@ public:
     template<allocator StringAllocator = Allocator>
     string<StringAllocator> as_string(Allocator allocator) const
     {
-        return string<StringAllocator>{as_string_view(), ASL_MOVE(allocator)};
+        return string<StringAllocator>{as_string_view(), std::move(allocator)};
     }
 };
 
@@ -86,7 +86,7 @@ class StringWriter : public asl::Writer
 
 public:
     constexpr StringWriter() requires default_constructible<Allocator> = default;
-    explicit constexpr StringWriter(Allocator allocator) : m_builder{ASL_MOVE(allocator)} {}
+    explicit constexpr StringWriter(Allocator allocator) : m_builder{std::move(allocator)} {}
 
     constexpr ~StringWriter() override = default;
 
@@ -98,17 +98,18 @@ public:
 
     void write(span<const byte> str) override
     {
+        // NOLINTNEXTLINE(*-reinterpret-cast)
         m_builder.push(string_view{reinterpret_cast<const char*>(str.data()), str.size()});
     }
 
-    constexpr string_view as_string_view() const
+    [[nodiscard]] constexpr string_view as_string_view() const
     {
         return m_builder.as_string_view();
     }
 
     string<Allocator> finish() &&
     {
-        return ASL_MOVE(m_builder).finish();
+        return std::move(m_builder).finish();
     }
 
     template<allocator StringAllocator = Allocator>
@@ -121,7 +122,7 @@ public:
     template<allocator StringAllocator = Allocator>
     string<StringAllocator> as_string(Allocator allocator) const
     {
-        return m_builder.as_string(ASL_MOVE(allocator));
+        return m_builder.as_string(std::move(allocator));
     }
 };
 
@@ -133,15 +134,15 @@ string<Allocator> format_to_string(string_view fmt, const formattable auto&... a
 {
     StringWriter writer{};
     format(&writer, fmt, args...);
-    return ASL_MOVE(writer).finish();
+    return std::move(writer).finish();
 }
 
 template<allocator Allocator = DefaultAllocator>
 string<Allocator> format_to_string(Allocator allocator, string_view fmt, const formattable auto&... args)
 {
-    StringWriter writer{ASL_MOVE(allocator)};
+    StringWriter writer{std::move(allocator)};
     format(&writer, fmt, args...);
-    return ASL_MOVE(writer).finish();
+    return std::move(writer).finish();
 }
 
 } // namespace asl

asl/strings/string_builder_tests.cpp

@@ -14,13 +14,13 @@ ASL_TEST(string_builder)
 
     ASL_TEST_EXPECT(b.as_string_view() == "abcdefg");
 
-    asl::string s = b.as_string();
+    const asl::string s = b.as_string();
     ASL_TEST_EXPECT(s == "abcdefg");
 }
 
 ASL_TEST(string_builder_rvalue)
 {
-    asl::string s = asl::StringBuilder{}.push('a').push("bcdef").push('g').finish();
+    const asl::string s = asl::StringBuilder{}.push('a').push("bcdef").push('g').finish();
 
     ASL_TEST_EXPECT(s == "abcdefg");
 }

asl/strings/string_tests.cpp

@@ -8,7 +8,7 @@
 
 ASL_TEST(default)
 {
-    asl::string s;
+    const asl::string s;
     ASL_TEST_ASSERT(s.size() == 0);
     ASL_TEST_ASSERT(s.as_string_view().size() == 0);
     ASL_TEST_ASSERT(s == ""_sv);
@@ -17,7 +17,7 @@ ASL_TEST(default)
 
 ASL_TEST(from_string_view)
 {
-    asl::string s = "hello"_sv;
+    const asl::string s = "hello"_sv;
     ASL_TEST_ASSERT(s.size() == 5);
     ASL_TEST_ASSERT(s == "hello"_sv);
 }

asl/strings/string_view.hpp

@@ -12,6 +12,7 @@
 namespace asl
 {
 
+// NOLINTBEGIN(*-convert-member-functions-to-static)
 class string_view
 {
     const char* m_data{};
@@ -20,7 +21,7 @@ class string_view
 public:
     constexpr string_view() = default;
 
-    constexpr string_view(nullptr_t) : string_view() {} // NOLINT(*-explicit-conversions)
+    constexpr string_view(nullptr_t) : string_view() {} // NOLINT(*explicit*)
 
     constexpr string_view(const char* data, isize_t size)
         : m_data{data}
@@ -28,9 +29,9 @@ public:
     {}
 
     template<isize_t kSize>
-    constexpr string_view(const char (&str)[kSize]) // NOLINT(*-explicit-conversions)
+    constexpr string_view(const char (&str)[kSize]) // NOLINT(*explicit*)
         requires (kSize >= 1)
-        : m_data{str}
+        : m_data{static_cast<const char*>(str)}
         , m_size{kSize - 1}
     {
         ASL_ASSERT(m_data[kSize - 1] == '\0'); // NOLINT(*-pointer-arithmetic)
@@ -38,7 +39,7 @@ public:
 
     static constexpr string_view from_zstr(const char* str)
     {
-        return string_view(str, asl::strlen(str));
+        return {str, asl::strlen(str)};
     }
 
     constexpr string_view(const string_view&) = default;
@@ -49,51 +50,69 @@ public:
 
     ~string_view() = default;
 
-    constexpr isize_t size() const { return m_size; }
+    [[nodiscard]] constexpr isize_t size(this string_view self)
+    {
+        return self.m_size;
+    }
 
-    constexpr bool is_empty() const { return m_size == 0; }
+    [[nodiscard]] constexpr bool is_empty(this string_view self)
+    {
+        return self.m_size == 0;
+    }
 
-    constexpr const char* data() const { return m_data; }
+    [[nodiscard]] constexpr const char* data(this string_view self)
+    {
+        return self.m_data;
+    }
 
-    constexpr contiguous_iterator<const char> begin() const { return contiguous_iterator{m_data}; }
+    [[nodiscard]] constexpr contiguous_iterator<const char> begin(this string_view self)
+    {
+        return contiguous_iterator{self.m_data};
+    }
 
+    [[nodiscard]] constexpr contiguous_iterator<const char> end(this string_view self)
+    {
         // NOLINTNEXTLINE(*-pointer-arithmetic)
-    constexpr contiguous_iterator<const char> end() const { return contiguous_iterator{m_data + m_size}; }
+        return contiguous_iterator{self.m_data + self.m_size};
-
-    constexpr span<const char> as_span() const { return span<const char>(m_data, m_size); }
-
-    constexpr char operator[](isize_t i) const
-    {
-        ASL_ASSERT(i >= 0 && i < m_size);
-        return m_data[i]; // NOLINT(*-pointer-arithmetic)
     }
 
-    constexpr string_view substr(isize_t offset, isize_t size) const
+    [[nodiscard]] constexpr span<const char> as_span(this string_view self)
     {
-        ASL_ASSERT(offset >= 0 && size >= 0 && offset + size <= m_size);
+        return {self.m_data, self.m_size};
-        return string_view{m_data + offset, size}; // NOLINT(*-pointer-arithmetic)
     }
 
-    constexpr string_view substr(isize_t offset) const
+    [[nodiscard]] constexpr char operator[](this string_view self, isize_t i)
     {
-        ASL_ASSERT(offset >= 0 && offset <= m_size);
+        ASL_ASSERT(i >= 0 && i < self.m_size);
-        return string_view{m_data + offset, m_size - offset}; // NOLINT(*-pointer-arithmetic)
+        return self.m_data[i]; // NOLINT(*-pointer-arithmetic)
     }
 
-    constexpr string_view first(isize_t size) const
+    [[nodiscard]] constexpr string_view substr(this string_view self, isize_t offset, isize_t size)
     {
-        return substr(0, size);
+        ASL_ASSERT(offset >= 0 && size >= 0 && offset + size <= self.m_size);
+        return string_view{self.m_data + offset, size}; // NOLINT(*-pointer-arithmetic)
     }
 
-    constexpr string_view last(isize_t size) const
+    [[nodiscard]] constexpr string_view substr(this string_view self, isize_t offset)
     {
-        return substr(m_size - size);
+        ASL_ASSERT(offset >= 0 && offset <= self.m_size);
+        return string_view{self.m_data + offset, self.m_size - offset}; // NOLINT(*-pointer-arithmetic)
     }
 
-    constexpr bool operator==(string_view other) const
+    [[nodiscard]] constexpr string_view first(this string_view self, isize_t size)
     {
-        if (m_size != other.m_size) { return false; }
+        return self.substr(0, size);
-        return memcmp(m_data, other.m_data, m_size) == 0;
+    }
+
+    [[nodiscard]] constexpr string_view last(this string_view self, isize_t size)
+    {
+        return self.substr(self.m_size - size);
+    }
+
+    constexpr bool operator==(this string_view self, string_view other)
+    {
+        if (self.m_size != other.m_size) { return false; }
+        return asl::memcmp(self.m_data, other.m_data, self.m_size) == 0;
     }
 
     template<typename H>
@@ -102,10 +121,11 @@ public:
         return H::combine(H::combine_contiguous(h, as_bytes(sv.as_span())), sv.size());
     }
 };
+// NOLINTEND(*-convert-member-functions-to-static)
 
 } // namespace asl
 
 constexpr asl::string_view operator ""_sv(const char* s, size_t len)
 {
-    return asl::string_view(s, static_cast<isize_t>(len));
+    return {s, static_cast<isize_t>(len)};
 }

asl/strings/string_view_tests.cpp

@@ -10,20 +10,20 @@ static_assert(asl::trivially_copy_constructible<asl::string_view>);
 
 ASL_TEST(default)
 {
-    asl::string_view s1;
+    const asl::string_view s1;
     ASL_TEST_EXPECT(s1.is_empty());
 
-    asl::string_view s2 = nullptr;
+    const asl::string_view s2 = nullptr;
     ASL_TEST_EXPECT(s2.is_empty());
 }
 
 ASL_TEST(from_literal)
 {
-    asl::string_view s1 = "Hello"_sv;
+    const asl::string_view s1 = "Hello"_sv;
     ASL_TEST_ASSERT(s1.size() == 5);
     ASL_TEST_EXPECT(asl::memcmp(s1.data(), "Hello", 5) == 0);
 
-    asl::string_view s2 = ""_sv;
+    const asl::string_view s2 = ""_sv;
     ASL_TEST_EXPECT(s2.is_empty());
 }
 
@@ -47,7 +47,7 @@ ASL_TEST(from_zstr)
 
 ASL_TEST(substr1)
 {
-    asl::string_view s1 = "abcd";
+    const asl::string_view s1 = "abcd";
 
     asl::string_view s2 = s1.substr(0);
     ASL_TEST_ASSERT(s2.size() == 4);
@@ -63,7 +63,7 @@ ASL_TEST(substr1)
 
 ASL_TEST(substr2)
 {
-    asl::string_view s1 = "abcd";
+    const asl::string_view s1 = "abcd";
 
     asl::string_view s2 = s1.substr(0, 4);
     ASL_TEST_ASSERT(s2.size() == 4);
@@ -82,7 +82,7 @@ ASL_TEST(substr2)
 
 ASL_TEST(first)
 {
-    asl::string_view s1 = "abcd";
+    const asl::string_view s1 = "abcd";
 
     asl::string_view s2 = s1.first(0);
     ASL_TEST_ASSERT(s2.size() == 0);
@@ -98,7 +98,7 @@ ASL_TEST(first)
 
 ASL_TEST(last)
 {
-    asl::string_view s1 = "abcd";
+    const asl::string_view s1 = "abcd";
 
     asl::string_view s2 = s1.last(0);
     ASL_TEST_ASSERT(s2.size() == 0);

asl/testing/testing.cpp

@@ -4,37 +4,51 @@
 
 #include "asl/testing/testing.hpp"
 
+#include "asl/base/assert.hpp"
+#include "asl/base/meta.hpp"
+#include "asl/base/utility.hpp"
 #include "asl/io/print.hpp"
 
-static asl::testing::Test* g_head = nullptr;
+namespace
-static asl::testing::Test* g_tail = nullptr;
+{
+
+struct TestingState
+{
+    asl::testing::Test* head = nullptr;
+    asl::testing::Test* tail = nullptr;
+
+    bool current_test_fail = false;
+};
+
+}  // namespace
+
+// NOLINTNEXTLINE(*-avoid-non-const-global-variables)
+static TestingState g_state{};
 
 void asl::testing::register_test(Test* test)
 {
-    if (g_head == nullptr && g_tail == nullptr)
+    if (g_state.head == nullptr && g_state.tail == nullptr)
     {
-        g_head = test;
+        g_state.head = test;
-        g_tail = test;
+        g_state.tail = test;
     }
     else
     {
-        g_tail->m_next = test;
+        g_state.tail->m_next = test;
-        test->m_prev = asl::exchange(g_tail, test);
+        test->m_prev = asl::exchange(g_state.tail, test);
     }
 }
 
-static bool g_current_test_fail = false;
-
 void asl::testing::report_failure(const char* msg, const asl::source_location& sl)
 {
     asl::eprint("--------------------------------------------------------------\n");
     asl::eprint("Test assertion failed at {}, line {}:\n", sl.file, sl.line);
     asl::eprint("    {}\n", msg);
     asl::eprint("--------------------------------------------------------------\n");
-    g_current_test_fail = true;
+    g_state.current_test_fail = true;
 }
 
-static void report_assert_failure(const char* msg, const asl::source_location& sl, void*)
+static void report_assert_failure(const char* msg, const asl::source_location& sl, void* /* userdata */)
 {
     asl::eprint("------------------------------------------------------------\n");
     asl::eprint("Assertion failure at {}, line {}:\n", sl.file, sl.line);
@@ -55,14 +69,14 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
 
     asl::testing::Test* failed_head = nullptr;
 
-    for (auto* it = g_head; it != nullptr; it = it->m_next)
+    for (auto* it = g_state.head; it != nullptr; it = it->m_next)
     {
         asl::eprint(GREEN("[ RUN      ]") " {}\n", it->m_case_name);
 
-        g_current_test_fail = false;
+        g_state.current_test_fail = false;
         it->m_fn();
 
-        if (!g_current_test_fail)
+        if (!g_state.current_test_fail)
         {
             asl::eprint(GREEN("[       OK ]") " {}\n", it->m_case_name);
             pass += 1;

asl/testing/testing.hpp

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "asl/base/utility.hpp"
+#include "asl/base/meta.hpp"
 
 namespace asl::testing
 {
@@ -35,7 +35,8 @@ struct Test
 } // namespace asl::testing
 
 #define ASL_TEST(CASE)                              \
-    static void asl_test_fn_##CASE();               \
+    static void asl_test_fn_##CASE(); /* NOLINT */  \
+    /* NOLINTNEXTLINE */                            \
     static ::asl::testing::Test asl_test_##CASE(    \
         #CASE,                                      \
         asl_test_fn_##CASE);                        \
@@ -45,6 +46,6 @@ struct Test
     if (EXPR) {}              \
     else { ::asl::testing::report_failure(#EXPR); return; }
 
-#define ASL_TEST_EXPECT(EXPR) \
+#define ASL_TEST_EXPECT(...) \
-    if (EXPR) {}              \
+    if (__VA_ARGS__) {}      \
-    else { ::asl::testing::report_failure(#EXPR); }
+    else { ::asl::testing::report_failure(#__VA_ARGS__); }

asl/types/BUILD.bazel

@@ -14,6 +14,7 @@ cc_library(
     deps = [
         "//asl/base",
         "//asl/memory",
+        "//asl/memory:allocator",
         "//asl/hashing",
     ],
     visibility = ["//visibility:public"],
@@ -78,6 +79,51 @@ cc_library(
     visibility = ["//visibility:public"],
 )
 
+cc_library(
+    name = "function",
+    hdrs = [
+        "function.hpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/memory",
+        "//asl/memory:allocator",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "function_ref",
+    hdrs = [
+        "function_ref.hpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/memory",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_test(
+    name = "function_tests",
+    srcs = ["function_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:function",
+    ],
+)
+
+cc_test(
+    name = "function_ref_tests",
+    srcs = ["function_ref_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:function_ref",
+    ],
+)
+
 cc_test(
     name = "box_tests",
     srcs = ["box_tests.cpp"],

asl/types/box.hpp

@@ -29,21 +29,21 @@ public:
 
     constexpr box(T* ptr, Allocator alloc)
         : m_ptr{ptr}
-        , m_alloc{ASL_MOVE(alloc)}
+        , m_alloc{std::move(alloc)}
     {
         ASL_ASSERT(m_ptr != nullptr);
     }
 
     constexpr box(box&& other)
         : m_ptr{exchange(other.m_ptr, nullptr)}
-        , m_alloc{ASL_MOVE(other.m_alloc)}
+        , m_alloc{std::move(other.m_alloc)}
     {}
 
     template<is_object U>
-    requires convertible_from<T*, U*>
+    requires convertible_to<U*, T*>
-    constexpr box(box<U, Allocator>&& other) // NOLINT(*-explicit-conversions)
+    constexpr box(box<U, Allocator>&& other) // NOLINT(*explicit*,*-not-moved)
         : m_ptr{exchange(other.m_ptr, nullptr)}
-        , m_alloc{ASL_MOVE(other.m_alloc)}
+        , m_alloc{std::move(other.m_alloc)}
     {}
 
     constexpr box& operator=(box&& other)
@@ -53,7 +53,7 @@ public:
         if (m_ptr != nullptr) { reset(); }
 
         m_ptr = exchange(other.m_ptr, nullptr);
-        m_alloc = ASL_MOVE(other.m_alloc);
+        m_alloc = std::move(other.m_alloc);
 
         return *this;
     }
@@ -76,18 +76,21 @@ public:
         }
     }
 
-    constexpr T* get() const { return m_ptr; }
+    constexpr auto* get(this auto&& self)
-
-    constexpr T& operator*() const
     {
-        ASL_ASSERT(m_ptr != nullptr);
+        return self.m_ptr;
-        return *m_ptr;
     }
 
-    constexpr T* operator->() const
+    constexpr auto&& operator*(this auto&& self)
     {
-        ASL_ASSERT(m_ptr != nullptr);
+        ASL_ASSERT(self.m_ptr != nullptr);
-        return m_ptr;
+        return std::forward_like<decltype(self)&&>(*self.m_ptr);
+    }
+
+    constexpr auto* operator->(this auto&& self)
+    {
+        ASL_ASSERT(self.m_ptr != nullptr);
+        return self.m_ptr;
     }
 
     constexpr bool operator==(niche_t) const
@@ -99,7 +102,7 @@ public:
     requires hashable<T>
     friend H AslHashValue(H h, const box& b)
     {
-        return H::combine(ASL_MOVE(h), *b);
+        return H::combine(std::move(h), *b);
     }
 
     template<is_object U, allocator A>
@@ -114,8 +117,8 @@ constexpr box<T, Allocator> make_box_in(Allocator allocator, Args&&... args)
     requires constructible_from<T, Args&&...>
 {
     void* raw_ptr = allocator.alloc(layout::of<T>());
-    auto* ptr = construct_at<T>(raw_ptr, ASL_FWD(args)...);
+    auto* ptr = construct_at<T>(raw_ptr, std::forward<Args>(args)...);
-    return box(ptr, ASL_MOVE(allocator));
+    return box(ptr, std::move(allocator));
 }
 
 template<is_object T, allocator Allocator = DefaultAllocator, typename... Args>
@@ -124,14 +127,14 @@ constexpr box<T, Allocator> make_box(Args&&... args)
 {
     Allocator allocator{};
     void* raw_ptr = allocator.alloc(layout::of<T>());
-    auto* ptr = construct_at<T>(raw_ptr, ASL_FWD(args)...);
+    auto* ptr = construct_at<T>(raw_ptr, std::forward<Args>(args)...);
-    return box<T>(ptr, ASL_MOVE(allocator));
+    return box<T>(ptr, std::move(allocator));
 }
 
 template<is_object T, allocator A>
 constexpr T* leak(box<T, A>&& b)
 {
-    return exchange(b.m_ptr, nullptr);
+    return exchange(std::move(b).m_ptr, nullptr);
 }
 
 } // namespace asl

asl/types/box_tests.cpp

@@ -23,7 +23,7 @@ ASL_TEST(destructor)
         ASL_TEST_ASSERT(!d);
 
 
-        auto box3 = ASL_MOVE(box);
+        auto box3 = std::move(box);
         ASL_TEST_ASSERT(!d);
     }
 
@@ -35,7 +35,7 @@ ASL_TEST(value)
     auto b = asl::make_box<int>(24);
     ASL_TEST_EXPECT(*b == 24);
 
-    auto b2 = ASL_MOVE(b);
+    auto b2 = std::move(b);
     ASL_TEST_EXPECT(*b2 == 24);
 }
 
@@ -44,7 +44,7 @@ ASL_TEST(ptr)
     auto b = asl::make_box<int>(24);
     auto* ptr1 = b.get();
 
-    auto b2 = ASL_MOVE(b);
+    auto b2 = std::move(b);
     auto* ptr2 = b2.get();
     ASL_TEST_EXPECT(ptr1 == ptr2);
 }
@@ -81,7 +81,7 @@ ASL_TEST(niche)
     ASL_TEST_EXPECT(destroyed);
 }
 
-class Base
+class Base // NOLINT
 {
 public:
     virtual ~Base() = default;
@@ -94,10 +94,10 @@ public:
     int number() override { return 2; }
 };
 
-static_assert(asl::convertible_from<asl::box<Base>, asl::box<Derived>>);
+static_assert(asl::convertible_to<asl::box<Derived>, asl::box<Base>>);
-static_assert(asl::convertible_from<asl::box<Base>, asl::box<Base>>);
+static_assert(asl::convertible_to<asl::box<Base>, asl::box<Base>>);
-static_assert(!asl::convertible_from<asl::box<Derived>, asl::box<Base>>);
+static_assert(!asl::convertible_to<asl::box<Base>, asl::box<Derived>>);
-static_assert(!asl::convertible_from<asl::box<int>, asl::box<float>>);
+static_assert(!asl::convertible_to<asl::box<float>, asl::box<int>>);
 
 ASL_TEST(derived)
 {

asl/types/function.hpp

@@ -0,0 +1,288 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+#include "asl/base/utility.hpp"
+#include "asl/base/meta.hpp"
+#include "asl/base/integers.hpp"
+#include "asl/memory/allocator.hpp"
+#include "asl/base/functional.hpp"
+
+namespace asl
+{
+
+namespace function_detail
+{
+
+static constexpr isize_t kStorageSize = size_of<void*> * 2;
+
+struct Storage
+{
+    alignas(align_of<void*>) byte raw[kStorageSize];
+
+    [[nodiscard]]
+    void* get_ptr() const
+    {
+        // NOLINTNEXTLINE(*-const-cast)
+        return const_cast<void*>(static_cast<const void*>(raw));
+    }
+};
+
+template<typename T>
+concept can_be_stored_inline =
+    size_of<T> <= size_of<Storage> &&
+    align_of<Storage> % align_of<T> == 0;
+
+enum class FunctionOp : uint8_t
+{
+    kDestroyThis,
+    kCopyFromOtherToThisUninit,
+    kMoveFromOtherToThisUninit,
+};
+
+template<typename Functor, bool kStoreInline = can_be_stored_inline<Functor>>
+struct FunctionImplBase
+{
+    using Allocator = DefaultAllocator;
+
+    template<typename T>
+    static void create(Storage* storage, T&& t)
+    {
+        Allocator allocator{};
+        auto* ptr = alloc_new<Functor>(allocator, std::forward<T>(t));
+        asl::memcpy(storage->get_ptr(), static_cast<void*>(&ptr), size_of<void*>);
+    }
+
+    static Functor** get_functor_ptr(const Storage* storage)
+    {
+        // NOLINTNEXTLINE(*-reinterpret-cast)
+        return std::launder(reinterpret_cast<Functor**>(storage->get_ptr()));
+    }
+
+    static Functor* get_functor(const Storage* storage)
+    {
+        return *get_functor_ptr(storage);
+    }
+
+    static void op(Storage* this_storage, Storage* other_storage, FunctionOp op)
+    {
+        switch (op)
+        {
+            using enum FunctionOp;
+            case kDestroyThis:
+            {
+                Allocator allocator{};
+                alloc_delete(allocator, get_functor(this_storage));
+                break;
+            }
+            case kCopyFromOtherToThisUninit:
+            {
+                create(this_storage, *static_cast<const Functor*>(get_functor(other_storage)));
+                break;
+            }
+            case kMoveFromOtherToThisUninit:
+            {
+                auto* ptr = asl::exchange(*get_functor_ptr(other_storage), nullptr);
+                asl::memcpy(this_storage->get_ptr(), static_cast<void*>(&ptr), size_of<void*>);
+                break;
+            }
+            default: break;
+        }
+    }
+};
+
+template<typename Functor>
+struct FunctionImplBase<Functor, true>
+{
+    template<typename T>
+    static void create(Storage* storage, T&& t)
+    {
+        new (storage->get_ptr()) Functor(std::forward<T>(t));
+    }
+
+    static Functor* get_functor(const Storage* storage)
+    {
+        // NOLINTNEXTLINE(*-reinterpret-cast)
+        return std::launder(reinterpret_cast<Functor*>(storage->get_ptr()));
+    }
+
+    static void op(Storage* this_storage, Storage* other_storage, FunctionOp op)
+    {
+        switch (op)
+        {
+            using enum FunctionOp;
+            case kDestroyThis:
+            {
+                destroy(get_functor(this_storage));
+                break;
+            }
+            case kCopyFromOtherToThisUninit:
+            {
+                create(this_storage, *static_cast<const Functor*>(get_functor(other_storage)));
+                break;
+            }
+            case kMoveFromOtherToThisUninit:
+            {
+                auto* other_functor = get_functor(other_storage);
+                create(this_storage, std::move(*static_cast<const Functor*>(other_functor)));
+                destroy(other_functor);
+                break;
+            }
+            default: break;
+        }
+    }
+};
+
+template<typename Functor, typename R, typename... Args>
+struct FunctionImpl : FunctionImplBase<Functor>
+{
+    static R invoke(Args... args, const Storage& storage)
+    {
+        auto* functor = FunctionImplBase<Functor>::get_functor(&storage);
+        return asl::invoke(*functor, std::forward<Args>(args)...);
+    }
+};
+
+
+template<typename T, typename R, typename... Args>
+concept valid_functor =
+    copy_constructible<T>
+    && move_constructible<T>
+    && invocable<T, Args...>
+    && same_as<R, invoke_result_t<T, Args...>>;
+
+}  // namespace function_detail
+
+template<typename T>
+class function;
+
+template<typename R, typename... Args>
+class function<R(Args...)> // NOLINT(*-member-init)
+{
+    using InvokeFn = R (*)(Args..., const function_detail::Storage&);
+    using OpFn = void (*)(function_detail::Storage*, function_detail::Storage*, function_detail::FunctionOp);
+
+    function_detail::Storage m_storage;
+    InvokeFn                 m_invoke{};
+    OpFn                     m_op{};
+
+    void destroy()
+    {
+        if (m_op != nullptr)
+        {
+            (*m_op)(&m_storage, nullptr, function_detail::FunctionOp::kDestroyThis);
+        }
+    }
+
+public:
+    function() = default;
+
+    template<typename T>
+    function(T&& func) // NOLINT(*explicit*,*-member-init)
+        requires (
+            !same_as<function, un_cvref_t<T>>
+            && function_detail::valid_functor<T, R, Args...>
+        )
+    {
+        using Functor = decay_t<T>;
+        using Impl = function_detail::FunctionImpl<Functor, R, Args...>;
+
+        Impl::create(&m_storage, std::forward<T>(func));
+        m_invoke = &Impl::invoke; // NOLINT(*-member-initializer)
+        m_op = &Impl::op; // NOLINT(*-member-initializer)
+    }
+
+    function(const function& other) // NOLINT(*-member-init)
+        : m_invoke{other.m_invoke}
+        , m_op{other.m_op}
+    {
+        if (m_op != nullptr)
+        {
+            m_op(
+                &m_storage,
+                const_cast<function_detail::Storage*>(&other.m_storage), // NOLINT(*-const-cast)
+                function_detail::FunctionOp::kCopyFromOtherToThisUninit);
+        }
+    }
+
+    function(function&& other) // NOLINT(*-member-init)
+        : m_invoke{asl::exchange(other.m_invoke, nullptr)}
+        , m_op{asl::exchange(other.m_op, nullptr)}
+    {
+        if (m_op != nullptr)
+        {
+            m_op(
+                &m_storage,
+                &other.m_storage,
+                function_detail::FunctionOp::kMoveFromOtherToThisUninit);
+        }
+    }
+
+    ~function()
+    {
+        destroy();
+    }
+
+    function& operator=(const function& other)
+    {
+        if (this != &other)
+        {
+            destroy();
+
+            m_invoke = other.m_invoke;
+            m_op = other.m_op;
+
+            m_op(
+                &m_storage,
+                const_cast<function_detail::Storage*>(&other.m_storage), // NOLINT(*-const-cast)
+                function_detail::FunctionOp::kCopyFromOtherToThisUninit);
+        }
+        return *this;
+    }
+
+    function& operator=(function&& other)
+    {
+        if (this != &other)
+        {
+            destroy();
+
+            m_invoke = asl::exchange(other.m_invoke, nullptr);
+            m_op = asl::exchange(other.m_op, nullptr);
+
+            m_op(
+                &m_storage,
+                &other.m_storage,
+                function_detail::FunctionOp::kMoveFromOtherToThisUninit);
+        }
+        return *this;
+    }
+
+    template<typename T>
+    function& operator=(T&& func)
+        requires (
+            !same_as<function, un_cvref_t<T>>
+            && function_detail::valid_functor<T, R, Args...>
+        )
+    {
+        destroy();
+
+        using Functor = decay_t<T>;
+        using Impl = function_detail::FunctionImpl<Functor, R, Args...>;
+
+        Impl::create(&m_storage, std::forward<T>(func));
+        m_invoke = &Impl::invoke;
+        m_op = &Impl::op;
+
+        return *this;
+    }
+
+    constexpr R operator()(Args... args) const
+    {
+        ASL_ASSERT(m_invoke);
+        return m_invoke(args..., m_storage);
+    }
+};
+
+} // namespace asl

asl/types/function_ref.hpp

@@ -0,0 +1,72 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+#include "asl/base/utility.hpp"
+#include "asl/base/meta.hpp"
+#include "asl/base/functional.hpp"
+#include "asl/memory/memory.hpp"
+
+namespace asl
+{
+
+template<typename T>
+class function_ref;
+
+template<typename R, typename... Args>
+class function_ref<R(Args...)>
+{
+    using InvokeFn = R (*)(Args..., void*);
+
+    void*       m_obj;
+    InvokeFn    m_invoke;
+
+    template<typename T>
+    static R invoke(Args... args, void* obj)
+    {
+        // NOLINTNEXTLINE(*-reinterpret-cast)
+        return asl::invoke(*reinterpret_cast<T*>(obj), std::forward<Args>(args)...);
+    }
+
+public:
+    function_ref() = delete;
+
+    ASL_DEFAULT_COPY_MOVE(function_ref);
+    ~function_ref() = default;
+
+    template<typename T>
+    function_ref(T&& t) // NOLINT(*-missing-std-forward, *explicit*)
+        requires (
+            !same_as<un_cvref_t<T>, function_ref>
+            && invocable<T, Args...>
+            && same_as<invoke_result_t<T, Args...>, R>
+        )
+        // NOLINTNEXTLINE(*cast*)
+        : m_obj{const_cast<void*>(reinterpret_cast<const void*>(address_of(t)))}
+        , m_invoke{invoke<un_ref_t<T>>}
+    {}
+
+    template<typename T>
+    function_ref& operator=(T&& t) // NOLINT(*-missing-std-forward)
+        requires (
+            !same_as<un_cvref_t<T>, function_ref>
+            && invocable<T, Args...>
+            && same_as<invoke_result_t<T, Args...>, R>
+        )
+    {
+        // NOLINTNEXTLINE(*cast*)
+        m_obj = const_cast<void*>(reinterpret_cast<const void*>(address_of(t)));
+        m_invoke = invoke<un_ref_t<T>>;
+
+        return *this;
+    }
+
+    constexpr R operator()(this function_ref self, Args... args)
+    {
+        return self.m_invoke(std::forward<Args>(args)..., self.m_obj);
+    }
+};
+
+} // namespace asl

asl/types/function_ref_tests.cpp

@@ -0,0 +1,54 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "asl/testing/testing.hpp"
+#include "asl/types/function_ref.hpp"
+
+static int add(int a, int b)
+{
+    return a + b;
+}
+
+struct Functor
+{
+    int state = 0;
+
+    int operator()(int x, int)
+    {
+        state += x;
+        return state;
+    }
+};
+
+static int invoke_fn_ref(asl::function_ref<int(int, int)> fn, int a, int b)
+{
+    return fn(a, b);
+}
+
+ASL_TEST(function_ref)
+{
+    const asl::function_ref<int(int, int)> fn(add);
+    ASL_TEST_EXPECT(invoke_fn_ref(fn, 4, 5) == 9);
+
+    ASL_TEST_EXPECT(invoke_fn_ref(add, 4, 5) == 9);
+
+    ASL_TEST_EXPECT(invoke_fn_ref([](int a, int b) { return a * b; }, 4, 5) == 20);
+
+    Functor fun;
+    ASL_TEST_EXPECT(invoke_fn_ref(fun, 4, 5) == 4);
+    ASL_TEST_EXPECT(invoke_fn_ref(fun, 4, 5) == 8);
+    ASL_TEST_EXPECT(invoke_fn_ref(fun, 4, 5) == 12);
+
+    asl::function_ref<int(int, int)> fn2 = fn;
+    ASL_TEST_EXPECT(invoke_fn_ref(fn2, 4, 5) == 9);
+
+    fn2 = [](int a, int b) { return a - b; };
+    ASL_TEST_EXPECT(invoke_fn_ref(fn2, 4, 5) == -1);
+
+    fn2 = fn;
+    ASL_TEST_EXPECT(invoke_fn_ref(fn2, 4, 5) == 9);
+
+    fn2 = add;
+    ASL_TEST_EXPECT(invoke_fn_ref(fn2, 4, 5) == 9);
+}

asl/types/function_tests.cpp

@@ -0,0 +1,195 @@
+// Copyright 2025 Steven Le Rouzic
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "asl/testing/testing.hpp"
+#include "asl/types/function.hpp"
+
+static_assert(asl::function_detail::can_be_stored_inline<int(*)(int, int, int)>);
+static_assert(asl::function_detail::can_be_stored_inline<decltype([](){})>);
+static_assert(asl::function_detail::can_be_stored_inline<decltype([]() static {})>);
+static_assert(asl::function_detail::can_be_stored_inline<decltype([a = 1ULL, b = 2ULL](){ return a + b; })>); // NOLINT
+static_assert(asl::function_detail::can_be_stored_inline<decltype([a = 1ULL, b = 2ULL]() mutable { return a = b++; })>); // NOLINT
+static_assert(!asl::function_detail::can_be_stored_inline<decltype([a = 1ULL, b = 2ULL, c = 3ULL](){ return a + b + c; })>); // NOLINT
+
+static int add(int x, int y)
+{
+    return x + y;
+}
+
+ASL_TEST(function_pointer)
+{
+    const asl::function<int(int, int)> fn = add;
+    ASL_TEST_EXPECT(fn(4, 5) == 9);
+    ASL_TEST_EXPECT(fn(40, 50) == 90);
+}
+
+ASL_TEST(lambda)
+{
+    const asl::function<int(int, int)> fn = [](int a, int b) {
+        return a + b;
+    };
+    ASL_TEST_EXPECT(fn(4, 5) == 9);
+}
+
+ASL_TEST(lambda_static)
+{
+    const asl::function<int(int, int)> fn = [](int a, int b) static {
+        return a + b;
+    };
+    ASL_TEST_EXPECT(fn(4, 5) == 9);
+}
+
+ASL_TEST(lambda_static_state)
+{
+    const asl::function<int(int)> fn = [state = 0](int b) mutable {
+        state += b;
+        return state;
+    };
+
+    ASL_TEST_EXPECT(fn(1) == 1);
+    ASL_TEST_EXPECT(fn(2) == 3);
+    ASL_TEST_EXPECT(fn(3) == 6);
+    ASL_TEST_EXPECT(fn(4) == 10);
+}
+
+ASL_TEST(lambda_state)
+{
+    int state = 0;
+    const asl::function<void(int)> fn = [&state](int x) {
+        state += x;
+    };
+
+    ASL_TEST_EXPECT(state == 0);
+
+    fn(5);
+    ASL_TEST_EXPECT(state == 5);
+
+    fn(4);
+    ASL_TEST_EXPECT(state == 9);
+}
+
+ASL_TEST(lambda_big_state)
+{
+    int s0 = 0;
+    int s1 = 0;
+    int s2 = 0;
+    int s3 = 0;
+
+    const asl::function<void(int)> fn = [&](int x) {
+        s0 += x;
+        s1 += x + 1;
+        s2 += x + 2;
+        s3 += x + 3;
+    };
+
+    ASL_TEST_EXPECT(s0 == 0);
+    ASL_TEST_EXPECT(s1 == 0);
+    ASL_TEST_EXPECT(s2 == 0);
+    ASL_TEST_EXPECT(s3 == 0);
+
+    fn(5);
+    ASL_TEST_EXPECT(s0 == 5);
+    ASL_TEST_EXPECT(s1 == 6);
+    ASL_TEST_EXPECT(s2 == 7);
+    ASL_TEST_EXPECT(s3 == 8);
+
+    fn(4);
+    ASL_TEST_EXPECT(s0 == 9);
+    ASL_TEST_EXPECT(s1 == 11);
+    ASL_TEST_EXPECT(s2 == 13);
+    ASL_TEST_EXPECT(s3 == 15);
+}
+
+struct Functor
+{
+    int state{};
+
+    int operator()(int x)
+    {
+        state += x;
+        return state;
+    }
+};
+
+ASL_TEST(functor)
+{
+    const asl::function<int(int)> fn = Functor{};
+
+    ASL_TEST_EXPECT(fn(1) == 1);
+    ASL_TEST_EXPECT(fn(2) == 3);
+    ASL_TEST_EXPECT(fn(3) == 6);
+    ASL_TEST_EXPECT(fn(4) == 10);
+}
+
+ASL_TEST(copy_move_construct_small)
+{
+    asl::function<int(int, int)> fn = [x = 0](int a, int b) mutable { return x++ + a + b; };
+    ASL_TEST_EXPECT(fn(1, 3) == 4);
+
+    asl::function<int(int, int)> fn2 = fn;
+    ASL_TEST_EXPECT(fn(1, 3) == 5);
+    ASL_TEST_EXPECT(fn2(5, 3) == 9);
+
+    asl::function<int(int, int)> fn3 = std::move(fn2);
+    ASL_TEST_EXPECT(fn(1, 3) == 6);
+    ASL_TEST_EXPECT(fn3(5, 3) == 10);
+
+    fn2 = fn;
+    ASL_TEST_EXPECT(fn(1, 3) == 7);
+    ASL_TEST_EXPECT(fn2(5, 3) == 11);
+    ASL_TEST_EXPECT(fn3(5, 3) == 11);
+
+    fn3 = std::move(fn);
+    ASL_TEST_EXPECT(fn2(5, 3) == 12);
+    ASL_TEST_EXPECT(fn3(5, 3) == 12);
+}
+
+ASL_TEST(copy_move_construct_big)
+{
+    const int64_t v1 = 1;
+    const int64_t v2 = 2;
+    const int64_t v3 = 3;
+    const int64_t v4 = 4;
+
+    asl::function<int64_t(int)> fn = [=](int x) { return v1 + v2 + v3 + v4 + x; };
+    ASL_TEST_EXPECT(fn(1) == 11);
+
+    asl::function<int64_t(int)> fn2 = fn;
+    ASL_TEST_EXPECT(fn(3) == 13);
+    ASL_TEST_EXPECT(fn2(5) == 15);
+
+    asl::function<int64_t(int)> fn3 = std::move(fn2);
+    ASL_TEST_EXPECT(fn(1) == 11);
+    ASL_TEST_EXPECT(fn3(3) == 13);
+
+    fn2 = fn;
+    ASL_TEST_EXPECT(fn(1) == 11);
+    ASL_TEST_EXPECT(fn2(5) == 15);
+    ASL_TEST_EXPECT(fn3(3) == 13);
+
+    fn3 = std::move(fn);
+    ASL_TEST_EXPECT(fn2(5) == 15);
+    ASL_TEST_EXPECT(fn3(3) == 13);
+}
+
+ASL_TEST(replace)
+{
+    asl::function<int(int)> fn = [](int x) { return x + 1; };
+    ASL_TEST_EXPECT(fn(5) == 6);
+
+    fn = [](int x) { return x + 3; };
+    ASL_TEST_EXPECT(fn(5) == 8);
+}
+
+static int foo(const asl::function<int(int, int)>& fn)
+{
+    return fn(5, 5);
+}
+
+ASL_TEST(function_parameter)
+{
+    ASL_TEST_EXPECT(foo(add) == 10);
+    ASL_TEST_EXPECT(foo([](int a, int b) { return a + b; }) == 10);
+}
+

asl/types/maybe_uninit.hpp

@@ -23,7 +23,7 @@ public:
 
     explicit constexpr maybe_uninit(in_place_t, auto&&... args)
         requires constructible_from<T, decltype(args)...>
-        : m_value{ASL_FWD(args)...}
+        : m_value{std::forward<decltype(args)>(args)...}
     {}
 
     constexpr maybe_uninit(const maybe_uninit&) requires trivially_copy_constructible<T> = default;
@@ -33,10 +33,10 @@ public:
     constexpr maybe_uninit(maybe_uninit&&) requires (!trivially_move_constructible<T>) {} // NOLINT
 
     constexpr maybe_uninit& operator=(const maybe_uninit&) requires trivially_copy_assignable<T> = default;
-    constexpr maybe_uninit& operator=(const maybe_uninit&) requires (!trivially_copy_assignable<T>) {}
+    constexpr maybe_uninit& operator=(const maybe_uninit&) requires (!trivially_copy_assignable<T>) { return *this; } // NOLINT
 
     constexpr maybe_uninit& operator=(maybe_uninit&&) requires trivially_move_assignable<T> = default;
-    constexpr maybe_uninit& operator=(maybe_uninit&&) requires (!trivially_move_assignable<T>) {}
+    constexpr maybe_uninit& operator=(maybe_uninit&&) requires (!trivially_move_assignable<T>) { return *this; } // NOLINT
 
     constexpr ~maybe_uninit() requires trivially_destructible<T> = default;
     constexpr ~maybe_uninit() requires (!trivially_destructible<T>) {} // NOLINT
@@ -45,14 +45,14 @@ public:
     constexpr void construct_unsafe(auto&&... args)
         requires constructible_from<T, decltype(args)...>
     {
-        construct_at<T>(&m_value, ASL_FWD(args)...);
+        construct_at<T>(&m_value, std::forward<decltype(args)>(args)...);
     }
 
     // @Safety Value must have been initialized
     constexpr void assign_unsafe(auto&& value)
         requires assignable_from<T&, decltype(value)>
     {
-        m_value = ASL_FWD(value);
+        m_value = std::forward<decltype(value)>(value);
     }
 
     // @Safety Value must have been initialized
@@ -67,7 +67,7 @@ public:
     // @Safety Value must have been initialized
     constexpr auto&& as_init_unsafe(this auto&& self)
     {
-        return ASL_FWD(self).m_value;
+        return std::forward<decltype(self)>(self).m_value;
     }
 };
 

asl/types/option.hpp

@@ -74,19 +74,19 @@ class option
 
         if constexpr (!kHasNiche)
         {
-            m_payload.construct_unsafe(ASL_FWD(args)...);
+            m_payload.construct_unsafe(std::forward<Args>(args)...);
             m_has_value = true;
         }
         else
         {
             if constexpr (move_assignable<T>)
             {
-                m_payload.assign_unsafe(ASL_MOVE(T{ASL_FWD(args)...}));
+                m_payload.assign_unsafe(T{std::forward<Args>(args)...});
             }
             else
             {
                 m_payload.destroy_unsafe();
-                m_payload.construct_unsafe(ASL_FWD(args)...);
+                m_payload.construct_unsafe(std::forward<Args>(args)...);
             }
         }
     }
@@ -95,7 +95,7 @@ class option
     constexpr void assign(U&& arg)
     {
         ASL_ASSERT(has_value());
-        m_payload.assign_unsafe(ASL_FWD(arg));
+        m_payload.assign_unsafe(std::forward<U>(arg));
     }
 
 public:
@@ -103,32 +103,32 @@ public:
 
     constexpr option() : option{nullopt} {}
 
-     // NOLINTNEXTLINE(*-explicit-conversions)
+     // NOLINTNEXTLINE(*explicit*)
     constexpr option(nullopt_t) requires (!kHasNiche) {}
 
-     // NOLINTNEXTLINE(*-explicit-conversions)
+     // NOLINTNEXTLINE(*explicit*)
     constexpr option(nullopt_t) requires kHasNiche : m_payload{in_place, niche_t{}} {}
 
     template<typename U = T>
-    constexpr explicit (!convertible_from<T, U&&>)
+    constexpr explicit (!convertible_to<U&&, T>)
     option(U&& value)
         requires (
             kHasNiche &&
             constructible_from<T, U&&> &&
             !same_as<un_cvref_t<U>, option>
         )
-        : m_payload{in_place, ASL_FWD(value)}
+        : m_payload{in_place, std::forward<U>(value)}
     {}
 
     template<typename U = T>
-    constexpr explicit (!convertible_from<T, U&&>)
+    constexpr explicit (!convertible_to<U&&, T>)
     option(U&& value)
         requires (
             !kHasNiche &&
             constructible_from<T, U&&> &&
             !is_option<U>
         )
-        : m_payload{in_place, ASL_FWD(value)}
+        : m_payload{in_place, std::forward<U>(value)}
         , m_has_value{true}
     {}
 
@@ -154,12 +154,12 @@ public:
     {
         if (other.has_value())
         {
-            construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+            construct(std::move(other.m_payload.as_init_unsafe()));
         }
     }
 
     template<typename U>
-    constexpr explicit (!convertible_from<T, const U&>)
+    constexpr explicit (!convertible_to<const U&, T>)
     option(const option<U>& other)
         requires (
             constructible_from<T, const U&> &&
@@ -174,7 +174,7 @@ public:
     }
 
     template<typename U>
-    constexpr explicit (!convertible_from<T, U&&>)
+    constexpr explicit (!convertible_to<U&&, T>)
     option(option<U>&& other)
         requires (
             constructible_from<T, U&&> &&
@@ -184,7 +184,7 @@ public:
     {
         if (other.has_value())
         {
-            construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+            construct(std::move(other).m_payload.as_init_unsafe());
         }
     }
 
@@ -204,11 +204,11 @@ public:
     {
         if (has_value())
         {
-            assign(ASL_FWD(value));
+            assign(std::forward<U>(value));
         }
         else
         {
-            construct(ASL_FWD(value));
+            construct(std::forward<U>(value));
         }
 
         return *this;
@@ -259,11 +259,11 @@ public:
         {
             if (has_value())
             {
-                assign(ASL_MOVE(other.m_payload.as_init_unsafe()));
+                assign(std::move(other.m_payload.as_init_unsafe()));
             }
             else
             {
-                construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+                construct(std::move(other.m_payload.as_init_unsafe()));
             }
         }
         else if (has_value())
@@ -313,11 +313,11 @@ public:
         {
             if (has_value())
             {
-                assign(ASL_MOVE(other.m_payload.as_init_unsafe()));
+                assign(std::move(other).m_payload.as_init_unsafe());
             }
             else
             {
-                construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+                construct(std::move(other).m_payload.as_init_unsafe());
             }
         }
         else if (has_value())
@@ -342,7 +342,7 @@ public:
         {
             if constexpr (move_assignable<T>)
             {
-                m_payload.assign_unsafe(ASL_MOVE(T{niche_t{}}));
+                m_payload.assign_unsafe(std::move(T{niche_t{}}));
             }
             else
             {
@@ -357,7 +357,7 @@ public:
         }
     }
 
-    constexpr bool has_value() const
+    [[nodiscard]] constexpr bool has_value() const
     {
         if constexpr (kHasNiche)
         {
@@ -372,28 +372,28 @@ public:
     constexpr auto&& value(this auto&& self)
     {
         ASL_ASSERT_RELEASE(self.has_value());
-        return ASL_FWD(self).m_payload.as_init_unsafe();
+        return std::forward<decltype(self)>(self).m_payload.as_init_unsafe();
     }
 
     template<typename U>
     constexpr T value_or(U&& other_value) const&
-        requires copy_constructible<T> && convertible_from<T, U&&>
+        requires copy_constructible<T> && convertible_to<U&&, T>
     {
-        return has_value() ? value() : static_cast<T>(ASL_FWD(other_value));
+        return has_value() ? value() : static_cast<T>(std::forward<U>(other_value));
     }
 
     template<typename U>
     constexpr T value_or(U&& other_value) &&
-        requires move_constructible<T> && convertible_from<T, U&&>
+        requires move_constructible<T> && convertible_to<U&&, T>
     {
-        return has_value() ? ASL_MOVE(value()) : static_cast<T>(ASL_FWD(other_value));
+        return has_value() ? std::move(value()) : static_cast<T>(std::forward<U>(other_value));
     }
 
     constexpr T& emplace(auto&&... args) &
         requires constructible_from<T, decltype(args)...>
     {
         if (has_value()) { reset(); }
-        construct(ASL_FWD(args)...);
+        construct(std::forward<decltype(args)>(args)...);
         return value();
     }
 
@@ -405,7 +405,7 @@ public:
 
         if (self.has_value())
         {
-            return invoke(ASL_FWD(f), ASL_FWD(self).value());
+            return invoke(std::forward<F>(f), std::forward<decltype(self)>(self).value());
         }
         return Result{ asl::nullopt };
     }
@@ -417,7 +417,7 @@ public:
         if (self.has_value())
         {
             return option<un_cvref_t<Result>>{
-                invoke(ASL_FWD(f), ASL_FWD(self).value())
+                invoke(std::forward<F>(f), std::forward<decltype(self)>(self).value())
             };
         }
         return option<un_cvref_t<Result>>{ asl::nullopt };
@@ -427,14 +427,14 @@ public:
     constexpr option or_else(F&& f) const&
         requires same_as<un_cvref_t<invoke_result_t<F>>, option>
     {
-        return has_value() ? *this : invoke(ASL_FWD(f));
+        return has_value() ? *this : invoke(std::forward<F>(f));
     }
 
     template<typename F>
     constexpr option or_else(F&& f) &&
         requires same_as<un_cvref_t<invoke_result_t<F>>, option>
     {
-        return has_value() ? ASL_MOVE(*this) : invoke(ASL_FWD(f));
+        return has_value() ? std::move(*this) : invoke(std::forward<F>(f));
     }
 
     template<typename H>
@@ -443,9 +443,9 @@ public:
     {
         if (!opt.has_value())
         {
-            return H::combine(ASL_MOVE(h), 0);
+            return H::combine(std::move(h), 0);
         }
-        return H::combine(ASL_MOVE(h), 1, opt.value());
+        return H::combine(std::move(h), 1, opt.value());
     }
 };
 

asl/types/option_tests.cpp

@@ -62,20 +62,20 @@ static_assert(!asl::move_assignable<asl::option<Pinned>>);
 static_assert(asl::assignable_from<asl::option<Base*>&, asl::option<Derived*>>);
 static_assert(!asl::assignable_from<asl::option<Derived*>&, asl::option<Base*>>);
 
-static_assert(asl::convertible_from<asl::option<Base*>, asl::option<Derived*>>);
+static_assert(asl::convertible_to<asl::option<Derived*>, asl::option<Base*>>);
-static_assert(!asl::convertible_from<asl::option<Derived*>, asl::option<Base*>>);
+static_assert(!asl::convertible_to<asl::option<Base*>, asl::option<Derived*>>);
 
 class ExplicitConversion { public: explicit ExplicitConversion(int) {} };
 class ImplicitConversion { public: ImplicitConversion(int) {} }; // NOLINT
 
-static_assert(!asl::convertible_from<ExplicitConversion, int>);
+static_assert(!asl::convertible_to<int, ExplicitConversion>);
-static_assert(asl::convertible_from<ImplicitConversion, int>);
+static_assert(asl::convertible_to<int, ImplicitConversion>);
 
-static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, int>);
+static_assert(!asl::convertible_to<int, asl::option<ExplicitConversion>>);
-static_assert(asl::convertible_from<asl::option<ImplicitConversion>, int>);
+static_assert(asl::convertible_to<int, asl::option<ImplicitConversion>>);
 
-static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, asl::option<int>>);
+static_assert(!asl::convertible_to<asl::option<int>, asl::option<ExplicitConversion>>);
-static_assert(asl::convertible_from<asl::option<ImplicitConversion>, asl::option<int>>);
+static_assert(asl::convertible_to<asl::option<int>, asl::option<ImplicitConversion>>);
 
 static_assert(asl::trivially_copy_constructible<asl::option<int>>);
 static_assert(asl::trivially_copy_constructible<asl::option<TrivialType>>);
@@ -99,8 +99,8 @@ static_assert(!asl::trivially_move_assignable<asl::option<MoveableOnly>>);
 
 ASL_TEST(make_null)
 {
-    asl::option<int> a;
+    const asl::option<int> a;
-    asl::option<int> b = asl::nullopt;
+    const asl::option<int> b = asl::nullopt;
 
     ASL_TEST_EXPECT(!a.has_value());
     ASL_TEST_EXPECT(!b.has_value());
@@ -108,7 +108,7 @@ ASL_TEST(make_null)
 
 ASL_TEST(make_value)
 {
-    asl::option<int> a = 48;
+    const asl::option<int> a = 48;
 
     ASL_TEST_EXPECT(a.has_value());
 }
@@ -129,10 +129,10 @@ ASL_TEST(call_destructor)
     {
         DestructorObserver obs(&destroyed);
 
-        asl::option<DestructorObserver> opt(ASL_MOVE(obs));
+        asl::option<DestructorObserver> opt(std::move(obs));
         ASL_TEST_EXPECT(!destroyed);
 
-        asl::option<DestructorObserver> opt2 = ASL_MOVE(opt);
+        const asl::option<DestructorObserver> opt2 = std::move(opt);
         ASL_TEST_EXPECT(!destroyed);
     }
 
@@ -172,7 +172,7 @@ ASL_TEST(value_move)
     ASL_TEST_EXPECT(!destroyed);
 
     {
-        auto x = ASL_MOVE(opt).value();
+        auto x = std::move(opt).value();
         ASL_TEST_EXPECT(!destroyed);
     }
 
@@ -208,27 +208,27 @@ ASL_TEST(convert_copy)
 ASL_TEST(convert_move)
 {
     asl::option<uint8_t> opt8 = uint8_t{8};
-    asl::option<uint16_t> opt16 = ASL_MOVE(opt8);
+    asl::option<uint16_t> opt16 = std::move(opt8);
 
     ASL_TEST_ASSERT(opt16.has_value());
     ASL_TEST_EXPECT(opt16.value() == 8);
 
-    opt8 = ASL_MOVE(uint8_t{10});
+    opt8 = uint8_t{10};
     ASL_TEST_ASSERT(opt8.has_value());
     ASL_TEST_EXPECT(opt8.value() == 10);
 
     opt16 = asl::nullopt;
     ASL_TEST_EXPECT(!opt16.has_value());
 
-    opt16 = ASL_MOVE(opt8);
+    opt16 = std::move(opt8);
     ASL_TEST_ASSERT(opt16.has_value());
     ASL_TEST_EXPECT(opt16.value() == 10);
 }
 
 ASL_TEST(value_or)
 {
-    asl::option<int> a = asl::nullopt;
+    const asl::option<int> a = asl::nullopt;
-    asl::option<int> b = 2;
+    const asl::option<int> b = 2;
 
     ASL_TEST_EXPECT(a.value_or(5) == 5);
     ASL_TEST_EXPECT(b.value_or(5) == 2);
@@ -296,8 +296,8 @@ ASL_TEST(transform)
 
 ASL_TEST(or_else)
 {
-    asl::option<int> a = 5;
+    const asl::option<int> a = 5;
-    asl::option<int> b;
+    const asl::option<int> b;
 
     auto fn = []() -> asl::option<int> { return 12; };
 

asl/types/span.hpp

@@ -14,6 +14,7 @@ namespace asl
 
 static constexpr isize_t dynamic_size = -1;
 
+// NOLINTBEGIN(*-convert-member-functions-to-static)
 template<typename T>
 class contiguous_iterator
 {
@@ -22,7 +23,7 @@ class contiguous_iterator
 public:
     constexpr explicit contiguous_iterator(T* ptr) : m_ptr{ptr} {}
 
-    constexpr bool operator==(const contiguous_iterator& other) const = default;
+    constexpr bool operator==(this contiguous_iterator self, contiguous_iterator other) = default;
 
     constexpr contiguous_iterator& operator++()
     {
@@ -35,9 +36,9 @@ public:
         return contiguous_iterator{ exchange(m_ptr, m_ptr + 1) };
     }
 
-    constexpr T& operator*() const { return *m_ptr; }
+    constexpr T& operator*(this contiguous_iterator self) { return *self.m_ptr; }
 
-    constexpr T* operator->() const { return m_ptr; }
+    constexpr T* operator->(this contiguous_iterator self) { return self.m_ptr; }
 };
 
 template<typename T>
@@ -75,27 +76,27 @@ public:
     }
 
     template<isize_t N>
-    constexpr span(T (&array)[N]) // NOLINT(*-explicit-conversions)
+    constexpr span(T (&array)[N]) // NOLINT(*explicit*)
         requires (kIsDynamic)
-        : m_data{array}
+        : m_data{static_cast<T*>(array)}
         , m_size{N}
     {}
 
     template<isize_t N>
-    constexpr span(T (&array)[N]) // NOLINT(*-explicit-conversions)
+    constexpr span(T (&array)[N]) // NOLINT(*explicit*)
         requires (!kIsDynamic) && (N == kSize)
-        : m_data{array}
+        : m_data{static_cast<T*>(array)}
     {}
 
     template<is_object U, isize_t kOtherSize>
     constexpr explicit(!kIsDynamic)
-    span(const span<U, kOtherSize>& other) // NOLINT(*-explicit-conversions)
+    span(const span<U, kOtherSize>& other)
         requires (
             (
                 kIsDynamic ||
                 is_dynamic(kOtherSize) ||
                 kOtherSize == kSize
-            ) && convertible_from<T(&)[], U(&)[]>
+            ) && convertible_to<U(&)[], T(&)[]>
         )
         : span{static_cast<U*>(other.data()), other.size()}
     {
@@ -109,115 +110,116 @@ public:
 
     ~span() = default;
 
-    constexpr isize_t size() const
+    [[nodiscard]] constexpr isize_t size(this span self)
     {
-        if constexpr (kIsDynamic) { return m_size; }
+        if constexpr (kIsDynamic) { return self.m_size; }
         else { return kSize; }
     }
 
-    constexpr isize_t size_bytes() const { return size() * size_of<T>; }
+    [[nodiscard]] constexpr isize_t size_bytes(this span self) { return self.size() * size_of<T>; }
 
-    constexpr bool is_empty() const { return size() == 0; }
+    [[nodiscard]] constexpr bool is_empty(this span self) { return self.size() == 0; }
 
-    constexpr T* data() const { return m_data; }
+    [[nodiscard]] constexpr T* data(this span self) { return self.m_data; }
 
-    constexpr contiguous_iterator<T> begin() const
+    [[nodiscard]] constexpr contiguous_iterator<T> begin(this span self)
     {
-        return contiguous_iterator{m_data};
+        return contiguous_iterator{self.m_data};
     }
 
-    constexpr contiguous_iterator<T> end() const
+    [[nodiscard]] constexpr contiguous_iterator<T> end(this span self)
     {
-        return contiguous_iterator{m_data + size()};
+        return contiguous_iterator{self.m_data + self.size()};
     }
 
-    constexpr T& operator[](isize_t i) const
+    constexpr T& operator[](this span self, isize_t i)
     {
-        ASL_ASSERT(i >= 0 && i < size());
+        ASL_ASSERT(i >= 0 && i < self.size());
-        return m_data[i]; // NOLINT(*-pointer-arithmetic)
+        return self.m_data[i]; // NOLINT(*-pointer-arithmetic)
     }
 
     template<isize_t kOffset, isize_t kSubSize = dynamic_size>
-    constexpr auto subspan() const
+    [[nodiscard]] constexpr auto subspan(this span self)
         requires (
             kOffset >= 0 &&
             (kIsDynamic || kOffset <= kSize) &&
             (kIsDynamic || is_dynamic(kSubSize) || kSubSize <= kSize - kOffset)
         )
     {
-        ASL_ASSERT(kOffset <= size());
+        ASL_ASSERT(kOffset <= self.size());
 
         if constexpr (is_dynamic(kSubSize))
         {
             if constexpr (kIsDynamic)
             {
-                return span<T>(data() + kOffset, size() - kOffset);
+                return span<T>(self.data() + kOffset, self.size() - kOffset);
             }
             else
             {
-                return span<T, kSize - kOffset>(data() + kOffset, size() - kOffset);
+                return span<T, kSize - kOffset>(self.data() + kOffset, self.size() - kOffset);
             }
         }
         else
         {
-            ASL_ASSERT(kSubSize <= size() - kOffset);
+            ASL_ASSERT(kSubSize <= self.size() - kOffset);
-            return span<T, kSubSize>(data() + kOffset, kSubSize);
+            return span<T, kSubSize>(self.data() + kOffset, kSubSize);
         }
     }
 
-    constexpr span<T> subspan(isize_t offset) const
+    [[nodiscard]] constexpr span<T> subspan(this span self, isize_t offset)
     {
-        ASL_ASSERT(offset <= size());
+        ASL_ASSERT(offset <= self.size());
-        return span<T>{ data() + offset, size() - offset };
+        return span<T>{ self.data() + offset, self.size() - offset };
     }
 
-    constexpr span<T> subspan(isize_t offset, isize_t sub_size) const
+    [[nodiscard]] constexpr span<T> subspan(this span self, isize_t offset, isize_t sub_size)
     {
-        ASL_ASSERT(offset <= size() && !is_dynamic(sub_size));
+        ASL_ASSERT(offset <= self.size() && !is_dynamic(sub_size));
-        ASL_ASSERT(sub_size <= size() - offset);
+        ASL_ASSERT(sub_size <= self.size() - offset);
-        return span<T>{ data() + offset, sub_size };
+        return span<T>{ self.data() + offset, sub_size };
     }
 
     template<isize_t kSubSize>
-    constexpr auto first() const
+    [[nodiscard]] constexpr auto first(this span self)
         requires (
             kSubSize >= 0 &&
             (kIsDynamic || kSubSize <= kSize)
         )
     {
-        ASL_ASSERT(kSubSize <= size());
+        ASL_ASSERT(kSubSize <= self.size());
-        return span<T, kSubSize>{ data(), kSubSize };
+        return span<T, kSubSize>{ self.data(), kSubSize };
     }
 
-    constexpr span<T> first(isize_t sub_size) const
+    [[nodiscard]] constexpr span<T> first(this span self, isize_t sub_size)
     {
-        ASL_ASSERT(sub_size >= 0 && sub_size <= size());
+        ASL_ASSERT(sub_size >= 0 && sub_size <= self.size());
-        return span<T>{ data(), sub_size };
+        return span<T>{ self.data(), sub_size };
     }
 
     template<isize_t kSubSize>
-    constexpr auto last() const
+    [[nodiscard]] constexpr auto last(this span self)
         requires (
             kSubSize >= 0 &&
             (kIsDynamic || kSubSize <= kSize)
         )
     {
-        ASL_ASSERT(kSubSize <= size());
+        ASL_ASSERT(kSubSize <= self.size());
-        return span<T, kSubSize>{ data() + size() - kSubSize, kSubSize };
+        return span<T, kSubSize>{ self.data() + self.size() - kSubSize, kSubSize };
     }
 
-    constexpr span<T> last(isize_t sub_size) const
+    [[nodiscard]] constexpr span<T> last(this span self, isize_t sub_size)
     {
-        ASL_ASSERT(sub_size >= 0 && sub_size <= size());
+        ASL_ASSERT(sub_size >= 0 && sub_size <= self.size());
-        return span<T>{ data() + size() - sub_size, sub_size };
+        return span<T>{ self.data() + self.size() - sub_size, sub_size };
     }
 };
+// NOLINTEND(*-convert-member-functions-to-static)
 
 template<is_object T, isize_t kSize>
 inline span<const byte> as_bytes(span<T, kSize> s)
 {
     return span<const byte>(
-        reinterpret_cast<const byte*>(s.data()),
+        reinterpret_cast<const byte*>(s.data()), // NOLINT(*-reinterpret-cast)
         s.size_bytes());
 }
 
@@ -226,7 +228,7 @@ inline span<byte> as_mutable_bytes(span<T, kSize> s)
     requires (!is_const<T>)
 {
     return span<byte>(
-        reinterpret_cast<byte*>(s.data()),
+        reinterpret_cast<byte*>(s.data()), // NOLINT(*-reinterpret-cast)
         s.size_bytes());
 }
 

asl/types/span_tests.cpp

@@ -17,7 +17,7 @@ static_assert(asl::size_of<asl::span<int, 2>> == asl::size_of<void*>);
 
 ASL_TEST(empty_dynamic)
 {
-    asl::span<int> s;
+    const asl::span<int> s;
     ASL_TEST_EXPECT(s.size() == 0);
     ASL_TEST_EXPECT(s.size_bytes() == 0);
     ASL_TEST_EXPECT(s.is_empty());
@@ -26,7 +26,7 @@ ASL_TEST(empty_dynamic)
 
 ASL_TEST(empty_static)
 {
-    asl::span<int, 0> s;
+    const asl::span<int, 0> s;
     ASL_TEST_EXPECT(s.size() == 0);
     ASL_TEST_EXPECT(s.size_bytes() == 0);
     ASL_TEST_EXPECT(s.is_empty());
@@ -35,7 +35,7 @@ ASL_TEST(empty_static)
 ASL_TEST(from_array_dynamic)
 {
     int array[] = {1, 2, 3};
-    asl::span<int> span = array;
+    const asl::span<int> span = array;
     ASL_TEST_ASSERT(span.size() == 3);
     ASL_TEST_EXPECT(span[0] == 1);
     ASL_TEST_EXPECT(span[1] == 2);
@@ -56,7 +56,7 @@ static_assert(!asl::constructible_from<asl::span<int32_t, 8>, int32_t(&)[10]>);
 ASL_TEST(from_array_static)
 {
     int array[] = {1, 2, 3};
-    asl::span<int, 3> span = array;
+    const asl::span<int, 3> span = array;
     ASL_TEST_ASSERT(span.size() == 3);
     ASL_TEST_EXPECT(span[0] == 1);
     ASL_TEST_EXPECT(span[1] == 2);
@@ -77,21 +77,21 @@ ASL_TEST(conversion)
 {
     int array[] = {1, 2, 3};
 
-    asl::span<int> span1 = array;
+    const asl::span<int> span1 = array;
 
-    asl::span<int, 3> span2{span1};
+    const asl::span<int, 3> span2{span1};
     ASL_TEST_ASSERT(span2.size() == 3);
     ASL_TEST_EXPECT(span2[0] == 1);
     ASL_TEST_EXPECT(span2[1] == 2);
     ASL_TEST_EXPECT(span2[2] == 3);
 
-    asl::span<int> span3 = span2;
+    const asl::span<int> span3 = span2;
     ASL_TEST_ASSERT(span3.size() == 3);
     ASL_TEST_EXPECT(span3[0] == 1);
     ASL_TEST_EXPECT(span3[1] == 2);
     ASL_TEST_EXPECT(span3[2] == 3);
 
-    asl::span<const int, 3> span4{span2};
+    const asl::span<const int, 3> span4{span2};
     ASL_TEST_ASSERT(span4.size() == 3);
     ASL_TEST_EXPECT(span4[0] == 1);
     ASL_TEST_EXPECT(span4[1] == 2);
@@ -138,7 +138,7 @@ static_assert(!IsValidSubspan<asl::span<int, 4>, 2, 3>);
 ASL_TEST(subspan_static_from_static)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int, 4> span{array};
+    const asl::span<int, 4> span{array};
 
     auto s1 = span.subspan<0>();
     ASL_TEST_ASSERT(s1.size() == 4);
@@ -164,7 +164,7 @@ ASL_TEST(subspan_static_from_static)
 ASL_TEST(subspan_static_from_dynamic)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int> span{array};
+    const asl::span<int> span{array};
 
     auto s1 = span.subspan<0>();
     ASL_TEST_ASSERT(s1.size() == 4);
@@ -190,7 +190,7 @@ ASL_TEST(subspan_static_from_dynamic)
 ASL_TEST(subspan_dynamic)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int> span{array};
+    const asl::span<int> span{array};
 
     auto s1 = span.subspan(0);
     ASL_TEST_ASSERT(s1.size() == 4);
@@ -249,7 +249,7 @@ static_assert(!IsValidFirst<asl::span<int, 4>, asl::dynamic_size>);
 ASL_TEST(first_static_from_static)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int, 4> span{array};
+    const asl::span<int, 4> span{array};
 
     auto s1 = span.first<0>();
     ASL_TEST_ASSERT(s1.size() == 0);
@@ -270,7 +270,7 @@ ASL_TEST(first_static_from_static)
 ASL_TEST(first_static_from_dynamic)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int> span{array};
+    const asl::span<int> span{array};
 
     auto s1 = span.first<0>();
     ASL_TEST_ASSERT(s1.size() == 0);
@@ -291,7 +291,7 @@ ASL_TEST(first_static_from_dynamic)
 ASL_TEST(first_dynamic)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int> span{array};
+    const asl::span<int> span{array};
 
     auto s1 = span.first(0);
     ASL_TEST_ASSERT(s1.size() == 0);
@@ -345,7 +345,7 @@ static_assert(!IsValidLast<asl::span<int, 4>, asl::dynamic_size>);
 ASL_TEST(last_static_from_static)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int, 4> span{array};
+    const asl::span<int, 4> span{array};
 
     auto s1 = span.last<0>();
     ASL_TEST_ASSERT(s1.size() == 0);
@@ -366,7 +366,7 @@ ASL_TEST(last_static_from_static)
 ASL_TEST(last_static_from_dynamic)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int> span{array};
+    const asl::span<int> span{array};
 
     auto s1 = span.last<0>();
     ASL_TEST_ASSERT(s1.size() == 0);
@@ -387,7 +387,7 @@ ASL_TEST(last_static_from_dynamic)
 ASL_TEST(last_dynamic)
 {
     int array[] = {1, 2, 3, 4};
-    asl::span<int> span{array};
+    const asl::span<int> span{array};
 
     auto s1 = span.last(0);
     ASL_TEST_ASSERT(s1.size() == 0);
@@ -416,8 +416,8 @@ static_assert(HasAsMutableBytes<const int*>);
 ASL_TEST(as_bytes)
 {
      uint32_t data[] = {0x01020304, 0x05060708};
-     asl::span s1(data);
+     const asl::span s1(data);
-     asl::span s2 = asl::as_bytes(s1);
+     const asl::span s2 = asl::as_bytes(s1);
 
      ASL_TEST_ASSERT(s2.size() == 8);
      ASL_TEST_ASSERT(static_cast<int>(s2[0]) == 0x04);
@@ -433,8 +433,8 @@ ASL_TEST(as_bytes)
 ASL_TEST(as_mutable_bytes)
 {
      uint32_t data[] = {0x01020304, 0x05060708};
-     asl::span s1(data);
+     const asl::span s1(data);
-     asl::span s2 = asl::as_mutable_bytes(s1);
+     const asl::span s2 = asl::as_mutable_bytes(s1);
 
      ASL_TEST_ASSERT(s2.size() == 8);
      ASL_TEST_ASSERT(static_cast<int>(s2[0]) == 0x04);

asl/types/status.cpp

@@ -11,9 +11,11 @@
 
 // @Todo Use custom allocator
 using Allocator = asl::DefaultAllocator;
+
+// NOLINTNEXTLINE(*-non-const-global-variables)
 static Allocator g_allocator{};
 
-namespace
+namespace asl
 {
 
 struct StatusInternal
@@ -23,7 +25,7 @@ struct StatusInternal
     asl::atomic<int32_t> ref_count;
 
     constexpr StatusInternal(asl::string<Allocator>&& msg_, asl::status_code code_)
-        : msg{ASL_MOVE(msg_)}
+        : msg{std::move(msg_)}
         , code{code_}
     {
         ASL_ASSERT(code != asl::status_code::ok);
@@ -31,7 +33,7 @@ struct StatusInternal
     }
 };
 
-} // anonymous namespace
+}  // namespace asl
 
 asl::status::status(status_code code, string_view msg)
     : m_payload{alloc_new<StatusInternal>(g_allocator, msg, code)}
@@ -41,36 +43,35 @@ asl::status::status(status_code code, string_view fmt, span<format_internals::ty
 {
     StringWriter<Allocator> sink{g_allocator};
     format_internals::format(&sink, fmt, args);
-    m_payload = alloc_new<StatusInternal>(g_allocator, ASL_MOVE(sink).finish(), code);
+    m_payload = alloc_new<StatusInternal>(g_allocator, std::move(sink).finish(), code);
 }
 
 asl::status_code asl::status::code_internal() const
 {
     ASL_ASSERT(!is_inline());
-    return reinterpret_cast<const StatusInternal*>(m_payload)->code;
+    return m_payload->code;
 }
 
 asl::string_view asl::status::message_internal() const
 {
     ASL_ASSERT(!is_inline());
-    return reinterpret_cast<const StatusInternal*>(m_payload)->msg;
+    return m_payload->msg;
 }
 
 void asl::status::ref()
 {
     ASL_ASSERT(!is_inline());
-    auto* internal = reinterpret_cast<StatusInternal*>(m_payload);
+    atomic_fetch_increment(&m_payload->ref_count, memory_order::relaxed);
-    atomic_fetch_increment(&internal->ref_count, memory_order::relaxed);
 }
 
 void asl::status::unref()
 {
     ASL_ASSERT(!is_inline());
-    auto* internal = reinterpret_cast<StatusInternal*>(m_payload);
+    if (atomic_fetch_decrement(&m_payload->ref_count, memory_order::release) == 1)
-    if (atomic_fetch_decrement(&internal->ref_count, memory_order::release) == 1)
     {
         atomic_fence(memory_order::acquire);
-        alloc_delete(g_allocator, internal);
+        alloc_delete(g_allocator, m_payload);
+        m_payload = nullptr;
     }
 }
 

asl/types/status.hpp

@@ -22,15 +22,17 @@ enum class status_code : uint8_t
     invalid_argument = 4,
 };
 
+struct StatusInternal;
+
 class status
 {
-    void* m_payload{};
+    StatusInternal* m_payload{};
 
-    static constexpr void* status_to_payload(status_code code)
+    static constexpr StatusInternal* status_to_payload(status_code code)
     {
         return code == status_code::ok
             ? nullptr
-            : bit_cast<void*>((static_cast<uintptr_t>(code) << 1) | 1);
+            : bit_cast<StatusInternal*>((static_cast<uintptr_t>(code) << 1) | 1);
     }
 
     static constexpr status_code payload_to_status(void* payload)
@@ -38,12 +40,12 @@ class status
         return static_cast<status_code>(bit_cast<uintptr_t>(payload) >> 1);
     }
 
-    constexpr bool is_inline() const
+    [[nodiscard]] constexpr bool is_inline() const
     {
         return m_payload == nullptr || (bit_cast<uintptr_t>(m_payload) & 1) != 0;
     }
 
-    constexpr status_code code_inline() const
+    [[nodiscard]] constexpr status_code code_inline() const
     {
         ASL_ASSERT(is_inline());
         if (m_payload == nullptr)
@@ -53,8 +55,8 @@ class status
         return payload_to_status(m_payload);
     }
 
-    status_code code_internal() const;
+    [[nodiscard]] status_code code_internal() const;
-    string_view message_internal() const;
+    [[nodiscard]] string_view message_internal() const;
 
     void ref();
     void unref();
@@ -103,17 +105,17 @@ public:
         return *this;
     }
 
-    constexpr bool ok() const
+    [[nodiscard]] constexpr bool ok() const
     {
         return m_payload == nullptr;
     }
 
-    constexpr status_code code() const
+    [[nodiscard]] constexpr status_code code() const
     {
         return is_inline() ? code_inline() : code_internal();
     }
 
-    constexpr string_view message() const
+    [[nodiscard]] constexpr string_view message() const
     {
         if (!is_inline())
         {
@@ -122,7 +124,7 @@ public:
         return {};
     }
 
-    constexpr status&& throw_status() && { return ASL_MOVE(*this); }
+    constexpr status&& throw_status() && { return std::move(*this); }
 
     friend void AslFormat(Formatter& f, const status&);
 
@@ -131,9 +133,9 @@ public:
     {
         if (s.is_inline())
         {
-            return H::combine(ASL_MOVE(h), s.code());
+            return H::combine(std::move(h), s.code());
         }
-        return H::combine(ASL_MOVE(h), s.code(), s.message());
+        return H::combine(std::move(h), s.code(), s.message());
     }
 };
 
@@ -156,6 +158,6 @@ ASL_DEFINE_ERROR_(internal)
 ASL_DEFINE_ERROR_(runtime)
 ASL_DEFINE_ERROR_(invalid_argument)
 
-#define ASL_TRY(VALUE) if (VALUE.ok()) {} else { return ASL_MOVE(VALUE).throw_status(); }
+#define ASL_TRY(VALUE) if ((VALUE).ok()) {} else { return std::move(VALUE).throw_status(); }
 
 } // namespace asl

asl/types/status_or.hpp

@@ -33,11 +33,11 @@ public:
 
     constexpr status_or(status_or&& other)
         requires move_constructible<T>
-        : m_status{ASL_MOVE(other.m_status)}
+        : m_status{std::move(other.m_status)}
     {
         if (other.ok())
         {
-            m_value.construct_unsafe(ASL_MOVE(other.m_value.as_init_unsafe()));
+            m_value.construct_unsafe(std::move(other.m_value.as_init_unsafe()));
         }
     }
 
@@ -75,7 +75,7 @@ public:
             {
                 if (other.ok())
                 {
-                    m_value.assign_unsafe(ASL_MOVE(other.m_value.as_init_unsafe()));
+                    m_value.assign_unsafe(std::move(other.m_value.as_init_unsafe()));
                 }
                 else
                 {
@@ -84,9 +84,9 @@ public:
             }
             else if (other.ok())
             {
-                m_value.construct_unsafe(ASL_MOVE(other.m_value.as_init_unsafe()));
+                m_value.construct_unsafe(std::move(other.m_value.as_init_unsafe()));
             }
-            m_status = ASL_MOVE(other.m_status);
+            m_status = std::move(other.m_status);
         }
         return *this;
     }
@@ -99,14 +99,14 @@ public:
         }
     }
 
-    // NOLINTNEXTLINE(*-explicit-conversions)
+    // NOLINTNEXTLINE(*explicit*)
     constexpr status_or(const status& status) : m_status{status}
     {
         ASL_ASSERT_RELEASE(!m_status.ok());
     }
 
-    // NOLINTNEXTLINE(*-explicit-conversions)
+    // NOLINTNEXTLINE(*explicit*)
-    constexpr status_or(status&& status) : m_status{ASL_MOVE(status)}
+    constexpr status_or(status&& status) : m_status{std::move(status)}
     {
         ASL_ASSERT_RELEASE(!m_status.ok());
     }
@@ -114,7 +114,7 @@ public:
     status_or& operator=(status status) = delete;
 
     template<typename U = T>
-    constexpr explicit (!convertible_from<T, U&&>)
+    constexpr explicit (!convertible_to<U&&, T>)
     status_or(U&& value)
         requires (
             constructible_from<T, U&&> &&
@@ -122,35 +122,35 @@ public:
             !same_as<un_cvref_t<U>, status>
         )
         : m_status{status_code::ok}
-        , m_value{in_place, ASL_FWD(value)}
+        , m_value{in_place, std::forward<U>(value)}
     {}
 
-    constexpr bool ok() const { return m_status.ok(); }
+    [[nodiscard]] constexpr bool ok() const { return m_status.ok(); }
 
-    constexpr status_code code() const { return m_status.code(); }
+    [[nodiscard]] constexpr status_code code() const { return m_status.code(); }
 
-    constexpr string_view message() const { return m_status.message(); }
+    [[nodiscard]] constexpr string_view message() const { return m_status.message(); }
 
-    constexpr status&& throw_status() && { return ASL_MOVE(m_status); }
+    constexpr status&& throw_status() && { return std::move(m_status); }
 
     constexpr auto&& value(this auto&& self)
     {
         ASL_ASSERT_RELEASE(self.ok());
-        return ASL_FWD(self).m_value.as_init_unsafe();
+        return std::forward<decltype(self)>(self).m_value.as_init_unsafe();
     }
 
     template<typename U>
     constexpr T value_or(U&& other_value) const&
-        requires copy_constructible<T> && convertible_from<T, U&&>
+        requires copy_constructible<T> && convertible_to<U&&, T>
     {
-        return ok() ? value() : static_cast<T>(ASL_FWD(other_value));
+        return ok() ? value() : static_cast<T>(std::forward<U>(other_value));
     }
 
     template<typename U>
     constexpr T value_or(U&& other_value) &&
-        requires move_constructible<T> && convertible_from<T, U&&>
+        requires move_constructible<T> && convertible_to<U&&, T>
     {
-        return ok() ? ASL_MOVE(value()) : static_cast<T>(ASL_FWD(other_value));
+        return ok() ? std::move(value()) : static_cast<T>(std::forward<U>(other_value));
     }
 
     friend void AslFormat(Formatter& f, const status_or& status)
@@ -164,9 +164,9 @@ public:
     {
         if (s.ok())
         {
-            return H::combine(ASL_MOVE(h), s.m_status, s.value());
+            return H::combine(std::move(h), s.m_status, s.value());
         }
-        return H::combine(ASL_MOVE(h), s.m_status);
+        return H::combine(std::move(h), s.m_status);
     }
 };
 

asl/types/status_or_tests.cpp

@@ -20,24 +20,24 @@ static_assert(!asl::moveable<asl::status_or<Pinned>>);
 
 ASL_TEST(ok)
 {
-    asl::status_or<int> s = 6;
+    const  asl::status_or<int> s = 6;
     ASL_TEST_EXPECT(s.ok());
     ASL_TEST_EXPECT(s.code() == asl::status_code::ok);
 }
 
 ASL_TEST(from_status)
 {
-    asl::status_or<char> s = asl::internal_error();
+    const asl::status_or<char> s = asl::internal_error();
     ASL_TEST_EXPECT(!s.ok());
     ASL_TEST_EXPECT(s.code() == asl::status_code::internal);
     ASL_TEST_EXPECT(s.message() == ""_sv);
 
-    asl::status_or<int> s2 = asl::internal_error("oh no");
+    const asl::status_or<int> s2 = asl::internal_error("oh no");
     ASL_TEST_EXPECT(!s2.ok());
     ASL_TEST_EXPECT(s2.code() == asl::status_code::internal);
     ASL_TEST_EXPECT(s2.message() == "oh no"_sv);
 
-    asl::status_or<int> s3 = asl::internal_error("{} {}", 1, 2);
+    const asl::status_or<int> s3 = asl::internal_error("{} {}", 1, 2);
     ASL_TEST_EXPECT(!s3.ok());
     ASL_TEST_EXPECT(s3.code() == asl::status_code::internal);
     ASL_TEST_EXPECT(s3.message() == "1 2"_sv);
@@ -52,11 +52,11 @@ ASL_TEST(destructor)
         ASL_TEST_EXPECT(s.ok());
         ASL_TEST_EXPECT(!d);
 
-        asl::status_or s2 = ASL_MOVE(s);
+        asl::status_or s2 = std::move(s);
-        ASL_TEST_EXPECT(s.ok());
+        ASL_TEST_EXPECT(s2.ok());
         ASL_TEST_EXPECT(!d);
 
-        s = ASL_MOVE(s2);
+        s = std::move(s2);
         ASL_TEST_EXPECT(s.ok());
         ASL_TEST_EXPECT(!d);
     }
@@ -79,8 +79,8 @@ ASL_TEST(copy)
 
 ASL_TEST(value_or)
 {
-    asl::status_or<int> s = 7;
+    const asl::status_or<int> s = 7;
-    asl::status_or<int> s2 = asl::internal_error();
+    const asl::status_or<int> s2 = asl::internal_error();
 
     ASL_TEST_EXPECT(s.value_or(45) == 7);
     ASL_TEST_EXPECT(s2.value_or(45) == 45);

asl/types/status_tests.cpp

@@ -9,14 +9,14 @@
 
 ASL_TEST(simple_ok)
 {
-    asl::status s = asl::ok();
+    const asl::status s = asl::ok();
     ASL_TEST_ASSERT(s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::ok);
 }
 
 ASL_TEST(simple_code)
 {
-    asl::status s = asl::runtime_error();
+    const asl::status s = asl::runtime_error();
     ASL_TEST_ASSERT(!s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::runtime);
     ASL_TEST_ASSERT(s.message() == ""_sv);
@@ -24,7 +24,7 @@ ASL_TEST(simple_code)
 
 ASL_TEST(with_message)
 {
-    asl::status s = asl::internal_error("We done goofed");
+    const asl::status s = asl::internal_error("We done goofed");
     ASL_TEST_ASSERT(!s.ok());
     ASL_TEST_ASSERT(s.code() == asl::status_code::internal);
     ASL_TEST_ASSERT(s.message() == "We done goofed"_sv);
@@ -32,8 +32,8 @@ ASL_TEST(with_message)
 
 ASL_TEST(copy_inline)
 {
-    asl::status s = asl::ok();
+    const asl::status s = asl::ok();
-    asl::status s2 = asl::internal_error();
+    const asl::status s2 = asl::internal_error();
 
     asl::status s3 = s;
     ASL_TEST_ASSERT(s3.code() == asl::status_code::ok);
@@ -47,7 +47,7 @@ ASL_TEST(copy_message)
     asl::status s2 = asl::ok();
 
     {
-        asl::status s = asl::internal_error("Oh no!");
+        const asl::status s = asl::internal_error("Oh no!");
         ASL_TEST_ASSERT(!s.ok());
         ASL_TEST_ASSERT(s.code() == asl::status_code::internal);
         ASL_TEST_ASSERT(s.message() == "Oh no!"_sv);

tools/fix_line_endings.py

@@ -12,6 +12,7 @@ import time
 TO_FIX = [
     ".bazelrc",
     ".clang-tidy",
+    ".clangd",
     ".gitignore",
     "**/*.hpp",
     "**/*.h",