diff --git a/include/iris/ranges.hpp b/include/iris/ranges.hpp
new file mode 100644
index 0000000..89fd5a8
--- /dev/null
+++ b/include/iris/ranges.hpp
@@ -0,0 +1,247 @@
+#ifndef IRIS_ZZ_RANGES_HPP
+#define IRIS_ZZ_RANGES_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/utility.hpp>
+
+#include <ranges> // IWYU pragma: export
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+namespace iris::ranges {
+
+namespace detail {
+
+template<std::ranges::range R>
+using kv_element_t = std::remove_cvref_t<std::ranges::range_reference_t<R>>;
+
+} // detail
+
+// `R` is a range with value type of 2-element tuple.
+// This accepts also array of pair. If stricter check is needed, use `mapping_range<R>`.
+// Note: To convert `key_value_range` to `mapping_range`, use `iris::ranges::as_map`.
+template<class R>
+concept key_value_range =
+    std::ranges::input_range<R> &&
+    requires {
+        typename detail::kv_element_t<R>;
+        requires std::tuple_size<detail::kv_element_t<R>>::value == 2;
+        typename std::tuple_element<0, detail::kv_element_t<R>>::type;
+        typename std::tuple_element<1, detail::kv_element_t<R>>::type;
+    } &&
+    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>>>;
+
+template<key_value_range R>
+using range_mapped_t = std::remove_cvref_t<std::tuple_element_t<1, detail::kv_element_t<R>>>;
+
+
+// `R` is a range with value type of 2-element tuple AND it has certain
+// strictly map-specific traits such as `::key_type` and `::mapped_type`.
+// To include more loose type like an array of pair, use `key_value_range<R>`.
+template<class R>
+concept mapping_range =
+    key_value_range<R> &&
+    requires {
+        typename std::remove_cvref_t<R>::key_type;
+        typename std::remove_cvref_t<R>::mapped_type;
+    } &&
+    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`.
+template<std::ranges::input_range R>
+    requires ranges::key_value_range<R>
+struct as_map_view : std::ranges::view_interface<as_map_view<R>>
+{
+    R base_ = R{};
+
+public:
+    using key_type    = range_key_t<R>;
+    using mapped_type = range_mapped_t<R>;
+
+    as_map_view() requires std::default_initializable<R> = default;
+    constexpr explicit as_map_view(R base) : base_(std::move(base)) {}
+
+    [[nodiscard]] constexpr R base() const& requires std::copy_constructible<R> { return base_; }
+    [[nodiscard]] constexpr R base() && { return std::move(base_); }
+
+    [[nodiscard]] constexpr auto begin()       { return std::ranges::begin(base_); }
+    [[nodiscard]] constexpr auto end()         { return std::ranges::end(base_); }
+    [[nodiscard]] constexpr auto begin() const requires std::ranges::range<R const> { return std::ranges::begin(base_); }
+    [[nodiscard]] constexpr auto end()   const requires std::ranges::range<R const> { return std::ranges::end(base_); }
+
+    [[nodiscard]] constexpr auto size()       requires std::ranges::sized_range<R>       { return std::ranges::size(base_); }
+    [[nodiscard]] constexpr auto size() const requires std::ranges::sized_range<R const> { return std::ranges::size(base_); }
+};
+
+template<class R>
+as_map_view(R&&) -> as_map_view<std::views::all_t<R>>;
+
+
+namespace detail {
+
+struct as_map_fn : std::ranges::range_adaptor_closure<as_map_fn>
+{
+    template<std::ranges::viewable_range R>
+        requires ranges::key_value_range<R>
+    [[nodiscard]] static constexpr auto operator()(R&& r)
+    {
+        return as_map_view{std::views::all(std::forward<R>(r))};
+    }
+};
+
+} // detail
+
+// Can be used for making `key_value_range` model `mapping_range`.
+[[maybe_unused]] inline constexpr detail::as_map_fn as_map{};
+
+} // iris::ranges
+
+template<class V>
+inline constexpr bool std::ranges::enable_borrowed_range<iris::ranges::as_map_view<V>>
+    = 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));
+    };
+
+template<class K, class V>
+struct dummy_mapping_container
+{
+    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&&);
+};
+
+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>
+{
+    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();
+};
+
+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
+
+#endif
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index e1565b4..96f1630 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -182,6 +182,7 @@ if(PROJECT_IS_TOP_LEVEL)
             library_config
             core
             type_traits
+            ranges
             stdint
             enum
             indirect
diff --git a/test/ranges.cpp b/test/ranges.cpp
new file mode 100644
index 0000000..08d69ba
--- /dev/null
+++ b/test/ranges.cpp
@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: MIT
+
+#include "iris_test.hpp"
+
+#include <iris/ranges.hpp>
+
+#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
+{
+    using key_type = KeyT;
+    using value_type = std::pair<KeyT const, ValueT>;
+    using mapped_type = ValueT;
+};
+
+template<class KeyT, class ValueT>
+struct FakeRangeMapWithoutMappedType
+{
+    using key_type = KeyT;
+    using value_type = std::pair<KeyT const, ValueT>;
+
+    value_type const* begin() const;
+    value_type const* end() const;
+};
+
+template<class KeyT, class ValueT>
+struct RangeMapWith2TupleSize
+{
+    using key_type = KeyT;
+    using value_type = std::tuple<KeyT const, ValueT>; // NOT pair
+    using mapped_type = ValueT;
+
+    value_type const* begin() const;
+    value_type const* end() const;
+};
+
+template<class KeyT, class ValueT>
+struct FakeRangeMapWithWrongTupleSize
+{
+    using key_type = KeyT;
+    using value_type = std::tuple<KeyT const, ValueT, char>; // additional element
+    using mapped_type = ValueT;
+
+    value_type const* begin() const;
+    value_type const* end() const;
+};
+
+template<class KeyT, class ValueT>
+struct FakeRangeMapWithNonTupleKey
+{
+    using key_type = KeyT;
+    using value_type = char; // non-tuple
+    using mapped_type = ValueT;
+
+    value_type const* begin() const;
+    value_type const* end() const;
+};
+
+TEST_CASE("ranges: map related traits")
+{
+    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
+    {
+        [[maybe_unused]] constexpr auto filter = std::views::filter([](auto&&) { return true; });
+        {
+            using Map = std::map<int, int>;
+
+            // 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)>);
+
+            // 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)>);
+
+            // 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)>);
+        }
+        {
+            using PairVec = std::vector<std::pair<int, int>>;
+
+            // Map
+            STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec>())>);
+            STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<PairVec>())>);
+            STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<PairVec>() | as_map)>);
+            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)>);
+
+            // Map&
+            STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec&>())>);
+            STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<PairVec&>())>);
+            STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<PairVec&>() | as_map)>);
+            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)>);
+
+            // Map const&
+            STATIC_CHECK(iris::ranges::key_value_range<decltype(std::declval<PairVec const&>())>);
+            STATIC_CHECK(!iris::ranges::mapping_range<decltype(std::declval<PairVec const&>())>);
+            STATIC_CHECK(iris::ranges::mapping_range<decltype(std::declval<PairVec const&>() | as_map)>);
+            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)>);
+        }
+    }
+
+    // ---------------------------------------------------
+    // Exotic types
+
+    STATIC_CHECK(!iris::ranges::key_value_range<FakeNonRangeMap<int, int>>);
+
+    static_assert(std::ranges::forward_range<FakeRangeMapWithoutMappedType<int, int>>);
+    STATIC_CHECK(iris::ranges::key_value_range<FakeRangeMapWithoutMappedType<int, int>>);
+
+    static_assert(std::ranges::forward_range<RangeMapWith2TupleSize<int, int>>);
+    STATIC_CHECK(iris::ranges::key_value_range<RangeMapWith2TupleSize<int, int>>);
+
+    static_assert(std::ranges::forward_range<FakeRangeMapWithWrongTupleSize<int, int>>);
+    STATIC_CHECK(!iris::ranges::key_value_range<FakeRangeMapWithWrongTupleSize<int, int>>);
+
+    static_assert(std::ranges::forward_range<FakeRangeMapWithNonTupleKey<int, int>>);
+    STATIC_CHECK(!iris::ranges::key_value_range<FakeRangeMapWithNonTupleKey<int, int>>);
+
+    STATIC_CHECK(!iris::ranges::key_value_range<std::vector<int>>);
+    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>>);
+}