diff --git a/CMakeLists.txt b/CMakeLists.txt
index f4a87a9..ac664fb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,7 +10,7 @@ project(iris VERSION 0.0.1 LANGUAGES CXX)
 
 get_directory_property(IRIS_PARENT_DIRECTORY PARENT_DIRECTORY)
 
-if(DEFINED IRIS_ROOT AND NOT "${IRIS_ROOT}" PATH_EQUAL "${CMAKE_CURRENT_LIST_DIR}")
+if(TARGET Iris::Iris)
     message(FATAL_ERROR "Cannot include Iris more than once")
 endif()
 
diff --git a/include/iris/alloy/traits.hpp b/include/iris/alloy/traits.hpp
index 3d9a379..d08e7f3 100644
--- a/include/iris/alloy/traits.hpp
+++ b/include/iris/alloy/traits.hpp
@@ -7,6 +7,7 @@
 
 #include <iris/alloy/detail/deduce.hpp>
 
+#include <iris/type_list.hpp>
 #include <iris/bits/specialization_of.hpp>
 
 #include <functional>
diff --git a/include/iris/rvariant/detail/recursive_traits.hpp b/include/iris/rvariant/detail/recursive_traits.hpp
index e53e2fa..0e2b27c 100644
--- a/include/iris/rvariant/detail/recursive_traits.hpp
+++ b/include/iris/rvariant/detail/recursive_traits.hpp
@@ -7,7 +7,7 @@
 
 // IWYU pragma: private, include <iris/rvariant.hpp>
 
