From a141c401f78467bc15f62882fca5d55a007cacbb Mon Sep 17 00:00:00 2001
From: Steven Le Rouzic <steven.lerouzic@gmail.com>
Date: Mon, 17 Feb 2025 00:21:48 +0100
Subject: Reorganize everything

---
 asl/types/BUILD.bazel            | 135 +++++++++++
 asl/types/box.hpp                | 134 +++++++++++
 asl/types/box_tests.cpp          | 102 ++++++++
 asl/types/maybe_uninit.hpp       |  72 ++++++
 asl/types/maybe_uninit_tests.cpp |  22 ++
 asl/types/option.hpp             | 509 +++++++++++++++++++++++++++++++++++++++
 asl/types/option_tests.cpp       | 330 +++++++++++++++++++++++++
 asl/types/span.hpp               | 235 ++++++++++++++++++
 asl/types/span_tests.cpp         | 444 ++++++++++++++++++++++++++++++++++
 asl/types/status.cpp             |  96 ++++++++
 asl/types/status.hpp             | 157 ++++++++++++
 asl/types/status_or.hpp          | 186 ++++++++++++++
 asl/types/status_or_tests.cpp    |  84 +++++++
 asl/types/status_tests.cpp       |  82 +++++++
 14 files changed, 2588 insertions(+)
 create mode 100644 asl/types/BUILD.bazel
 create mode 100644 asl/types/box.hpp
 create mode 100644 asl/types/box_tests.cpp
 create mode 100644 asl/types/maybe_uninit.hpp
 create mode 100644 asl/types/maybe_uninit_tests.cpp
 create mode 100644 asl/types/option.hpp
 create mode 100644 asl/types/option_tests.cpp
 create mode 100644 asl/types/span.hpp
 create mode 100644 asl/types/span_tests.cpp
 create mode 100644 asl/types/status.cpp
 create mode 100644 asl/types/status.hpp
 create mode 100644 asl/types/status_or.hpp
 create mode 100644 asl/types/status_or_tests.cpp
 create mode 100644 asl/types/status_tests.cpp

(limited to 'asl/types')

