diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..137266e
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,4 @@
+root = true
+
+[*.{cpp,h,hpp,ixx,ipp}]
+charset = utf-8
diff --git a/include/iris/container_traits.hpp b/include/iris/container_traits.hpp
new file mode 100644
index 0000000..eaa095f
--- /dev/null
+++ b/include/iris/container_traits.hpp
@@ -0,0 +1,671 @@
+#ifndef IRIS_ZZ_CONTAINER_TRAITS_HPP
+#define IRIS_ZZ_CONTAINER_TRAITS_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/iterator.hpp> // IWYU pragma: keep
+#include <iris/ranges.hpp> // IWYU pragma: keep
+
+#include <iterator>
+#include <ranges>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+namespace iris::container {
+
+template<class C>
+concept mapping_container =
+    ranges::mapping_range<C> &&
+    std::default_initializable<std::remove_cvref_t<C>> &&
+    requires(
+        std::remove_cvref_t<C>& c,
+        typename std::remove_cvref_t<C>::key_type k,
+        typename std::remove_cvref_t<C>::mapped_type v
+    ) {
+        c.emplace(std::move(k), std::move(v));
+    };
+
+template<class C>
+concept unique_mapping_container =
+    mapping_container<C> &&
+    requires(
+        std::remove_cvref_t<C>& c,
+        typename std::remove_cvref_t<C>::key_type k,
+        typename std::remove_cvref_t<C>::mapped_type v
+    ) {
+        { c.try_emplace(std::move(k), std::move(v)).second } -> std::convertible_to<bool>;
+        { c.insert_or_assign(std::move(k), std::move(v)).second } -> std::convertible_to<bool>;
+    };
+
+
+namespace detail {
+
+template<class ContainerT>
+concept has_front = requires(ContainerT& cont) {
+    { cont.front() } -> std::same_as<std::ranges::range_reference_t<ContainerT>>;
+};
+
+template<class ContainerT>
+concept has_back = requires(ContainerT& cont) {
+    { cont.back() } -> std::same_as<std::ranges::range_reference_t<ContainerT>>;
+};
+
+struct front_fn
+{
+    template<std::ranges::borrowed_range R>
+        requires has_front<R>
+    [[nodiscard]] static constexpr decltype(auto) operator()(R&& r)
+        noexcept(noexcept(r.front()))
+    {
+        return r.front();
+    }
+
+    template<std::ranges::borrowed_range R>
+        requires (!has_front<R>) && std::ranges::input_range<R>
+    [[nodiscard]] static constexpr decltype(auto) operator()(R&& r)
+        noexcept(noexcept(*std::ranges::begin(r)))
+    {
+        return *std::ranges::begin(r);
+    }
+};
+
+struct back_fn
+{
+    template<std::ranges::borrowed_range R>
+        requires has_back<R>
+    [[nodiscard]] static constexpr decltype(auto) operator()(R&& r)
+        noexcept(noexcept(r.back()))
+    {
+        return r.back();
+    }
+
+    template<std::ranges::borrowed_range R>
+        requires
+            (!has_back<R>) &&
+            std::ranges::bidirectional_range<R> &&
+            std::ranges::common_range<R>
+    [[nodiscard]] static constexpr decltype(auto) operator()(R&& r)
+        noexcept(noexcept(*std::ranges::prev(std::ranges::end(r))))
+    {
+        return *std::ranges::prev(std::ranges::end(r));
+    }
+};
+
+} // detail
+
+[[maybe_unused]] inline constexpr detail::front_fn front{};
+[[maybe_unused]] inline constexpr detail::back_fn back{};
+
+template<class R> concept front_accessible = requires(R& r) { front(r); };
+template<class R> concept back_accessible = requires(R& r) { back(r); };
+
+
+// ------------------------------------------------------------
+
+namespace detail {
+
+template<class ContainerT, class... Args>
+concept has_emplace_front =
+    requires(ContainerT& cont) {
+        cont.emplace_front(std::declval<Args>()...);
+    };
+
+template<class ContainerT, class... Args>
+concept has_push_front =
+    sizeof...(Args) == 1 &&
+    requires(ContainerT& cont) {
+        cont.push_front(std::declval<Args>()...);
+    };
+
+template<class ContainerT, class... Args>
+concept has_begin_emplace =
+    std::ranges::range<ContainerT> &&
+    requires(ContainerT& cont) {
+        cont.emplace(std::ranges::begin(cont), std::declval<Args>()...);
+    };
+
+template<class ContainerT, class... Args>
+concept has_begin_insert =
+    sizeof...(Args) == 1 &&
+    std::ranges::range<ContainerT> &&
+    requires(ContainerT& cont) {
+        cont.insert(std::ranges::begin(cont), std::declval<Args>()...);
+    };
+
+} // detail
+
+template<class ContainerT, class... Args>
+concept front_pushable =
+    detail::has_emplace_front<ContainerT, Args...> ||
+    detail::has_push_front<ContainerT, Args...>;
+
+template<class ContainerT>
+concept default_prependable =
+    std::ranges::range<ContainerT> &&
+    std::default_initializable<std::ranges::range_value_t<ContainerT>> &&
+    (
+        detail::has_emplace_front<ContainerT> || detail::has_begin_emplace<ContainerT> ||
+        (
+            std::move_constructible<std::ranges::range_value_t<ContainerT>> &&
+            (
+                detail::has_push_front<ContainerT, std::ranges::range_value_t<ContainerT>> ||
+                detail::has_begin_insert<ContainerT, std::ranges::range_value_t<ContainerT>>
+            )
+        )
+    );
+
+template<class ContainerT, class... Args>
+concept prependable =
+    front_pushable<ContainerT, Args...> ||
+    detail::has_begin_emplace<ContainerT, Args...> ||
+    detail::has_begin_insert<ContainerT, Args...> ||
+    (sizeof...(Args) == 0 && default_prependable<ContainerT>);
+
+namespace detail {
+
+template<class ContainerT, class... Args>
+concept front_emplace_returns =
+    has_emplace_front<ContainerT, Args...> &&
+    !std::is_void_v<decltype(std::declval<ContainerT&>().emplace_front(std::declval<Args>()...))>;
+
+template<bool NeedReturn, class ContainerT>
+concept default_front_emplace_front_accessible =
+    !NeedReturn ||
+    front_emplace_returns<ContainerT> ||
+    front_accessible<ContainerT> ||
+    (
+        !has_emplace_front<ContainerT> &&
+        (
+            has_begin_emplace<ContainerT> ||
+            (
+                !has_push_front<ContainerT, std::ranges::range_value_t<ContainerT>> &&
+                has_begin_insert<ContainerT, std::ranges::range_value_t<ContainerT>>
+            )
+        )
+    );
+
+template<bool NeedReturn, class ContainerT, class... Args>
+concept front_emplace_front_accessible =
+    !NeedReturn ||
+    front_emplace_returns<ContainerT, Args...> ||
+    front_accessible<ContainerT> ||
+    (
+        !has_emplace_front<ContainerT, Args...> &&
+        !has_push_front<ContainerT, Args...> &&
+        (has_begin_emplace<ContainerT, Args...> || has_begin_insert<ContainerT, Args...>)
+    );
+
+template<bool NeedReturn>
+struct prepend_fn
+{
+    template<class ContainerT>
+        requires default_prependable<ContainerT> && default_front_emplace_front_accessible<NeedReturn, ContainerT>
+    static constexpr decltype(auto)
+    operator()(ContainerT& cont)
+    {
+        if constexpr (has_emplace_front<ContainerT>) {
+            if constexpr (NeedReturn) {
+                if constexpr (std::is_void_v<decltype(cont.emplace_front())>) {
+                    cont.emplace_front();
+                    return front(cont);
+                } else {
+                    return cont.emplace_front();
+                }
+            } else {
+                (void)cont.emplace_front();
+            }
+        } else {
+            using ValueT = std::ranges::range_value_t<ContainerT>;
+            if constexpr (has_begin_emplace<ContainerT>) { // prefer most ergonomic insertion for immovable types
+                if constexpr (NeedReturn) {
+                    return *cont.emplace(std::ranges::begin(cont));
+                } else {
+                    (void)cont.emplace(std::ranges::begin(cont));
+                }
+            } else if constexpr (has_push_front<ContainerT, ValueT>) {
+                cont.push_front(ValueT{});
+                if constexpr (NeedReturn) {
+                    return front(cont);
+                }
+            } else if constexpr (has_begin_insert<ContainerT, ValueT>) {
+                if constexpr (NeedReturn) {
+                    return *cont.insert(std::ranges::begin(cont), ValueT{});
+                } else {
+                    (void)cont.insert(std::ranges::begin(cont), ValueT{});
+                }
+            } else {
+                static_assert(false);
+            }
+        }
+    }
+
+    template<class ContainerT, class FirstT, class... Rest>
+        requires prependable<ContainerT, FirstT, Rest...> && front_emplace_front_accessible<NeedReturn, ContainerT, FirstT, Rest...>
+    static constexpr decltype(auto)
+    operator()(ContainerT& cont, FirstT&& first, Rest&&... rest)
+    {
+        if constexpr (has_emplace_front<ContainerT, FirstT, Rest...>) {
+            if constexpr (NeedReturn) {
+                if constexpr (std::is_void_v<decltype(cont.emplace_front(std::forward<FirstT>(first), std::forward<Rest>(rest)...))>) {
+                    cont.emplace_front(std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                    return front(cont);
+                } else {
+                    return cont.emplace_front(std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                }
+            } else {
+                (void)cont.emplace_front(std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+            }
+        } else {
+            if constexpr (has_push_front<ContainerT, FirstT, Rest...>) {
+                static_assert(sizeof...(Rest) == 0);
+                cont.push_front(std::forward<FirstT>(first));
+                if constexpr (NeedReturn) {
+                    return front(cont);
+                }
+            } else if constexpr (has_begin_emplace<ContainerT, FirstT, Rest...>) {
+                if constexpr (NeedReturn) {
+                    return *cont.emplace(std::ranges::begin(cont), std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                } else {
+                    (void)cont.emplace(std::ranges::begin(cont), std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                }
+            } else if constexpr (has_begin_insert<ContainerT, FirstT, Rest...>) {
+                static_assert(sizeof...(Rest) == 0);
+                if constexpr (NeedReturn) {
+                    return *cont.insert(std::ranges::begin(cont), std::forward<FirstT>(first));
+                } else {
+                    (void)cont.insert(std::ranges::begin(cont), std::forward<FirstT>(first));
+                }
+            } else {
+                static_assert(false);
+            }
+        }
+    }
+};
+
+} // detail
+
+[[maybe_unused]] inline constexpr detail::prepend_fn<true> prepend_return{};
+[[maybe_unused]] inline constexpr detail::prepend_fn<false> prepend{};
+
+
+// ------------------------------------------------------------
+
+namespace detail {
+
+template<class ContainerT, class... Args>
+concept has_emplace_back =
+    requires(ContainerT& cont) {
+        cont.emplace_back(std::declval<Args>()...);
+    };
+
+template<class ContainerT, class... Args>
+concept has_push_back =
+    sizeof...(Args) == 1 &&
+    requires(ContainerT& cont) {
+        cont.push_back(std::declval<Args>()...);
+    };
+
+template<class ContainerT, class... Args>
+concept has_end_emplace =
+    std::ranges::range<ContainerT> &&
+    requires(ContainerT& cont) {
+        cont.emplace(std::ranges::end(cont), std::declval<Args>()...);
+    };
+
+template<class ContainerT, class... Args>
+concept has_end_insert =
+    sizeof...(Args) == 1 &&
+    std::ranges::range<ContainerT> &&
+    requires(ContainerT& cont) {
+        cont.insert(std::ranges::end(cont), std::declval<Args>()...);
+    };
+
+} // detail
+
+template<class ContainerT, class... Args>
+concept back_pushable =
+    detail::has_emplace_back<ContainerT, Args...> ||
+    detail::has_push_back<ContainerT, Args...>;
+
+template<class ContainerT>
+concept default_appendable =
+    std::ranges::range<ContainerT> &&
+    std::default_initializable<std::ranges::range_value_t<ContainerT>> &&
+    (
+        detail::has_emplace_back<ContainerT> || detail::has_end_emplace<ContainerT> ||
+        (
+            std::move_constructible<std::ranges::range_value_t<ContainerT>> &&
+            (
+                detail::has_push_back<ContainerT, std::ranges::range_value_t<ContainerT>> ||
+                detail::has_end_insert<ContainerT, std::ranges::range_value_t<ContainerT>>
+            )
+        )
+    );
+
+template<class ContainerT, class... Args>
+concept appendable =
+    back_pushable<ContainerT, Args...> ||
+    detail::has_end_emplace<ContainerT, Args...> ||
+    detail::has_end_insert<ContainerT, Args...> ||
+    (sizeof...(Args) == 0 && default_appendable<ContainerT>);
+
+namespace detail {
+
+template<class ContainerT, class... Args>
+concept back_emplace_returns =
+    has_emplace_back<ContainerT, Args...> &&
+    !std::is_void_v<decltype(std::declval<ContainerT&>().emplace_back(std::declval<Args>()...))>;
+
+template<bool NeedReturn, class ContainerT>
+concept default_back_emplace_back_accessible =
+    !NeedReturn ||
+    back_emplace_returns<ContainerT> ||
+    back_accessible<ContainerT> ||
+    (
+        !has_emplace_back<ContainerT> &&
+        (
+            has_end_emplace<ContainerT> ||
+            (
+                !has_push_back<ContainerT, std::ranges::range_value_t<ContainerT>> &&
+                has_end_insert<ContainerT, std::ranges::range_value_t<ContainerT>>
+            )
+        )
+    );
+
+template<bool NeedReturn, class ContainerT, class... Args>
+concept back_emplace_back_accessible =
+    !NeedReturn ||
+    back_emplace_returns<ContainerT, Args...> ||
+    back_accessible<ContainerT> ||
+    (
+        !has_emplace_back<ContainerT, Args...> &&
+        !has_push_back<ContainerT, Args...> &&
+        (has_end_emplace<ContainerT, Args...> || has_end_insert<ContainerT, Args...>)
+    );
+
+template<bool NeedReturn>
+struct append_fn
+{
+    template<class ContainerT>
+        requires default_appendable<ContainerT> && default_back_emplace_back_accessible<NeedReturn, ContainerT>
+    static constexpr decltype(auto)
+    operator()(ContainerT& cont)
+    {
+        if constexpr (has_emplace_back<ContainerT>) {
+            if constexpr (NeedReturn) {
+                if constexpr (std::is_void_v<decltype(cont.emplace_back())>) {
+                    cont.emplace_back();
+                    return back(cont);
+                } else {
+                    return cont.emplace_back();
+                }
+            } else {
+                (void)cont.emplace_back();
+            }
+        } else {
+            using ValueT = std::ranges::range_value_t<ContainerT>;
+            if constexpr (has_end_emplace<ContainerT>) { // prefer most ergonomic insertion for immovable types
+                if constexpr (NeedReturn) {
+                    return *cont.emplace(std::ranges::end(cont));
+                } else {
+                    (void)cont.emplace(std::ranges::end(cont));
+                }
+            } else if constexpr (has_push_back<ContainerT, ValueT>) {
+                cont.push_back(ValueT{});
+                if constexpr (NeedReturn) {
+                    return back(cont);
+                }
+            } else if constexpr (has_end_insert<ContainerT, ValueT>) {
+                if constexpr (NeedReturn) {
+                    return *cont.insert(std::ranges::end(cont), ValueT{});
+                } else {
+                    (void)cont.insert(std::ranges::end(cont), ValueT{});
+                }
+            } else {
+                static_assert(false);
+            }
+        }
+    }
+
+    template<class ContainerT, class FirstT, class... Rest>
+        requires appendable<ContainerT, FirstT, Rest...> && back_emplace_back_accessible<NeedReturn, ContainerT, FirstT, Rest...>
+    static constexpr decltype(auto)
+    operator()(ContainerT& cont, FirstT&& first, Rest&&... rest)
+    {
+        if constexpr (has_emplace_back<ContainerT, FirstT, Rest...>) {
+            if constexpr (NeedReturn) {
+                if constexpr (std::is_void_v<decltype(cont.emplace_back(std::forward<FirstT>(first), std::forward<Rest>(rest)...))>) {
+                    cont.emplace_back(std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                    return back(cont);
+                } else {
+                    return cont.emplace_back(std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                }
+            } else {
+                (void)cont.emplace_back(std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+            }
+        } else {
+            if constexpr (has_push_back<ContainerT, FirstT, Rest...>) {
+                static_assert(sizeof...(Rest) == 0);
+                cont.push_back(std::forward<FirstT>(first));
+                if constexpr (NeedReturn) {
+                    return back(cont);
+                }
+            } else if constexpr (has_end_emplace<ContainerT, FirstT, Rest...>) {
+                if constexpr (NeedReturn) {
+                    return *cont.emplace(std::ranges::end(cont), std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                } else {
+                    (void)cont.emplace(std::ranges::end(cont), std::forward<FirstT>(first), std::forward<Rest>(rest)...);
+                }
+            } else if constexpr (has_end_insert<ContainerT, FirstT, Rest...>) {
+                static_assert(sizeof...(Rest) == 0);
+                if constexpr (NeedReturn) {
+                    return *cont.insert(std::ranges::end(cont), std::forward<FirstT>(first));
+                } else {
+                    (void)cont.insert(std::ranges::end(cont), std::forward<FirstT>(first));
+                }
+            } else {
+                static_assert(false);
+            }
+        }
+    }
+};
+
+} // detail
+
+[[maybe_unused]] inline constexpr detail::append_fn<true> append_return{};
+[[maybe_unused]] inline constexpr detail::append_fn<false> append{};
+
+// ------------------------------------------------------------
+
+namespace detail {
+
+template<class ContainerT>
+concept begin_erasable =
+    std::ranges::range<ContainerT> &&
+    requires(ContainerT& cont) {
+        cont.erase(std::ranges::begin(cont));
+    };
+
+template<class ContainerT>
+concept end_erasable =
+    std::ranges::bidirectional_range<ContainerT> &&
+    std::ranges::common_range<ContainerT> &&
+    requires(ContainerT& cont) {
+        cont.erase(std::ranges::prev(std::ranges::end(cont)));
+    };
+
+template<class ContainerT>
+concept front_poppable = requires(ContainerT& cont) {
+    cont.pop_front();
+};
+
+template<class ContainerT>
+concept back_poppable = requires(ContainerT& cont) {
+    cont.pop_back();
+};
+
+struct erase_front_fn
+{
+    template<class ContainerT>
+        requires front_poppable<ContainerT>
+    static constexpr void operator()(ContainerT& cont)
+        noexcept(noexcept(cont.pop_front()))
+    {
+        cont.pop_front();
+    }
+
+    template<class ContainerT>
+        requires (!front_poppable<ContainerT>) && begin_erasable<ContainerT>
+    static constexpr void operator()(ContainerT& cont)
+        noexcept(noexcept(cont.erase(std::ranges::begin(cont))))
+    {
+        cont.erase(std::ranges::begin(cont));
+    }
+};
+
+struct erase_back_fn
+{
+    template<class ContainerT>
+        requires back_poppable<ContainerT>
+    static constexpr void operator()(ContainerT& cont)
+        noexcept(noexcept(cont.pop_back()))
+    {
+        cont.pop_back();
+    }
+
+    template<class ContainerT>
+        requires (!back_poppable<ContainerT>) && end_erasable<ContainerT>
+    static constexpr void operator()(ContainerT& cont)
+        noexcept(noexcept(cont.erase(std::ranges::prev(std::ranges::end(cont)))))
+    {
+        cont.erase(std::ranges::prev(std::ranges::end(cont)));
+    }
+};
+
+} // detail
+
+[[maybe_unused]] inline constexpr detail::erase_front_fn erase_front{};
+[[maybe_unused]] inline constexpr detail::erase_back_fn erase_back{};
+
+template<class ContainerT> concept front_erasable = requires(ContainerT& cont) { erase_front(cont); };
+template<class ContainerT> concept back_erasable = requires(ContainerT& cont) { erase_back(cont); };
+
+
+// ------------------------------------------------------------
+
+template<class ContainerT>
+concept growable_array =
+    std::ranges::range<ContainerT> &&
+    (
+        (
+            std::default_initializable<std::ranges::range_value_t<ContainerT>> &&
+            appendable<ContainerT>
+        ) ||
+        (
+            std::move_constructible<std::ranges::range_value_t<ContainerT>> &&
+            appendable<ContainerT, std::ranges::range_value_t<ContainerT>>
+        )
+    );
+
+template<class ContainerT>
+concept fixed_array =
+    !growable_array<ContainerT> &&
+    std::ranges::output_range<ContainerT, std::ranges::range_value_t<ContainerT>> &&
+    std::ranges::sized_range<ContainerT>;
+
+// ------------------------------------------------------------
+
+template<class ContainerT, class SizeT>
+concept has_reserve = requires(std::remove_cvref_t<ContainerT>& cont, SizeT const size) {
+    cont.reserve(size);
+};
+
+template<class ContainerT>
+concept has_shrink_to_fit = requires(std::remove_cvref_t<ContainerT>& cont) {
+    cont.shrink_to_fit();
+};
+
+
+template<class It, class ElemT>
+concept compatible_iterator =
+    // The standard only requires "not participating unless `It` qualifies as an input
+    // iterator" and leaves the extent unspecified; implementations check as little as
+    // `iterator_traits<It>::iterator_category`. The iterators that satisfy Cpp17InputIterator
+    // but not `std::input_iterator` are legacy defects (e.g. `difference_type = void`),
+    // which we do not support, so `std::input_iterator` is used here.
+    std::input_iterator<It> &&
+    // This is NOT `std::convertible_to`; see: https://stackoverflow.com/questions/79940611/stdfrom-range-does-not-work-with-explicit-conversions?noredirect=1
+    std::constructible_from<ElemT, std::iter_reference_t<It>>;
+
+// Note: `compatible_range` does NOT subsume `compatible_iterator` by design.
+// Historically in the C++ standard, `container(std::from_range_t, R)` and `container(it, se)`
+// meant two distinct semantics. For details, see the comment on `compatible_iterator`.
+//
+// Also note that in the standard, the element requirement of `container(it, se)` is a
+// precondition (Cpp17EmplaceConstructible; violation is a hard error inside the constructor),
+// whereas `compatible_iterator` makes it a constraint. This keeps
+// `std::constructible_from<Container, It, Se>` honest, which generic code such as
+// `std::ranges::to` relies on when choosing a construction strategy.
+template<class R, class ElemT>
+concept compatible_range =
+    std::ranges::input_range<R> &&
+    std::convertible_to<std::ranges::range_reference_t<R>, ElemT>;
+
+} // iris::container
+
+namespace iris::container::dummy {
+
+template<class K, class V>
+struct mapping_container
+{
+    using key_type = K;
+    using mapped_type = V;
+    std::pair<K, V> const* begin() const;
+    std::pair<K, V> const* end() const;
+
+    mapping_container() = default;
+    mapping_container(mapping_container const&) = delete;
+    mapping_container(mapping_container&&) = delete;
+    mapping_container& operator=(mapping_container const&) = delete;
+    mapping_container& operator=(mapping_container&&) = delete;
+
+    void emplace(K&&, V&&);
+};
+
+template<class K, class V>
+struct unique_mapping_container
+{
+    using key_type = K;
+    using mapped_type = V;
+    std::pair<K, V> const* begin() const;
+    std::pair<K, V> const* end() const;
+
+    unique_mapping_container() = default;
+    unique_mapping_container(unique_mapping_container const&) = delete;
+    unique_mapping_container(unique_mapping_container&&) = delete;
+    unique_mapping_container& operator=(unique_mapping_container const&) = delete;
+    unique_mapping_container& operator=(unique_mapping_container&&) = delete;
+
+    void emplace(K&&, V&&);
+    std::pair<std::pair<K, V> const*, bool> try_emplace(K&&, V&&);
+    std::pair<std::pair<K, V> const*, bool> insert_or_assign(K&&, V&&);
+};
+
+template<class T>
+struct growable_array
+{
+    T const* begin() const;
+    T const* end() const;
+    void emplace_back(T&&);
+    void emplace_back() requires std::default_initializable<T>;
+};
+
+template<class T>
+using fixed_array = T[1];
+
+} // iris::container::dummy
+
+#endif
diff --git a/include/iris/error/throwf.hpp b/include/iris/error/throwf.hpp
new file mode 100644
index 0000000..eac5e0c
--- /dev/null
+++ b/include/iris/error/throwf.hpp
@@ -0,0 +1,50 @@
+#ifndef IRIS_ZZ_ERROR_THROWF_HPP
+#define IRIS_ZZ_ERROR_THROWF_HPP
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <exception> // IWYU pragma: export
+#include <stdexcept> // IWYU pragma: export
+#include <type_traits>
+#include <utility>
+
+#ifndef IRIS_CONFIG_THROW_IMPL
+# define IRIS_CONFIG_THROW_IMPL(...) throw __VA_ARGS__
+#endif
+
+#ifndef IRIS_CONFIG_THROW_NORETURN
+# define IRIS_CONFIG_THROW_NORETURN [[noreturn]]
+#endif
+
+namespace iris {
+
+inline namespace error_functions {
+
+// This function can be used to strongly assume optimization in some performance-
+// critical paths as some compilers fail to optimize the plain `throw` statement
+// even though the statement itself should imply `[[noreturn]]`.
+template<class E>
+IRIS_CONFIG_THROW_NORETURN void throwf()
+{
+    static_assert(std::is_base_of_v<std::exception, E>);
+    static_assert(std::is_constructible_v<E>);
+    IRIS_CONFIG_THROW_IMPL(E{});
+}
+
+// This function can be used to strongly assume optimization in some performance-
+// critical paths as some compilers fail to optimize the plain `throw` statement
+// even though the statement itself should imply `[[noreturn]]`.
+template<class E, class Arg, class... Rest>
+    requires std::is_constructible_v<E, Arg, Rest...>
+IRIS_CONFIG_THROW_NORETURN void throwf(Arg&& arg, Rest&&... rest)
+{
+    static_assert(std::is_base_of_v<std::exception, E>);
+    static_assert(!std::is_base_of_v<std::exception, std::remove_cvref_t<Arg>>, "don't copy/move construct exception types directly");
+    IRIS_CONFIG_THROW_IMPL(E{std::forward<Arg>(arg), std::forward<Rest>(rest)...});
+}
+
+} // error_functions
+
+} // iris
+
+#endif
diff --git a/include/iris/error/throwf_format.hpp b/include/iris/error/throwf_format.hpp
new file mode 100644
index 0000000..0403227
--- /dev/null
+++ b/include/iris/error/throwf_format.hpp
@@ -0,0 +1,64 @@
+#ifndef IRIS_ZZ_ERROR_THROWF_FORMAT_HPP
+#define IRIS_ZZ_ERROR_THROWF_FORMAT_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+#include <iris/error/throwf.hpp> // IWYU pragma: export
+#include <iris/string.hpp>
+
+#include <exception> // IWYU pragma: export
+#include <format>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace iris {
+
+namespace detail {
+
+template<class T, class... Args>
+concept constructible_from_string_like_types =
+    std::is_constructible_v<T, Args..., std::string> ||
+    std::is_constructible_v<T, Args..., std::string_view> ||
+    std::is_constructible_v<T, Args..., const char*>;
+
+} // detail
+
+inline namespace error_functions {
+
+template<class E, class... Args>
+    requires detail::constructible_from_string_like_types<E>
+IRIS_CONFIG_THROW_NORETURN void throwf(std::format_string<Args...> fmt, Args&&... args)
+{
+    static_assert(std::is_base_of_v<std::exception, E>);
+    IRIS_CONFIG_THROW_IMPL(E{std::format(std::move(fmt), std::forward<Args>(args)...)});
+}
+
+template<class E, NotStringLike Arg0, class... Args>
+    requires detail::constructible_from_string_like_types<E, Arg0>
+IRIS_CONFIG_THROW_NORETURN void throwf(Arg0&& arg0, std::format_string<Args...> fmt, Args&&... args)
+{
+    static_assert(std::is_base_of_v<std::exception, E>);
+    IRIS_CONFIG_THROW_IMPL(E{std::forward<Arg0>(arg0), std::format(std::move(fmt), std::forward<Args>(args)...)});
+}
+
+template<class E, NotStringLike Arg0, NotStringLike Arg1, class... Args>
+    requires detail::constructible_from_string_like_types<E, Arg0, Arg1>
+IRIS_CONFIG_THROW_NORETURN void throwf(Arg0&& arg0, Arg1&& arg1, std::format_string<Args...> fmt, Args&&... args)
+{
+    static_assert(std::is_base_of_v<std::exception, E>);
+    IRIS_CONFIG_THROW_IMPL(
+        E{
+            std::forward<Arg0>(arg0), std::forward<Arg1>(arg1),
+            std::format(std::move(fmt), std::forward<Args>(args)...)
+        }
+    );
+}
+
+} // error_functions
+
+} // iris
+
+#endif
diff --git a/include/iris/exception.hpp b/include/iris/exception.hpp
index 058644d..990b788 100644
--- a/include/iris/exception.hpp
+++ b/include/iris/exception.hpp
@@ -1,88 +1,14 @@
 #ifndef IRIS_ZZ_EXCEPTION_HPP
 #define IRIS_ZZ_EXCEPTION_HPP
 
-#include <iris/config.hpp> // IWYU pragma: keep
-
-#include <iris/string.hpp>
-
-#include <exception>
-#include <format>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <utility>
-
-#ifndef IRIS_CONFIG_THROW_IMPL
-# define IRIS_CONFIG_THROW_IMPL(...) throw __VA_ARGS__
-#endif
-
-#ifndef IRIS_CONFIG_THROW_NORETURN
-# define IRIS_CONFIG_THROW_NORETURN [[noreturn]]
-#endif
-
-namespace iris {
-
-namespace detail {
+// SPDX-License-Identifier: MIT
 
-template<class T, class... Args>
-concept constructible_from_string_like_types =
-    std::is_constructible_v<T, Args..., std::string> ||
-    std::is_constructible_v<T, Args..., std::string_view> ||
-    std::is_constructible_v<T, Args..., const char*>;
-
-} // detail
-
-inline namespace error_functions {
-
-template<class E>
-IRIS_CONFIG_THROW_NORETURN void throwf()
-{
-    static_assert(std::is_base_of_v<std::exception, E>);
-    static_assert(std::is_constructible_v<E>);
-    IRIS_CONFIG_THROW_IMPL(E{});
-}
-
-template<class E, class Arg, class... Rest>
-    requires std::is_constructible_v<E, Arg, Rest...>
-IRIS_CONFIG_THROW_NORETURN void throwf(Arg&& arg, Rest&&... rest)
-{
-    static_assert(std::is_base_of_v<std::exception, E>);
-    static_assert(!std::is_base_of_v<std::exception, std::remove_cvref_t<Arg>>, "don't copy/move construct exception types directly");
-    IRIS_CONFIG_THROW_IMPL(E{std::forward<Arg>(arg), std::forward<Rest>(rest)...});
-}
-
-template<class E, class... Args>
-    requires detail::constructible_from_string_like_types<E>
-IRIS_CONFIG_THROW_NORETURN void throwf(std::format_string<Args...> fmt, Args&&... args)
-{
-    static_assert(std::is_base_of_v<std::exception, E>);
-    IRIS_CONFIG_THROW_IMPL(E{std::format(std::move(fmt), std::forward<Args>(args)...)});
-}
-
-template<class E, NotStringLike Arg0, class... Args>
-    requires detail::constructible_from_string_like_types<E, Arg0>
-IRIS_CONFIG_THROW_NORETURN void throwf(Arg0&& arg0, std::format_string<Args...> fmt, Args&&... args)
-{
-    static_assert(std::is_base_of_v<std::exception, E>);
-    IRIS_CONFIG_THROW_IMPL(E{std::forward<Arg0>(arg0), std::format(std::move(fmt), std::forward<Args>(args)...)});
-}
-
-template<class E, NotStringLike Arg0, NotStringLike Arg1, class... Args>
-    requires detail::constructible_from_string_like_types<E, Arg0, Arg1>
-IRIS_CONFIG_THROW_NORETURN void throwf(Arg0&& arg0, Arg1&& arg1, std::format_string<Args...> fmt, Args&&... args)
-{
-    static_assert(std::is_base_of_v<std::exception, E>);
-    IRIS_CONFIG_THROW_IMPL(
-        E{
-            std::forward<Arg0>(arg0), std::forward<Arg1>(arg1),
-            std::format(std::move(fmt), std::forward<Args>(args)...)
-        }
-    );
-}
+#include <iris/config.hpp> // IWYU pragma: keep
 
-} // error_functions
+#include <iris/error/throwf.hpp> // IWYU pragma: export
+#include <iris/error/throwf_format.hpp> // IWYU pragma: export
 
-} // iris
+#include <exception> // IWYU pragma: export
+#include <stdexcept> // IWYU pragma: export
 
 #endif
diff --git a/include/iris/indexed_value.hpp b/include/iris/indexed_value.hpp
new file mode 100644
index 0000000..a530993
--- /dev/null
+++ b/include/iris/indexed_value.hpp
@@ -0,0 +1,506 @@
+#ifndef IRIS_ZZ_INDEXED_VALUE_HPP
+#define IRIS_ZZ_INDEXED_VALUE_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+#include <iris/requirements.hpp>
+#include <iris/compare.hpp>
+
+#include <iris/bits/specialization_of.hpp>
+
+#include <concepts>
+#include <type_traits>
+#include <utility>
+#include <tuple>
+
+#include <cstddef>
+
+namespace iris {
+
+template<class IndexT, class T>
+struct indexed_value
+{
+    using index_type = IndexT;
+    using value_type = T;
+
+    IndexT index;
+    T value;
+
+    // ----------------------------------------------------
+
+    template<class IndexU, class U>
+        requires
+            std::convertible_to<IndexT&, IndexU> &&
+            std::convertible_to<T&, U>
+    constexpr operator indexed_value<IndexU, U>() &
+        noexcept(
+            noexcept(static_cast<IndexU>(std::declval<IndexT&>())) &&
+            noexcept(static_cast<U>(std::declval<T&>()))
+        )
+    {
+        return {
+            static_cast<IndexU>(index),
+            static_cast<U>(value)
+        };
+    }
+
+    template<class IndexU, class U>
+        requires
+            std::convertible_to<IndexT const&, IndexU> &&
+            std::convertible_to<T const&, U>
+    constexpr operator indexed_value<IndexU, U>() const&
+        noexcept(
+            noexcept(static_cast<IndexU>(std::declval<IndexT const&>())) &&
+            noexcept(static_cast<U>(std::declval<T const&>()))
+        )
+    {
+        return {
+            static_cast<IndexU>(index),
+            static_cast<U>(value)
+        };
+    }
+
+    template<class IndexU, class U>
+        requires
+            std::convertible_to<IndexT&&, IndexU> &&
+            std::convertible_to<T&&, U>
+    constexpr operator indexed_value<IndexU, U>() &&
+        noexcept(
+            noexcept(static_cast<IndexU>(std::declval<IndexT&&>())) &&
+            noexcept(static_cast<U>(std::declval<T&&>()))
+        )
+    {
+        return {
+            static_cast<IndexU>(static_cast<IndexT&&>(index)),
+            static_cast<U>(static_cast<T&&>(value))
+        };
+    }
+
+    template<class IndexU, class U>
+        requires
+            std::convertible_to<IndexT const&&, IndexU> &&
+            std::convertible_to<T const&&, U>
+    constexpr operator indexed_value<IndexU, U>() const&&
+        noexcept(
+            noexcept(static_cast<IndexU>(std::declval<IndexT const&&>())) &&
+            noexcept(static_cast<U>(std::declval<T const&&>()))
+        )
+    {
+        return {
+            static_cast<IndexU>(static_cast<IndexT const&&>(index)),
+            static_cast<U>(static_cast<T const&&>(value))
+        };
+    }
+
+    // ----------------------------------------------------
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT&, U> &&
+            std::convertible_to<T&, V>
+    constexpr operator std::tuple<U, V>() &
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT&>())) &&
+            noexcept(static_cast<V>(std::declval<T&>()))
+        )
+    {
+        return std::tuple<U, V>(
+            static_cast<U>(index),
+            static_cast<V>(value)
+        );
+    }
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT const&, U> &&
+            std::convertible_to<T const&, V>
+    constexpr operator std::tuple<U, V>() const&
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT const&>())) &&
+            noexcept(static_cast<V>(std::declval<T const&>()))
+        )
+    {
+        return std::tuple<U, V>(
+            static_cast<U>(index),
+            static_cast<V>(value)
+        );
+    }
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT&&, U> &&
+            std::convertible_to<T&&, V>
+    constexpr operator std::tuple<U, V>() &&
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT&&>())) &&
+            noexcept(static_cast<V>(std::declval<T&&>()))
+        )
+    {
+        return std::tuple<U, V>(
+            static_cast<U>(static_cast<IndexT&&>(index)),
+            static_cast<V>(static_cast<T&&>(value))
+        );
+    }
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT const&&, U> &&
+            std::convertible_to<T const&&, V>
+    constexpr operator std::tuple<U, V>() const&&
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT const&&>())) &&
+            noexcept(static_cast<V>(std::declval<T const&&>()))
+        )
+    {
+        return std::tuple<U, V>(
+            static_cast<U>(static_cast<IndexT const&&>(index)),
+            static_cast<V>(static_cast<T const&&>(value))
+        );
+    }
+
+    // ----------------------------------------------------
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT&, U> &&
+            std::convertible_to<T&, V>
+    constexpr operator std::pair<U, V>() &
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT&>())) &&
+            noexcept(static_cast<V>(std::declval<T&>()))
+        )
+    {
+        return std::pair<U, V>(
+            static_cast<U>(index),
+            static_cast<V>(value)
+        );
+    }
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT const&, U> &&
+            std::convertible_to<T const&, V>
+    constexpr operator std::pair<U, V>() const&
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT const&>())) &&
+            noexcept(static_cast<V>(std::declval<T const&>()))
+        )
+    {
+        return std::pair<U, V>(
+            static_cast<U>(index),
+            static_cast<V>(value)
+        );
+    }
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT&&, U> &&
+            std::convertible_to<T&&, V>
+    constexpr operator std::pair<U, V>() &&
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT&&>())) &&
+            noexcept(static_cast<V>(std::declval<T&&>()))
+        )
+    {
+        return std::pair<U, V>(
+            static_cast<U>(static_cast<IndexT&&>(index)),
+            static_cast<V>(static_cast<T&&>(value))
+        );
+    }
+
+    template<class U, class V>
+        requires
+            std::convertible_to<IndexT const&&, U> &&
+            std::convertible_to<T const&&, V>
+    constexpr operator std::pair<U, V>() const&&
+        noexcept(
+            noexcept(static_cast<U>(std::declval<IndexT const&&>())) &&
+            noexcept(static_cast<V>(std::declval<T const&&>()))
+        )
+    {
+        return std::pair<U, V>(
+            static_cast<U>(static_cast<IndexT const&&>(index)),
+            static_cast<V>(static_cast<T const&&>(value))
+        );
+    }
+};
+
+template<class IndexT, class T, class IndexU, class U>
+    requires req::half_equality_comparable<IndexT, IndexU> && req::half_equality_comparable<T, U>
+[[nodiscard]] constexpr bool operator==(indexed_value<IndexT, T> const& a, indexed_value<IndexU, U> const& b)
+    noexcept(noexcept(a.index == b.index) && noexcept(a.value == b.value))
+{
+    return a.index == b.index && a.value == b.value;
+}
+
+template<class IndexT, class T, class U>
+    requires
+        (!is_ttp_specialization_of_v<U, indexed_value>) &&
+        (std::tuple_size<std::remove_cvref_t<U>>::value == 2) &&
+        req::half_equality_comparable<IndexT, std::tuple_element_t<0, std::remove_cvref_t<U>>> &&
+        req::half_equality_comparable<T, std::tuple_element_t<1, std::remove_cvref_t<U>>>
+[[nodiscard]] constexpr bool operator==(indexed_value<IndexT, T> const& a, U const& b)
+{
+    return a.index == std::get<0>(b) && a.value == std::get<1>(b);
+}
+
+template<class IndexT, class T, class IndexU, class U>
+    requires requires (IndexT const& i, IndexU const& j, T const& t, U const& u) {
+        cmp::synth_three_way{}(i, j);
+        cmp::synth_three_way{}(t, u);
+    }
+[[nodiscard]] constexpr auto operator<=>(indexed_value<IndexT, T> const& a, indexed_value<IndexU, U> const& b)
+    noexcept(
+        noexcept(cmp::synth_three_way{}(a.index, b.index)) &&
+        noexcept(cmp::synth_three_way{}(a.value, b.value))
+    )
+    -> std::common_comparison_category_t<
+        cmp::synth_three_way_result<IndexT, IndexU>,
+        cmp::synth_three_way_result<T, U>
+    >
+{
+    if (auto const comp = cmp::synth_three_way{}(a.index, b.index); comp != 0) {
+        return comp;
+    }
+    return cmp::synth_three_way{}(a.value, b.value);
+}
+
+template<std::size_t I, class IndexT, class T>
+[[nodiscard]] constexpr decltype(auto) get(indexed_value<IndexT, T>& elem) noexcept
+{
+    static_assert(I < 2);
+    if constexpr (I == 0)      { return (elem.index); }
+    else if constexpr (I == 1) { return (elem.value); }
+}
+
+template<std::size_t I, class IndexT, class T>
+[[nodiscard]] constexpr decltype(auto) get(indexed_value<IndexT, T> const& elem) noexcept
+{
+    static_assert(I < 2);
+    if constexpr (I == 0)      { return (elem.index); }
+    else if constexpr (I == 1) { return (elem.value); }
+}
+
+template<std::size_t I, class IndexT, class T>
+[[nodiscard]] constexpr decltype(auto) get(indexed_value<IndexT, T>&& elem) noexcept
+{
+    static_assert(I < 2);
+    if constexpr (I == 0)      { return static_cast<IndexT&&>(elem.index); }
+    else if constexpr (I == 1) { return static_cast<T&&>(elem.value); }
+}
+
+template<std::size_t I, class IndexT, class T>
+[[nodiscard]] constexpr decltype(auto) get(indexed_value<IndexT, T> const&& elem) noexcept
+{
+    static_assert(I < 2);
+    if constexpr (I == 0)      { return static_cast<IndexT const&&>(elem.index); }
+    else if constexpr (I == 1) { return static_cast<T const&&>(elem.value); }
+}
+
+} // iris
+
+template<class IndexT, class T>
+struct std::tuple_size<iris::indexed_value<IndexT, T>>
+    : std::integral_constant<std::size_t, 2>
+{};
+
+template<class IndexT, class T>
+struct std::tuple_element<0, iris::indexed_value<IndexT, T>>
+{
+    using type = IndexT;
+};
+template<class IndexT, class T>
+struct std::tuple_element<1, iris::indexed_value<IndexT, T>>
+{
+    using type = T;
+};
+
+
+// indexed_value + indexed_value
+template<class IndexT, class T, class IndexU, class U>
+    requires requires {
+        typename std::common_type_t<IndexT, IndexU>;
+        typename std::common_type_t<T, U>;
+    }
+struct std::common_type<
+    iris::indexed_value<IndexT, T>,
+    iris::indexed_value<IndexU, U>
+>
+{
+    using type = iris::indexed_value<
+        std::common_type_t<IndexT, IndexU>,
+        std::common_type_t<T, U>
+    >;
+};
+
+// indexed_value + indexed_value
+template<
+    class IndexT, class T, class IndexU, class U,
+    template<class> class TQual, template<class> class UQual
+>
+    requires requires {
+        typename std::common_reference_t<TQual<IndexT>, UQual<IndexU>>;
+        typename std::common_reference_t<TQual<T>, UQual<U>>;
+    }
+struct std::basic_common_reference<
+    iris::indexed_value<IndexT, T>, iris::indexed_value<IndexU, U>, TQual, UQual
+>
+{
+    using type = iris::indexed_value<
+        std::common_reference_t<TQual<IndexT>, UQual<IndexU>>,
+        std::common_reference_t<TQual<T>, UQual<U>>
+    >;
+};
+
+// -----------------------------------------------------------
+
+// indexed_value + std::tuple
+template<class IndexT, class T, class Tup0, class Tup1>
+    requires requires {
+        typename std::common_type_t<IndexT, Tup0>;
+        typename std::common_type_t<T, Tup1>;
+    }
+struct std::common_type<
+    iris::indexed_value<IndexT, T>,
+    std::tuple<Tup0, Tup1>
+>
+{
+    using type = std::tuple<
+        std::common_type_t<IndexT, Tup0>,
+        std::common_type_t<T, Tup1>
+    >;
+};
+
+// std::tuple + indexed_value
+template<class Tup0, class Tup1, class IndexU, class U>
+    requires requires {
+        typename std::common_type_t<Tup0, IndexU>;
+        typename std::common_type_t<Tup1, U>;
+    }
+struct std::common_type<
+    std::tuple<Tup0, Tup1>,
+    iris::indexed_value<IndexU, U>
+>
+{
+    using type = std::tuple<
+        std::common_type_t<Tup0, IndexU>,
+        std::common_type_t<Tup1, U>
+    >;
+};
+
+
+// indexed_value + std::tuple
+template<
+    class IndexT, class T, class Tup0, class Tup1,
+    template<class> class TQual, template<class> class UQual
+>
+    requires requires {
+        typename std::common_reference_t<TQual<IndexT>, UQual<Tup0>>;
+        typename std::common_reference_t<TQual<T>, UQual<Tup1>>;
+    }
+struct std::basic_common_reference<
+    iris::indexed_value<IndexT, T>, std::tuple<Tup0, Tup1>, TQual, UQual
+>
+{
+    using type = std::tuple<
+        std::common_reference_t<TQual<IndexT>, UQual<Tup0>>,
+        std::common_reference_t<TQual<T>, UQual<Tup1>>
+    >;
+};
+
+// std::tuple + indexed_value
+template<
+    class Tup0, class Tup1, class IndexU, class U,
+    template<class> class TQual, template<class> class UQual
+>
+    requires requires {
+        typename std::common_reference_t<TQual<Tup0>, UQual<IndexU>>;
+        typename std::common_reference_t<TQual<Tup1>, UQual<U>>;
+    }
+struct std::basic_common_reference<
+    std::tuple<Tup0, Tup1>, iris::indexed_value<IndexU, U>, TQual, UQual
+>
+{
+    using type = std::tuple<
+        std::common_reference_t<TQual<Tup0>, UQual<IndexU>>,
+        std::common_reference_t<TQual<Tup1>, UQual<U>>
+    >;
+};
+
+// -----------------------------------------------------------
+
+// indexed_value + std::pair
+template<class IndexT, class T, class Tup0, class Tup1>
+    requires requires {
+        typename std::common_type_t<IndexT, Tup0>;
+        typename std::common_type_t<T, Tup1>;
+    }
+struct std::common_type<
+    iris::indexed_value<IndexT, T>,
+    std::pair<Tup0, Tup1>
+>
+{
+    using type = std::pair<
+        std::common_type_t<IndexT, Tup0>,
+        std::common_type_t<T, Tup1>
+    >;
+};
+
+// std::pair + indexed_value
+template<class Tup0, class Tup1, class IndexU, class U>
+    requires requires {
+        typename std::common_type_t<Tup0, IndexU>;
+        typename std::common_type_t<Tup1, U>;
+    }
+struct std::common_type<
+    std::pair<Tup0, Tup1>,
+    iris::indexed_value<IndexU, U>
+>
+{
+    using type = std::pair<
+        std::common_type_t<Tup0, IndexU>,
+        std::common_type_t<Tup1, U>
+    >;
+};
+
+
+// indexed_value + std::pair
+template<
+    class IndexT, class T, class Tup0, class Tup1,
+    template<class> class TQual, template<class> class UQual
+>
+    requires requires {
+        typename std::common_reference_t<TQual<IndexT>, UQual<Tup0>>;
+        typename std::common_reference_t<TQual<T>, UQual<Tup1>>;
+    }
+struct std::basic_common_reference<
+    iris::indexed_value<IndexT, T>, std::pair<Tup0, Tup1>, TQual, UQual
+>
+{
+    using type = std::pair<
+        std::common_reference_t<TQual<IndexT>, UQual<Tup0>>,
+        std::common_reference_t<TQual<T>, UQual<Tup1>>
+    >;
+};
+
+// std::pair + indexed_value
+template<
+    class Tup0, class Tup1, class IndexU, class U,
+    template<class> class TQual, template<class> class UQual
+>
+    requires requires {
+        typename std::common_reference_t<TQual<Tup0>, UQual<IndexU>>;
+        typename std::common_reference_t<TQual<Tup1>, UQual<U>>;
+    }
+struct std::basic_common_reference<
+    std::pair<Tup0, Tup1>, iris::indexed_value<IndexU, U>, TQual, UQual
+>
+{
+    using type = std::pair<
+        std::common_reference_t<TQual<Tup0>, UQual<IndexU>>,
+        std::common_reference_t<TQual<Tup1>, UQual<U>>
+    >;
+};
+
+#endif
diff --git a/include/iris/interval.hpp b/include/iris/interval.hpp
index 7d55521..4c95191 100644
--- a/include/iris/interval.hpp
+++ b/include/iris/interval.hpp
@@ -21,7 +21,7 @@
 
 namespace iris {
 
-template<std::signed_integral T>
+template<std::integral T>
 struct interval
 {
     using value_type = T;
@@ -61,7 +61,7 @@ struct interval
     // Returns `true` if `other` shares any point with `*this`.
     // Note 1: intersects(∅) always returns `false`.
     // Note 2: Adjacent-only contact is touches(); for intersects-or-touches use connected().
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr bool intersects(interval<U> const other) const noexcept
     {
         return (lower < other.upper && other.lower < upper) && !empty() && !other.empty();
@@ -69,7 +69,7 @@ struct interval
 
     // !intersects
     // Note: disjoint(∅) always returns `true`.
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr bool disjoint(interval<U> const other) const noexcept
     {
         return (upper <= other.lower || other.upper <= lower) || empty() || other.empty();
@@ -77,7 +77,7 @@ struct interval
 
     // Closures meet but the sets share no point.
     // Note: touches(∅) always returns `false`.
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr bool touches(interval<U> const other) const noexcept
     {
         return (upper == other.lower || other.upper == lower) && !empty() && !other.empty();
@@ -85,7 +85,7 @@ struct interval
 
     // intersects || touches
     // Note: connected(∅) always returns `false`.
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr bool connected(interval<U> const other) const noexcept
     {
         return (lower <= other.upper && other.lower <= upper) && !empty() && !other.empty();
@@ -94,7 +94,7 @@ struct interval
     // Returns `true` if every point of `other` is a point of `*this`.
     // Note: covers(∅) always returns `true`.
     // See also: `encloses(other)`.
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr bool covers(interval<U> const other) const noexcept
     {
         return (lower <= other.lower && other.upper <= upper) || other.empty();
@@ -103,7 +103,7 @@ struct interval
     // Returns `true` if `other`'s bounds lie within [lower, upper].
     // For nonempty `other`: identical to `covers(other)`.
     // For empty `other`: position-respecting (treats it like a 0-length "text caret".)
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr bool encloses(interval<U> const other) const noexcept
     {
         return lower <= other.lower && other.upper <= upper;
@@ -134,7 +134,7 @@ struct interval
     // Returns `true` if both intervals have exactly same bounds.
     // Note: All empty intervals denote ∅ and are mutually equal regardless of
     //       bounds. Differs from `operator==`, which compares data representations.
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr bool equals(interval<U> const other) const noexcept
     {
         return (lower == other.lower && upper == other.upper) || (empty() && other.empty());
@@ -143,14 +143,14 @@ struct interval
     // -------------------------------------------
 
     // A ∩ B. Result is canonical empty [0,0) when the sets share no point.
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr interval intersection(interval<U> const other) const noexcept
     {
         auto const lo = std::max<value_type>(lower, static_cast<value_type>(other.lower));
         auto const hi = std::min<value_type>(upper, static_cast<value_type>(other.upper));
         return lo < hi ? interval{lo, hi} : interval{};
     }
-    template<std::signed_integral U = T>
+    template<std::integral U = T>
     [[nodiscard]] constexpr interval operator&(interval<U> const other) const noexcept
     {
         return intersection(other);
diff --git a/include/iris/interval_set.hpp b/include/iris/interval_set.hpp
index 8746d73..d7797e6 100644
--- a/include/iris/interval_set.hpp
+++ b/include/iris/interval_set.hpp
@@ -4,7 +4,6 @@
 // SPDX-License-Identifier: MIT
 
 #include <iris/config.hpp> // IWYU pragma: keep
-#include <iris/iterator.hpp>
 
 #include <format>
 #include <concepts>
@@ -29,20 +28,24 @@ class interval_set
     using map_type = MapT;
     using offset_type = IntervalT::value_type;
 
-    class const_iterator : public iterator_base<typename map_type::const_iterator>
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+
+    class const_iterator
     {
-        using typename iterator_base<typename map_type::const_iterator>::iterator_base_type;
-        static_assert(std::bidirectional_iterator<iterator_base_type>);
-        iterator_base_type it_;
+        map_type::const_iterator it_;
 
     public:
+        using iterator_concept = std::bidirectional_iterator_tag;
+        using iterator_category = std::bidirectional_iterator_tag;
+
         using value_type = IntervalT;
-        using pointer    = IntervalT const*;
         using reference  = IntervalT;
+        using difference_type = interval_set::difference_type;
 
         constexpr const_iterator() noexcept = default;
 
-        constexpr explicit const_iterator(iterator_base_type it) noexcept
+        constexpr explicit const_iterator(map_type::const_iterator it) noexcept
             : it_(std::move(it))
         {}
 
diff --git a/include/iris/iterator.hpp b/include/iris/iterator.hpp
index 47aecc7..51d5edc 100644
--- a/include/iris/iterator.hpp
+++ b/include/iris/iterator.hpp
@@ -6,64 +6,43 @@
 #include <iris/config.hpp> // IWYU pragma: keep
 
 #include <iterator>
-#include <compare>
+#include <type_traits>
+#include <concepts>
 
 namespace iris {
 
-template<std::input_or_output_iterator It>
-struct iterator_tags_base;
-
-template<std::input_or_output_iterator It>
-    requires requires {
-        typename std::iterator_traits<It>::iterator_category;
-        typename std::iterator_traits<It>::iterator_concept;
-    }
-struct iterator_tags_base<It>
-{
-    using iterator_base_type = It;
-    using iterator_category = std::iterator_traits<It>::iterator_category;
-    using iterator_concept = std::iterator_traits<It>::iterator_concept;
-
-    [[nodiscard]] constexpr bool operator==(iterator_tags_base const&) const noexcept = default;
-    [[nodiscard]] constexpr std::strong_ordering operator<=>(iterator_tags_base const&) const noexcept = default;
-};
-
-template<std::input_or_output_iterator It>
-    requires
-        requires { typename std::iterator_traits<It>::iterator_category; } &&
-        (!requires { typename std::iterator_traits<It>::iterator_concept; })
-struct iterator_tags_base<It>
-{
-    using iterator_base_type = It;
-    using iterator_category = std::iterator_traits<It>::iterator_category;
-
-    [[nodiscard]] constexpr bool operator==(iterator_tags_base const&) const noexcept = default;
-    [[nodiscard]] constexpr std::strong_ordering operator<=>(iterator_tags_base const&) const noexcept = default;
-};
-
-template<std::input_or_output_iterator It>
-    requires
-        (!requires { typename std::iterator_traits<It>::iterator_category; }) &&
-        requires { typename std::iterator_traits<It>::iterator_concept; }
-struct iterator_tags_base<It>
-{
-    using iterator_base_type = It;
-    using iterator_concept = std::iterator_traits<It>::iterator_concept;
-
-    [[nodiscard]] constexpr bool operator==(iterator_tags_base const&) const noexcept = default;
-    [[nodiscard]] constexpr std::strong_ordering operator<=>(iterator_tags_base const&) const noexcept = default;
-};
-
-// ----------------------------------------------
-
-template<std::input_or_output_iterator It>
-struct iterator_base : iterator_tags_base<It>
-{
-    using difference_type = std::iterator_traits<It>::difference_type;
-
-    [[nodiscard]] constexpr bool operator==(iterator_base const&) const noexcept = default;
-    [[nodiscard]] constexpr std::strong_ordering operator<=>(iterator_base const&) const noexcept = default;
-};
+namespace detail {
+
+template<std::input_iterator It>
+std::input_iterator_tag iter_concept_of();
+
+template<std::forward_iterator It>
+std::forward_iterator_tag iter_concept_of();
+
+template<std::bidirectional_iterator It>
+std::bidirectional_iterator_tag iter_concept_of();
+
+template<std::random_access_iterator It>
+std::random_access_iterator_tag iter_concept_of();
+
+template<std::contiguous_iterator It>
+std::contiguous_iterator_tag iter_concept_of();
+
+} // detail
+
+template<std::input_iterator It>
+using iter_concept_t = decltype(detail::iter_concept_of<It>());
+
+template<class It>
+using iter_cat_t = std::iterator_traits<It>::iterator_category;
+
+template<class It>
+concept has_iter_cat = requires { typename iter_cat_t<It>; };
+
+// min(Tag, Limit) on the standard tag hierarchy
+template<class Tag, class Limit>
+    requires std::derived_from<Tag, Limit> || std::derived_from<Limit, Tag>
+using clamp_iter_tag_t = std::conditional_t<std::derived_from<Tag, Limit>, Limit, Tag>;
 
 } // iris
 
diff --git a/include/iris/marshal/serialize.hpp b/include/iris/marshal/serialize.hpp
index ef026bc..62f2b4a 100644
--- a/include/iris/marshal/serialize.hpp
+++ b/include/iris/marshal/serialize.hpp
@@ -5,6 +5,9 @@
 
 #include <iris/config.hpp> // IWYU pragma: keep
 
+#include <iris/ranges.hpp>
+#include <iris/container_traits.hpp>
+
 #include <iris/marshal/serialize_traits.hpp>
 #include <iris/marshal/detail/field.hpp>
 
@@ -207,7 +210,7 @@ struct basic_load_fn
     }
 
     template<deserializable_array<format> R>
-        requires ranges::growable_array_writable<R&>
+        requires container::growable_array<R&>
     static constexpr void operator()(ReaderT& rd, R& arr)
     {
         R tmp{};
@@ -216,8 +219,8 @@ struct basic_load_fn
             std::ranges::range_value_t<R> elem{};
             basic_load_fn{}(elem_rd, elem);
 
-            if constexpr (ranges::back_emplaceable<R>) {
-                tmp.emplace_back(std::move(elem));
+            if constexpr (container::back_pushable<R>) {
+                container::append(tmp, std::move(elem));
             } else {
                 tmp.emplace(std::move(elem));
             }
@@ -231,7 +234,7 @@ struct basic_load_fn
     }
 
     template<deserializable_array<format> R>
-        requires ranges::fixed_array_writable<R&>
+        requires container::fixed_array<R&>
     static constexpr void operator()(ReaderT& rd, R& arr)
     {
         auto it = std::ranges::begin(arr);
@@ -274,7 +277,7 @@ struct basic_load_fn
             mapped_type v{};
             basic_load_fn{}(member_rd, v);
 
-            if constexpr (ranges::unique_mapping_container<MapT>) {
+            if constexpr (container::unique_mapping_container<MapT>) {
                 if (!tmp.try_emplace(std::move(k), std::move(v)).second) {
                     throw load_error{"object: duplicate key"};
                 }
diff --git a/include/iris/marshal/serialize_traits.hpp b/include/iris/marshal/serialize_traits.hpp
index ee098f5..3001eca 100644
--- a/include/iris/marshal/serialize_traits.hpp
+++ b/include/iris/marshal/serialize_traits.hpp
@@ -11,6 +11,7 @@
 
 #include <iris/string.hpp>
 #include <iris/ranges.hpp>
+#include <iris/container_traits.hpp>
 
 #include <iris/bits/specialization_of.hpp>
 
@@ -313,16 +314,16 @@ consteval bool is_deserializable_impl()
 
     } else if constexpr (ranges::mapping_range<V>) {
         return
-            ranges::mapping_container<V> &&
+            container::mapping_container<V> &&
             Format::template loadable_key<ranges::range_key_t<V>> &&
             loadable<ranges::range_key_t<V>, Format> &&
             loadable<ranges::range_mapped_t<V>, Format>;
 
     } else if constexpr (std::ranges::input_range<V>) {
-        if constexpr (ranges::growable_array_writable<V>) {
+        if constexpr (container::growable_array<V>) {
             return loadable<std::ranges::range_value_t<V>, Format>;
 
-        } else if constexpr (ranges::fixed_array_writable<V>) {
+        } else if constexpr (container::fixed_array<V>) {
             return is_deserializable_impl<std::ranges::range_value_t<V>, Format>();
 
         } else {
diff --git a/include/iris/ranges.hpp b/include/iris/ranges.hpp
index 89fd5a8..897a465 100644
--- a/include/iris/ranges.hpp
+++ b/include/iris/ranges.hpp
@@ -5,8 +5,10 @@
 
 #include <iris/config.hpp> // IWYU pragma: keep
 
+#include <iris/iterator.hpp> // IWYU pragma: keep
 #include <iris/utility.hpp>
 
+#include <iterator> // IWYU pragma: keep
 #include <ranges> // IWYU pragma: export
 #include <concepts>
 #include <type_traits>
@@ -36,14 +38,6 @@ concept key_value_range =
     gettable<0, std::ranges::range_reference_t<R>> &&
     gettable<1, std::ranges::range_reference_t<R>>;
 
-template<class K, class V>
-struct dummy_key_value_range
-{
-    std::pair<K, V> const* begin() const;
-    std::pair<K, V> const* end() const;
-    ~dummy_key_value_range() = delete;
-};
-
 template<key_value_range R>
 using range_key_t    = std::remove_cvref_t<std::tuple_element_t<0, detail::kv_element_t<R>>>;
 
@@ -64,16 +58,6 @@ concept mapping_range =
     std::same_as<range_key_t<R>,    typename std::remove_cvref_t<R>::key_type> &&
     std::same_as<range_mapped_t<R>, typename std::remove_cvref_t<R>::mapped_type>;
 
-template<class K, class V>
-struct dummy_mapping_range
-{
-    using key_type = K;
-    using mapped_type = V;
-    std::pair<K, V> const* begin() const;
-    std::pair<K, V> const* end() const;
-    ~dummy_mapping_range() = delete;
-};
-
 
 // Thin view that adds the map-specific trait to the underlying range.
 // Can be used for making `key_value_range` model `mapping_range`.
@@ -130,118 +114,26 @@ inline constexpr bool std::ranges::enable_borrowed_range<iris::ranges::as_map_vi
     = std::ranges::enable_borrowed_range<V>;
 
 
-namespace iris::ranges {
-
-template<class C>
-concept mapping_container =
-    mapping_range<C> &&
-    std::default_initializable<std::remove_cvref_t<C>> &&
-    requires(
-        std::remove_cvref_t<C>& c,
-        typename std::remove_cvref_t<C>::key_type k,
-        typename std::remove_cvref_t<C>::mapped_type v
-    ) {
-        c.emplace(std::move(k), std::move(v));
-    };
+namespace iris::ranges::dummy {
 
 template<class K, class V>
-struct dummy_mapping_container
+struct key_value_range
 {
-    using key_type = K;
-    using mapped_type = V;
     std::pair<K, V> const* begin() const;
     std::pair<K, V> const* end() const;
-
-    dummy_mapping_container() = default;
-    dummy_mapping_container(dummy_mapping_container const&) = delete;
-    dummy_mapping_container(dummy_mapping_container&&) = delete;
-    dummy_mapping_container& operator=(dummy_mapping_container const&) = delete;
-    dummy_mapping_container& operator=(dummy_mapping_container&&) = delete;
-
-    void emplace(K&&, V&&);
+    ~key_value_range() = delete;
 };
 
-template<class C>
-concept unique_mapping_container =
-    mapping_container<C> &&
-    requires(
-        std::remove_cvref_t<C>& c,
-        typename std::remove_cvref_t<C>::key_type k,
-        typename std::remove_cvref_t<C>::mapped_type v
-    ) {
-        { c.try_emplace(std::move(k), std::move(v)).second } -> std::convertible_to<bool>;
-        { c.insert_or_assign(std::move(k), std::move(v)).second } -> std::convertible_to<bool>;
-    };
-
 template<class K, class V>
-struct dummy_unique_mapping_container : dummy_mapping_container<K, V>
+struct mapping_range
 {
     using key_type = K;
     using mapped_type = V;
     std::pair<K, V> const* begin() const;
     std::pair<K, V> const* end() const;
-
-    using dummy_mapping_container<K, V>::dummy_mapping_container;
-
-    std::pair<std::pair<K, V> const*, bool> try_emplace(K&&, V&&);
-    std::pair<std::pair<K, V> const*, bool> insert_or_assign(K&&, V&&);
-};
-
-
-template<class T>
-concept default_back_emplaceable = requires(T c) {
-    std::forward<T>(c).emplace_back();
-};
-
-template<class T>
-concept back_emplaceable =
-    requires(T c, std::ranges::range_value_t<std::remove_cvref_t<T>> v) {
-        std::forward<T>(c).emplace_back(std::move(v));
-    } &&
-    (
-        !std::default_initializable<std::ranges::range_value_t<std::remove_cvref_t<T>>> ||
-        default_back_emplaceable<T>
-    );
-
-template<class T>
-concept default_emplaceable = requires(T c) {
-    std::forward<T>(c).emplace();
+    ~mapping_range() = delete;
 };
 
-template<class T>
-concept emplaceable =
-    requires(T c, std::ranges::range_value_t<std::remove_cvref_t<T>> v) {
-        std::forward<T>(c).emplace(std::move(v));
-    } &&
-    (
-        !std::default_initializable<std::ranges::range_value_t<std::remove_cvref_t<T>>> ||
-        default_emplaceable<T>
-    );
-
-template<class T>
-concept growable_array_writable = back_emplaceable<T> || emplaceable<T>;
-
-template<class T>
-struct dummy_growable_array
-{
-    T const* begin() const;
-    T const* end() const;
-    void emplace_back(T&&);
-    void emplace_back() requires std::default_initializable<T>;
-};
-
-template<class T>
-concept fixed_array_writable =
-    !growable_array_writable<T> &&
-    std::ranges::forward_range<T> &&
-    std::ranges::sized_range<T> &&
-    std::is_lvalue_reference_v<std::ranges::range_reference_t<T>> &&
-    !std::is_const_v<std::remove_reference_t<std::ranges::range_reference_t<T>>> &&
-    std::is_move_assignable_v<std::remove_cvref_t<std::ranges::range_value_t<T>>>;
-
-template<class T>
-using dummy_fixed_array = T[1];
-
-} // iris::ranges
+} // iris::ranges::dummy
 
 #endif
diff --git a/include/iris/requirements.hpp b/include/iris/requirements.hpp
index 6a43bda..c120633 100644
--- a/include/iris/requirements.hpp
+++ b/include/iris/requirements.hpp
@@ -28,6 +28,12 @@ concept boolean_testable = detail::boolean_testable_impl<T> && requires(T&& t) {
     { !std::forward<T>(t) } -> detail::boolean_testable_impl;
 };
 
+template<class T, class U>
+concept half_equality_comparable = requires(std::remove_reference_t<T> const& a, std::remove_reference_t<U> const& b) {
+    { a == b } -> boolean_testable;
+    { a != b } -> boolean_testable;
+};
+
 // https://eel.is/c++draft/utility.arg.requirements#tab:cpp17.equalitycomparable
 template<class T>
 concept Cpp17EqualityComparable =
diff --git a/include/iris/run_length_sequence.hpp b/include/iris/run_length_sequence.hpp
new file mode 100644
index 0000000..46f2965
--- /dev/null
+++ b/include/iris/run_length_sequence.hpp
@@ -0,0 +1,680 @@
+#ifndef IRIS_ZZ_RUN_LENGTH_SEQUENCE_HPP
+#define IRIS_ZZ_RUN_LENGTH_SEQUENCE_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+#include <iris/indexed_value.hpp>
+#include <iris/interval.hpp>
+
+#include <iris/error/throwf.hpp>
+
+#include <iris/default_init_allocator.hpp>
+#include <iris/ranges.hpp>
+#include <iris/container_traits.hpp>
+#include <iris/requirements.hpp>
+#include <iris/type_traits.hpp>
+
+#include <algorithm>
+#include <vector>
+#include <ranges>
+#include <iterator>
+#include <limits>
+#include <stdexcept>
+#include <utility>
+#include <concepts>
+#include <type_traits>
+
+#include <cstddef> // IWYU pragma: keep
+#include <cassert>
+
+namespace iris::detail {
+struct run_length_sequence_comp;
+} // iris::detail
+
+namespace iris {
+
+template<class T, class IndexT>
+struct run_length_run_ref
+{
+    T const& value;
+    interval<IndexT> span;
+};
+
+// A compressed bidirectional container that holds only one instance of `T`
+// per each adjacent equivalent elements.
+//
+// Invariant: adjacent runs never compare equal. This makes the representation
+// canonical, which `operator==` relies on.
+//
+// Iterator invalidation does not follow `RunContainerT`: any insertion that starts a
+// new run may invalidate all iterators, regardless of `RunContainerT`. Reference
+// stability of the elements follows `RunContainerT`.
+//
+// Precondition for heterogeneous comparison: `e == value` must hold iff
+// `e == T(value)`; otherwise the run structure would depend on which overload
+// of `emplace_back` (or relevant insertion members) was chosen.
+//
+// When inserting an element, `run_length_sequence` does lazy construction of the
+// actual element object iff heterogeneous comparison is supported for the given
+// type `U`; otherwise,
+//   - If `RunContainerT` supports `runs_.pop_back()` or `runs_.erase(iterator to the
+//     last inserted element)`, the element is first constructed in-place and
+//     the resulting object is used for comparison; when the comparison holds, the
+//     last element is popped back or erased. Otherwise,
+//
+//   - The element is first constructed as a local variable `temp` and is used for
+//     comparison; when the comparison does not hold, the object is move-inserted
+//     into `RunContainerT` as if by `runs_.emplace_back(std::forward<T>(temp))`.
+//
+// Internal structure is maintained with two independent containers, where the first
+// container holds one element instance per each run and the other one holds the
+// *offsets* that represent each insertion of elements.
+//
+// For example, when items are emplaced in this order:
+//   A A A B B C C C C
+//
+// then the internal state is:
+//   runs_:
+//     [A] [B] [C]
+//
+//   offsets_:
+//     [0] [3] [5] [9 /* sentinel */]
+template<
+    class T,
+    class IndexT = unsigned,
+    template<class, class> class IndexedValuePairTT = indexed_value,
+    class RunContainerT = std::vector<T>
+>
+class run_length_sequence
+{
+public:
+    static_assert(!std::is_const_v<T>);
+    static_assert(unsigned_numeric_integral<IndexT> && !std::is_const_v<IndexT>);
+    static_assert(sizeof(IndexT) >= sizeof(int), "Small index type has no practical benefit");
+    static_assert(!std::is_const_v<RunContainerT>);
+
+    using size_type = std::common_type_t<std::size_t, IndexT>;
+    using difference_type = std::ptrdiff_t;
+
+    [[nodiscard]] static constexpr size_type max_size() noexcept
+    {
+        constexpr auto a = std::numeric_limits<IndexT>::max();
+        constexpr auto b = std::numeric_limits<difference_type>::max();
+        return std::cmp_less(b, a) ? static_cast<size_type>(b) : static_cast<size_type>(a);
+    }
+
+private:
+    using offsets_type = std::vector<IndexT, default_init_allocator<IndexT>>;
+
+    struct iterator_impl
+    {
+    private:
+        using value_iterator = std::ranges::iterator_t<RunContainerT const>;
+        using offset_iterator = offsets_type::const_iterator;
+
+    public:
+        using iterator_concept = std::bidirectional_iterator_tag;
+        using iterator_category = std::input_iterator_tag; // Our reference type is proxy, so this can only be input
+
+        using value_type = IndexedValuePairTT<
+            IndexT,
+            std::iter_value_t<value_iterator>
+        >;
+        using reference = IndexedValuePairTT<
+            IndexT,
+            std::iter_reference_t<value_iterator>
+        >;
+        using difference_type = run_length_sequence::difference_type;
+
+        constexpr iterator_impl() noexcept = default;
+
+        constexpr explicit iterator_impl(value_iterator value_it, offset_iterator ofs_it) noexcept
+            : value_it_(std::move(value_it))
+            , ofs_it_(std::move(ofs_it))
+        {}
+
+        constexpr explicit iterator_impl(value_iterator value_it, offset_iterator ofs_it, IndexT pos) noexcept
+            : value_it_(std::move(value_it))
+            , ofs_it_(std::move(ofs_it))
+            , rel_pos_(pos)
+        {}
+
+        [[nodiscard]] constexpr reference operator*() const noexcept
+        {
+            return {index(), *value_it_};
+        }
+
+        constexpr iterator_impl& operator++() noexcept
+        {
+            auto ofs_next = std::next(ofs_it_);
+            if (++rel_pos_ == *ofs_next - *ofs_it_) {
+                ofs_it_ = std::move(ofs_next);
+                rel_pos_ = static_cast<IndexT>(0u);
+                ++value_it_;
+            }
+            return *this;
+        }
+
+        [[nodiscard]] constexpr iterator_impl operator++(int) noexcept
+        {
+            auto temp{*this};
+            ++*this;
+            return temp;
+        }
+
+        constexpr iterator_impl& operator--() noexcept
+        {
+            if (rel_pos_ != static_cast<IndexT>(0u)) {
+                --rel_pos_;
+                return *this;
+            }
+
+            auto const current_ofs = *ofs_it_--;
+            rel_pos_ = current_ofs - *ofs_it_ - static_cast<IndexT>(1u);
+            --value_it_;
+            return *this;
+        }
+
+        [[nodiscard]] constexpr iterator_impl operator--(int) noexcept
+        {
+            auto temp{*this};
+            --*this;
+            return temp;
+        }
+
+        [[nodiscard]] constexpr bool operator==(iterator_impl const&) const noexcept = default;
+
+        [[nodiscard]] friend constexpr difference_type operator-(iterator_impl const& a, iterator_impl const& b) noexcept
+        {
+            if (a == b) return 0;
+            return static_cast<difference_type>(a.index()) - static_cast<difference_type>(b.index());
+        }
+
+    private:
+        [[nodiscard]] constexpr IndexT index() const noexcept
+        {
+            return static_cast<IndexT>(*ofs_it_ + rel_pos_);
+        }
+
+        value_iterator value_it_{};
+        offset_iterator ofs_it_{};
+        IndexT rel_pos_{};
+    };
+
+#ifdef NDEBUG
+# define IRIS_ZZ_RUN_LENGTH_SEQUENCE_INVARIANT_GUARD
+#else
+# define IRIS_ZZ_RUN_LENGTH_SEQUENCE_INVARIANT_GUARD [[maybe_unused]] check_invariant_guard invariant_guard_{this};
+#endif
+
+public:
+    using item_type = T;
+    using index_type = IndexT;
+    using run_container_type = RunContainerT;
+    using allocator_type = run_container_type::allocator_type;
+    using run_ref = run_length_run_ref<T, IndexT>;
+
+    using value_type = IndexedValuePairTT<IndexT, T>;
+    using const_reference = IndexedValuePairTT<IndexT, T const&>;
+    using reference = const_reference;
+
+    using const_iterator = iterator_impl;
+    using iterator = const_iterator;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    constexpr run_length_sequence() = default;
+
+    constexpr explicit run_length_sequence(allocator_type const& alloc) noexcept
+        : runs_(alloc)
+    {}
+
+    template<container::compatible_range<T> R>
+    constexpr run_length_sequence(std::from_range_t, R&& r, allocator_type const& alloc = allocator_type())
+        : runs_(alloc)
+    {
+        for (auto&& elem : r) {
+            this->emplace_back(std::forward<decltype(elem)>(elem));
+        }
+    }
+
+    template<container::compatible_iterator<T> It, std::sentinel_for<It> Se>
+    constexpr run_length_sequence(It it, Se se, allocator_type const& alloc = allocator_type())
+        : runs_(alloc)
+    {
+        for (; it != se; ++it) {
+            this->emplace_back(*it);
+        }
+    }
+
+    constexpr run_length_sequence(std::initializer_list<T> il, allocator_type const& alloc = allocator_type())
+        : run_length_sequence(il.begin(), il.end(), alloc)
+    {}
+
+    [[nodiscard]] constexpr const_iterator begin() const noexcept { check_range_concepts(); return const_iterator{std::ranges::begin(runs_), offsets_.begin()}; }
+    [[nodiscard]] constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+    [[nodiscard]] constexpr const_iterator end() const noexcept
+    {
+        check_range_concepts();
+        if (offsets_.empty()) {
+            assert(std::ranges::empty(runs_));
+            return const_iterator{std::ranges::end(runs_), offsets_.end()};
+        } else {
+            assert(offsets_.size() >= 2);
+            return const_iterator{std::ranges::end(runs_), std::prev(offsets_.end())};
+        }
+    }
+    [[nodiscard]] constexpr const_iterator cend() const noexcept { return end(); }
+
+    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator{end()}; }
+    [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept { return const_reverse_iterator{begin()}; }
+    [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept { return rend(); }
+
+    [[nodiscard]] constexpr bool empty() const noexcept
+    {
+        static_assert(std::ranges::sized_range<RunContainerT>);
+        assert(std::ranges::empty(runs_) == offsets_.empty());
+        return offsets_.empty();
+    }
+
+    [[nodiscard]] constexpr size_type size() const noexcept
+    {
+        static_assert(std::ranges::sized_range<RunContainerT>);
+        if (offsets_.empty()) return 0uz;
+        assert(!std::ranges::empty(runs_));
+        assert(offsets_.size() >= 2);
+        return static_cast<size_type>(offsets_.back());
+    }
+
+    constexpr void clear() noexcept
+        requires requires(RunContainerT& runs) { runs.clear(); }
+    {
+        static_assert(req::Cpp17Destructible<T>);
+        IRIS_ZZ_RUN_LENGTH_SEQUENCE_INVARIANT_GUARD
+        runs_.clear();
+        offsets_.clear();
+    }
+
+    [[nodiscard]] constexpr const_reference front() const noexcept IRIS_LIFETIMEBOUND
+    {
+        assert(!this->empty());
+        return {static_cast<IndexT>(0u), container::front(runs_)};
+    }
+    [[nodiscard]] constexpr const_reference back() const noexcept IRIS_LIFETIMEBOUND
+    {
+        assert(!this->empty());
+        return {static_cast<IndexT>(offsets_.back() - static_cast<IndexT>(1u)), container::back(runs_)};
+    }
+
+    template<class U>
+        requires std::constructible_from<T, U> && req::half_equality_comparable<T, U>
+    constexpr const_reference emplace_back(U&& value) IRIS_LIFETIMEBOUND
+    {
+        check_range_concepts();
+        static_assert(std::equality_comparable<T>);
+        IRIS_ZZ_RUN_LENGTH_SEQUENCE_INVARIANT_GUARD
+
+        if (offsets_.empty()) {
+            return this->emplace_back_on_empty(std::forward<U>(value));
+
+        } else {
+            assert(!std::ranges::empty(runs_));
+            assert(offsets_.size() >= 2);
+            if (offsets_.back() == max_size()) {
+                throwf<std::length_error>("run_length_sequence capacity exceeded");
+            }
+
+            if (container::back(std::as_const(runs_)) == std::as_const(value)) {
+                // Equivalent element already exists; no need to insert.
+                return {offsets_.back()++, container::back(runs_)};
+            }
+            // Need to insert new element
+            auto const new_pos = offsets_.back();
+            offsets_.emplace_back(new_pos + static_cast<IndexT>(1u)); // new sentinel
+            [[maybe_unused]] ofs_insertion_guard<false> ofs_insertion_guard{this};
+            auto& elem = container::append_return(runs_, std::forward<U>(value));
+            ofs_insertion_guard.clear();
+            return {new_pos, elem};
+        }
+    }
+
+    template<class... Args>
+        requires std::constructible_from<T, Args...>
+    constexpr const_reference emplace_back(Args&&... args) IRIS_LIFETIMEBOUND
+    {
+        check_range_concepts();
+        static_assert(std::equality_comparable<T>);
+        IRIS_ZZ_RUN_LENGTH_SEQUENCE_INVARIANT_GUARD
+
+        if (offsets_.empty()) {
+            return this->emplace_back_on_empty(std::forward<Args>(args)...);
+
+        } else {
+            assert(!std::ranges::empty(runs_));
+            assert(offsets_.size() >= 2);
+            if (offsets_.back() == max_size()) {
+                throwf<std::length_error>("run_length_sequence capacity exceeded");
+            }
+            if constexpr (requires { container::erase_back(runs_); }) {
+                auto& elem = container::append_return(runs_, std::forward<Args>(args)...);
+                [[maybe_unused]] elem_insertion_guard elem_insertion_guard{this};
+
+                auto const prev_it = std::ranges::prev(std::ranges::end(runs_), 2);
+
+                if (std::as_const(*prev_it) == std::as_const(elem)) {
+                    // Equivalent element already exists; no need to insert.
+                    elem_insertion_guard.clear();
+                    container::erase_back(runs_);
+                    return {offsets_.back()++, container::back(runs_)};
+                }
+
+                // Need to insert new element
+                auto const new_pos = offsets_.back();
+                offsets_.emplace_back(new_pos + static_cast<IndexT>(1u)); // new sentinel
+                elem_insertion_guard.clear();
+                return {new_pos, elem};
+
+            } else {
+                T temp(std::forward<Args>(args)...);
+                if (container::back(std::as_const(runs_)) == std::as_const(temp)) {
+                    // Equivalent element already exists; no need to insert.
+                    return {offsets_.back()++, container::back(runs_)};
+                }
+                // Need to insert new element
+                auto const new_pos = offsets_.back();
+                offsets_.emplace_back(new_pos + static_cast<IndexT>(1u)); // new sentinel
+                [[maybe_unused]] ofs_insertion_guard<false> ofs_insertion_guard{this};
+                auto& elem = container::append_return(runs_, std::move(temp));
+                ofs_insertion_guard.clear();
+                return {new_pos, elem};
+            }
+        }
+    }
+
+    // Offers heterogeneous comparison benefit
+    template<class U>
+        requires
+            (!std::same_as<std::remove_cvref_t<U>, T>) &&
+            std::constructible_from<T, U>
+    constexpr const_reference push_back(U&& value_like) IRIS_LIFETIMEBOUND
+    {
+        return this->emplace_back(std::forward<U>(value_like));
+    }
+    constexpr const_reference push_back(T const& value) IRIS_LIFETIMEBOUND
+    {
+        return this->emplace_back(value);
+    }
+    constexpr const_reference push_back(T&& value) IRIS_LIFETIMEBOUND
+    {
+        return this->emplace_back(std::move(value));
+    }
+
+    constexpr void pop_back()
+        noexcept(noexcept(container::erase_back(runs_)))
+        requires requires(RunContainerT& runs) { container::erase_back(runs); }
+    {
+        static_assert(req::Cpp17Destructible<T>);
+        IRIS_ZZ_RUN_LENGTH_SEQUENCE_INVARIANT_GUARD
+        assert(!this->empty());
+        assert(offsets_.size() >= 2);
+
+        auto const n = offsets_.size();
+        if (offsets_[n - 1] - offsets_[n - 2] == static_cast<IndexT>(1u)) {
+            container::erase_back(runs_);
+            offsets_.pop_back();
+            if (offsets_.size() == 1) {
+                offsets_.clear(); // remove sentinel
+            }
+
+        } else {
+            --offsets_.back();
+        }
+    }
+
+    constexpr void shrink_to_fit()
+    {
+        if constexpr (container::has_shrink_to_fit<RunContainerT>) {
+            runs_.shrink_to_fit();
+        }
+        offsets_.shrink_to_fit();
+    }
+
+    template<container::compatible_range<T> R>
+    constexpr void append_range(R&& r)
+    {
+        for (auto it = std::ranges::begin(r); it != std::ranges::end(r); ++it) {
+            this->emplace_back(*it);
+        }
+    }
+
+    // ---------------------------------------------------------------------
+
+    [[nodiscard]] constexpr RunContainerT const& runs() const noexcept
+    {
+        return runs_;
+    }
+
+    [[nodiscard]] constexpr size_type run_count() const noexcept
+    {
+        static_assert(std::ranges::sized_range<RunContainerT>);
+        return static_cast<size_type>(std::ranges::size(runs_));
+    }
+
+    [[nodiscard]] constexpr auto run_view() const noexcept
+    {
+        check_range_concepts();
+        return std::views::zip_transform(
+            [](T const& value, auto const& bounds) noexcept -> run_ref {
+                return {value, interval<IndexT>{std::get<0>(bounds), std::get<1>(bounds)}};
+            },
+            runs_, offsets_ | std::views::pairwise
+        );
+    }
+
+    // ---------------------------------------------------------------------
+
+    // Returns an iterator to the element at logical position `pos`, or `end()`
+    // when `pos >= size()`.
+    //
+    // Complexity: O(log run_count()) for locating the run, plus the cost of
+    // advancing an iterator of `RunContainerT` by the run index (O(1) when
+    // `RunContainerT` is random access).
+    [[nodiscard]] constexpr const_iterator nth(IndexT pos) const noexcept
+    {
+        check_range_concepts();
+        if (pos >= this->size()) return this->end();
+
+        auto const ofs_next = std::ranges::upper_bound(offsets_, pos);
+        assert(ofs_next != offsets_.begin());
+        assert(ofs_next != offsets_.end());
+        auto const ofs_it = std::ranges::prev(ofs_next);
+
+        auto const run_index = ofs_it - offsets_.begin();
+        auto const value_it = std::ranges::next(std::ranges::begin(runs_), run_index);
+
+        return const_iterator{value_it, ofs_it, static_cast<IndexT>(pos - *ofs_it)};
+    }
+
+    // ---------------------------------------------------------------------
+
+    constexpr void swap(run_length_sequence& other)
+        noexcept(std::is_nothrow_swappable_v<RunContainerT> && std::is_nothrow_swappable_v<offsets_type>)
+    {
+        using std::swap;
+        swap(runs_, other.runs_);
+        swap(offsets_, other.offsets_);
+    }
+
+private:
+    static constexpr void check_range_concepts() noexcept
+    {
+        static_assert(std::ranges::bidirectional_range<RunContainerT>);
+        static_assert(std::same_as<std::ranges::range_value_t<RunContainerT>, T>);
+        static_assert(std::same_as<std::ranges::range_reference_t<RunContainerT>, T&>);
+        static_assert(std::same_as<std::ranges::range_reference_t<RunContainerT const>, T const&>);
+
+        static_assert(container::back_pushable<RunContainerT, T>);
+        static_assert(container::back_accessible<RunContainerT>);
+        static_assert(container::front_accessible<RunContainerT>);
+
+        static_assert(requires (RunContainerT& runs) {
+            { container::back(runs) } -> std::same_as<T&>;
+            { container::front(runs) } -> std::same_as<T&>;
+        });
+    }
+
+    template<class... Args>
+    constexpr const_reference emplace_back_on_empty(Args&&... args) IRIS_LIFETIMEBOUND
+    {
+        assert(this->empty());
+        [[maybe_unused]] ofs_insertion_guard<true> ofs_insertion_guard{this};
+        offsets_.emplace_back(static_cast<IndexT>(0u));
+        offsets_.emplace_back(static_cast<IndexT>(1u)); // sentinel
+        auto& elem = container::append_return(runs_, std::forward<Args>(args)...);
+        ofs_insertion_guard.clear();
+        return {static_cast<IndexT>(0u), elem};
+    }
+
+    template<bool WasEmpty>
+    struct [[nodiscard]] ofs_insertion_guard
+    {
+        constexpr explicit ofs_insertion_guard(run_length_sequence* self) noexcept
+            : self_(self)
+        {}
+
+        constexpr void clear() noexcept
+        {
+            self_ = nullptr;
+        }
+
+        constexpr ~ofs_insertion_guard() noexcept
+        {
+            if (!self_) return;
+            if constexpr (WasEmpty) {
+                self_->offsets_.clear();
+            } else {
+                self_->offsets_.pop_back();
+            }
+        }
+
+    private:
+        run_length_sequence* self_;
+    };
+    template<bool WasEmpty>
+    friend struct ofs_insertion_guard;
+
+    struct [[nodiscard]] elem_insertion_guard
+    {
+        constexpr explicit elem_insertion_guard(run_length_sequence* self) noexcept
+            : self_(self)
+        {}
+
+        constexpr void clear() noexcept
+        {
+            self_ = nullptr;
+        }
+
+        constexpr ~elem_insertion_guard() noexcept
+        {
+            if (!self_) return;
+            container::erase_back(self_->runs_);
+        }
+
+    private:
+        run_length_sequence* self_;
+    };
+    friend struct elem_insertion_guard;
+
+#ifndef NDEBUG
+    struct [[nodiscard]] check_invariant_guard
+    {
+        constexpr explicit check_invariant_guard(run_length_sequence const* self) noexcept
+            : self_(self)
+        {}
+
+        constexpr ~check_invariant_guard() noexcept
+        {
+            auto const& offsets = self_->offsets_;
+            auto const& runs = self_->runs_;
+            if (offsets.empty()) {
+                assert(std::ranges::empty(runs));
+                return;
+            }
+            assert(offsets.size() >= 2);
+            assert(offsets.size() == std::ranges::size(runs) + 1);
+            assert(offsets.front() == static_cast<IndexT>(0u));
+            auto const n = offsets.size();
+            assert(offsets[n - 2] < offsets[n - 1]);
+
+            // Adjacent runs must differ
+            if (n >= 3) {
+                auto const last = std::ranges::prev(std::ranges::end(runs));
+                auto const before_last = std::ranges::prev(last);
+                assert(!(*before_last == *last));
+            }
+        }
+
+    private:
+        run_length_sequence const* self_;
+    };
+    friend struct check_invariant_guard;
+#endif
+
+    friend struct detail::run_length_sequence_comp;
+
+    RunContainerT runs_;
+    offsets_type offsets_;
+
+#undef IRIS_ZZ_RUN_LENGTH_SEQUENCE_INVARIANT_GUARD
+};
+
+template<class T, class IndexT, template<class, class> class IndexedValuePairTT, class RunContainerT>
+constexpr void swap(
+    run_length_sequence<T, IndexT, IndexedValuePairTT, RunContainerT>& a,
+    run_length_sequence<T, IndexT, IndexedValuePairTT, RunContainerT>& b
+)
+    noexcept(noexcept(a.swap(b)))
+{
+    a.swap(b);
+}
+
+
+namespace detail {
+
+struct run_length_sequence_comp
+{
+    template<class T, class IndexT, template<class, class> class IndexedValuePairTT, class RunContainerT>
+    [[nodiscard]] static constexpr bool
+    equals(
+        run_length_sequence<T, IndexT, IndexedValuePairTT, RunContainerT> const& a,
+        run_length_sequence<T, IndexT, IndexedValuePairTT, RunContainerT> const& b
+    )
+        noexcept(noexcept(std::declval<T const&>() == std::declval<T const&>()))
+    {
+        static_assert(std::equality_comparable<T>);
+        static_assert(std::equality_comparable<RunContainerT>);
+        // Adjacent runs never compare equal (class invariant), so the representation
+        // is canonical and representational equality is logical equality.
+        return a.offsets_ == b.offsets_ && a.runs_ == b.runs_;
+    }
+};
+
+} // detail
+
+template<class T, class IndexT, template<class, class> class IndexedValuePairTT, class RunContainerT>
+[[nodiscard]] constexpr bool
+operator==(
+    run_length_sequence<T, IndexT, IndexedValuePairTT, RunContainerT> const& a,
+    run_length_sequence<T, IndexT, IndexedValuePairTT, RunContainerT> const& b
+)
+    noexcept(noexcept(detail::run_length_sequence_comp::equals(a, b)))
+{
+    return detail::run_length_sequence_comp::equals(a, b);
+}
+
+} // iris
+
+#endif
diff --git a/include/iris/type_traits.hpp b/include/iris/type_traits.hpp
index 06b93cb..6f0a51f 100644
--- a/include/iris/type_traits.hpp
+++ b/include/iris/type_traits.hpp
@@ -18,6 +18,25 @@
 
 namespace iris {
 
+template<class T>
+concept signed_numeric_integral =
+    std::signed_integral<T> &&
+    !std::same_as<std::remove_cv_t<T>, char> &&
+    !std::same_as<std::remove_cv_t<T>, wchar_t>;
+
+template<class T>
+concept unsigned_numeric_integral =
+    std::unsigned_integral<T> &&
+    !std::same_as<std::remove_cv_t<T>, bool> &&
+    !std::same_as<std::remove_cv_t<T>, char> &&
+    !std::same_as<std::remove_cv_t<T>, wchar_t> &&
+    !std::same_as<std::remove_cv_t<T>, char8_t> &&
+    !std::same_as<std::remove_cv_t<T>, char16_t> &&
+    !std::same_as<std::remove_cv_t<T>, char32_t>;
+
+template<class T>
+concept numeric_integral = signed_numeric_integral<T> || unsigned_numeric_integral<T>;
+
 template<class T>
 struct remove_cv
 {
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 6d72e40..ead5c33 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -183,6 +183,7 @@ if(PROJECT_IS_TOP_LEVEL)
             core
             type_traits
             ranges
+            container_traits
             stdint
             enum
             indirect
@@ -196,6 +197,8 @@ if(PROJECT_IS_TOP_LEVEL)
             alloy
             alloy_visit
             marshal
+            indexed_value
+            run_length_sequence
         )
         foreach(test_name IN LISTS IRIS_TEST_IRIS_TESTS)
             iris_define_internal_test(${test_name} ${test_name}.cpp)
diff --git a/test/container_traits.cpp b/test/container_traits.cpp
new file mode 100644
index 0000000..4fdfb88
--- /dev/null
+++ b/test/container_traits.cpp
@@ -0,0 +1,800 @@
+// SPDX-License-Identifier: MIT
+
+#include "iris_test.hpp"
+
+#include <iris/iterator.hpp>
+#include <iris/ranges.hpp>
+#include <iris/container_traits.hpp>
+
+#include <format>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <deque>
+#include <set>
+#include <array>
+#include <map>
+#include <unordered_set> // TODO
+#include <unordered_map>
+#include <flat_map>
+#include <span>
+#include <iterator>
+#include <ranges>
+#include <algorithm>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+using namespace std::string_view_literals;
+using namespace std::string_literals;
+
+TEST_CASE("container: map")
+{
+    STATIC_CHECK(iris::ranges::key_value_range<std::map<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<std::map<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<std::map<int, int>>);
+    STATIC_CHECK(iris::container::unique_mapping_container<std::map<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<std::multimap<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<std::multimap<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<std::multimap<int, int>>);
+    STATIC_CHECK(!iris::container::unique_mapping_container<std::multimap<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<std::unordered_map<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<std::unordered_map<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<std::unordered_map<int, int>>);
+    STATIC_CHECK(iris::container::unique_mapping_container<std::unordered_map<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<std::unordered_multimap<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<std::unordered_multimap<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<std::unordered_multimap<int, int>>);
+    STATIC_CHECK(!iris::container::unique_mapping_container<std::unordered_multimap<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<std::flat_map<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<std::flat_map<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<std::flat_map<int, int>>);
+    STATIC_CHECK(iris::container::unique_mapping_container<std::flat_map<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<std::flat_multimap<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<std::flat_multimap<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<std::flat_multimap<int, int>>);
+    STATIC_CHECK(!iris::container::unique_mapping_container<std::flat_multimap<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<std::vector<std::pair<int, int>>>);
+    STATIC_CHECK(!iris::ranges::mapping_range<std::vector<std::pair<int, int>>>);
+    STATIC_CHECK(!iris::container::mapping_container<std::vector<std::pair<int, int>>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<std::vector<std::tuple<int, int>>>);
+    STATIC_CHECK(!iris::ranges::mapping_range<std::vector<std::tuple<int, int>>>);
+    STATIC_CHECK(!iris::container::mapping_container<std::vector<std::tuple<int, int>>>);
+}
+
+TEST_CASE("container: compatible range/iterator")
+{
+    static_assert(!std::is_constructible_v<std::vector<std::string>, std::from_range_t, std::vector<std::string_view>>);
+    STATIC_CHECK(iris::container::compatible_iterator<std::vector<std::string_view>::const_iterator, std::string>);
+
+    static_assert(std::is_constructible_v<std::vector<std::string>, std::vector<std::string_view>::const_iterator, std::vector<std::string_view>::const_iterator>);
+    STATIC_CHECK(!iris::container::compatible_range<std::vector<std::string_view>, std::string>);
+}
+
+TEST_CASE("container: member traits")
+{
+    STATIC_CHECK(iris::container::back_pushable<std::vector<int>>);
+    STATIC_CHECK(iris::container::back_pushable<std::vector<int>&>);
+    STATIC_CHECK(!iris::container::back_pushable<std::vector<int> const&>);
+    STATIC_CHECK(iris::container::growable_array<std::vector<int>>);
+    STATIC_CHECK(iris::container::growable_array<std::vector<int>&>);
+    STATIC_CHECK(!iris::container::growable_array<std::vector<int> const&>);
+    STATIC_CHECK(!iris::container::fixed_array<std::vector<int>>);
+
+    STATIC_CHECK(iris::container::appendable<std::set<int>>);
+    STATIC_CHECK(iris::container::appendable<std::set<int>&>);
+    STATIC_CHECK(!iris::container::appendable<std::set<int> const&>);
+    STATIC_CHECK(iris::container::growable_array<std::set<int>>);
+    STATIC_CHECK(iris::container::growable_array<std::set<int>&>);
+    STATIC_CHECK(!iris::container::growable_array<std::set<int> const&>);
+    STATIC_CHECK(!iris::container::fixed_array<std::set<int>>);
+
+    STATIC_CHECK(iris::container::fixed_array<int[5]>);
+    STATIC_CHECK(iris::container::fixed_array<int (&)[5]>);
+    STATIC_CHECK(!iris::container::fixed_array<int const (&)[5]>);
+    STATIC_CHECK(!iris::container::growable_array<int[5]>);
+
+    STATIC_CHECK(iris::container::fixed_array<std::array<int, 5>>);
+    STATIC_CHECK(iris::container::fixed_array<std::array<int, 5>&>);
+    STATIC_CHECK(!iris::container::fixed_array<std::array<int, 5> const&>);
+    STATIC_CHECK(!iris::container::growable_array<std::array<int, 5>>);
+
+    STATIC_CHECK(iris::container::fixed_array<std::span<int, 5>>);
+    STATIC_CHECK(iris::container::fixed_array<std::span<int, 5>&>);
+    STATIC_CHECK(iris::container::fixed_array<std::span<int, 5> const&>);
+    STATIC_CHECK(!iris::container::growable_array<std::span<int, 5>>);
+
+    STATIC_CHECK(!iris::container::fixed_array<std::span<int const, 5>>);
+    STATIC_CHECK(!iris::container::fixed_array<std::span<int const, 5>&>);
+    STATIC_CHECK(!iris::container::fixed_array<std::span<int const, 5> const&>);
+    STATIC_CHECK(!iris::container::growable_array<std::span<int const, 5>>);
+
+    STATIC_CHECK(iris::container::fixed_array<std::span<int>>);
+    STATIC_CHECK(iris::container::fixed_array<std::span<int>&>);
+    STATIC_CHECK(iris::container::fixed_array<std::span<int> const&>);
+    STATIC_CHECK(!iris::container::growable_array<std::span<int>>);
+}
+
+TEST_CASE("container: dummy types")
+{
+    STATIC_CHECK(iris::ranges::key_value_range<iris::ranges::dummy::key_value_range<int, int>>);
+    STATIC_CHECK(!iris::ranges::mapping_range<iris::ranges::dummy::key_value_range<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<iris::ranges::dummy::mapping_range<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<iris::ranges::dummy::mapping_range<int, int>>);
+    STATIC_CHECK(!iris::container::mapping_container<iris::ranges::dummy::mapping_range<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<iris::container::dummy::mapping_container<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<iris::container::dummy::mapping_container<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<iris::container::dummy::mapping_container<int, int>>);
+    STATIC_CHECK(!iris::container::unique_mapping_container<iris::container::dummy::mapping_container<int, int>>);
+
+    STATIC_CHECK(iris::ranges::key_value_range<iris::container::dummy::unique_mapping_container<int, int>>);
+    STATIC_CHECK(iris::ranges::mapping_range<iris::container::dummy::unique_mapping_container<int, int>>);
+    STATIC_CHECK(iris::container::mapping_container<iris::container::dummy::unique_mapping_container<int, int>>);
+    STATIC_CHECK(iris::container::unique_mapping_container<iris::container::dummy::unique_mapping_container<int, int>>);
+
+    STATIC_CHECK(iris::container::growable_array<iris::container::dummy::growable_array<int>>);
+    STATIC_CHECK(iris::container::fixed_array<iris::container::dummy::fixed_array<int>>);
+}
+
+
+struct recording_item
+{
+    [[nodiscard]] static recording_item make_moved(recording_item const& other)
+    {
+        return recording_item{"move[" + other.log + "]"};
+    }
+
+    recording_item()
+    {
+        log += "default";
+    }
+
+    recording_item(int a)
+    {
+        log += std::format("{}", a);
+    }
+
+    recording_item(int a, int b)
+    {
+        log += std::format("({},{})", a, b);
+    }
+
+    recording_item(recording_item const& other)
+    {
+        log = "copy[" + other.log + "]";
+    }
+
+    recording_item(recording_item&& other)  // NOLINT(cppcoreguidelines-noexcept-move-operations, performance-noexcept-move-constructor)
+    {
+        log = "move[" + other.log + "]";
+    }
+
+    recording_item& operator=(recording_item const&) = delete;
+    recording_item& operator=(recording_item&&) = default;
+
+    [[nodiscard]] bool operator==(recording_item const&) const = default;
+
+    std::string log;
+
+private:
+    explicit recording_item(std::string override_log)
+        : log(std::move(override_log))
+    {}
+};
+
+template<>
+struct std::formatter<recording_item> : std::formatter<std::string>
+{
+    auto format(recording_item const& rec, auto& ctx) const
+    {
+        return std::formatter<std::string>::format(rec.log, ctx);
+    }
+};
+
+template<bool IsFrontTest, class T, bool HasEmplaceMeow, bool HasPushMeow, bool HasEmplace, bool HasInsert>
+struct recording_container
+{
+    recording_container()
+    {
+        elems.reserve(100);
+    }
+
+    auto begin() const
+    {
+        if constexpr (IsFrontTest) {
+            return std::reverse_iterator{elems.end()};
+        } else {
+            return elems.begin();
+        }
+    }
+    auto begin()
+    {
+        if constexpr (IsFrontTest) {
+            return std::reverse_iterator{elems.end()};
+        } else {
+            return elems.begin();
+        }
+    }
+    auto end() const
+    {
+        if constexpr (IsFrontTest) {
+            return std::reverse_iterator{elems.begin()};
+        } else {
+            return elems.end();
+        }
+    }
+    auto end()
+    {
+        if constexpr (IsFrontTest) {
+            return std::reverse_iterator{elems.begin()};
+        } else {
+            return elems.end();
+        }
+    }
+
+    template<class... Args>
+    decltype(auto) emplace_front(Args&&... args) requires IsFrontTest && HasEmplaceMeow
+    {
+        log += " emplace_front";
+        return elems.emplace_back(std::forward<Args>(args)...);
+    }
+
+    void push_front(T const& value) requires IsFrontTest && HasPushMeow
+    {
+        log += " push_front";
+        elems.push_back(value);
+    }
+
+    void push_front(T&& value) requires IsFrontTest && HasPushMeow
+    {
+        log += " push_front";
+        elems.push_back(std::move(value));
+    }
+
+    template<class... Args>
+    decltype(auto) emplace_back(Args&&... args) requires (!IsFrontTest) && HasEmplaceMeow
+    {
+        log += " emplace_back";
+        return elems.emplace_back(std::forward<Args>(args)...);
+    }
+
+    void push_back(T const& value) requires (!IsFrontTest) && HasPushMeow
+    {
+        log += " push_back";
+        elems.push_back(value);
+    }
+
+    void push_back(T&& value) requires (!IsFrontTest) && HasPushMeow
+    {
+        log += " push_back";
+        elems.push_back(std::move(value));
+    }
+
+    template<class... Args>
+    auto emplace(auto it, Args&&... args) requires HasEmplace
+    {
+        log += " emplace";
+        if constexpr (IsFrontTest) {
+            return elems.emplace(it.base(), std::forward<Args>(args)...);
+        } else {
+            return elems.emplace(it, std::forward<Args>(args)...);
+        }
+    }
+
+    auto insert(auto it, T const& value) requires HasInsert
+    {
+        log += " insert";
+        if constexpr (IsFrontTest) {
+            return elems.insert(it.base(), value);
+        } else {
+            return elems.insert(it, value);
+        }
+    }
+
+    auto insert(auto it, T&& value) requires HasInsert
+    {
+        log += " insert";
+        if constexpr (IsFrontTest) {
+            return elems.insert(it.base(), std::move(value));
+        } else {
+            return elems.insert(it, std::move(value));
+        }
+    }
+
+    [[nodiscard]] std::string elems_str() const
+    {
+        return elems | std::views::transform([](T const& value) {
+            return std::format("{}", value);
+        }) | std::views::join_with("|"sv) | std::ranges::to<std::string>();
+    }
+
+    std::vector<T> elems;
+    std::string log;
+};
+
+static_assert(std::ranges::range<recording_container<true, int, true, true, true, true>>);
+static_assert(std::same_as<std::ranges::range_reference_t<recording_container<true, int, true, true, true, true>>, int&>);
+static_assert(std::same_as<std::ranges::range_reference_t<recording_container<true, int, true, true, true, true> const>, int const&>);
+
+TEST_CASE("container: prepend")
+{
+    {
+        // emplace_front + push_front + emplace + insert
+        using Cont = recording_container<true, recording_item, true, true, true, true>;
+
+        STATIC_CHECK(iris::container::front_pushable<Cont>);
+        STATIC_CHECK(iris::container::front_pushable<Cont, int>);
+        STATIC_CHECK(iris::container::front_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont, int>);
+        STATIC_CHECK(iris::container::prependable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::prepend(cont); cont_log_expected += " emplace_front"; elems_str_expected += "default";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::prepend(cont, 1); cont_log_expected += " emplace_front"; elems_str_expected += "|1";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::prepend(cont, 2, 3); cont_log_expected += " emplace_front"; elems_str_expected += "|(2,3)";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::prepend_return(cont); cont_log_expected += " emplace_front"; elems_str_expected += "|default";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{});
+        }
+        {
+            auto&& elem = iris::container::prepend_return(cont, 4); cont_log_expected += " emplace_front"; elems_str_expected += "|4";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{4});
+        }
+        {
+            auto&& elem = iris::container::prepend_return(cont, 5, 6); cont_log_expected += " emplace_front"; elems_str_expected += "|(5,6)";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{5, 6});
+        }
+    }
+    {
+        // push_front + emplace + insert
+        using Cont = recording_container<true, recording_item, false, true, true, true>;
+
+        STATIC_CHECK(!iris::container::front_pushable<Cont>);
+        STATIC_CHECK(iris::container::front_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::front_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont, int>);
+        STATIC_CHECK(iris::container::prependable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::prepend(cont); cont_log_expected += " emplace"; elems_str_expected += "default";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::prepend(cont, 1); cont_log_expected += " push_front"; elems_str_expected += "|move[1]";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::prepend(cont, 2, 3); cont_log_expected += " emplace"; elems_str_expected += "|(2,3)";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::prepend_return(cont); cont_log_expected += " emplace"; elems_str_expected += "|default";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{});
+        }
+        {
+            auto&& elem = iris::container::prepend_return(cont, 4); cont_log_expected += " push_front"; elems_str_expected += "|move[4]";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item::make_moved(recording_item{4}));
+        }
+        {
+            auto&& elem = iris::container::prepend_return(cont, 5, 6); cont_log_expected += " emplace"; elems_str_expected += "|(5,6)";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{5, 6});
+        }
+    }
+    {
+        // emplace + insert
+        using Cont = recording_container<true, recording_item, false, false, true, true>;
+
+        STATIC_CHECK(!iris::container::front_pushable<Cont>);
+        STATIC_CHECK(!iris::container::front_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::front_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont, int>);
+        STATIC_CHECK(iris::container::prependable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::prepend(cont); cont_log_expected += " emplace"; elems_str_expected += "default";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::prepend(cont, 1); cont_log_expected += " emplace"; elems_str_expected += "|1";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::prepend(cont, 2, 3); cont_log_expected += " emplace"; elems_str_expected += "|(2,3)";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::prepend_return(cont); cont_log_expected += " emplace"; elems_str_expected += "|default";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{});
+        }
+        {
+            auto&& elem = iris::container::prepend_return(cont, 4); cont_log_expected += " emplace"; elems_str_expected += "|4";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{4});
+        }
+        {
+            auto&& elem = iris::container::prepend_return(cont, 5, 6); cont_log_expected += " emplace"; elems_str_expected += "|(5,6)";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{5, 6});
+        }
+    }
+    {
+        // insert
+        using Cont = recording_container<true, recording_item, false, false, false, true>;
+
+        STATIC_CHECK(!iris::container::front_pushable<Cont>);
+        STATIC_CHECK(!iris::container::front_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::front_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont>);
+        STATIC_CHECK(iris::container::prependable<Cont, int>);
+        STATIC_CHECK(!iris::container::prependable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::prepend_return), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::prepend(cont); cont_log_expected += " insert"; elems_str_expected += "move[default]";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::prepend(cont, 1); cont_log_expected += " insert"; elems_str_expected += "|move[1]";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::prepend_return(cont); cont_log_expected += " insert"; elems_str_expected += "|move[default]";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item::make_moved(recording_item{}));
+        }
+        {
+            auto&& elem = iris::container::prepend_return(cont, 4); cont_log_expected += " insert"; elems_str_expected += "|move[4]";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item::make_moved(recording_item{4}));
+        }
+    }
+    {
+        // no accessor
+        using Cont = recording_container<true, recording_item, false, false, false, false>;
+
+        STATIC_CHECK(!iris::container::front_pushable<Cont>);
+        STATIC_CHECK(!iris::container::front_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::front_pushable<Cont, int, int>);
+
+        STATIC_CHECK(!iris::container::default_prependable<Cont>);
+        STATIC_CHECK(!iris::container::prependable<Cont>);
+        STATIC_CHECK(!iris::container::prependable<Cont, int>);
+        STATIC_CHECK(!iris::container::prependable<Cont, int, int>);
+
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend), Cont&>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend), Cont&, int, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend_return), Cont&>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend_return), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::prepend_return), Cont&, int, int>);
+    }
+}
+
+TEST_CASE("container: append")
+{
+    {
+        // emplace_back + push_back + emplace + insert
+        using Cont = recording_container<false, recording_item, true, true, true, true>;
+
+        STATIC_CHECK(iris::container::back_pushable<Cont>);
+        STATIC_CHECK(iris::container::back_pushable<Cont, int>);
+        STATIC_CHECK(iris::container::back_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont, int>);
+        STATIC_CHECK(iris::container::appendable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::append(cont); cont_log_expected += " emplace_back"; elems_str_expected += "default";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::append(cont, 1); cont_log_expected += " emplace_back"; elems_str_expected += "|1";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::append(cont, 2, 3); cont_log_expected += " emplace_back"; elems_str_expected += "|(2,3)";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::append_return(cont); cont_log_expected += " emplace_back"; elems_str_expected += "|default";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{});
+        }
+        {
+            auto&& elem = iris::container::append_return(cont, 4); cont_log_expected += " emplace_back"; elems_str_expected += "|4";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{4});
+        }
+        {
+            auto&& elem = iris::container::append_return(cont, 5, 6); cont_log_expected += " emplace_back"; elems_str_expected += "|(5,6)";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{5, 6});
+        }
+    }
+    {
+        // push_back + emplace + insert
+        using Cont = recording_container<false, recording_item, false, true, true, true>;
+
+        STATIC_CHECK(!iris::container::back_pushable<Cont>);
+        STATIC_CHECK(iris::container::back_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::back_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont, int>);
+        STATIC_CHECK(iris::container::appendable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::append(cont); cont_log_expected += " emplace"; elems_str_expected += "default";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::append(cont, 1); cont_log_expected += " push_back"; elems_str_expected += "|move[1]";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::append(cont, 2, 3); cont_log_expected += " emplace"; elems_str_expected += "|(2,3)";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::append_return(cont); cont_log_expected += " emplace"; elems_str_expected += "|default";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{});
+        }
+        {
+            auto&& elem = iris::container::append_return(cont, 4); cont_log_expected += " push_back"; elems_str_expected += "|move[4]";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item::make_moved(recording_item{4}));
+        }
+        {
+            auto&& elem = iris::container::append_return(cont, 5, 6); cont_log_expected += " emplace"; elems_str_expected += "|(5,6)";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{5, 6});
+        }
+    }
+    {
+        // emplace + insert
+        using Cont = recording_container<false, recording_item, false, false, true, true>;
+
+        STATIC_CHECK(!iris::container::back_pushable<Cont>);
+        STATIC_CHECK(!iris::container::back_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::back_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont, int>);
+        STATIC_CHECK(iris::container::appendable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::append(cont); cont_log_expected += " emplace"; elems_str_expected += "default";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::append(cont, 1); cont_log_expected += " emplace"; elems_str_expected += "|1";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::append(cont, 2, 3); cont_log_expected += " emplace"; elems_str_expected += "|(2,3)";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::append_return(cont); cont_log_expected += " emplace"; elems_str_expected += "|default";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{});
+        }
+        {
+            auto&& elem = iris::container::append_return(cont, 4); cont_log_expected += " emplace"; elems_str_expected += "|4";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{4});
+        }
+        {
+            auto&& elem = iris::container::append_return(cont, 5, 6); cont_log_expected += " emplace"; elems_str_expected += "|(5,6)";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item{5, 6});
+        }
+    }
+    {
+        // insert
+        using Cont = recording_container<false, recording_item, false, false, false, true>;
+
+        STATIC_CHECK(!iris::container::back_pushable<Cont>);
+        STATIC_CHECK(!iris::container::back_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::back_pushable<Cont, int, int>);
+
+        STATIC_CHECK(iris::container::default_appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont>);
+        STATIC_CHECK(iris::container::appendable<Cont, int>);
+        STATIC_CHECK(!iris::container::appendable<Cont, int, int>);
+
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append), Cont&, int, int>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&>);
+        STATIC_CHECK(std::invocable<decltype(iris::container::append_return), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append_return), Cont&, int, int>);
+
+        Cont cont;
+        std::string elems_str_expected;
+        std::string cont_log_expected;
+
+        iris::container::append(cont); cont_log_expected += " insert"; elems_str_expected += "move[default]";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        iris::container::append(cont, 1); cont_log_expected += " insert"; elems_str_expected += "|move[1]";
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        CHECK(cont.log == cont_log_expected);
+        REQUIRE(cont.elems_str() == elems_str_expected);
+
+        {
+            auto&& elem = iris::container::append_return(cont); cont_log_expected += " insert"; elems_str_expected += "|move[default]";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item::make_moved(recording_item{}));
+        }
+        {
+            auto&& elem = iris::container::append_return(cont, 4); cont_log_expected += " insert"; elems_str_expected += "|move[4]";
+            CHECK(cont.log == cont_log_expected);
+            REQUIRE(cont.elems_str() == elems_str_expected);
+            CHECK(elem == recording_item::make_moved(recording_item{4}));
+        }
+    }
+    {
+        // no accessor
+        using Cont = recording_container<false, recording_item, false, false, false, false>;
+
+        STATIC_CHECK(!iris::container::back_pushable<Cont>);
+        STATIC_CHECK(!iris::container::back_pushable<Cont, int>);
+        STATIC_CHECK(!iris::container::back_pushable<Cont, int, int>);
+
+        STATIC_CHECK(!iris::container::default_appendable<Cont>);
+        STATIC_CHECK(!iris::container::appendable<Cont>);
+        STATIC_CHECK(!iris::container::appendable<Cont, int>);
+        STATIC_CHECK(!iris::container::appendable<Cont, int, int>);
+
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append), Cont&>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append), Cont&, int, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append_return), Cont&>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append_return), Cont&, int>);
+        STATIC_CHECK(!std::invocable<decltype(iris::container::append_return), Cont&, int, int>);
+    }
+}
diff --git a/test/indexed_value.cpp b/test/indexed_value.cpp
new file mode 100644
index 0000000..412d41e
--- /dev/null
+++ b/test/indexed_value.cpp
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+
+#include "iris_test.hpp"
+
+#include <iris/indexed_value.hpp>
+
+#include <functional>
+#include <string>
+#include <concepts>
+#include <type_traits>
+
+using iris::indexed_value;
+
+TEST_CASE("indexed_value")
+{
+    using V =   indexed_value<int, std::string>;
+    //using CV =  indexed_value<int, std::string const>;
+    using LR =  indexed_value<int, std::string&>;
+    using CLR = indexed_value<int, std::string const&>;
+    using RR =  indexed_value<int, std::string&&>;
+    using CRR = indexed_value<int, std::string const&&>;
+
+    // ---------------------------------------------------
+
+    STATIC_CHECK(std::is_aggregate_v<V>);
+    STATIC_CHECK(std::is_aggregate_v<LR>);
+
+    STATIC_CHECK(std::is_trivially_copyable_v<indexed_value<int, int>>);
+    STATIC_CHECK(std::is_trivially_copyable_v<indexed_value<int, std::string&>>);
+    STATIC_CHECK(!std::is_trivially_copyable_v<indexed_value<int, std::string>>);
+
+    // ---------------------------------------------------
+
+    STATIC_CHECK(std::same_as<std::common_type_t<LR, LR>,   V>);
+    STATIC_CHECK(std::same_as<std::common_type_t<CLR, CLR>, V>);
+    STATIC_CHECK(std::same_as<std::common_type_t<RR, RR>,   V>);
+    STATIC_CHECK(std::same_as<std::common_type_t<CRR, CRR>, V>);
+
+    // ---------------------------------------------------
+
+    STATIC_CHECK(std::same_as<std::common_reference_t<LR&&, V&>,     std::common_reference_t<V&, LR&&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<LR&&, RR&&>,   std::common_reference_t<RR&&, LR&&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<CLR&&, CRR&&>, std::common_reference_t<CRR&&, CLR&&>>);
+
+    STATIC_CHECK(std::common_reference_with<LR&&, V&>);
+    STATIC_CHECK(std::common_reference_with<LR&&, RR&&>);
+    STATIC_CHECK(std::common_reference_with<RR&&, V const&>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<LR&&, V&>,       indexed_value<int const&, std::string&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<LR&&, RR&&>,     indexed_value<int&&, std::string const&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<RR&&, V const&>, indexed_value<int const&, std::string const&>>);
+
+    STATIC_CHECK(std::common_reference_with<CLR&&, V&>);
+    STATIC_CHECK(std::common_reference_with<CLR&&, CRR&&>);
+    STATIC_CHECK(std::common_reference_with<CRR&&, V const&>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<CLR&&, V&>,       indexed_value<int const&, std::string const&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<CLR&&, CRR&&>,    indexed_value<int&&, std::string const&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<CRR&&, V const&>, indexed_value<int const&, std::string const&>>);
+
+    // ---------------------------------------------------
+
+    STATIC_CHECK(std::same_as<
+        std::common_type_t<indexed_value<short, char>, indexed_value<int, long>>,
+        indexed_value<int, long>
+    >);
+
+    // ---------------------------------------------------
+
+    STATIC_CHECK(std::convertible_to<LR&,   indexed_value<int const&, std::string&>>);
+    STATIC_CHECK(std::convertible_to<LR&&,  indexed_value<int&&, std::string&>>);
+    STATIC_CHECK(std::convertible_to<RR&&,  indexed_value<int&&, std::string&&>>);
+    STATIC_CHECK(std::convertible_to<CRR&&, indexed_value<int const&&, std::string const&&>>);
+
+    // ---------------------------------------------------
+
+    STATIC_CHECK(std::same_as<decltype(get<0>(std::declval<V&>())),       int&>);
+    STATIC_CHECK(std::same_as<decltype(get<0>(std::declval<V const&>())), int const&>);
+    STATIC_CHECK(std::same_as<decltype(get<0>(std::declval<V&&>())),      int&&>);
+
+    STATIC_CHECK(std::same_as<decltype(get<1>(std::declval<V&>())),       std::string&>);
+    STATIC_CHECK(std::same_as<decltype(get<1>(std::declval<V const&>())), std::string const&>);
+    STATIC_CHECK(std::same_as<decltype(get<1>(std::declval<V&&>())),      std::string&&>);
+
+    STATIC_CHECK(std::same_as<decltype(get<1>(std::declval<LR&&>())),  std::string&>);
+    STATIC_CHECK(std::same_as<decltype(get<1>(std::declval<RR&&>())),  std::string&&>);
+    STATIC_CHECK(std::same_as<decltype(get<1>(std::declval<CLR&&>())), std::string const&>);
+
+    // ---------------------------------------------------
+
+    STATIC_CHECK(std::tuple_size_v<V> == 2);
+    STATIC_CHECK(std::same_as<std::tuple_element_t<0, V>, int>);
+    STATIC_CHECK(std::same_as<std::tuple_element_t<1, V>, std::string>);
+
+    STATIC_CHECK(std::same_as<std::tuple_element_t<1, LR>, std::string&>);
+    STATIC_CHECK(std::same_as<std::tuple_element_t<1, CLR>, std::string const&>);
+
+    {
+        std::string value{"foo"};
+        LR indexed{42, value};
+        CHECK(indexed == indexed);
+        CHECK((indexed <=> indexed) == std::strong_ordering::equal);
+        auto [index, element] = indexed;
+        CHECK(index == 42);
+        CHECK(&element == &value);
+    }
+}
+
+TEST_CASE("indexed_value: tuple/pair")
+{
+    STATIC_CHECK(std::equal_to{}(indexed_value<int, double>{}, indexed_value<int, double>{}));
+
+    STATIC_CHECK(std::equal_to{}(indexed_value<int, double>{}, std::tuple<int, double>{}));
+    STATIC_CHECK(std::equal_to{}(std::tuple<int, double>{}, indexed_value<int, double>{}));
+
+    STATIC_CHECK(std::equal_to{}(indexed_value<int, double>{}, std::pair<int, double>{}));
+    STATIC_CHECK(std::equal_to{}(std::pair<int, double>{}, indexed_value<int, double>{}));
+}
diff --git a/test/ranges.cpp b/test/ranges.cpp
index 08d69ba..fda8194 100644
--- a/test/ranges.cpp
+++ b/test/ranges.cpp
@@ -2,16 +2,15 @@
 
 #include "iris_test.hpp"
 