-#include <iris/rvariant/detail/rvariant_fwd.hpp>
+#include <iris/rvariant/rvariant_fwd.hpp>
 
 namespace iris::detail {
 
@@ -45,7 +45,7 @@ struct select_maybe_wrapped : select_maybe_wrapped_impl<false, 0, U, Ts...>
 {
     // Precondition: either T or recursive_wrapper<T> occurs at least once in Ts...
     static_assert(sizeof...(Ts) > 0);
-    static_assert(!detail::is_recursive_wrapper_like_v<U>);
+    static_assert(!is_recursive_wrapper_v<U>);
 };
 
 template<class U, class... Ts>
diff --git a/include/iris/rvariant/detail/variant_storage.hpp b/include/iris/rvariant/detail/variant_storage.hpp
index dc89dab..0af7de2 100644
--- a/include/iris/rvariant/detail/variant_storage.hpp
+++ b/include/iris/rvariant/detail/variant_storage.hpp
@@ -7,7 +7,7 @@
 
 // IWYU pragma: private, include <iris/rvariant.hpp>
 
-#include <iris/rvariant/detail/rvariant_fwd.hpp>
+#include <iris/rvariant/rvariant_fwd.hpp>
 
 #include <iris/type_list.hpp>
 #include <iris/bits/specialization_of.hpp>
diff --git a/include/iris/rvariant/detail/visit.hpp b/include/iris/rvariant/detail/visit.hpp
index b003d53..c336385 100644
--- a/include/iris/rvariant/detail/visit.hpp
+++ b/include/iris/rvariant/detail/visit.hpp
@@ -7,10 +7,10 @@
 
 // IWYU pragma: private, include <iris/rvariant.hpp>
 
-#include <iris/rvariant/detail/rvariant_fwd.hpp>
 #include <iris/rvariant/detail/seq.hpp>
 #include <iris/rvariant/detail/variant_storage.hpp>
 #include <iris/rvariant/variant_helper.hpp>
+#include <iris/rvariant/rvariant_fwd.hpp>
 
 #include <iris/type_list.hpp>
 #include <iris/type_traits.hpp>
diff --git a/include/iris/rvariant/rvariant.hpp b/include/iris/rvariant/rvariant.hpp
index 44e67de..b790646 100644
--- a/include/iris/rvariant/rvariant.hpp
+++ b/include/iris/rvariant/rvariant.hpp
@@ -5,12 +5,12 @@
 
 #include <iris/config.hpp> // IWYU pragma: keep
 
-#include <iris/rvariant/detail/rvariant_fwd.hpp>
 #include <iris/rvariant/detail/variant_storage.hpp>
 #include <iris/rvariant/detail/visit.hpp>
 #include <iris/rvariant/detail/recursive_traits.hpp>
 #include <iris/rvariant/variant_helper.hpp>  // IWYU pragma: export
 #include <iris/rvariant/subset.hpp>
+#include <iris/rvariant/rvariant_fwd.hpp>
 
 #include <iris/hash/FNV_hash.hpp>
 
@@ -41,7 +41,7 @@ struct check_recursive_wrapper_duplicate_impl : std::true_type {};
 template<class T, class U>
     requires
         (!std::same_as<T, U>) &&
-        (is_recursive_wrapper_like_v<T> || is_recursive_wrapper_like_v<U>) &&
+        (is_recursive_wrapper_v<T> || is_recursive_wrapper_v<U>) &&
         std::same_as<unwrap_recursive_t<T>, unwrap_recursive_t<U>>
 struct check_recursive_wrapper_duplicate_impl<T, U>
     : std::false_type
@@ -66,7 +66,7 @@ template<class T, class List>
 struct non_wrapped_exactly_once : exactly_once<T, List>
 {
     static_assert(
-        !detail::is_recursive_wrapper_like_v<T>,
+        !is_recursive_wrapper_v<T>,
         "Constructing a `recursive_wrapper` alternative with its full type as the tag is "
         "prohibited to avoid confusion; just specify `T` instead."
     );
@@ -167,9 +167,9 @@ struct rvariant_base
 IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
     // Primary constructor called from derived class
     template<std::size_t I, class... Args>
-        requires std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
+        requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
     constexpr explicit rvariant_base(std::in_place_index_t<I>, Args&&... args)
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
         : storage_(std::in_place_index<I>, std::forward<Args>(args)...)
         , index_{static_cast<variant_index_t<sizeof...(Ts)>>(I)}
     {}
@@ -291,7 +291,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
     {
         if constexpr (need_destructor_call) {
             // ReSharper disable once CppTypeAliasNeverUsed
-            using T = pack_indexing_t<I, Ts...>;
+            using T = IRIS_PACK_INDEXING(I, Ts...);
             auto&& alt = raw_get<I>(storage_);
             alt.~T();
         }
@@ -330,7 +330,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
         assert(index_ == I);
         if constexpr (I != std::variant_npos) {
             // ReSharper disable once CppTypeAliasNeverUsed
-            using T = pack_indexing_t<I, Ts...>;
+            using T = IRIS_PACK_INDEXING(I, Ts...);
             auto&& alt = raw_get<I>(storage_);
             alt.~T();
             index_ = variant_npos<sizeof...(Ts)>;
@@ -340,7 +340,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
 IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
     template<std::size_t I, class... Args>
     constexpr void construct_on_valueless(Args&&... args)
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
     {
         static_assert(I != std::variant_npos);
         assert(index_ == variant_npos<sizeof...(Ts)>);
@@ -350,7 +350,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
 
     template<std::size_t I, class... Args>
     constexpr void reset_construct(Args&&... args)
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
     {
         static_assert(I != std::variant_npos);
         visit_reset();
@@ -360,11 +360,11 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
 
     template<std::size_t i, std::size_t j, class... Args>
     constexpr void reset_construct(Args&&... args)
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<j, Ts...>, Args...>)
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(j, Ts...), Args...>)
     {
         if constexpr (i != std::variant_npos) {
             destroy<i>();
-            if constexpr (!std::is_nothrow_constructible_v<pack_indexing_t<j, Ts...>, Args...>) {
+            if constexpr (!std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(j, Ts...), Args...>) {
                 index_ = variant_npos<sizeof...(Ts)>;
             }
         }
@@ -377,7 +377,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
     constexpr void reset_construct_never_valueless(Args&&... args) noexcept
     {
         static_assert(I != std::variant_npos);
-        static_assert(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>);
+        static_assert(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>);
         static_assert(std::is_nothrow_constructible_v<storage_type, std::in_place_index_t<I>, Args...>);
         visit_destroy();
         std::construct_at(&storage_, std::in_place_index<I>, std::forward<Args>(args)...);
@@ -406,13 +406,13 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
 
 IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
     template<std::size_t I, class... Args>
-        requires std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
+        requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
     constexpr variant_alternative_t<I, rvariant<Ts...>>&
     emplace_impl(Args&&... args)
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>) IRIS_LIFETIMEBOUND
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>) IRIS_LIFETIMEBOUND
     {
         static_assert(I < sizeof...(Ts));
-        using T = pack_indexing_t<I, Ts...>;
+        using T = IRIS_PACK_INDEXING(I, Ts...);
 
 #ifndef NDEBUG
         // Self-emplace on non-valueless instance ALWAYS leads to UB.
@@ -470,7 +470,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
                 } else if constexpr (std::is_same_v<T_old_i, T>) { // NOT type-changing
                     if constexpr (
                         (sizeof(T) <= detail::never_valueless_trivial_size_limit && std::is_trivially_move_assignable_v<T>) ||
-                        detail::is_recursive_wrapper_like_v<T>
+                        is_recursive_wrapper_v<T>
                     ) {
                         T tmp{std::forward<Args>(args)...}; // may throw
                         static_assert(noexcept(t_old_i = std::move(tmp)));
@@ -493,7 +493,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_BEGIN
                 } else { // type-changing
                     if constexpr (
                         (sizeof(T) <= detail::never_valueless_trivial_size_limit && std::is_trivially_move_constructible_v<T>) ||
-                        detail::is_recursive_wrapper_like_v<T>
+                        is_recursive_wrapper_v<T>
                     ) {
                         T tmp{std::forward<Args>(args)...}; // may throw
                         t_old_i.~T_old_i();
@@ -610,8 +610,8 @@ class rvariant : private detail::rvariant_base_t<Ts...>
     using base_type::index;
 
     // Default constructor
-    constexpr rvariant() noexcept(std::is_nothrow_default_constructible_v<pack_indexing_t<0, Ts...>>)
-        requires std::is_default_constructible_v<pack_indexing_t<0, Ts...>>
+    constexpr rvariant() noexcept(std::is_nothrow_default_constructible_v<IRIS_PACK_INDEXING(0, Ts...)>)
+        requires std::is_default_constructible_v<IRIS_PACK_INDEXING(0, Ts...)>
         : base_type(std::in_place_index<0>) // value-initialized
     {}
 
@@ -840,9 +840,9 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
     template<std::size_t I, class... Args>
         requires
             (I < sizeof...(Ts)) &&
-            std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
+            std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
     constexpr explicit rvariant(std::in_place_index_t<I>, Args&&... args) // NOLINT
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>)
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>)
         : base_type(std::in_place_index<I>, std::forward<Args>(args)...)
     {}
 
@@ -850,9 +850,9 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
     template<std::size_t I, class U, class... Args>
         requires
             (I < sizeof...(Ts)) &&
-            std::is_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>
+            std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>
     constexpr explicit rvariant(std::in_place_index_t<I>, std::initializer_list<U> il, Args&&... args) // NOLINT
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>)
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>)
         : base_type(std::in_place_index<I>, il, std::forward<Args>(args)...)
     {}
 
@@ -879,20 +879,20 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
     }
 
     template<std::size_t I, class... Args>
-        requires std::is_constructible_v<pack_indexing_t<I, Ts...>, Args...>
+        requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>
     constexpr variant_alternative_t<I, rvariant>&
     emplace(Args&&... args)
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, Args...>) IRIS_LIFETIMEBOUND
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), Args...>) IRIS_LIFETIMEBOUND
     {
         static_assert(I < sizeof...(Ts));
         return base_type::template emplace_impl<I>(std::forward<Args>(args)...);
     }
 
     template<std::size_t I, class U, class... Args>