diff --git a/asl/types/BUILD.bazel b/asl/types/BUILD.bazel
new file mode 100644
index 0000000..d39586b
--- /dev/null
+++ b/asl/types/BUILD.bazel
@@ -0,0 +1,135 @@
+cc_library(
+    name = "box",
+    hdrs = [
+        "box.hpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/memory",
+        "//asl/hashing",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "span",
+    hdrs = [
+        "span.hpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/memory",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "maybe_uninit",
+    hdrs = [
+        "maybe_uninit.hpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/memory",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "option",
+    hdrs = [
+        "option.hpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/types:maybe_uninit",
+        "//asl/hashing",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_library(
+    name = "status",
+    hdrs = [
+        "status.hpp",
+        "status_or.hpp",
+    ],
+    srcs = [
+        "status.cpp",
+    ],
+    deps = [
+        "//asl/base",
+        "//asl/strings:string",
+        "//asl/strings:string_builder",
+        "//asl/formatting",
+        "//asl/memory",
+        "//asl/synchronization:atomic",
+        "//asl/types:maybe_uninit",
+        "//asl/hashing",
+    ],
+    visibility = ["//visibility:public"],
+)
+
+cc_test(
+    name = "box_tests",
+    srcs = ["box_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:box",
+        "//asl/types:option",
+        "//asl/types:maybe_uninit",
+        "//asl/hashing",
+    ],
+)
+
+cc_test(
+    name = "maybe_uninit_tests",
+    srcs = ["maybe_uninit_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:maybe_uninit",
+    ],
+)
+
+cc_test(
+    name = "span_tests",
+    srcs = ["span_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:span",
+    ],
+)
+
+cc_test(
+    name = "option_tests",
+    srcs = ["option_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:option",
+    ],
+)
+
+cc_test(
+    name = "status_tests",
+    srcs = ["status_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:status",
+    ],
+)
+
+cc_test(
+    name = "status_or_tests",
+    srcs = ["status_or_tests.cpp"],
+    deps = [
+        "//asl/tests:utils",
+        "//asl/testing",
+        "//asl/types:status",
+    ],
+)
+
diff --git a/asl/types/box.hpp b/asl/types/box.hpp
new file mode 100644
index 0000000..d8577ec
--- /dev/null
+++ b/asl/types/box.hpp
@@ -0,0 +1,134 @@
+#pragma once
+
+#include "asl/base/assert.hpp"
+#include "asl/base/annotations.hpp"
+#include "asl/base/utility.hpp"
+#include "asl/memory/memory.hpp"
+#include "asl/memory/allocator.hpp"
+#include "asl/hashing/hash.hpp"
+
+namespace asl
+{
+
+template<is_object T, allocator Allocator = DefaultAllocator>
+class box
+{
+    T* m_ptr;
+    ASL_NO_UNIQUE_ADDRESS Allocator m_alloc;
+
+public:
+    explicit constexpr box(niche_t)
+        requires default_constructible<Allocator>
+        : m_ptr{nullptr}
+        , m_alloc{}
+    {}
+
+    constexpr box(T* ptr, Allocator alloc)
+        : m_ptr{ptr}
+        , m_alloc{ASL_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)}
+    {}
+
+    template<is_object U>
+    requires convertible_from<T*, U*>
+    constexpr box(box<U, Allocator>&& other) // NOLINT(*-explicit-conversions)
+        : m_ptr{exchange(other.m_ptr, nullptr)}
+        , m_alloc{ASL_MOVE(other.m_alloc)}
+    {}
+
+    constexpr box& operator=(box&& other)
+    {
+        if (this == &other) { return *this; }
+
+        if (m_ptr != nullptr) { reset(); }
+
+        m_ptr = exchange(other.m_ptr, nullptr);
+        m_alloc = ASL_MOVE(other.m_alloc);
+
+        return *this;
+    }
+
+    box(const box&) = delete;
+    box& operator=(const box&) = delete;
+
+    constexpr ~box()
+    {
+        reset();
+    }
+
+    constexpr void reset()
+    {
+        if (m_ptr != nullptr)
+        {
+            destroy(m_ptr);
+            m_alloc.dealloc(m_ptr, layout::of<T>());
+            m_ptr = nullptr;
+        }
+    }
+
+    constexpr T* get() const { return m_ptr; }
+
+    constexpr T& operator*() const
+    {
+        ASL_ASSERT(m_ptr != nullptr);
+        return *m_ptr;
+    }
+
+    constexpr T* operator->() const
+    {
+        ASL_ASSERT(m_ptr != nullptr);
+        return m_ptr;
+    }
+
+    constexpr bool operator==(niche_t) const
+    {
+        return m_ptr == nullptr;
+    }
+
+    template<typename H>
+    requires hashable<T>
+    friend H AslHashValue(H h, const box& b)
+    {
+        return H::combine(ASL_MOVE(h), *b);
+    }
+
+    template<is_object U, allocator A>
+    friend constexpr U* leak(box<U, A>&&);
+
+    template<is_object U, allocator A>
+    friend class box;
+};
+
+template<is_object T, allocator Allocator = DefaultAllocator, typename... Args>
+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)...);
+    return box(ptr, ASL_MOVE(allocator));
+}
+
+template<is_object T, allocator Allocator = DefaultAllocator, typename... Args>
+constexpr box<T, Allocator> make_box(Args&&... args)
+    requires default_constructible<Allocator> && constructible_from<T, Args&&...>
+{
+    Allocator allocator{};
+    void* raw_ptr = allocator.alloc(layout::of<T>());
+    auto* ptr = construct_at<T>(raw_ptr, ASL_FWD(args)...);
+    return box<T>(ptr, ASL_MOVE(allocator));
+}
+
+template<is_object T, allocator A>
+constexpr T* leak(box<T, A>&& b)
+{
+    return exchange(b.m_ptr, nullptr);
+}
+
+} // namespace asl
+
diff --git a/asl/types/box_tests.cpp b/asl/types/box_tests.cpp
new file mode 100644
index 0000000..58eb4f6
--- /dev/null
+++ b/asl/types/box_tests.cpp
@@ -0,0 +1,102 @@
+#include "asl/types/box.hpp"
+#include "asl/types/option.hpp"
+
+#include "asl/testing/testing.hpp"
+#include "asl/tests/types.hpp"
+
+static_assert(sizeof(asl::box<int>) == sizeof(int*));
+static_assert(!asl::copyable<asl::box<int>>);
+static_assert(asl::moveable<asl::box<int>>);
+static_assert(asl::has_niche<asl::box<int>>);
+static_assert(sizeof(asl::option<asl::box<int>>) == sizeof(int*));
+
+ASL_TEST(destructor)
+{
+    bool d = false;
+
+    {
+        auto box = asl::make_box<DestructorObserver>(&d);
+        ASL_TEST_ASSERT(!d);
+
+
+        auto box3 = ASL_MOVE(box);
+        ASL_TEST_ASSERT(!d);
+    }
+
+    ASL_TEST_ASSERT(d);
+}
+
+ASL_TEST(value)
+{
+    auto b = asl::make_box<int>(24);
+    ASL_TEST_EXPECT(*b == 24);
+
+    auto b2 = ASL_MOVE(b);
+    ASL_TEST_EXPECT(*b2 == 24);
+}
+
+ASL_TEST(ptr)
+{
+    auto b = asl::make_box<int>(24);
+    auto* ptr1 = b.get();
+
+    auto b2 = ASL_MOVE(b);
+    auto* ptr2 = b2.get();
+    ASL_TEST_EXPECT(ptr1 == ptr2);
+}
+
+struct Struct { int a; };
+
+ASL_TEST(arrow)
+{
+    auto b = asl::make_box<Struct>(45);
+    ASL_TEST_EXPECT(b->a == 45);
+}
+
+ASL_TEST(niche)
+{
+    static_assert(sizeof(asl::box<int>) == sizeof(asl::option<asl::box<int>>));
+
+    asl::option<asl::box<int>> opt;
+    ASL_TEST_EXPECT(!opt.has_value());
+
+    opt = asl::make_box<int>(66);
+    ASL_TEST_EXPECT(opt.has_value());
+    ASL_TEST_EXPECT(*opt.value() == 66);
+
+    opt = asl::nullopt;
+    ASL_TEST_EXPECT(!opt.has_value());
+
+    bool destroyed = false;
+    asl::option opt2 = asl::make_box<DestructorObserver>(&destroyed);
+    ASL_TEST_EXPECT(opt2.has_value());
+    ASL_TEST_EXPECT(!destroyed);
+
+    opt2.reset();
+    ASL_TEST_EXPECT(!opt2.has_value());
+    ASL_TEST_EXPECT(destroyed);
+}
+
+class Base
+{
+public:
+    virtual ~Base() = default;
+    virtual int number() { return 1; }
+};
+
+class Derived : public Base
+{
+public:
+    int number() override { return 2; }
+};
+
+static_assert(asl::convertible_from<asl::box<Base>, asl::box<Derived>>);
+static_assert(asl::convertible_from<asl::box<Base>, asl::box<Base>>);
+static_assert(!asl::convertible_from<asl::box<Derived>, asl::box<Base>>);
+static_assert(!asl::convertible_from<asl::box<int>, asl::box<float>>);
+
+ASL_TEST(derived)
+{
+    asl::box<Base> obj = asl::make_box<Derived>();
+    ASL_TEST_ASSERT(obj->number() == 2);
+}
diff --git a/asl/types/maybe_uninit.hpp b/asl/types/maybe_uninit.hpp
new file mode 100644
index 0000000..9134fe9
--- /dev/null
+++ b/asl/types/maybe_uninit.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "asl/base/meta.hpp"
+#include "asl/base/utility.hpp"
+#include "asl/memory/memory.hpp"
+
+namespace asl
+{
+
+template<is_object T>
+union maybe_uninit
+{
+private:
+    T m_value;
+
+public:
+    constexpr maybe_uninit() requires trivially_default_constructible<T> = default;
+    constexpr maybe_uninit() requires (!trivially_default_constructible<T>) {} // NOLINT
+
+    template<typename... Args>
+    explicit constexpr maybe_uninit(in_place_t, Args&&... args)
+        requires constructible_from<T, Args&&...>
+        : m_value{ASL_FWD(args)...}
+    {}
+
+    constexpr maybe_uninit(const maybe_uninit&) requires trivially_copy_constructible<T> = default;
+    constexpr maybe_uninit(const maybe_uninit&) requires (!trivially_copy_constructible<T>) {} // NOLINT
+
+    constexpr maybe_uninit(maybe_uninit&&) requires trivially_move_constructible<T> = default;
+    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=(maybe_uninit&&) requires trivially_move_assignable<T> = default;
+    constexpr maybe_uninit& operator=(maybe_uninit&&) requires (!trivially_move_assignable<T>) {}
+
+    constexpr ~maybe_uninit() requires trivially_destructible<T> = default;
+    constexpr ~maybe_uninit() requires (!trivially_destructible<T>) {} // NOLINT
+
+    // @Safety Value must not have been initialized yet
+    template<typename... Args>
+    constexpr void construct_unsafe(Args&&... args)
+        requires constructible_from<T, Args&&...>
+    {
+        construct_at<T>(&m_value, ASL_FWD(args)...);
+    }
+
+    // @Safety Value must have been initialized
+    template<typename U>
+    constexpr void assign_unsafe(U&& value)
+        requires assignable_from<T&, U&&>
+    {
+        m_value = ASL_FWD(value);
+    }
+
+    // @Safety Value must have been initialized
+    constexpr void destroy_unsafe()
+    {
+        if constexpr (!trivially_destructible<T>)
+        {
+            destroy(&m_value);
+        }
+    }
+
+    // @Safety Value must have been initialized
+    constexpr const T& as_init_unsafe() const& { return m_value; }
+    constexpr T&       as_init_unsafe() &      { return m_value; }
+    constexpr T&&      as_init_unsafe() &&     { return ASL_MOVE(m_value); }
+};
+
+} // namespace asl
diff --git a/asl/types/maybe_uninit_tests.cpp b/asl/types/maybe_uninit_tests.cpp
new file mode 100644
index 0000000..4b414cd
--- /dev/null
+++ b/asl/types/maybe_uninit_tests.cpp
@@ -0,0 +1,22 @@
+#include "asl/types/maybe_uninit.hpp"
+#include "asl/tests/types.hpp"
+
+static_assert(asl::layout::of<int>() == asl::layout::of<asl::maybe_uninit<int>>());
+static_assert(asl::size_of<int> == asl::size_of<asl::maybe_uninit<int>>);
+static_assert(asl::align_of<int> == asl::align_of<asl::maybe_uninit<int>>);
+
+#define TEST_TYPE_PROPERTIES(PRP) \
+    static_assert(asl::PRP<asl::maybe_uninit<TrivialType>> == asl::PRP<TrivialType>); \
+    static_assert(asl::PRP<asl::maybe_uninit<TrivialTypeDefaultValue>> == asl::PRP<TrivialTypeDefaultValue>); \
+    static_assert(asl::PRP<asl::maybe_uninit<WithDestructor>> == asl::PRP<WithDestructor>); \
+    static_assert(asl::PRP<asl::maybe_uninit<Copyable>> == asl::PRP<Copyable>); \
+    static_assert(asl::PRP<asl::maybe_uninit<MoveableOnly>> == asl::PRP<MoveableOnly>); \
+    static_assert(asl::PRP<asl::maybe_uninit<Pinned>> == asl::PRP<Pinned>);
+
+TEST_TYPE_PROPERTIES(trivially_default_constructible);
+TEST_TYPE_PROPERTIES(trivially_copy_constructible);
+TEST_TYPE_PROPERTIES(trivially_move_constructible);
+TEST_TYPE_PROPERTIES(trivially_copy_assignable);
+TEST_TYPE_PROPERTIES(trivially_move_assignable);
+TEST_TYPE_PROPERTIES(trivially_destructible);
+
diff --git a/asl/types/option.hpp b/asl/types/option.hpp
new file mode 100644
index 0000000..86cfca3
--- /dev/null
+++ b/asl/types/option.hpp
@@ -0,0 +1,509 @@
+#pragma once
+
+#include "asl/base/assert.hpp"
+#include "asl/base/meta.hpp"
+#include "asl/base/functional.hpp"
+#include "asl/base/annotations.hpp"
+#include "asl/types/maybe_uninit.hpp"
+#include "asl/hashing/hash.hpp"
+
+namespace asl
+{
+
+struct nullopt_t {};
+static constexpr nullopt_t nullopt{};
+
+// @Todo(option) Reference
+// @Todo(option) Function
+// @Todo(option) Arrays
+
+template<is_object T> class option;
+
+namespace option_internal
+{
+
+template<typename T, typename U>
+concept not_constructible_from_option =
+    !constructible_from<T, option<U>&> &&
+    !constructible_from<T, const option<U>&> &&
+    !constructible_from<T, option<U>&&> &&
+    !constructible_from<T, const option<U>&&>;
+
+template<typename T, typename U>
+concept not_assignable_from_option =
+    !assignable_from<T&, option<U>&> &&
+    !assignable_from<T&, const option<U>&> &&
+    !assignable_from<T&, option<U>&&> &&
+    !assignable_from<T&, const option<U>&&>;
+
+template<typename T, typename U>
+concept not_constructible_assignable_from_option =
+    not_constructible_from_option<T, U> &&
+    not_assignable_from_option<T, U>;
+
+} // namespace option_internal
+
+template<typename T>
+concept is_option = requires
+{
+    typename T::type;
+    requires same_as<un_cvref_t<T>, option<typename T::type>>;
+};
+
+template<is_object T>
+class option
+{
+    static constexpr bool kHasNiche = has_niche<T>;
+
+    using HasValueMarker = select_t<kHasNiche, empty, bool>;
+
+    maybe_uninit<T> m_payload{};
+    ASL_NO_UNIQUE_ADDRESS HasValueMarker m_has_value{};
+
+    template<is_object U>
+    friend class option;
+
+    template<typename... Args>
+    constexpr void construct(Args&&... args)
+    {
+        ASL_ASSERT(!has_value());
+
+        if constexpr (!kHasNiche)
+        {
+            m_payload.construct_unsafe(ASL_FWD(args)...);
+            m_has_value = true;
+        }
+        else
+        {
+            if constexpr (move_assignable<T>)
+            {
+                m_payload.assign_unsafe(ASL_MOVE(T{ASL_FWD(args)...}));
+            }
+            else
+            {
+                m_payload.destroy_unsafe();
+                m_payload.construct_unsafe(ASL_FWD(args)...);
+            }
+        }
+    }
+
+    template<typename U>
+    constexpr void assign(U&& arg)
+    {
+        ASL_ASSERT(has_value());
+        m_payload.assign_unsafe(ASL_FWD(arg));
+    }
+
+public:
+    using type = T;
+
+    constexpr option() : option{nullopt} {}
+
+     // NOLINTNEXTLINE(*-explicit-conversions)
+    constexpr option(nullopt_t) requires (!kHasNiche) {}
+
+     // NOLINTNEXTLINE(*-explicit-conversions)
+    constexpr option(nullopt_t) requires kHasNiche : m_payload{in_place, niche_t{}} {}
+
+    template<typename U = T>
+    constexpr explicit (!convertible_from<T, U&&>)
+    option(U&& value)
+        requires (
+            kHasNiche &&
+            constructible_from<T, U&&> &&
+            !same_as<un_cvref_t<U>, option>
+        )
+        : m_payload{in_place, ASL_FWD(value)}
+    {}
+
+    template<typename U = T>
+    constexpr explicit (!convertible_from<T, U&&>)
+    option(U&& value)
+        requires (
+            !kHasNiche &&
+            constructible_from<T, U&&> &&
+            !is_option<U>
+        )
+        : m_payload{in_place, ASL_FWD(value)}
+        , m_has_value{true}
+    {}
+
+    constexpr option(const option& other) requires trivially_copy_constructible<T> = default;
+    constexpr option(const option& other) requires (!copy_constructible<T>) = delete;
+
+    constexpr option(const option& other)
+        requires copy_constructible<T> && (!trivially_copy_constructible<T>)
+        : option{nullopt}
+    {
+        if (other.has_value())
+        {
+            construct(other.m_payload.as_init_unsafe());
+        }
+    }
+
+    constexpr option(option&& other) requires trivially_move_constructible<T> = default;
+    constexpr option(option&& other) requires (!move_constructible<T>) = delete;
+
+    constexpr option(option&& other)
+        requires move_constructible<T> && (!trivially_move_constructible<T>)
+        : option{nullopt}
+    {
+        if (other.has_value())
+        {
+            construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+        }
+    }
+
+    template<typename U>
+    constexpr explicit (!convertible_from<T, const U&>)
+    option(const option<U>& other)
+        requires (
+            constructible_from<T, const U&> &&
+            option_internal::not_constructible_from_option<T, U>
+        )
+        : option{nullopt}
+    {
+        if (other.has_value())
+        {
+            construct(other.m_payload.as_init_unsafe());
+        }
+    }
+
+    template<typename U>
+    constexpr explicit (!convertible_from<T, U&&>)
+    option(option<U>&& other)
+        requires (
+            constructible_from<T, U&&> &&
+            option_internal::not_constructible_from_option<T, U>
+        )
+        : option{nullopt}
+    {
+        if (other.has_value())
+        {
+            construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+        }
+    }
+
+    constexpr option& operator=(nullopt_t) &
+    {
+        reset();
+        return *this;
+    }
+
+    template<typename U = T>
+    constexpr option& operator=(U&& value) &
+        requires (
+            assignable_from<T&, U&&> &&
+            constructible_from<T, U&&> &&
+            !is_option<U>
+        )
+    {
+        if (has_value())
+        {
+            assign(ASL_FWD(value));
+        }
+        else
+        {
+            construct(ASL_FWD(value));
+        }
+
+        return *this;
+    }
+
+    constexpr option& operator=(const option& other) &
+        requires (!copy_assignable<T>) = delete;
+
+    constexpr option& operator=(const option& other) &
+        requires trivially_copy_assignable<T> = default;
+
+    constexpr option& operator=(const option& other) &
+        requires copy_assignable<T> && (!trivially_copy_constructible<T>)
+    {
+        if (&other == this) { return *this; }
+
+        if (other.has_value())
+        {
+            if (has_value())
+            {
+                assign(other.m_payload.as_init_unsafe());
+            }
+            else
+            {
+                construct(other.m_payload.as_init_unsafe());
+            }
+        }
+        else if (has_value())
+        {
+            reset();
+        }
+
+        return *this;
+    }
+
+    constexpr option& operator=(option&& other) &
+        requires (!move_assignable<T>) = delete;
+
+    constexpr option& operator=(option&& other) &
+        requires trivially_move_assignable<T> = default;
+
+    constexpr option& operator=(option&& other) &
+        requires move_assignable<T> && (!trivially_move_constructible<T>)
+    {
+        if (&other == this) { return *this; }
+
+        if (other.has_value())
+        {
+            if (has_value())
+            {
+                assign(ASL_MOVE(other.m_payload.as_init_unsafe()));
+            }
+            else
+            {
+                construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+            }
+        }
+        else if (has_value())
+        {
+            reset();
+        }
+
+        return *this;
+    }
+
+    template<typename U = T>
+    constexpr option& operator=(const option<U>& other) &
+        requires (
+            constructible_from<T, const U&> &&
+            assignable_from<T&, const U&> &&
+            option_internal::not_constructible_assignable_from_option<T, U>
+        )
+    {
+        if (other.has_value())
+        {
+            if (has_value())
+            {
+                assign(other.m_payload.as_init_unsafe());
+            }
+            else
+            {
+                construct(other.m_payload.as_init_unsafe());
+            }
+        }
+        else if (has_value())
+        {
+            reset();
+        }
+
+        return *this;
+    }
+
+    template<typename U = T>
+    constexpr option& operator=(option<U>&& other) &
+        requires (
+            constructible_from<T, U&&> &&
+            assignable_from<T&, U&&> &&
+            option_internal::not_constructible_assignable_from_option<T, U>
+        )
+    {
+        if (other.has_value())
+        {
+            if (has_value())
+            {
+                assign(ASL_MOVE(other.m_payload.as_init_unsafe()));
+            }
+            else
+            {
+                construct(ASL_MOVE(other.m_payload.as_init_unsafe()));
+            }
+        }
+        else if (has_value())
+        {
+            reset();
+        }
+
+        return *this;
+    }
+
+    constexpr ~option() requires trivially_destructible<T> = default;
+    constexpr ~option() requires (!trivially_destructible<T>)
+    {
+        reset();
+    }
+
+    constexpr void reset()
+    {
+        if (!has_value()) { return; }
+
+        if constexpr (kHasNiche)
+        {
+            if constexpr (move_assignable<T>)
+            {
+                m_payload.assign_unsafe(ASL_MOVE(T{niche_t{}}));
+            }
+            else
+            {
+                m_payload.destroy_unsafe();
+                m_payload.construct_unsafe(niche_t{});
+            }
+        }
+        else
+        {
+            m_has_value = false;
+            m_payload.destroy_unsafe();
+        }
+    }
+
+    constexpr bool has_value() const
+    {
+        if constexpr (kHasNiche)
+        {
+            return m_payload.as_init_unsafe() != niche_t{};
+        }
+        else
+        {
+            return m_has_value;
+        }
+    }
+
+    // @Todo(C++23) Deducing this
+    constexpr T&& value() &&
+    {
+        ASL_ASSERT_RELEASE(has_value());
+        return ASL_MOVE(m_payload).as_init_unsafe();
+    }
+
+    constexpr T& value() &
+    {
+        ASL_ASSERT_RELEASE(has_value());
+        return m_payload.as_init_unsafe();
+    }
+
+    constexpr const T& value() const&
+    {
+        ASL_ASSERT_RELEASE(has_value());
+        return m_payload.as_init_unsafe();
+    }
+
+    template<typename U>
+    constexpr T value_or(U&& other_value) const&
+        requires copy_constructible<T> && convertible_from<T, U&&>
+    {
+        return has_value() ? value() : static_cast<T>(ASL_FWD(other_value));
+    }
+
+    template<typename U>
+    constexpr T value_or(U&& other_value) &&
+        requires move_constructible<T> && convertible_from<T, U&&>
+    {
+        return has_value() ? ASL_MOVE(value()) : static_cast<T>(ASL_FWD(other_value));
+    }
+
+    template<typename... Args>
+    constexpr T& emplace(Args&&... args) &
+        requires constructible_from<T, Args&&...>
+    {
+        if (has_value()) { reset(); }
+        construct(ASL_FWD(args)...);
+        return value();
+    }
+
+    template<typename F>
+    constexpr auto and_then(F&& f) &
+        requires is_option<result_of_t<F(T&)>>
+    {
+        if (has_value())
+        {
+            return invoke(ASL_FWD(f), value());
+        }
+        return un_cvref_t<result_of_t<F(T&)>>{};
+    }
+
+    template<typename F>
+    constexpr auto and_then(F&& f) const&
+        requires is_option<result_of_t<F(const T&)>>
+    {
+        if (has_value())
+        {
+            return invoke(ASL_FWD(f), value());
+        }
+        return un_cvref_t<result_of_t<F(const T&)>>{};
+    }
+
+    template<typename F>
+    constexpr auto and_then(F&& f) &&
+        requires is_option<result_of_t<F(T)>>
+    {
+        if (has_value())
+        {
+            return invoke(ASL_FWD(f), ASL_MOVE(value()));
+        }
+        return un_cvref_t<result_of_t<F(T)>>{};
+    }
+
+    template<typename F>
+    constexpr auto transform(F&& f) &
+    {
+        using U = un_cvref_t<result_of_t<F(T&)>>;
+        if (has_value())
+        {
+            return option<U>{ invoke(ASL_FWD(f), value()) };
+        }
+        return option<U>{};
+    }
+
+    template<typename F>
+    constexpr auto transform(F&& f) const&
+    {
+        using U = un_cvref_t<result_of_t<F(const T&)>>;
+        if (has_value())
+        {
+            return option<U>{ invoke(ASL_FWD(f), value()) };
+        }
+        return option<U>{};
+    }
+
+    template<typename F>
+    constexpr auto transform(F&& f) &&
+    {
+        using U = un_cvref_t<result_of_t<F(T)>>;
+        if (has_value())
+        {
+            return option<U>{ invoke(ASL_FWD(f), ASL_MOVE(value())) };
+        }
+        return option<U>{};
+    }
+
+    template<typename F>
+    constexpr option or_else(F&& f) const&
+        requires same_as<un_cvref_t<result_of_t<F()>>, option>
+    {
+        return has_value() ? *this : invoke(ASL_FWD(f));
+    }
+
+    template<typename F>
+    constexpr option or_else(F&& f) &&
+        requires same_as<un_cvref_t<result_of_t<F()>>, option>
+    {
+        return has_value() ? ASL_MOVE(*this) : invoke(ASL_FWD(f));
+    }
+
+    template<typename H>
+    requires (!uniquely_represented<option>) && hashable<T>
+    friend H AslHashValue(H h, const option& opt)
+    {
+        if (!opt.has_value())
+        {
+            return H::combine(ASL_MOVE(h), 0);
+        }
+        return H::combine(ASL_MOVE(h), 1, opt.value());
+    }
+};
+
+template<typename T>
+requires has_niche<T> && uniquely_represented<T>
+struct is_uniquely_represented<option<T>> : true_type {};
+
+template<typename T>
+option(T) -> option<T>;
+
+} // namespace asl
diff --git a/asl/types/option_tests.cpp b/asl/types/option_tests.cpp
new file mode 100644
index 0000000..272b40a
--- /dev/null
+++ b/asl/types/option_tests.cpp
@@ -0,0 +1,330 @@
+#include "asl/types/option.hpp"
+#include "asl/tests/types.hpp"
+#include "asl/testing/testing.hpp"
+
+class Base {};
+class Derived : public Base {};
+
+struct NonZero
+{
+    int value;
+
+    constexpr explicit NonZero(int x) : value(x)
+    {
+        ASL_ASSERT(x != 0);
+    }
+
+    constexpr explicit NonZero(asl::niche_t) : value(0) {}
+
+    constexpr bool operator==(asl::niche_t) const { return value == 0; }
+};
+static_assert(asl::has_niche<NonZero>);
+static_assert(!asl::has_niche<int>);
+
+static_assert(sizeof(asl::option<int>) >= sizeof(int));
+static_assert(sizeof(asl::option<NonZero>) == sizeof(NonZero));
+
+static_assert(!asl::is_option<int>);
+static_assert(asl::is_option<asl::option<int>>);
+static_assert(asl::is_option<const asl::option<int>>);
+
+static_assert(asl::trivially_destructible<asl::option<TrivialType>>);
+static_assert(!asl::trivially_destructible<asl::option<WithDestructor>>);
+
+static_assert(asl::trivially_copy_constructible<asl::option<int>>);
+static_assert(asl::trivially_copy_constructible<asl::option<NonZero>>);
+static_assert(asl::copy_constructible<asl::option<Copyable>>);
+static_assert(!asl::copy_constructible<asl::option<MoveableOnly>>);
+static_assert(!asl::copy_constructible<asl::option<Pinned>>);
+
+static_assert(asl::trivially_move_constructible<asl::option<int>>);
+static_assert(asl::trivially_move_constructible<asl::option<NonZero>>);
+static_assert(asl::move_constructible<asl::option<Copyable>>);
+static_assert(asl::move_constructible<asl::option<MoveableOnly>>);
+static_assert(!asl::move_constructible<asl::option<Pinned>>);
+
+static_assert(asl::trivially_copy_assignable<asl::option<int>>);
+static_assert(asl::trivially_copy_assignable<asl::option<NonZero>>);
+static_assert(asl::copy_assignable<asl::option<Copyable>>);
+static_assert(!asl::copy_assignable<asl::option<MoveableOnly>>);
+static_assert(!asl::copy_assignable<asl::option<Pinned>>);
+
+static_assert(asl::trivially_move_assignable<asl::option<int>>);
+static_assert(asl::trivially_move_assignable<asl::option<NonZero>>);
+static_assert(asl::move_assignable<asl::option<Copyable>>);
+static_assert(asl::move_assignable<asl::option<MoveableOnly>>);
+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_from<asl::option<Derived*>, asl::option<Base*>>);
+
+class ExplicitConversion { public: explicit ExplicitConversion(int) {} };
+class ImplicitConversion { public: ImplicitConversion(int) {} }; // NOLINT
+
+static_assert(!asl::convertible_from<ExplicitConversion, int>);
+static_assert(asl::convertible_from<ImplicitConversion, int>);
+
+static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, int>);
+static_assert(asl::convertible_from<asl::option<ImplicitConversion>, int>);
+
+static_assert(!asl::convertible_from<asl::option<ExplicitConversion>, asl::option<int>>);
+static_assert(asl::convertible_from<asl::option<ImplicitConversion>, asl::option<int>>);
+
+static_assert(asl::trivially_copy_constructible<asl::option<int>>);
+static_assert(asl::trivially_copy_constructible<asl::option<TrivialType>>);
+static_assert(asl::trivially_copy_constructible<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_copy_constructible<asl::option<Copyable>>);
+
+static_assert(asl::trivially_move_constructible<asl::option<int>>);
+static_assert(asl::trivially_move_constructible<asl::option<TrivialType>>);
+static_assert(asl::trivially_move_constructible<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_move_constructible<asl::option<MoveableOnly>>);
+
+static_assert(asl::trivially_copy_assignable<asl::option<int>>);
+static_assert(asl::trivially_copy_assignable<asl::option<TrivialType>>);
+static_assert(asl::trivially_copy_assignable<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_copy_assignable<asl::option<Copyable>>);
+
+static_assert(asl::trivially_move_assignable<asl::option<int>>);
+static_assert(asl::trivially_move_assignable<asl::option<TrivialType>>);
+static_assert(asl::trivially_move_assignable<asl::option<TrivialTypeDefaultValue>>);
+static_assert(!asl::trivially_move_assignable<asl::option<MoveableOnly>>);
+
+ASL_TEST(make_null)
+{
+    asl::option<int> a;
+    asl::option<int> b = asl::nullopt;
+
+    ASL_TEST_EXPECT(!a.has_value());
+    ASL_TEST_EXPECT(!b.has_value());
+}
+
+ASL_TEST(make_value)
+{
+    asl::option<int> a = 48;
+
+    ASL_TEST_EXPECT(a.has_value());
+}
+
+ASL_TEST(reset)
+{
+    asl::option<int> b = 48;
+    ASL_TEST_EXPECT(b.has_value());
+
+    b.reset();
+    ASL_TEST_EXPECT(!b.has_value());
+}
+
+ASL_TEST(call_destructor)
+{
+    bool destroyed = false;
+
+    {
+        DestructorObserver obs(&destroyed);
+
+        asl::option<DestructorObserver> opt(ASL_MOVE(obs));
+        ASL_TEST_EXPECT(!destroyed);
+
+        asl::option<DestructorObserver> opt2 = ASL_MOVE(opt);
+        ASL_TEST_EXPECT(!destroyed);
+    }
+
+    ASL_TEST_EXPECT(destroyed);
+}
+
+ASL_TEST(call_destructor_on_reset)
+{
+    bool destroyed = false;
+
+    asl::option<DestructorObserver> opt(&destroyed);
+    ASL_TEST_EXPECT(!destroyed);
+
+    opt.reset();
+    ASL_TEST_EXPECT(destroyed);
+}
+
+ASL_TEST(value)
+{
+    asl::option<int> a = 1;
+    asl::option<int> b = 2;
+    asl::option<int> c = a;
+
+    ASL_TEST_EXPECT(a.value() == 1);
+    ASL_TEST_EXPECT(b.value() == 2);
+    ASL_TEST_EXPECT(c.value() == 1);
+
+    c = b;
+    ASL_TEST_EXPECT(c.value() == 2);
+}
+
+ASL_TEST(value_move)
+{
+    bool destroyed = false;
+
+    asl::option<DestructorObserver> opt(&destroyed);
+    ASL_TEST_EXPECT(!destroyed);
+
+    {
+        auto x = ASL_MOVE(opt).value();
+        ASL_TEST_EXPECT(!destroyed);
+    }
+
+    ASL_TEST_EXPECT(destroyed);
+}
+
+ASL_TEST(deduction_guide)
+{
+    asl::option opt(45);
+    ASL_TEST_EXPECT(opt.value() == 45);
+}
+
+ASL_TEST(convert_copy)
+{
+    asl::option<uint8_t> opt8 = uint8_t{8};
+    asl::option<uint16_t> opt16 = opt8;
+
+    ASL_TEST_ASSERT(opt16.has_value());
+    ASL_TEST_EXPECT(opt16.value() == 8);
+
+    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 = opt8;
+    ASL_TEST_ASSERT(opt16.has_value());
+    ASL_TEST_EXPECT(opt16.value() == 10);
+}
+
+ASL_TEST(convert_move)
+{
+    asl::option<uint8_t> opt8 = uint8_t{8};
+    asl::option<uint16_t> opt16 = ASL_MOVE(opt8);
+
+    ASL_TEST_ASSERT(opt16.has_value());
+    ASL_TEST_EXPECT(opt16.value() == 8);
+
+    opt8 = ASL_MOVE(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);
+    ASL_TEST_ASSERT(opt16.has_value());
+    ASL_TEST_EXPECT(opt16.value() == 10);
+}
+
+ASL_TEST(value_or)
+{
+    asl::option<int> a = asl::nullopt;
+    asl::option<int> b = 2;
+
+    ASL_TEST_EXPECT(a.value_or(5) == 5);
+    ASL_TEST_EXPECT(b.value_or(5) == 2);
+}
+
+ASL_TEST(emplace)
+{
+    asl::option<int> a = asl::nullopt;
+
+    a.emplace(42);
+    ASL_TEST_ASSERT(a.has_value());
+    ASL_TEST_EXPECT(a.value() == 42);
+}
+
+ASL_TEST(emplace_destroys_previous)
+{
+    bool b1 = false;
+    bool b2 = false;
+
+    {
+        asl::option<DestructorObserver> a{&b1};
+        ASL_TEST_EXPECT(!b1);
+
+        a.emplace(&b2);
+        ASL_TEST_EXPECT(b1);
+        ASL_TEST_EXPECT(!b2);
+    }
+
+    ASL_TEST_EXPECT(b2);
+}
+
+ASL_TEST(and_then)
+{
+    asl::option<int> a = 5;
+    asl::option<int> b;
+
+    auto fn = [](int x) -> asl::option<float> { return static_cast<float>(x) + 0.5F; };
+
+    auto a2 = a.and_then(fn);
+    static_assert(asl::same_as<decltype(a2), asl::option<float>>);
+    ASL_TEST_ASSERT(a2.has_value());
+    ASL_TEST_EXPECT(a2.value() == 5.5F);
+
+    auto b2 = b.and_then(fn);
+    static_assert(asl::same_as<decltype(b2), asl::option<float>>);
+    ASL_TEST_ASSERT(!b2.has_value());
+}
+
+ASL_TEST(transform)
+{
+    asl::option<int> a = 5;
+    asl::option<int> b;
+
+    auto fn = [](int x) -> float { return static_cast<float>(x) + 0.5F; };
+
+    auto a2 = a.transform(fn);
+    static_assert(asl::same_as<decltype(a2), asl::option<float>>);
+    ASL_TEST_ASSERT(a2.has_value());
+    ASL_TEST_EXPECT(a2.value() == 5.5F);
+
+    auto b2 = b.transform(fn);
+    static_assert(asl::same_as<decltype(b2), asl::option<float>>);
+    ASL_TEST_ASSERT(!b2.has_value());
+}
+
+ASL_TEST(or_else)
+{
+    asl::option<int> a = 5;
+    asl::option<int> b;
+
+    auto fn = []() -> asl::option<int> { return 12; };
+
+    auto a2 = a.or_else(fn);
+    static_assert(asl::same_as<decltype(a2), asl::option<int>>);
+    ASL_TEST_ASSERT(a2.has_value());
+    ASL_TEST_EXPECT(a2.value() == 5);
+
+    auto b2 = b.or_else(fn);
+    static_assert(asl::same_as<decltype(b2), asl::option<int>>);
+    ASL_TEST_ASSERT(b2.has_value());
+    ASL_TEST_EXPECT(b2.value() == 12);
+}
+
+ASL_TEST(niche)
+{
+    asl::option<NonZero> opt;
+    ASL_TEST_EXPECT(!opt.has_value());
+
+    asl::option<NonZero> opt2(2);
+    ASL_TEST_EXPECT(opt2.has_value());
+    ASL_TEST_EXPECT(opt2.value().value == 2);
+
+    opt = opt2;
+    ASL_TEST_EXPECT(opt2.has_value());
+    ASL_TEST_EXPECT(opt2.value().value == 2);
+
+    opt.reset();
+    ASL_TEST_EXPECT(!opt.has_value());
+
+    opt = NonZero(87);
+    ASL_TEST_EXPECT(opt.has_value());
+    ASL_TEST_EXPECT(opt.value().value == 87);
+}
diff --git a/asl/types/span.hpp b/asl/types/span.hpp
new file mode 100644
index 0000000..b258708
--- /dev/null
+++ b/asl/types/span.hpp
@@ -0,0 +1,235 @@
+#pragma once
+
+#include "asl/base/meta.hpp"
+#include "asl/base/assert.hpp"
+#include "asl/base/annotations.hpp"
+#include "asl/memory/layout.hpp"
+
+namespace asl
+{
+
+static constexpr isize_t dynamic_size = -1;
+
+template<typename T>
+class contiguous_iterator
+{
+    T* m_ptr;
+
+public:
+    constexpr explicit contiguous_iterator(T* ptr) : m_ptr{ptr} {}
+
+    constexpr bool operator==(const contiguous_iterator& other) const
+    {
+        return other.m_ptr == m_ptr;
+    }
+
+    constexpr contiguous_iterator& operator++()
+    {
+        m_ptr += 1;
+        return *this;
+    }
+
+    constexpr contiguous_iterator operator++(int)
+    {
+        return contiguous_iterator{ exchange(m_ptr, m_ptr + 1) };
+    }
+
+    constexpr T& operator*() const { return *m_ptr; }
+
+    constexpr T* operator->() const { return m_ptr; }
+};
+
+template<typename T>
+contiguous_iterator(T) -> contiguous_iterator<T>;
+
+template<is_object T, isize_t kSize = dynamic_size>
+class span
+{
+    static constexpr bool is_dynamic(isize_t size)
+    {
+        return size < 0;
+    }
+
+    static constexpr bool kIsDynamic = is_dynamic(kSize);
+
+    using SizeType = select_t<kIsDynamic, isize_t, empty>;
+
+    T* m_data{};
+    ASL_NO_UNIQUE_ADDRESS SizeType m_size{};
+
+public:
+    constexpr span() requires (kIsDynamic || kSize == 0) = default;
+
+    constexpr span(T* data, isize_t size)
+        requires kIsDynamic
+        : m_data{data}
+        , m_size{size}
+    {}
+
+    constexpr explicit span(T* data, isize_t size)
+        requires (!kIsDynamic)
+        : m_data{data}
+    {
+        ASL_ASSERT(size == kSize);
+    }
+
+    template<isize_t N>
+    constexpr span(T (&array)[N]) // NOLINT(*-explicit-conversions)
+        requires (kIsDynamic)
+        : m_data{array}
+        , m_size{N}
+    {}
+
+    template<isize_t N>
+    constexpr span(T (&array)[N]) // NOLINT(*-explicit-conversions)
+        requires (!kIsDynamic) && (N == kSize)
+        : m_data{array}
+    {}
+
+    template<is_object U, isize_t kOtherSize>
+    constexpr explicit(!kIsDynamic)
+    span(const span<U, kOtherSize>& other) // NOLINT(*-explicit-conversions)
+        requires (
+            (
+                kIsDynamic ||
+                is_dynamic(kOtherSize) ||
+                kOtherSize == kSize
+            ) && convertible_from<T(&)[], U(&)[]>
+        )
+        : span{static_cast<U*>(other.data()), other.size()}
+    {
+    }
+
+    constexpr span(const span&) = default;
+    constexpr span(span&&) = default;
+
+    constexpr span& operator=(const span&) = default;
+    constexpr span& operator=(span&&) = default;
+
+    ~span() = default;
+
+    constexpr isize_t size() const
+    {
+        if constexpr (kIsDynamic) { return m_size; }
+        else { return kSize; }
+    }
+
+    constexpr isize_t size_bytes() const { return size() * size_of<T>; }
+
+    constexpr bool is_empty() const { return size() == 0; }
+
+    constexpr T* data() const { return m_data; }
+
+    constexpr contiguous_iterator<T> begin() const
+    {
+        return contiguous_iterator{m_data};
+    }
+
+    constexpr contiguous_iterator<T> end() const
+    {
+        return contiguous_iterator{m_data + size()};
+    }
+
+    constexpr T& operator[](isize_t i) const
+    {
+        ASL_ASSERT(i >= 0 && i < size());
+        return m_data[i]; // NOLINT(*-pointer-arithmetic)
+    }
+
+    template<isize_t kOffset, isize_t kSubSize = dynamic_size>
+    constexpr auto subspan() const
+        requires (
+            kOffset >= 0 &&
+            (kIsDynamic || kOffset <= kSize) &&
+            (kIsDynamic || is_dynamic(kSubSize) || kSubSize <= kSize - kOffset)
+        )
+    {
+        ASL_ASSERT(kOffset <= size());
+
+        if constexpr (is_dynamic(kSubSize))
+        {
+            if constexpr (kIsDynamic)
+            {
+                return span<T>(data() + kOffset, size() - kOffset);
+            }
+            else
+            {
+                return span<T, kSize - kOffset>(data() + kOffset, size() - kOffset);
+            }
+        }
+        else
+        {
+            ASL_ASSERT(kSubSize <= size() - kOffset);
+            return span<T, kSubSize>(data() + kOffset, kSubSize);
+        }
+    }
+
+    constexpr span<T> subspan(isize_t offset) const
+    {
+        ASL_ASSERT(offset <= size());
+        return span<T>{ data() + offset, size() - offset };
+    }
+
+    constexpr span<T> subspan(isize_t offset, isize_t sub_size) const
+    {
+        ASL_ASSERT(offset <= size() && !is_dynamic(sub_size));
+        ASL_ASSERT(sub_size <= size() - offset);
+        return span<T>{ data() + offset, sub_size };
+    }
+
+    template<isize_t kSubSize>
+    constexpr auto first() const
+        requires (
+            kSubSize >= 0 &&
+            (kIsDynamic || kSubSize <= kSize)
+        )
+    {
+        ASL_ASSERT(kSubSize <= size());
+        return span<T, kSubSize>{ data(), kSubSize };
+    }
+
+    constexpr span<T> first(isize_t sub_size) const
+    {
+        ASL_ASSERT(sub_size >= 0 && sub_size <= size());
+        return span<T>{ data(), sub_size };
+    }
+
+    template<isize_t kSubSize>
+    constexpr auto last() const
+        requires (
+            kSubSize >= 0 &&
+            (kIsDynamic || kSubSize <= kSize)
+        )
+    {
+        ASL_ASSERT(kSubSize <= size());
+        return span<T, kSubSize>{ data() + size() - kSubSize, kSubSize };
+    }
+
+    constexpr span<T> last(isize_t sub_size) const
+    {
+        ASL_ASSERT(sub_size >= 0 && sub_size <= size());
+        return span<T>{ data() + size() - sub_size, sub_size };
+    }
+};
+
+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()),
+        s.size_bytes());
+}
+
+template<is_object T, isize_t kSize>
+inline span<byte> as_mutable_bytes(span<T, kSize> s)
+    requires (!is_const<T>)
+{
+    return span<byte>(
+        reinterpret_cast<byte*>(s.data()),
+        s.size_bytes());
+}
+
+template<is_object T, isize_t kSize>
+span(T (&)[kSize]) -> span<T, kSize>;
+
+} // namespace asl
diff --git a/asl/types/span_tests.cpp b/asl/types/span_tests.cpp
new file mode 100644
index 0000000..43be2fc
--- /dev/null
+++ b/asl/types/span_tests.cpp
@@ -0,0 +1,444 @@
+#include "asl/types/span.hpp"
+#include "asl/testing/testing.hpp"
+#include "asl/tests/types.hpp"
+
+static_assert(asl::trivially_destructible<asl::span<int>>);
+static_assert(asl::trivially_destructible<asl::span<WithDestructor>>);
+
+static_assert(asl::trivially_copy_constructible<asl::span<int>>);
+static_assert(asl::trivially_copy_constructible<asl::span<Pinned>>);
+
+static_assert(asl::size_of<asl::span<int>> == asl::size_of<void*> * 2);
+static_assert(asl::size_of<asl::span<int, 2>> == asl::size_of<void*>);
+
+ASL_TEST(empty_dynamic)
+{
+    asl::span<int> s;
+    ASL_TEST_EXPECT(s.size() == 0);
+    ASL_TEST_EXPECT(s.size_bytes() == 0);
+    ASL_TEST_EXPECT(s.is_empty());
+}
+
+
+ASL_TEST(empty_static)
+{
+    asl::span<int, 0> s;
+    ASL_TEST_EXPECT(s.size() == 0);
+    ASL_TEST_EXPECT(s.size_bytes() == 0);
+    ASL_TEST_EXPECT(s.is_empty());
+}
+
+ASL_TEST(from_array_dynamic)
+{
+    int array[] = {1, 2, 3};
+    asl::span<int> span = array;
+    ASL_TEST_ASSERT(span.size() == 3);
+    ASL_TEST_EXPECT(span[0] == 1);
+    ASL_TEST_EXPECT(span[1] == 2);
+    ASL_TEST_EXPECT(span[2] == 3);
+}
+
+static_assert(asl::default_constructible<asl::span<int>>);
+static_assert(asl::default_constructible<asl::span<int, 0>>);
+static_assert(!asl::default_constructible<asl::span<int, 8>>);
+
+static_assert(asl::constructible_from<asl::span<int32_t>, int32_t(&)[8]>);
+static_assert(!asl::constructible_from<asl::span<int32_t>, const int32_t(&)[8]>);
+static_assert(asl::constructible_from<asl::span<const int32_t>, int32_t(&)[8]>);
+static_assert(asl::constructible_from<asl::span<const int32_t>, const int32_t(&)[8]>);
+static_assert(asl::constructible_from<asl::span<int32_t, 8>, int32_t(&)[8]>);
+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;
+    ASL_TEST_ASSERT(span.size() == 3);
+    ASL_TEST_EXPECT(span[0] == 1);
+    ASL_TEST_EXPECT(span[1] == 2);
+    ASL_TEST_EXPECT(span[2] == 3);
+}
+
+static_assert(asl::constructible_from<asl::span<const int32_t>, asl::span<int32_t>>);
+static_assert(!asl::constructible_from<asl::span<int32_t>, asl::span<const int32_t>>);
+static_assert(!asl::constructible_from<asl::span<int32_t>, asl::span<int16_t>>);
+static_assert(!asl::constructible_from<asl::span<int32_t>, asl::span<uint32_t>>);
+static_assert(asl::constructible_from<asl::span<int32_t>, asl::span<int32_t, 6>>);
+static_assert(asl::constructible_from<asl::span<int32_t, 6>, asl::span<int32_t>>);
+static_assert(asl::constructible_from<asl::span<int32_t>, asl::span<int32_t, 6>>);
+static_assert(asl::constructible_from<asl::span<int32_t, 6>, asl::span<int32_t, 6>>);
+static_assert(!asl::constructible_from<asl::span<int32_t, 6>, asl::span<int32_t, 7>>);
+
+ASL_TEST(conversion)
+{
+    int array[] = {1, 2, 3};
+
+    asl::span<int> span1 = array;
+
+    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;
+    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};
+    ASL_TEST_ASSERT(span4.size() == 3);
+    ASL_TEST_EXPECT(span4[0] == 1);
+    ASL_TEST_EXPECT(span4[1] == 2);
+    ASL_TEST_EXPECT(span4[2] == 3);
+}
+
+template<typename Span, isize_t kOffset, isize_t kSize = asl::dynamic_size>
+concept IsValidSubspan = requires (Span s) { s.template subspan<kOffset, kSize>(); };
+
+static_assert(asl::same_as<asl::span<int, 4>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<0>())>);
+
+static_assert(asl::same_as<asl::span<int, 3>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<1>())>);
+
+static_assert(asl::same_as<asl::span<int, 2>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<2>())>);
+
+static_assert(asl::same_as<asl::span<int, 1>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<3>())>);
+
+static_assert(asl::same_as<asl::span<int, 0>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<4>())>);
+
+static_assert(!IsValidSubspan<asl::span<int, 4>, 5>);
+
+static_assert(asl::same_as<asl::span<int>,
+     decltype(asl::declval<asl::span<int>>().subspan<0>())>);
+
+static_assert(asl::same_as<asl::span<int, 4>,
+     decltype(asl::declval<asl::span<int>>().subspan<0, 4>())>);
+
+static_assert(asl::same_as<asl::span<int, 4>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<0, 4>())>);
+
+static_assert(asl::same_as<asl::span<int, 2>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<1, 2>())>);
+
+static_assert(asl::same_as<asl::span<int, 2>,
+     decltype(asl::declval<asl::span<int, 4>>().subspan<2, 2>())>);
+
+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};
+
+    auto s1 = span.subspan<0>();
+    ASL_TEST_ASSERT(s1.size() == 4);
+    ASL_TEST_EXPECT(s1[0] == 1);
+    ASL_TEST_EXPECT(s1[1] == 2);
+    ASL_TEST_EXPECT(s1[2] == 3);
+    ASL_TEST_EXPECT(s1[3] == 4);
+
+    auto s2 = span.subspan<2>();
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 3);
+    ASL_TEST_EXPECT(s2[1] == 4);
+
+    auto s3 = span.subspan<4>();
+    ASL_TEST_ASSERT(s3.size() == 0);
+
+    auto s4 = span.subspan<1, 2>();
+    ASL_TEST_ASSERT(s4.size() == 2);
+    ASL_TEST_EXPECT(s4[0] == 2);
+    ASL_TEST_EXPECT(s4[1] == 3);
+}
+
+ASL_TEST(subspan_static_from_dynamic)
+{
+    int array[] = {1, 2, 3, 4};
+    asl::span<int> span{array};
+
+    auto s1 = span.subspan<0>();
+    ASL_TEST_ASSERT(s1.size() == 4);
+    ASL_TEST_EXPECT(s1[0] == 1);
+    ASL_TEST_EXPECT(s1[1] == 2);
+    ASL_TEST_EXPECT(s1[2] == 3);
+    ASL_TEST_EXPECT(s1[3] == 4);
+
+    auto s2 = span.subspan<2>();
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 3);
+    ASL_TEST_EXPECT(s2[1] == 4);
+
+    auto s3 = span.subspan<4>();
+    ASL_TEST_ASSERT(s3.size() == 0);
+
+    auto s4 = span.subspan<1, 2>();
+    ASL_TEST_ASSERT(s4.size() == 2);
+    ASL_TEST_EXPECT(s4[0] == 2);
+    ASL_TEST_EXPECT(s4[1] == 3);
+}
+
+ASL_TEST(subspan_dynamic)
+{
+    int array[] = {1, 2, 3, 4};
+    asl::span<int> span{array};
+
+    auto s1 = span.subspan(0);
+    ASL_TEST_ASSERT(s1.size() == 4);
+    ASL_TEST_EXPECT(s1[0] == 1);
+    ASL_TEST_EXPECT(s1[1] == 2);
+    ASL_TEST_EXPECT(s1[2] == 3);
+    ASL_TEST_EXPECT(s1[3] == 4);
+
+    auto s2 = span.subspan(2);
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 3);
+    ASL_TEST_EXPECT(s2[1] == 4);
+
+    auto s3 = span.subspan(4);
+    ASL_TEST_ASSERT(s3.size() == 0);
+
+    auto s4 = span.subspan(1, 2);
+    ASL_TEST_ASSERT(s4.size() == 2);
+    ASL_TEST_EXPECT(s4[0] == 2);
+    ASL_TEST_EXPECT(s4[1] == 3);
+}
+
+template<typename Span, isize_t kSize>
+concept IsValidFirst = requires (Span s) { s.template first<kSize>(); };
+
+static_assert(asl::same_as<asl::span<int, 0>,
+     decltype(asl::declval<asl::span<int>>().first<0>())>);
+
+static_assert(asl::same_as<asl::span<int, 1>,
+     decltype(asl::declval<asl::span<int>>().first<1>())>);
+
+static_assert(asl::same_as<asl::span<int, 2>,
+     decltype(asl::declval<asl::span<int>>().first<2>())>);
+
+static_assert(asl::same_as<asl::span<int, 3>,
+     decltype(asl::declval<asl::span<int>>().first<3>())>);
+
+static_assert(asl::same_as<asl::span<int, 0>,
+     decltype(asl::declval<asl::span<int, 4>>().first<0>())>);
+
+static_assert(asl::same_as<asl::span<int, 1>,
+     decltype(asl::declval<asl::span<int, 4>>().first<1>())>);
+
+static_assert(asl::same_as<asl::span<int, 2>,
+     decltype(asl::declval<asl::span<int, 4>>().first<2>())>);
+
+static_assert(asl::same_as<asl::span<int, 3>,
+     decltype(asl::declval<asl::span<int, 4>>().first<3>())>);
+
+static_assert(asl::same_as<asl::span<int, 4>,
+     decltype(asl::declval<asl::span<int, 4>>().first<4>())>);
+
+static_assert(!IsValidFirst<asl::span<int, 4>, 5>);
+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};
+
+    auto s1 = span.first<0>();
+    ASL_TEST_ASSERT(s1.size() == 0);
+
+    auto s2 = span.first<2>();
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 1);
+    ASL_TEST_EXPECT(s2[1] == 2);
+
+    auto s3 = span.first<4>();
+    ASL_TEST_ASSERT(s3.size() == 4);
+    ASL_TEST_EXPECT(s3[0] == 1);
+    ASL_TEST_EXPECT(s3[1] == 2);
+    ASL_TEST_EXPECT(s3[2] == 3);
+    ASL_TEST_EXPECT(s3[3] == 4);
+}
+
+ASL_TEST(first_static_from_dynamic)
+{
+    int array[] = {1, 2, 3, 4};
+    asl::span<int> span{array};
+
+    auto s1 = span.first<0>();
+    ASL_TEST_ASSERT(s1.size() == 0);
+
+    auto s2 = span.first<2>();
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 1);
+    ASL_TEST_EXPECT(s2[1] == 2);
+
+    auto s3 = span.first<4>();
+    ASL_TEST_ASSERT(s3.size() == 4);
+    ASL_TEST_EXPECT(s3[0] == 1);
+    ASL_TEST_EXPECT(s3[1] == 2);
+    ASL_TEST_EXPECT(s3[2] == 3);
+    ASL_TEST_EXPECT(s3[3] == 4);
+}
+
+ASL_TEST(first_dynamic)
+{
+    int array[] = {1, 2, 3, 4};
+    asl::span<int> span{array};
+
+    auto s1 = span.first(0);
+    ASL_TEST_ASSERT(s1.size() == 0);
+
+    auto s2 = span.first(2);
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 1);
+    ASL_TEST_EXPECT(s2[1] == 2);
+
+    auto s3 = span.first(4);
+    ASL_TEST_ASSERT(s3.size() == 4);
+    ASL_TEST_EXPECT(s3[0] == 1);
+    ASL_TEST_EXPECT(s3[1] == 2);
+    ASL_TEST_EXPECT(s3[2] == 3);
+    ASL_TEST_EXPECT(s3[3] == 4);
+}
+
+template<typename Span, isize_t kSize>
+concept IsValidLast = requires (Span s) { s.template last<kSize>(); };
+
+static_assert(asl::same_as<asl::span<int, 0>,
+     decltype(asl::declval<asl::span<int>>().last<0>())>);
+
+static_assert(asl::same_as<asl::span<int, 1>,
+     decltype(asl::declval<asl::span<int>>().last<1>())>);
+
+static_assert(asl::same_as<asl::span<int, 2>,
+     decltype(asl::declval<asl::span<int>>().last<2>())>);
+
+static_assert(asl::same_as<asl::span<int, 3>,
+     decltype(asl::declval<asl::span<int>>().last<3>())>);
+
+static_assert(asl::same_as<asl::span<int, 0>,
+     decltype(asl::declval<asl::span<int, 4>>().last<0>())>);
+
+static_assert(asl::same_as<asl::span<int, 1>,
+     decltype(asl::declval<asl::span<int, 4>>().last<1>())>);
+
+static_assert(asl::same_as<asl::span<int, 2>,
+     decltype(asl::declval<asl::span<int, 4>>().last<2>())>);
+
+static_assert(asl::same_as<asl::span<int, 3>,
+     decltype(asl::declval<asl::span<int, 4>>().last<3>())>);
+
+static_assert(asl::same_as<asl::span<int, 4>,
+     decltype(asl::declval<asl::span<int, 4>>().last<4>())>);
+
+static_assert(!IsValidLast<asl::span<int, 4>, 5>);
+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};
+
+    auto s1 = span.last<0>();
+    ASL_TEST_ASSERT(s1.size() == 0);
+
+    auto s2 = span.last<2>();
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 3);
+    ASL_TEST_EXPECT(s2[1] == 4);
+
+    auto s3 = span.last<4>();
+    ASL_TEST_ASSERT(s3.size() == 4);
+    ASL_TEST_EXPECT(s3[0] == 1);
+    ASL_TEST_EXPECT(s3[1] == 2);
+    ASL_TEST_EXPECT(s3[2] == 3);
+    ASL_TEST_EXPECT(s3[3] == 4);
+}
+
+ASL_TEST(last_static_from_dynamic)
+{
+    int array[] = {1, 2, 3, 4};
+    asl::span<int> span{array};
+
+    auto s1 = span.last<0>();
+    ASL_TEST_ASSERT(s1.size() == 0);
+
+    auto s2 = span.last<2>();
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 3);
+    ASL_TEST_EXPECT(s2[1] == 4);
+
+    auto s3 = span.last<4>();
+    ASL_TEST_ASSERT(s3.size() == 4);
+    ASL_TEST_EXPECT(s3[0] == 1);
+    ASL_TEST_EXPECT(s3[1] == 2);
+    ASL_TEST_EXPECT(s3[2] == 3);
+    ASL_TEST_EXPECT(s3[3] == 4);
+}
+
+ASL_TEST(last_dynamic)
+{
+    int array[] = {1, 2, 3, 4};
+    asl::span<int> span{array};
+
+    auto s1 = span.last(0);
+    ASL_TEST_ASSERT(s1.size() == 0);
+
+    auto s2 = span.last(2);
+    ASL_TEST_ASSERT(s2.size() == 2);
+    ASL_TEST_EXPECT(s2[0] == 3);
+    ASL_TEST_EXPECT(s2[1] == 4);
+
+    auto s3 = span.last(4);
+    ASL_TEST_ASSERT(s3.size() == 4);
+    ASL_TEST_EXPECT(s3[0] == 1);
+    ASL_TEST_EXPECT(s3[1] == 2);
+    ASL_TEST_EXPECT(s3[2] == 3);
+    ASL_TEST_EXPECT(s3[3] == 4);
+}
+
+template<typename T>
+concept HasAsMutableBytes = requires(asl::span<T> s) { asl::as_mutable_bytes(s); };
+
+static_assert(HasAsMutableBytes<int>);
+static_assert(!HasAsMutableBytes<const int>);
+static_assert(!HasAsMutableBytes<int* const>);
+static_assert(HasAsMutableBytes<const int*>);
+
+ASL_TEST(as_bytes)
+{
+     uint32_t data[] = {0x01020304, 0x05060708};
+     asl::span s1(data);
+     asl::span s2 = asl::as_bytes(s1);
+
+     ASL_TEST_ASSERT(s2.size() == 8);
+     ASL_TEST_ASSERT(static_cast<int>(s2[0]) == 0x04);
+     ASL_TEST_ASSERT(static_cast<int>(s2[1]) == 0x03);
+     ASL_TEST_ASSERT(static_cast<int>(s2[2]) == 0x02);
+     ASL_TEST_ASSERT(static_cast<int>(s2[3]) == 0x01);
+     ASL_TEST_ASSERT(static_cast<int>(s2[4]) == 0x08);
+     ASL_TEST_ASSERT(static_cast<int>(s2[5]) == 0x07);
+     ASL_TEST_ASSERT(static_cast<int>(s2[6]) == 0x06);
+     ASL_TEST_ASSERT(static_cast<int>(s2[7]) == 0x05);
+}
+
+ASL_TEST(as_mutable_bytes)
+{
+     uint32_t data[] = {0x01020304, 0x05060708};
+     asl::span s1(data);
+     asl::span s2 = asl::as_mutable_bytes(s1);
+
+     ASL_TEST_ASSERT(s2.size() == 8);
+     ASL_TEST_ASSERT(static_cast<int>(s2[0]) == 0x04);
+     ASL_TEST_ASSERT(static_cast<int>(s2[1]) == 0x03);
+     ASL_TEST_ASSERT(static_cast<int>(s2[2]) == 0x02);
+     ASL_TEST_ASSERT(static_cast<int>(s2[3]) == 0x01);
+     ASL_TEST_ASSERT(static_cast<int>(s2[4]) == 0x08);
+     ASL_TEST_ASSERT(static_cast<int>(s2[5]) == 0x07);
+     ASL_TEST_ASSERT(static_cast<int>(s2[6]) == 0x06);
+     ASL_TEST_ASSERT(static_cast<int>(s2[7]) == 0x05);
+}
diff --git a/asl/types/status.cpp b/asl/types/status.cpp
new file mode 100644
index 0000000..a16b1a2
--- /dev/null
+++ b/asl/types/status.cpp
@@ -0,0 +1,96 @@
+#include "asl/types/status.hpp"
+#include "asl/memory/allocator.hpp"
+#include "asl/strings/string.hpp"
+#include "asl/synchronization/atomic.hpp"
+#include "asl/formatting/format.hpp"
+#include "asl/strings/string_builder.hpp"
+
+// @Todo Use custom allocator
+using Allocator = asl::DefaultAllocator;
+static Allocator g_allocator{};
+
+namespace
+{
+
+struct StatusInternal
+{
+    asl::string<Allocator> msg;
+    asl::status_code code;
+    asl::atomic<int32_t> ref_count;
+
+    constexpr StatusInternal(asl::string<Allocator>&& msg_, asl::status_code code_)
+        : msg{ASL_MOVE(msg_)}
+        , code{code_}
+    {
+        ASL_ASSERT(code != asl::status_code::ok);
+        atomic_store(&ref_count, 1);
+    }
+};
+
+} // anonymous namespace
+
+asl::status::status(status_code code, string_view msg)
+    : m_payload{alloc_new<StatusInternal>(g_allocator, msg, code)}
+{}
+
+asl::status::status(status_code code, string_view fmt, span<format_internals::type_erased_arg> args)
+{
+    StringWriter<Allocator> sink{g_allocator};
+    format_internals::format(&sink, fmt, args);
+    m_payload = alloc_new<StatusInternal>(g_allocator, ASL_MOVE(sink).finish(), code);
+}
+
+asl::status_code asl::status::code_internal() const
+{
+    ASL_ASSERT(!is_inline());
+    return reinterpret_cast<const StatusInternal*>(m_payload)->code;
+}
+
+asl::string_view asl::status::message_internal() const
+{
+    ASL_ASSERT(!is_inline());
+    return reinterpret_cast<const StatusInternal*>(m_payload)->msg;
+}
+
+void asl::status::ref()
+{
+    ASL_ASSERT(!is_inline());
+    auto* internal = reinterpret_cast<StatusInternal*>(m_payload);
+    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(&internal->ref_count, memory_order::release) == 1)
+    {
+        atomic_fence(memory_order::acquire);
+        alloc_delete(g_allocator, internal);
+    }
+}
+
+void asl::AslFormat(asl::Formatter& f, const asl::status& s)
+{
+    string_view status_str{};
+
+    switch (s.code())
+    {
+        case status_code::ok: status_str = "ok"_sv; break;
+        case status_code::unknown: status_str = "unknown"_sv; break;
+        case status_code::internal: status_str = "internal"_sv; break;
+        case status_code::runtime: status_str = "runtime"_sv; break;
+        case status_code::invalid_argument: status_str = "invalid_argument"_sv; break;
+        default: status_str = "<unknown>"_sv; break;
+    }
+
+    if (s.is_inline())
+    {
+        format(f.writer(), "[{}]", status_str);
+    }
+    else
+    {
+        format(f.writer(), "[{}: {}]", status_str, s.message_internal());
+    }
+}
+
diff --git a/asl/types/status.hpp b/asl/types/status.hpp
new file mode 100644
index 0000000..738feb1
--- /dev/null
+++ b/asl/types/status.hpp
@@ -0,0 +1,157 @@
+#pragma once
+
+#include "asl/base/integers.hpp"
+#include "asl/strings/string_view.hpp"
+#include "asl/formatting/format.hpp"
+
+namespace asl
+{
+
+class Formatter;
+
+enum class status_code : uint8_t
+{
+    ok               = 0,
+    unknown          = 1,
+    internal         = 2,
+    runtime          = 3,
+    invalid_argument = 4,
+};
+
+class status
+{
+    void* m_payload{};
+
+    static constexpr void* status_to_payload(status_code code)
+    {
+        return code == status_code::ok
+            ? nullptr
+            : bit_cast<void*>((static_cast<uintptr_t>(code) << 1) | 1);
+    }
+
+    static constexpr status_code payload_to_status(void* payload)
+    {
+        return static_cast<status_code>(bit_cast<uintptr_t>(payload) >> 1);
+    }
+
+    constexpr bool is_inline() const
+    {
+        return m_payload == nullptr || (bit_cast<uintptr_t>(m_payload) & 1) != 0;
+    }
+
+    constexpr status_code code_inline() const
+    {
+        ASL_ASSERT(is_inline());
+        if (m_payload == nullptr)
+        {
+            return status_code::ok;
+        }
+        return payload_to_status(m_payload);
+    }
+
+    status_code code_internal() const;
+    string_view message_internal() const;
+
+    void ref();
+    void unref();
+
+public:
+    constexpr ~status()
+    {
+        if (!is_inline()) { unref(); }
+    }
+
+    explicit constexpr status(status_code code)
+        : m_payload{status_to_payload(code)}
+    {}
+
+    status(status_code code, string_view msg);
+    status(status_code code, string_view fmt, span<format_internals::type_erased_arg> args);
+
+    constexpr status(const status& other)
+        : m_payload{other.m_payload}
+    {
+        if (!is_inline()) { ref(); }
+    }
+
+    constexpr status(status&& other)
+        : m_payload{exchange(other.m_payload, status_to_payload(other.code()))}
+    {}
+
+    constexpr status& operator=(const status& other)
+    {
+        if (&other != this)
+        {
+            if (!is_inline()) { unref(); }
+            m_payload = other.m_payload;
+            if (!is_inline()) { ref(); }
+        }
+        return *this;
+    }
+
+    constexpr status& operator=(status&& other)
+    {
+        if (&other != this)
+        {
+            if (!is_inline()) { unref(); }
+            m_payload = exchange(other.m_payload, status_to_payload(other.code()));
+        }
+        return *this;
+    }
+
+    constexpr bool ok() const
+    {
+        return m_payload == nullptr;
+    }
+
+    constexpr status_code code() const
+    {
+        return is_inline() ? code_inline() : code_internal();
+    }
+
+    constexpr string_view message() const
+    {
+        if (!is_inline())
+        {
+            return message_internal();
+        }
+        return {};
+    }
+
+    constexpr status&& throw_status() && { return ASL_MOVE(*this); }
+
+    friend void AslFormat(Formatter& f, const status&);
+
+    template<typename H>
+    friend H AslHashValue(H h, const status& s)
+    {
+        if (s.is_inline())
+        {
+            return H::combine(ASL_MOVE(h), s.code());
+        }
+        return H::combine(ASL_MOVE(h), s.code(), s.message());
+    }
+};
+
+static constexpr status ok() { return status{status_code::ok}; }
+
+#define ASL_DEFINE_ERROR_(type) \
+    static constexpr status type##_error() { return status{status_code::type}; }                \
+    static inline status type##_error(string_view sv) { return status{status_code::type, sv}; } \
+    template<formattable... Args>