+#include <iris/iterator.hpp>
 #include <iris/ranges.hpp>
+#include <iris/container_traits.hpp>
 
+#include <tuple>
 #include <vector>
 #include <map>
-#include <unordered_map>
-#include <flat_map>
 #include <set>
 #include <utility>
-#include <span>
-#include <array>
 
 template<class KeyT, class ValueT>
 struct FakeNonRangeMap
@@ -64,48 +63,10 @@ struct FakeRangeMapWithNonTupleKey
     value_type const* end() const;
 };
 
-TEST_CASE("ranges: map related traits")
+TEST_CASE("ranges: as_map")
 {
     using iris::ranges::as_map;
 
-    STATIC_CHECK(iris::ranges::key_value_range<std::map<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<std::map<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<std::map<int, int>>);
-    STATIC_CHECK(iris::ranges::unique_mapping_container<std::map<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<std::multimap<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<std::multimap<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<std::multimap<int, int>>);
-    STATIC_CHECK(!iris::ranges::unique_mapping_container<std::multimap<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<std::unordered_map<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<std::unordered_map<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<std::unordered_map<int, int>>);
-    STATIC_CHECK(iris::ranges::unique_mapping_container<std::unordered_map<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<std::unordered_multimap<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<std::unordered_multimap<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<std::unordered_multimap<int, int>>);
-    STATIC_CHECK(!iris::ranges::unique_mapping_container<std::unordered_multimap<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<std::flat_map<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<std::flat_map<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<std::flat_map<int, int>>);
-    STATIC_CHECK(iris::ranges::unique_mapping_container<std::flat_map<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<std::flat_multimap<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<std::flat_multimap<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<std::flat_multimap<int, int>>);
-    STATIC_CHECK(!iris::ranges::unique_mapping_container<std::flat_multimap<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<std::vector<std::pair<int, int>>>);
-    STATIC_CHECK(!iris::ranges::mapping_range<std::vector<std::pair<int, int>>>);
-    STATIC_CHECK(!iris::ranges::mapping_container<std::vector<std::pair<int, int>>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<std::vector<std::tuple<int, int>>>);
-    STATIC_CHECK(!iris::ranges::mapping_range<std::vector<std::tuple<int, int>>>);
-    STATIC_CHECK(!iris::ranges::mapping_container<std::vector<std::tuple<int, int>>>);
-
     // ---------------------------------------------------
     // Viewed maps
     {
@@ -117,19 +78,19 @@ TEST_CASE("ranges: map related traits")
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<Map>() | filter)>);
             STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<Map>() | filter)>);
             STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<Map>() | filter | as_map)>);