-        requires std::is_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>
+        requires std::is_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>
     constexpr variant_alternative_t<I, rvariant>&
     emplace(std::initializer_list<U> il, Args&&... args)
-        noexcept(std::is_nothrow_constructible_v<pack_indexing_t<I, Ts...>, std::initializer_list<U>&, Args...>) IRIS_LIFETIMEBOUND
+        noexcept(std::is_nothrow_constructible_v<IRIS_PACK_INDEXING(I, Ts...), std::initializer_list<U>&, Args...>) IRIS_LIFETIMEBOUND
     {
         static_assert(I < sizeof...(Ts));
         return base_type::template emplace_impl<I>(il, std::forward<Args>(args)...);
@@ -1193,7 +1193,7 @@ IRIS_RVARIANT_ALWAYS_THROWING_UNREACHABLE_END
 // -------------------------------------------------
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 [[nodiscard]] constexpr bool holds_alternative(rvariant<Ts...> const& v) noexcept = delete;
 
 template<class T, class... Ts>
@@ -1294,19 +1294,19 @@ get(rvariant<Ts...> const&& v IRIS_LIFETIMEBOUND)
 }
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T& get(rvariant<Ts...>&) = delete;
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T&& get(rvariant<Ts...>&&) = delete;
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T const& get(rvariant<Ts...> const&) = delete;
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T const&& get(rvariant<Ts...> const&&) = delete;
 
 // -------------------------------------------------
@@ -1375,19 +1375,19 @@ unsafe_get(rvariant<Ts...> const&& v IRIS_LIFETIMEBOUND) noexcept
 }
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T& unsafe_get(rvariant<Ts...>&) = delete;
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T&& unsafe_get(rvariant<Ts...>&&) = delete;
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T const& unsafe_get(rvariant<Ts...> const&) = delete;
 
 template<class T, class... Ts>
-    requires detail::is_recursive_wrapper_like_v<T>
+    requires is_recursive_wrapper_v<T>
 constexpr T const&& unsafe_get(rvariant<Ts...> const&&) = delete;
 
 // ---------------------------------------------
diff --git a/include/iris/rvariant/detail/rvariant_fwd.hpp b/include/iris/rvariant/rvariant_fwd.hpp
similarity index 52%
rename from include/iris/rvariant/detail/rvariant_fwd.hpp
rename to include/iris/rvariant/rvariant_fwd.hpp
index 8aee95a..47bcae0 100644
--- a/include/iris/rvariant/detail/rvariant_fwd.hpp
+++ b/include/iris/rvariant/rvariant_fwd.hpp
@@ -1,12 +1,10 @@
-#ifndef IRIS_ZZ_RVARIANT_DETAIL_RVARIANT_FWD_HPP
-#define IRIS_ZZ_RVARIANT_DETAIL_RVARIANT_FWD_HPP
+#ifndef IRIS_ZZ_RVARIANT_RVARIANT_FWD_HPP
+#define IRIS_ZZ_RVARIANT_RVARIANT_FWD_HPP
 
 // SPDX-License-Identifier: MIT
 
 #include <iris/config.hpp> // IWYU pragma: keep
 