-            STATIC_CHECK(!iris::ranges::mapping_container<decltype(std::declval<Map>() | filter | as_map)>);
+            STATIC_CHECK(!iris::container::mapping_container<decltype(std::declval<Map>() | filter | as_map)>);
 
             // Map&
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<Map&>() | filter)>);
             STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<Map&>() | filter)>);
             STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<Map&>() | filter | as_map)>);
-            STATIC_CHECK(!iris::ranges::mapping_container<decltype(std::declval<Map&>() | filter | as_map)>);
+            STATIC_CHECK(!iris::container::mapping_container<decltype(std::declval<Map&>() | filter | as_map)>);
 
             // Map const&
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<Map const&>() | filter)>);
             STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<Map const&>() | filter)>);
             STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<Map const&>() | filter | as_map)>);
-            STATIC_CHECK(!iris::ranges::mapping_container<decltype(std::declval<Map const&>() | filter | as_map)>);
+            STATIC_CHECK(!iris::container::mapping_container<decltype(std::declval<Map const&>() | filter | as_map)>);
         }
         {
             using PairVec = std::vector<std::pair<int, int>>;
@@ -141,7 +102,7 @@ TEST_CASE("ranges: map related traits")
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec>() | filter)>);
             STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<PairVec>() | filter)>);
             STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<PairVec>() | filter | as_map)>);
-            STATIC_CHECK(!iris::ranges::mapping_container<decltype(std::declval<PairVec>() | filter | as_map)>);
+            STATIC_CHECK(!iris::container::mapping_container<decltype(std::declval<PairVec>() | filter | as_map)>);
 
             // Map&
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec&>())>);
@@ -150,7 +111,7 @@ TEST_CASE("ranges: map related traits")
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec&>() | filter)>);
             STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<PairVec&>() | filter)>);
             STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<PairVec&>() | filter | as_map)>);
-            STATIC_CHECK(!iris::ranges::mapping_container<decltype(std::declval<PairVec&>() | filter | as_map)>);
+            STATIC_CHECK(!iris::container::mapping_container<decltype(std::declval<PairVec&>() | filter | as_map)>);
 
             // Map const&
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec const&>())>);
@@ -159,7 +120,7 @@ TEST_CASE("ranges: map related traits")
             STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec const&>() | filter)>);
             STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<PairVec const&>() | filter)>);
             STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<PairVec const&>() | filter | as_map)>);
-            STATIC_CHECK(!iris::ranges::mapping_container<decltype(std::declval<PairVec const&>() | filter | as_map)>);
+            STATIC_CHECK(!iris::container::mapping_container<decltype(std::declval<PairVec const&>() | filter | as_map)>);
         }
     }
 