-#include <cstddef> // IWYU pragma: keep
-
 namespace iris {
 
 template<class... Ts>
@@ -18,6 +16,14 @@ class recursive_wrapper;
 template<class T, class Allocator>
 class recursive_wrapper_alloca;
 
+template<class T>
+inline constexpr bool is_recursive_wrapper_v = false;
+
+template<class T>
+inline constexpr bool is_recursive_wrapper_v<recursive_wrapper<T>> = true;
+
+template<class T, class Allocator>
+inline constexpr bool is_recursive_wrapper_v<recursive_wrapper_alloca<T, Allocator>> = true;
 
 namespace detail {
 
diff --git a/include/iris/rvariant/subset.hpp b/include/iris/rvariant/subset.hpp
index d86dc04..b2c2321 100644
--- a/include/iris/rvariant/subset.hpp
+++ b/include/iris/rvariant/subset.hpp
@@ -5,8 +5,8 @@
 
 #include <iris/config.hpp> // IWYU pragma: keep
 
-#include <iris/rvariant/detail/rvariant_fwd.hpp>
 #include <iris/rvariant/variant_helper.hpp>
+#include <iris/rvariant/rvariant_fwd.hpp>
 #include <iris/type_list.hpp>
 
 #include <iris/bits/specialization_of.hpp>
diff --git a/include/iris/rvariant/variant_helper.hpp b/include/iris/rvariant/variant_helper.hpp
index 7267371..d20bc78 100644
--- a/include/iris/rvariant/variant_helper.hpp
+++ b/include/iris/rvariant/variant_helper.hpp
@@ -11,13 +11,12 @@
 
 #include <iris/config.hpp> // IWYU pragma: keep
 
-#include <iris/rvariant/detail/rvariant_fwd.hpp>
+#include <iris/rvariant/rvariant_fwd.hpp>
 #include <iris/type_list.hpp>
-#include <iris/bits/specialization_of.hpp>
 
-#include <utility>
 #include <type_traits>
-#include <cstddef>
+
+#include <cstddef> // IWYU pragma: keep
 
 namespace iris {
 
@@ -72,11 +71,6 @@ struct variant_size<rvariant<Ts...>> : std::integral_constant<std::size_t, sizeo
 
 namespace detail {
 
-template<class T>
-constexpr bool is_recursive_wrapper_like_v =
-    is_ttp_specialization_of_v<T, recursive_wrapper> ||
-    is_ttp_specialization_of_v<T, recursive_wrapper_alloca>;
-
 template<class T>
 struct unwrap_recursive_impl
 {
@@ -119,10 +113,10 @@ struct unwrap_recursive_fn
     [[nodiscard]] IRIS_FORCEINLINE static constexpr auto&&
     operator()(T&& o IRIS_LIFETIMEBOUND) noexcept
     {
-        if constexpr (is_recursive_wrapper_like_v<std::remove_cvref_t<T>>) {
-            return *std::forward<T>(o);
+        if constexpr (is_recursive_wrapper_v<std::remove_cvref_t<T>>) {
+            return *static_cast<T&&>(o);
         } else {
-            return std::forward<T>(o);
+            return static_cast<T&&>(o);
         }
     }
 };
diff --git a/include/iris/type_list.hpp b/include/iris/type_list.hpp
index e495b69..b4f19b5 100644
--- a/include/iris/type_list.hpp
+++ b/include/iris/type_list.hpp
@@ -61,6 +61,62 @@ struct concat_type_list<type_list<Ts...>, type_list<Us...>, Rest...>
 
 namespace detail {
 
+template<class... Ts>
+struct identity_bases : std::type_identity<Ts>...
+{
+    template<template<class...> class TT>
+    using rebind = TT<Ts...>;
+};
+
+template<class T, class BasesT>
+concept identity_base_of = requires(BasesT* bases) {
+    static_cast<std::type_identity<T>*>(bases);
+};
+
+template<class BasesT, class... Ts>
+struct unique_type_list_impl;
+
+template<class BasesT>
+struct unique_type_list_impl<BasesT>
+{
+    using type = BasesT;
+};
+
+template<class BasesT, class T, class... Rest>
+    requires identity_base_of<T, BasesT>
+struct unique_type_list_impl<BasesT, T, Rest...>
+    : unique_type_list_impl<BasesT, Rest...>
+{};
+
+template<class... AcceptedTs, class T, class... Rest>
+    requires (!identity_base_of<T, identity_bases<AcceptedTs...>>)
+struct unique_type_list_impl<identity_bases<AcceptedTs...>, T, Rest...>
+    : unique_type_list_impl<identity_bases<AcceptedTs..., T>, Rest...>
+{};
+
+} // detail
+
+template<class List = void>
+struct unique_type_list;
+
+template<>
+struct unique_type_list<void>
+{
+    using type = type_list<>;
+};
+
+template<class... Ts>
+struct unique_type_list<type_list<Ts...>>
+{
+    using type = detail::unique_type_list_impl<
+        detail::identity_bases<>, Ts...
+    >::type::template rebind<type_list>;
+};
+
+// ----------------------------------------------------------
+
+namespace detail {
+
 template<class Voids>
 struct do_pack_indexing;
 
diff --git a/include/iris/type_traits.hpp b/include/iris/type_traits.hpp
index 05098f5..a27fb64 100644
--- a/include/iris/type_traits.hpp
+++ b/include/iris/type_traits.hpp
@@ -8,8 +8,6 @@
 #include <iris/bits/is_function_object.hpp>  // IWYU pragma: export
 #include <iris/bits/specialization_of.hpp>  // IWYU pragma: export
 
-#include <iris/requirements.hpp>
-
 #include <concepts>
 #include <type_traits> // IWYU pragma: export
 #include <utility>
@@ -189,6 +187,11 @@ template<> struct is_trivially_swappable<std::byte> : std::true_type {};
 template<class T>
 inline constexpr bool is_trivially_swappable_v = is_trivially_swappable<T>::value;
 
+// ----------------------------------------------
+
+template<class T, class U>
+concept weakly_assignable_from = std::is_assignable_v<T, U>;
+
 
 namespace detail {
 
diff --git a/test/type_list.cpp b/test/type_list.cpp
index ac5de05..19bb5e9 100644
--- a/test/type_list.cpp
+++ b/test/type_list.cpp
@@ -8,6 +8,7 @@
 
 using iris::type_list;
 using iris::concat_type_list;
+using iris::unique_type_list;
 
 TEST_CASE("type_list")
 {
@@ -23,6 +24,35 @@ TEST_CASE("type_list")
     STATIC_CHECK(std::same_as<concat_type_list<type_list<int>, type_list<>, type_list<>>::type, type_list<int>>);
     STATIC_CHECK(std::same_as<concat_type_list<type_list<>, type_list<int>, type_list<>>::type, type_list<int>>);
     STATIC_CHECK(std::same_as<concat_type_list<type_list<>, type_list<>, type_list<int>>::type, type_list<int>>);
+
+    // -----------------------------------------------------------
+
+    STATIC_CHECK(std::same_as<unique_type_list<>::type, type_list<>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<>>::type, type_list<>>);
+
+    struct A{};
+    struct B{};
+
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A>>::type, type_list<A>>);
+
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, B>>::type, type_list<A, B>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, B, A>>::type, type_list<A, B>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, B, B>>::type, type_list<A, B>>);
+
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, A>>::type, type_list<A>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, A, A>>::type, type_list<A>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, A, B>>::type, type_list<A, B>>);
+
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<B, A>>::type, type_list<B, A>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<B, A, A>>::type, type_list<B, A>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<B, A, B>>::type, type_list<B, A>>);
+
+    struct C{};
+
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, B, C>>::type, type_list<A, B, C>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, B, C, A>>::type, type_list<A, B, C>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, B, C, B>>::type, type_list<A, B, C>>);
+    STATIC_CHECK(std::same_as<unique_type_list<type_list<A, B, C, C>>::type, type_list<A, B, C>>);
 }
 
 TEST_CASE("pack_indexing")