@@ -184,69 +145,5 @@ TEST_CASE("ranges: map related traits")
     STATIC_CHECK(!iris::ranges::key_value_range<std::set<int>>);
 }
 
-TEST_CASE("ranges: container related traits")
-{
-    STATIC_CHECK(iris::ranges::back_emplaceable<std::vector<int>>);
-    STATIC_CHECK(iris::ranges::back_emplaceable<std::vector<int>&>);
-    STATIC_CHECK(!iris::ranges::back_emplaceable<std::vector<int> const&>);
-    STATIC_CHECK(iris::ranges::growable_array_writable<std::vector<int>>);
-    STATIC_CHECK(iris::ranges::growable_array_writable<std::vector<int>&>);
-    STATIC_CHECK(!iris::ranges::growable_array_writable<std::vector<int> const&>);
-    STATIC_CHECK(!iris::ranges::fixed_array_writable<std::vector<int>>);
-
-    STATIC_CHECK(iris::ranges::emplaceable<std::set<int>>);
-    STATIC_CHECK(iris::ranges::emplaceable<std::set<int>&>);
-    STATIC_CHECK(!iris::ranges::emplaceable<std::set<int> const&>);
-    STATIC_CHECK(iris::ranges::growable_array_writable<std::set<int>>);
-    STATIC_CHECK(iris::ranges::growable_array_writable<std::set<int>&>);
-    STATIC_CHECK(!iris::ranges::growable_array_writable<std::set<int> const&>);
-    STATIC_CHECK(!iris::ranges::fixed_array_writable<std::set<int>>);
-
-    STATIC_CHECK(iris::ranges::fixed_array_writable<int[5]>);
-    STATIC_CHECK(iris::ranges::fixed_array_writable<int (&)[5]>);
-    STATIC_CHECK(!iris::ranges::fixed_array_writable<int const (&)[5]>);
-    STATIC_CHECK(!iris::ranges::growable_array_writable<int[5]>);
-
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::array<int, 5>>);
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::array<int, 5>&>);
-    STATIC_CHECK(!iris::ranges::fixed_array_writable<std::array<int, 5> const&>);
-    STATIC_CHECK(!iris::ranges::growable_array_writable<std::array<int, 5>>);
-
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::span<int, 5>>);
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::span<int, 5>&>);
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::span<int, 5> const&>);
-    STATIC_CHECK(!iris::ranges::growable_array_writable<std::span<int, 5>>);
-
-    STATIC_CHECK(!iris::ranges::fixed_array_writable<std::span<int const, 5>>);
-    STATIC_CHECK(!iris::ranges::fixed_array_writable<std::span<int const, 5>&>);
-    STATIC_CHECK(!iris::ranges::fixed_array_writable<std::span<int const, 5> const&>);
-    STATIC_CHECK(!iris::ranges::growable_array_writable<std::span<int const, 5>>);
-
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::span<int>>);
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::span<int>&>);
-    STATIC_CHECK(iris::ranges::fixed_array_writable<std::span<int> const&>);
-    STATIC_CHECK(!iris::ranges::growable_array_writable<std::span<int>>);
-}
-
-TEST_CASE("ranges: dummy types")
-{
-    STATIC_CHECK(iris::ranges::key_value_range<iris::ranges::dummy_key_value_range<int, int>>);
-    STATIC_CHECK(!iris::ranges::mapping_range<iris::ranges::dummy_key_value_range<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<iris::ranges::dummy_mapping_range<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<iris::ranges::dummy_mapping_range<int, int>>);
-    STATIC_CHECK(!iris::ranges::mapping_container<iris::ranges::dummy_mapping_range<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<iris::ranges::dummy_mapping_container<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<iris::ranges::dummy_mapping_container<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<iris::ranges::dummy_mapping_container<int, int>>);
-    STATIC_CHECK(!iris::ranges::unique_mapping_container<iris::ranges::dummy_mapping_container<int, int>>);
-
-    STATIC_CHECK(iris::ranges::key_value_range<iris::ranges::dummy_unique_mapping_container<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_range<iris::ranges::dummy_unique_mapping_container<int, int>>);
-    STATIC_CHECK(iris::ranges::mapping_container<iris::ranges::dummy_unique_mapping_container<int, int>>);
-    STATIC_CHECK(iris::ranges::unique_mapping_container<iris::ranges::dummy_unique_mapping_container<int, int>>);
-
-    STATIC_CHECK(iris::ranges::growable_array_writable<iris::ranges::dummy_growable_array<int>>);
-    STATIC_CHECK(iris::ranges::fixed_array_writable<iris::ranges::dummy_fixed_array<int>>);
-}
+// Test cases involving containers must go to `container_traits.cpp`
+// Test cases for dummy ranges / dummy containers must go to `container_traits.cpp`
diff --git a/test/run_length_sequence.cpp b/test/run_length_sequence.cpp
new file mode 100644
index 0000000..830cc75
--- /dev/null
+++ b/test/run_length_sequence.cpp
@@ -0,0 +1,554 @@
+// SPDX-License-Identifier: MIT
+
+#include "iris_test.hpp"
+
+#include <iris/run_length_sequence.hpp>
+
+#include <algorithm>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <concepts>
+#include <iterator>
+#include <ranges>
+
+using namespace std::string_view_literals;
+using namespace std::string_literals;
+
+TEST_CASE("run_length_sequence: traits")
+{
+    using RLS = iris::run_length_sequence<double>;
+    STATIC_CHECK(std::same_as<RLS::item_type, double>);
+    STATIC_CHECK(std::same_as<RLS::index_type, unsigned>);
+
+    STATIC_CHECK(std::same_as<RLS::value_type, iris::indexed_value<unsigned, double>>);
+    STATIC_CHECK(std::is_trivially_copyable_v<RLS::value_type>);
+
+    STATIC_CHECK(std::same_as<RLS::value_type, std::iter_value_t<RLS::iterator>>);
+    STATIC_CHECK(std::same_as<RLS::reference, std::iter_reference_t<RLS::iterator>>);
+    STATIC_CHECK(std::same_as<RLS::const_reference, std::iter_reference_t<RLS::const_iterator>>);
+
+    STATIC_CHECK(std::indirectly_readable<RLS::iterator>);
+    STATIC_CHECK(std::bidirectional_iterator<RLS::iterator>);
+
+    STATIC_CHECK(std::indirectly_readable<RLS::const_iterator>);
+    STATIC_CHECK(std::bidirectional_iterator<RLS::const_iterator>);
+
+    STATIC_CHECK(std::ranges::bidirectional_range<RLS>);
+    STATIC_CHECK(std::ranges::bidirectional_range<RLS const>);
+
+    STATIC_CHECK(std::sized_sentinel_for<RLS::const_iterator, RLS::iterator>);
+
+    STATIC_CHECK(std::default_initializable<RLS>);
+    STATIC_CHECK(std::is_copy_constructible_v<RLS>);
+    STATIC_CHECK(std::is_copy_assignable_v<RLS>);
+    STATIC_CHECK(std::is_move_constructible_v<RLS>);
+    STATIC_CHECK(std::is_move_assignable_v<RLS>);
+
+    {
+        RLS::value_type iv{};
+        auto&& [index, value] = iv;
+        index = 42;
+        value = 1.0;
+        CHECK(iv.index == 42);
+        CHECK(iv.value == 1.0);
+    }
+    {
+        RLS::value_type iv{};
+        auto [index, value] = iv;
+        index = 42;
+        value = 1.0;
+        CHECK(iv.index == 0);
+        CHECK(iv.value == 0.0);  // NOLINT(readability-container-size-empty)
+    }
+}
+
+TEST_CASE("run_length_sequence: construction")
+{
+    constexpr auto expected_input = std::array{2, 3, 3, 4, 2, 2, 3, 4, 4};
+    auto const expected_runs = std::vector{2, 3, 4, 2, 3, 4};
+
+    // std::from_range
+    {
+        iris::run_length_sequence<int, unsigned, std::tuple> seq{std::from_range, expected_input};
+        auto const expected_elems = std::views::zip(std::views::iota(0u), expected_input) | std::ranges::to<std::vector>();
+        auto const actual_elems = seq | std::ranges::to<std::vector>();
+        CHECK(expected_elems == actual_elems);
+        CHECK(seq.run_count() == expected_runs.size());
+        CHECK(seq.runs() == expected_runs);
+
+        auto const run_view = seq.run_view();
+        auto it = run_view.begin();
+        {
+            REQUIRE(it != run_view.end());
+            auto const run_ref = *it++;
+            CHECK(run_ref.value == 2);
+            CHECK(run_ref.span.equals({0, 1}));
+        }
+        {
+            REQUIRE(it != run_view.end());
+            auto const run_ref = *it++;
+            CHECK(run_ref.value == 3);
+            CHECK(run_ref.span.equals({1, 3}));
+        }
+        {
+            REQUIRE(it != run_view.end());
+            auto const run_ref = *it++;
+            CHECK(run_ref.value == 4);
+            CHECK(run_ref.span.equals({3, 4}));
+        }
+        {
+            REQUIRE(it != run_view.end());
+            auto const run_ref = *it++;
+            CHECK(run_ref.value == 2);
+            CHECK(run_ref.span.equals({4, 6}));
+        }
+        {
+            REQUIRE(it != run_view.end());
+            auto const run_ref = *it++;
+            CHECK(run_ref.value == 3);
+            CHECK(run_ref.span.equals({6, 7}));
+        }
+        {
+            REQUIRE(it != run_view.end());
+            auto const run_ref = *it++;
+            CHECK(run_ref.value == 4);
+            CHECK(run_ref.span.equals({7, 9}));
+        }
+        REQUIRE(it == run_view.end());
+    }
+
+    // it, se
+    {
+        iris::run_length_sequence<int, unsigned, std::tuple> seq{expected_input.begin(), expected_input.end()};
+        auto const expected_elems = std::views::zip(std::views::iota(0u), expected_input) | std::ranges::to<std::vector>();
+        auto const actual_elems = seq | std::ranges::to<std::vector>();
+        CHECK(expected_elems == actual_elems);
+        CHECK(seq.run_count() == expected_runs.size());
+        CHECK(seq.runs() == expected_runs);
+    }
+
+    // initializer list
+    {
+        iris::run_length_sequence<int, unsigned, std::tuple> seq{2, 3, 3, 4, 2, 2, 3, 4, 4};
+        auto const expected_elems = std::views::zip(std::views::iota(0u), expected_input) | std::ranges::to<std::vector>();
+        auto const actual_elems = seq | std::ranges::to<std::vector>();
+        CHECK(expected_elems == actual_elems);
+        CHECK(seq.run_count() == expected_runs.size());
+        CHECK(seq.runs() == expected_runs);
+    }
+
+    // initializer list + append_range
+    {
+        iris::run_length_sequence<int, unsigned, std::tuple> seq{2, 3, 3, 4, 2};
+        seq.append_range(std::array{2, 3, 4, 4});
+        auto const expected_elems = std::views::zip(std::views::iota(0u), expected_input) | std::ranges::to<std::vector>();
+        auto const actual_elems = seq | std::ranges::to<std::vector>();
+        CHECK(expected_elems == actual_elems);
+        CHECK(seq.run_count() == expected_runs.size());
+        CHECK(seq.runs() == expected_runs);
+    }
+}
+
+TEST_CASE("run_length_sequence: emplace_back / push_back / pop_back")
+{
+    using RLS = iris::run_length_sequence<std::string>;
+
+    // emplace_back(char array)
+    {
+        RLS seq;
+        auto&& elem = seq.emplace_back("foo");
+        CHECK(seq.size() == 1);
+        CHECK(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == "foo");
+
+        seq.pop_back();
+        CHECK(seq.empty());
+    }
+    // emplace_back(string_view)
+    {
+        RLS seq;
+        auto&& elem = seq.emplace_back("foo"sv);
+        CHECK(seq.size() == 1);
+        CHECK(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == "foo");
+
+        seq.pop_back();
+        CHECK(seq.empty());
+    }
+    // emplace_back(string)
+    {
+        RLS seq;
+        auto&& elem = seq.emplace_back("foo"s);
+        CHECK(seq.size() == 1);
+        CHECK(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == "foo");
+
+        seq.pop_back();
+        CHECK(seq.empty());
+    }
+
+    // push_back(char array)
+    {
+        RLS seq;
+        auto&& elem = seq.push_back("foo");
+        CHECK(seq.size() == 1);
+        CHECK(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == "foo");
+
+        seq.pop_back();
+        CHECK(seq.empty());
+    }
+    // push_back(string_view)
+    {
+        RLS seq;
+        auto&& elem = seq.push_back("foo"sv);
+        CHECK(seq.size() == 1);
+        CHECK(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == "foo");
+
+        seq.pop_back();
+        CHECK(seq.empty());
+    }
+    // push_back(string)
+    {
+        RLS seq;
+        auto&& elem = seq.push_back("foo"s);
+        CHECK(seq.size() == 1);
+        CHECK(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == "foo");
+
+        seq.pop_back();
+        CHECK(seq.empty());
+    }
+    // push_back(initializer_list)
+    {
+        constexpr auto str_arr = std::array{'a', 'b', 'c'};
+
+        RLS seq;
+        auto&& elem = seq.push_back({str_arr.begin(), str_arr.end()}); // this cannot be resolved by `emplace_back`
+        CHECK(seq.size() == 1);
+        CHECK(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == "abc");
+
+        seq.pop_back();
+        CHECK(seq.empty());
+    }
+}
+
+TEST_CASE("run_length_sequence: sequential insertion")
+{
+    using RLS = iris::run_length_sequence<double>;
+    RLS seq;
+    CHECK(seq == seq);
+    CHECK(seq.empty());
+    CHECK(seq.size() == 0);  // NOLINT(readability-container-size-empty)
+    CHECK(seq.begin() == seq.end());
+    CHECK(seq.nth(0) == seq.end());
+
+    {
+        using std::swap;
+        swap(seq, seq);
+    }
+
+    CHECK_NOTHROW((void)(seq.cbegin() = seq.begin()));
+
+    {
+        auto&& elem = seq.emplace_back(1.0);
+        REQUIRE(seq.size() == 1);
+        REQUIRE(seq.run_count() == 1);
+        CHECK(elem.index == 0);
+        CHECK(elem.value == 1.0);
+        CHECK(seq.front() == elem);
+        CHECK(seq.back() == elem);
+        {
+            auto nth0 = *seq.nth(0);
+            CHECK(nth0.index == 0);
+            CHECK(nth0.value == 1.0);
+        }
+        CHECK(seq.nth(1) == seq.end());
+
+        auto it = seq.begin();
+
+        REQUIRE(it != seq.end());
+        auto&& e0 = *it++;
+        CHECK(e0.index == 0);
+        CHECK(e0.value == 1.0);
+        CHECK(seq.front() == elem);
+        CHECK(seq.back() == e0);
+
+        REQUIRE(it == seq.end());
+    }
+    {
+        auto&& elem = seq.emplace_back(1.0);
+        REQUIRE(seq.size() == 2);
+        REQUIRE(seq.run_count() == 1);
+        CHECK(elem.index == 1);
+        CHECK(elem.value == 1.0);
+        CHECK(seq.back() == elem);
+        {
+            auto nth0 = *seq.nth(0);
+            CHECK(nth0.index == 0);
+            CHECK(nth0.value == 1.0);
+        }
+        {
+            auto nth1 = *seq.nth(1);
+            CHECK(nth1.index == 1);
+            CHECK(nth1.value == 1.0);
+        }
+        CHECK(seq.nth(2) == seq.end());
+
+        auto it = seq.begin();
+
+        REQUIRE(it != seq.end());
+        auto&& e0 = *it++;
+        CHECK(e0.index == 0);
+        CHECK(e0.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e1 = *it++;
+        CHECK(e1.index == 1);
+        CHECK(e1.value == 1.0);
+
+        REQUIRE(it == seq.end());
+    }
+    {
+        auto&& elem = seq.emplace_back(1.1);
+        REQUIRE(seq.size() == 3);
+        REQUIRE(seq.run_count() == 2);
+        CHECK(elem.index == 2);
+        CHECK(elem.value == 1.1);
+        CHECK(seq.back() == elem);
+        {
+            auto nth0 = *seq.nth(0);
+            CHECK(nth0.index == 0);
+            CHECK(nth0.value == 1.0);
+        }
+        {
+            auto nth1 = *seq.nth(1);
+            CHECK(nth1.index == 1);
+            CHECK(nth1.value == 1.0);
+        }
+        {
+            auto nth2 = *seq.nth(2);
+            CHECK(nth2.index == 2);
+            CHECK(nth2.value == 1.1);
+        }
+        CHECK(seq.nth(3) == seq.end());
+
+        auto it = seq.begin();
+
+        REQUIRE(it != seq.end());
+        auto&& e0 = *it++;
+        CHECK(e0.index == 0);
+        CHECK(e0.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e1 = *it++;
+        CHECK(e1.index == 1);
+        CHECK(e1.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e2 = *it++;
+        CHECK(e2.index == 2);
+        CHECK(e2.value == 1.1);
+
+        REQUIRE(it == seq.end());
+    }
+    {
+        auto&& elem = seq.emplace_back(1.1);
+        REQUIRE(seq.size() == 4);
+        REQUIRE(seq.run_count() == 2);
+        CHECK(elem.index == 3);
+        CHECK(elem.value == 1.1);
+        CHECK(seq.back() == elem);
+        {
+            auto nth0 = *seq.nth(0);
+            CHECK(nth0.index == 0);
+            CHECK(nth0.value == 1.0);
+        }
+        {
+            auto nth1 = *seq.nth(1);
+            CHECK(nth1.index == 1);
+            CHECK(nth1.value == 1.0);
+        }
+        {
+            auto nth2 = *seq.nth(2);
+            CHECK(nth2.index == 2);
+            CHECK(nth2.value == 1.1);
+        }
+        {
+            auto nth3 = *seq.nth(3);
+            CHECK(nth3.index == 3);
+            CHECK(nth3.value == 1.1);
+        }
+        CHECK(seq.nth(4) == seq.end());
+
+        auto it = seq.begin();
+
+        REQUIRE(it != seq.end());
+        auto&& e0 = *it++;
+        CHECK(e0.index == 0);
+        CHECK(e0.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e1 = *it++;
+        CHECK(e1.index == 1);
+        CHECK(e1.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e2 = *it++;
+        CHECK(e2.index == 2);
+        CHECK(e2.value == 1.1);
+
+        REQUIRE(it != seq.end());
+        auto&& e3 = *it++;
+        CHECK(e3.index == 3);
+        CHECK(e3.value == 1.1);
+
+        REQUIRE(it == seq.end());
+    }
+    {
+        auto&& elem = seq.emplace_back(1.1);
+        REQUIRE(seq.size() == 5);
+        REQUIRE(seq.run_count() == 2);
+        CHECK(elem.index == 4);
+        CHECK(elem.value == 1.1);
+        CHECK(seq.back() == elem);
+        {
+            auto nth0 = *seq.nth(0);
+            CHECK(nth0.index == 0);
+            CHECK(nth0.value == 1.0);
+        }
+        {
+            auto nth1 = *seq.nth(1);
+            CHECK(nth1.index == 1);
+            CHECK(nth1.value == 1.0);
+        }
+        {
+            auto nth2 = *seq.nth(2);
+            CHECK(nth2.index == 2);
+            CHECK(nth2.value == 1.1);
+        }
+        {
+            auto nth3 = *seq.nth(3);
+            CHECK(nth3.index == 3);
+            CHECK(nth3.value == 1.1);
+        }
+        {
+            auto nth4 = *seq.nth(4);
+            CHECK(nth4.index == 4);
+            CHECK(nth4.value == 1.1);
+        }
+        CHECK(seq.nth(5) == seq.end());
+
+        auto it = seq.begin();
+
+        REQUIRE(it != seq.end());
+        auto&& e0 = *it++;
+        CHECK(e0.index == 0);
+        CHECK(e0.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e1 = *it++;
+        CHECK(e1.index == 1);
+        CHECK(e1.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e2 = *it++;
+        CHECK(e2.index == 2);
+        CHECK(e2.value == 1.1);
+
+        REQUIRE(it != seq.end());
+        auto&& e3 = *it++;
+        CHECK(e3.index == 3);
+        CHECK(e3.value == 1.1);
+
+        REQUIRE(it != seq.end());
+        auto&& e4 = *it++;
+        CHECK(e4.index == 4);
+        CHECK(e4.value == 1.1);
+
+        REQUIRE(it == seq.end());
+    }
+    {
+        auto&& elem = seq.emplace_back(1.2);
+        REQUIRE(seq.size() == 6);
+        REQUIRE(seq.run_count() == 3);
+        CHECK(elem.index == 5);
+        CHECK(elem.value == 1.2);
+        CHECK(seq.back() == elem);
+        {
+            auto nth0 = *seq.nth(0);
+            CHECK(nth0.index == 0);
+            CHECK(nth0.value == 1.0);
+        }
+        {
+            auto nth1 = *seq.nth(1);
+            CHECK(nth1.index == 1);
+            CHECK(nth1.value == 1.0);
+        }
+        {
+            auto nth2 = *seq.nth(2);
+            CHECK(nth2.index == 2);
+            CHECK(nth2.value == 1.1);
+        }
+        {
+            auto nth3 = *seq.nth(3);
+            CHECK(nth3.index == 3);
+            CHECK(nth3.value == 1.1);
+        }
+        {
+            auto nth4 = *seq.nth(4);
+            CHECK(nth4.index == 4);
+            CHECK(nth4.value == 1.1);
+        }
+        {
+            auto nth5 = *seq.nth(5);
+            CHECK(nth5.index == 5);
+            CHECK(nth5.value == 1.2);
+        }
+        CHECK(seq.nth(6) == seq.end());
+
+        auto it = seq.begin();
+
+        REQUIRE(it != seq.end());
+        auto&& e0 = *it++;
+        CHECK(e0.index == 0);
+        CHECK(e0.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e1 = *it++;
+        CHECK(e1.index == 1);
+        CHECK(e1.value == 1.0);
+
+        REQUIRE(it != seq.end());
+        auto&& e2 = *it++;
+        CHECK(e2.index == 2);
+        CHECK(e2.value == 1.1);
+
+        REQUIRE(it != seq.end());
+        auto&& e3 = *it++;
+        CHECK(e3.index == 3);
+        CHECK(e3.value == 1.1);
+
+        REQUIRE(it != seq.end());
+        auto&& e4 = *it++;
+        CHECK(e4.index == 4);
+        CHECK(e4.value == 1.1);
+
+        REQUIRE(it != seq.end());
+        auto&& e5 = *it++;
+        CHECK(e5.index == 5);
+        CHECK(e5.value == 1.2);
+
+        REQUIRE(it == seq.end());
+    }
+}
diff --git a/test/type_traits.cpp b/test/type_traits.cpp
index a489ea5..c30cc89 100644
--- a/test/type_traits.cpp
+++ b/test/type_traits.cpp
@@ -4,7 +4,7 @@
 
 #include <iris/type_traits.hpp>
 
-namespace {
+#include <cstdint>
 
 template<class... Ts>
 struct tuple;
@@ -12,7 +12,6 @@ struct tuple;
 template<class... Ts>
 struct type_list;
 
-
 template<int... Ns>
 struct n_tuple;
 
@@ -41,8 +40,24 @@ struct member_ptr_test
 {
 };
 
-} // anonymous
-
+TEST_CASE("type traits")
+{
+    STATIC_CHECK(iris::signed_numeric_integral<std::int8_t>);
+    STATIC_CHECK(iris::signed_numeric_integral<std::int16_t>);
+    STATIC_CHECK(iris::signed_numeric_integral<std::int32_t>);
+    STATIC_CHECK(iris::signed_numeric_integral<std::int64_t>);
+    STATIC_CHECK(!iris::signed_numeric_integral<bool>);
+    STATIC_CHECK(!iris::signed_numeric_integral<char>);
+    STATIC_CHECK(!iris::signed_numeric_integral<wchar_t>);
+
+    STATIC_CHECK(iris::unsigned_numeric_integral<std::uint8_t>);
+    STATIC_CHECK(iris::unsigned_numeric_integral<std::uint16_t>);
+    STATIC_CHECK(iris::unsigned_numeric_integral<std::uint32_t>);
+    STATIC_CHECK(iris::unsigned_numeric_integral<std::uint64_t>);
+    STATIC_CHECK(!iris::unsigned_numeric_integral<bool>);
+    STATIC_CHECK(!iris::unsigned_numeric_integral<char>);
+    STATIC_CHECK(!iris::unsigned_numeric_integral<wchar_t>);
+}
 
 TEST_CASE("is_convertible_without_narrowing: same type identity")
 {