diff --git a/include/iris/alloy/adapt.hpp b/include/iris/alloy/adapt.hpp
index f3ebf23..e6133c4 100644
--- a/include/iris/alloy/adapt.hpp
+++ b/include/iris/alloy/adapt.hpp
@@ -3,33 +3,35 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/type_traits.hpp> // IWYU pragma: keep
+
 #include <iris/pp/comma.hpp>
 #include <iris/pp/seq.hpp>
 #include <iris/pp/tuple.hpp>
 
 namespace iris::alloy {
 
-namespace detail {
-
-template<auto... Vs>
-struct non_type_list;
-
-}  // detail
-
 template<class T>
 struct adaptor;
 
-template<auto... Getters>
-using make_getters_list = detail::non_type_list<Getters...>;
-
 }  // iris::alloy
 
-#define IRIS_ALLOY_ADAPT_STRUCT(class_name, ...)                                                                                                         \
-    template<>                                                                                                                                             \
-    struct iris::alloy::adaptor<class_name> {                                                                                                              \
-      using getters_list = make_getters_list<IRIS_PP_SEQ_FOR_EACH_WITH_INDEX(IRIS_PP_TUPLE_TO_SEQ((__VA_ARGS__)), IRIS_ALLOY_ADAPT_STRUCT_I, class_name)>; \
+#define IRIS_ALLOY_ADAPT_STRUCT_I(index, data_member, class_name) \
+    IRIS_PP_COMMA_IF(index) & class_name::data_member
+
+#define IRIS_ALLOY_ADAPT_STRUCT(class_name, ...) \
+    template<> \
+    struct iris::alloy::adaptor<class_name> \
+    { \
+        using getters_list = iris::constant_list< \
+            IRIS_PP_SEQ_FOR_EACH_WITH_INDEX( \
+                IRIS_PP_TUPLE_TO_SEQ((__VA_ARGS__)), \
+                IRIS_ALLOY_ADAPT_STRUCT_I, \
+                class_name \
+            ) \
+        >; \
     };
 
-#define IRIS_ALLOY_ADAPT_STRUCT_I(index, data_member, class_name) IRIS_PP_COMMA_IF(index) & class_name::data_member
-
 #endif
diff --git a/include/iris/alloy/adapted/std_pair.hpp b/include/iris/alloy/adapted/std_pair.hpp
index cc4b9d9..186aa0b 100644
--- a/include/iris/alloy/adapted/std_pair.hpp
+++ b/include/iris/alloy/adapted/std_pair.hpp
@@ -3,16 +3,54 @@
 
 // SPDX-License-Identifier: MIT
 
-#include <utility>
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/alloy/detail/std_get.hpp>
+
+#include <utility> // IWYU pragma: export
+
+#include <cstddef>
 
 namespace iris::alloy {
 
-namespace detail {
+template<class T>
+struct tuple_size;
+
+template<class T, class U>
+struct tuple_size<std::pair<T, U>> : std::integral_constant<std::size_t, 2>
+{};
+
+template<class T, class U>
+struct tuple_size<std::pair<T, U> const> : std::integral_constant<std::size_t, 2>
+{};
+
+template<class T, class U>
+struct tuple_size<std::pair<T, U> volatile> : std::integral_constant<std::size_t, 2>
+{};
+
+template<class T, class U>
+struct tuple_size<std::pair<T, U> const volatile> : std::integral_constant<std::size_t, 2>
+{};
+
+template<std::size_t I, class Tuple>
+struct tuple_element;
+
+template<std::size_t I, class T, class U>
+struct tuple_element<I, std::pair<T, U>> : std::tuple_element<I, std::pair<T, U>>
+{};
+
+template<std::size_t I, class T, class U>
+struct tuple_element<I, std::pair<T, U> const> : std::tuple_element<I, std::pair<T, U> const>
+{};
+
+template<std::size_t I, class T, class U>
+struct tuple_element<I, std::pair<T, U> volatile> : std::tuple_element<I, std::pair<T, U> volatile>
+{};
 
-template<auto... Vs>
-struct non_type_list;
+template<std::size_t I, class T, class U>
+struct tuple_element<I, std::pair<T, U> const volatile> : std::tuple_element<I, std::pair<T, U> const volatile>
+{};
 
-} // detail
 
 template<class T>
 struct adaptor;
@@ -20,7 +58,7 @@ struct adaptor;
 template<class T, class U>
 struct adaptor<std::pair<T, U>>
 {
-    using getters_list = detail::non_type_list<&std::pair<T, U>::first, &std::pair<T, U>::second>;
+    using getters_list = detail::call_std_get<std::index_sequence<0, 1>>::type;
 };
 
 } // iris::alloy
diff --git a/include/iris/alloy/adapted/std_tuple.hpp b/include/iris/alloy/adapted/std_tuple.hpp
index 1325dc2..f62f31a 100644
--- a/include/iris/alloy/adapted/std_tuple.hpp
+++ b/include/iris/alloy/adapted/std_tuple.hpp
@@ -3,9 +3,11 @@
 
 // SPDX-License-Identifier: MIT
 
-#include <iris/alloy/detail/integer_seq_transform.hpp>
+#include <iris/config.hpp> // IWYU pragma: keep
 
-#include <tuple>
+#include <iris/alloy/detail/std_get.hpp>
+
+#include <tuple> // IWYU pragma: export
 #include <utility>
 
 #include <cstddef>
@@ -13,32 +15,51 @@
 namespace iris::alloy {
 
 template<class T>
-struct adaptor;
+struct tuple_size;
 
-namespace detail {
+template<class... Ts>
+struct tuple_size<std::tuple<Ts...>> : std::integral_constant<std::size_t, sizeof...(Ts)>
+{};
 
-template<std::size_t I>
-struct call_std_get
-{
-    template<class Tuple>
-    static constexpr decltype(auto) operator()(Tuple&& t)
-    {
-        return std::get<I>(static_cast<Tuple&&>(t));
-    }
-};
+template<class... Ts>
+struct tuple_size<std::tuple<Ts...> const> : std::integral_constant<std::size_t, sizeof...(Ts)>
+{};
 
-template<std::size_t I>
-struct make_call_std_get
-{
-    static constexpr auto value = call_std_get<I>{};
-};
+template<class... Ts>
+struct tuple_size<std::tuple<Ts...> volatile> : std::integral_constant<std::size_t, sizeof...(Ts)>
+{};
 
-} // detail
+template<class... Ts>
+struct tuple_size<std::tuple<Ts...> const volatile> : std::integral_constant<std::size_t, sizeof...(Ts)>
+{};
+
+template<std::size_t I, class Tuple>
+struct tuple_element;
+
+template<std::size_t I, class... Ts>
+struct tuple_element<I, std::tuple<Ts...>> : std::tuple_element<I, std::tuple<Ts...>>
+{};
+
+template<std::size_t I, class... Ts>
+struct tuple_element<I, std::tuple<Ts...> const> : std::tuple_element<I, std::tuple<Ts...> const>
+{};
+
+template<std::size_t I, class... Ts>
+struct tuple_element<I, std::tuple<Ts...> volatile> : std::tuple_element<I, std::tuple<Ts...> volatile>
+{};
+
+template<std::size_t I, class... Ts>
+struct tuple_element<I, std::tuple<Ts...> const volatile> : std::tuple_element<I, std::tuple<Ts...> const volatile>
+{};
+
+
+template<class T>
+struct adaptor;
 
 template<class... Ts>
 struct adaptor<std::tuple<Ts...>>
 {
-    using getters_list = detail::integer_seq_transform_t<std::make_index_sequence<sizeof...(Ts)>, detail::make_call_std_get>;
+    using getters_list = detail::call_std_get<std::index_sequence_for<Ts...>>::type;
 };
 
 } // iris::alloy
diff --git a/include/iris/alloy/detail/deduce.hpp b/include/iris/alloy/detail/deduce.hpp
index 3e650ff..18e5e58 100644
--- a/include/iris/alloy/detail/deduce.hpp
+++ b/include/iris/alloy/detail/deduce.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <type_traits>
 
 namespace iris::alloy::detail {
@@ -10,8 +12,11 @@ namespace iris::alloy::detail {
 template<class FromLValue, class FromXValue>
 struct deduce
 {
-    static_assert(std::conjunction_v<std::is_reference<FromLValue>, std::is_reference<FromXValue>,
-                                     std::is_same<std::remove_reference_t<FromLValue>, std::remove_reference_t<FromXValue>>>);
+    static_assert(std::conjunction_v<
+        std::is_reference<FromLValue>,
+        std::is_reference<FromXValue>,
+        std::is_same<std::remove_reference_t<FromLValue>, std::remove_reference_t<FromXValue>>
+    >);
 };
 
 template<class T>
@@ -33,7 +38,7 @@ struct deduce<T&&, T&&>
 };
 
 template<class FromLValue, class FromXValue>
-using deduce_t = typename deduce<FromLValue, FromXValue>::type;
+using deduce_t = deduce<FromLValue, FromXValue>::type;
 
 } // iris::alloy::detail
 
diff --git a/include/iris/alloy/detail/integer_seq_transform.hpp b/include/iris/alloy/detail/integer_seq_transform.hpp
deleted file mode 100644
index b7c033c..0000000
--- a/include/iris/alloy/detail/integer_seq_transform.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef IRIS_ZZ_ALLOY_DETAIL_INTEGER_SEQ_TRANSFORM_HPP
-#define IRIS_ZZ_ALLOY_DETAIL_INTEGER_SEQ_TRANSFORM_HPP
-
-// SPDX-License-Identifier: MIT
-
-#include <utility>
-
-namespace iris::alloy::detail {
-
-template<auto... Vs>
-struct non_type_list;
-
-template<class IntegerSeq, template<typename IntegerSeq::value_type> class F>
-struct integer_seq_transform;
-
-template<class T, T... Is, template<T> class F>
-struct integer_seq_transform<std::integer_sequence<T, Is...>, F>
-{
-    using type = detail::non_type_list<F<Is>::value...>;
-};
-
-template<class IntegerSeq, template<typename IntegerSeq::value_type> class F>
-using integer_seq_transform_t = typename integer_seq_transform<IntegerSeq, F>::type;
-
-} // iris::alloy::detail
-
-#endif
diff --git a/include/iris/alloy/detail/std_get.hpp b/include/iris/alloy/detail/std_get.hpp
new file mode 100644
index 0000000..cc149af
--- /dev/null
+++ b/include/iris/alloy/detail/std_get.hpp
@@ -0,0 +1,37 @@
+#ifndef IRIS_ZZ_ALLOY_DETAIL_STD_GET_HPP
+#define IRIS_ZZ_ALLOY_DETAIL_STD_GET_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <iris/type_traits.hpp>
+
+#include <utility>
+
+#include <cstddef> // IWYU pragma: keep
+
+namespace iris::alloy::detail {
+
+template<std::size_t I>
+struct call_std_get_impl
+{
+    template<class Tuple>
+    [[nodiscard]] static constexpr decltype(auto) operator()(Tuple&& t) noexcept
+    {
+        return std::get<I>(static_cast<Tuple&&>(t));
+    }
+};
+
+template<class Seq>
+struct call_std_get;
+
+template<std::size_t... Is>
+struct call_std_get<std::index_sequence<Is...>>
+{
+    using type = constant_list<call_std_get_impl<Is>{}...>;
+};
+
+} // iris::alloy::detail
+
+#endif
diff --git a/include/iris/alloy/detail/tuple_comparison.hpp b/include/iris/alloy/detail/tuple_comparison.hpp
index 33c3375..88b7514 100644
--- a/include/iris/alloy/detail/tuple_comparison.hpp
+++ b/include/iris/alloy/detail/tuple_comparison.hpp
@@ -3,9 +3,10 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <iris/requirements.hpp>
 
-#include <concepts>
 #include <type_traits>
 
 namespace iris::alloy {
diff --git a/include/iris/alloy/detail/tuple_impl.hpp b/include/iris/alloy/detail/tuple_impl.hpp
index 042d15f..4100180 100644
--- a/include/iris/alloy/detail/tuple_impl.hpp
+++ b/include/iris/alloy/detail/tuple_impl.hpp
@@ -5,7 +5,7 @@
 
 #ifndef IRIS_ALLOY_GENERATE_PREPROCESSED
 
-#include <iris/config.hpp>
+#include <iris/config.hpp> // IWYU pragma: keep
 
 #include <iris/alloy/detail/tuple_comparison.hpp>
 
@@ -15,7 +15,7 @@
 
 #include <type_traits>
 
-#include <cstddef>
+#include <cstddef> // IWYU pragma: keep
 
 #endif
 
diff --git a/include/iris/alloy/io.hpp b/include/iris/alloy/io.hpp
index f4aa7ab..5cfa6fc 100644
--- a/include/iris/alloy/io.hpp
+++ b/include/iris/alloy/io.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <iris/io_fwd.hpp>
 
 #include <iris/alloy/tuple.hpp>
@@ -10,7 +12,7 @@
 #include <ostream>
 #include <utility>
 
-#include <cstddef>
+#include <cstddef> // IWYU pragma: keep
 
 namespace iris::alloy {
 
diff --git a/include/iris/alloy/traits.hpp b/include/iris/alloy/traits.hpp
index d70909e..edc5858 100644
--- a/include/iris/alloy/traits.hpp
+++ b/include/iris/alloy/traits.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <iris/alloy/detail/deduce.hpp>
 
 #include <iris/type_traits.hpp>
@@ -17,22 +19,6 @@ namespace iris::alloy {
 template<class T>
 struct adaptor;
 
-namespace detail {
-
-template<class T>
-struct non_type_list_size {};
-
-template<template<auto...> class TList, auto... Vs>
-struct non_type_list_size<TList<Vs...>> : std::integral_constant<std::size_t, sizeof...(Vs)> {};
-
-template<std::size_t I, class NonTypeList>
-struct non_type_list_indexing {};
-
-template<std::size_t I, template<auto...> class TList, auto... Vs>
-struct non_type_list_indexing<I, TList<Vs...>> : cpack_indexing<I, Vs...> {};
-
-} // detail
-
 struct value_initialize_t {};
 
 inline constexpr value_initialize_t value_initialize{};
@@ -40,9 +26,6 @@ inline constexpr value_initialize_t value_initialize{};
 template<class... Ts>
 class tuple;
 
-template<class T>
-struct adaptor;
-
 namespace detail {
 
 template<class T>
@@ -71,11 +54,17 @@ struct tuple_size {};
 template<class T>
 struct tuple_size<T const> : tuple_size<T> {};
 
+template<class T>
+struct tuple_size<T volatile> : tuple_size<T> {};
+
+template<class T>
+struct tuple_size<T const volatile> : tuple_size<T> {};
+
 template<class... Ts>
 struct tuple_size<tuple<Ts...>> : std::integral_constant<std::size_t, sizeof...(Ts)> {};
 
 template<Adapted T>
-struct tuple_size<T> : detail::non_type_list_size<typename adaptor<T>::getters_list> {};
+struct tuple_size<T> : std::integral_constant<std::size_t, adaptor<std::remove_cvref_t<T>>::getters_list::size> {};
 
 template<class T>
 inline constexpr std::size_t tuple_size_v = tuple_size<T>::value;
@@ -89,8 +78,27 @@ struct tuple_element<I, tuple<Ts...>>
     using type = IRIS_CORE_PACK_INDEXING(I, Ts...);
 };
 
+template<std::size_t I, class... Ts>
+struct tuple_element<I, tuple<Ts...> const>
+{
+    using type = tuple_element<I, tuple<Ts...>>::type const;
+};
+
+template<std::size_t I, class... Ts>
+struct tuple_element<I, tuple<Ts...> volatile>
+{
+    using type = tuple_element<I, tuple<Ts...>>::type volatile;
+};
+
+template<std::size_t I, class... Ts>
+struct tuple_element<I, tuple<Ts...> const volatile>
+{
+    using type = tuple_element<I, tuple<Ts...>>::type const volatile;
+};
+
+
 template<std::size_t I, class Tuple>
-using tuple_element_t = typename tuple_element<I, Tuple>::type;
+using tuple_element_t = tuple_element<I, Tuple>::type;
 
 template<std::size_t I, class... Ts>
 [[nodiscard]] constexpr tuple_element_t<I, tuple<Ts...>>& get(tuple<Ts...>& t) noexcept;
@@ -106,17 +114,42 @@ template<std::size_t I, class... Ts>
 
 namespace detail {
 
+template<Adapted T, std::size_t I, auto... Getters>
+struct adaptor_getter_t_impl;
+
+template<Adapted T, auto Getter, auto... Getters>
+struct adaptor_getter_t_impl<T, 0, Getter, Getters...>
+{
+    static constexpr auto getter = Getter;
+    using getter_type = decltype(Getter);
+    using type = decltype(std::invoke(Getter, std::declval<T>()));
+};
+
+template<Adapted T, std::size_t I, auto Getter, auto... Getters>
+struct adaptor_getter_t_impl<T, I, Getter, Getters...>
+    : adaptor_getter_t_impl<T, I - 1, Getters...>
+{};
+
+template<Adapted T, std::size_t I, class GettersListT>
+struct adaptor_getter_t_dispatch;
+
+template<Adapted T, std::size_t I, auto... Getters>
+struct adaptor_getter_t_dispatch<T, I, constant_list<Getters...>>
+{
+    using type = adaptor_getter_t_impl<T, I, Getters...>;
+};
+
 template<std::size_t I, Adapted T>
-inline constexpr auto getter_of = non_type_list_indexing<I, typename adaptor<T>::getters_list>::value;
+using adaptor_getter_t = adaptor_getter_t_dispatch<T, I, typename adaptor<std::remove_cvref_t<T>>::getters_list>::type;
 
-}  // namespace detail
+} // detail
 
 template<std::size_t I, Adapted T>
-[[nodiscard]] constexpr auto get(T&& x)
-    noexcept(std::is_nothrow_invocable_v<decltype(detail::getter_of<I, std::remove_cvref_t<T>>), T>)
-    -> std::invoke_result_t<decltype(detail::getter_of<I, std::remove_cvref_t<T>>), T>
+[[nodiscard]] constexpr detail::adaptor_getter_t<I, T>::type
+get(T&& x)
+    noexcept(std::is_nothrow_invocable_v<typename detail::adaptor_getter_t<I, T>::getter_type, T>)
 {
-    return std::invoke(detail::getter_of<I, std::remove_cvref_t<T>>, std::forward<T>(x));
+    return std::invoke(detail::adaptor_getter_t<I, T>::getter, std::forward<T>(x));
 }
 
 namespace detail {
@@ -189,7 +222,7 @@ struct basic_common_reference_impl<TTuple, UTuple, TQual, UQual, std::index_sequ
 // Doing so would produce some hard errors on completely irrelevant
 // context; for example, calling `std::map<T, U>{}.rbegin()` would
 // inevitably *check* `TupleLike` for `std::pair<T const, U>` thus
-// leads to instantiation of `getter_of`. Then if the instantiation
+// leads to instantiation of `alloy::get`. Then if the instantiation
 // yields hard error for some reason, the error is propagated to the
 // caller in SFINAE-unfriendly context.
 template<class TTuple, class UTuple, template<class> class TQual, template<class> class UQual>
diff --git a/include/iris/alloy/tuple.hpp b/include/iris/alloy/tuple.hpp
index 1e6a3c3..0dbdf00 100644
--- a/include/iris/alloy/tuple.hpp
+++ b/include/iris/alloy/tuple.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #ifndef IRIS_USE_PREPROCESSED
 #define IRIS_USE_PREPROCESSED 1
 #endif
@@ -13,7 +15,6 @@
 #include <iris/alloy/detail/tuple_impl.hpp>
 #endif
 
-#include <iris/alloy/detail/integer_seq_transform.hpp>
 #include <iris/alloy/detail/tuple_comparison.hpp>
 
 #include <type_traits>
@@ -25,9 +26,6 @@ namespace iris::alloy {
 
 namespace detail {
 
-template<class... Ts>
-struct type_list;
-
 template<class IndexSeq, class UTuple, class... Ts>
 struct tuple_traits_impl;
 
diff --git a/include/iris/alloy/utility.hpp b/include/iris/alloy/utility.hpp
index 9b13cbd..d757202 100644
--- a/include/iris/alloy/utility.hpp
+++ b/include/iris/alloy/utility.hpp
@@ -3,10 +3,15 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <iris/alloy/traits.hpp>
 #include <iris/alloy/tuple.hpp>
 
-#include <functional>
+#include <iris/utility.hpp>
+#include <iris/type_traits.hpp>
+
+#include <functional> // std::invoke
 #include <type_traits>
 #include <utility>
 
@@ -16,9 +21,6 @@ namespace iris::alloy {
 
 namespace detail {
 
-template<class... Ts>
-struct type_list;
-
 template<class ResultTypeList, class IndexSeqList, class... Tuples>
 struct tuple_cat_result_impl;
 
@@ -30,10 +32,20 @@ struct tuple_cat_result_impl<type_list<ResultTypes...>, type_list<>>
 
 template<class... ResultTypes, std::size_t... Is, class... IndexSeqs, class Tuple, class... Tuples>
 struct tuple_cat_result_impl<type_list<ResultTypes...>, type_list<std::index_sequence<Is...>, IndexSeqs...>, Tuple, Tuples...>
-    : tuple_cat_result_impl<type_list<ResultTypes..., tuple_element_t<Is, std::remove_cvref_t<Tuple>>...>, type_list<IndexSeqs...>, Tuples...> {};
+    : tuple_cat_result_impl<
+        type_list<ResultTypes..., tuple_element_t<Is, std::remove_cvref_t<Tuple>>...>,
+        type_list<IndexSeqs...>,
+        Tuples...
+>
+{};
 
 template<class... Tuples>
-struct tuple_cat_result : tuple_cat_result_impl<type_list<>, type_list<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuples>>>...>, Tuples...> {};
+struct tuple_cat_result : tuple_cat_result_impl<
+    type_list<>,
+    type_list<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuples>>>...>,
+    Tuples...
+>
+{};
 
 template<class ResultTuple, class IndexSeqList, class... Tuples>
 struct tuple_cat_impl_base;
@@ -56,25 +68,31 @@ struct tuple_cat_impl_base<ResultTuple, type_list<std::index_sequence<Is...>, In
 {
     template<class... Args>
     static constexpr bool nothrow =
-        tuple_cat_impl_base<ResultTuple, type_list<IndexSeqs...>, Tuples...>::template nothrow<Args...> && (is_nothrow_gettable_v<Is, Tuple> && ...);
+        tuple_cat_impl_base<ResultTuple, type_list<IndexSeqs...>, Tuples...>::template nothrow<Args...> &&
+        (is_nothrow_gettable_v<Is, Tuple> && ...);
 
     template<class... Args>
     static constexpr ResultTuple apply(Tuple&& tuple, Tuples&&... tuples, Args&&... args) noexcept(nothrow<Args...>)
     {
-        return tuple_cat_impl_base<ResultTuple, type_list<IndexSeqs...>, Tuples...>::apply(std::forward<Tuples>(tuples)..., std::forward<Args>(args)...,
-                                                                                           alloy::get<Is>(std::forward<Tuple>(tuple))...);
+        return tuple_cat_impl_base<ResultTuple, type_list<IndexSeqs...>, Tuples...>::apply(
+            std::forward<Tuples>(tuples)..., std::forward<Args>(args)...,
+            alloy::get<Is>(std::forward<Tuple>(tuple))...
+        );
     }
 };
 
 template<class... Tuples>
 struct tuple_cat_impl
 {
-    using Base = tuple_cat_impl_base<typename tuple_cat_result<Tuples...>::type,
-                                     detail::type_list<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuples>>>...>, Tuples...>;
+    using Base = tuple_cat_impl_base<
+        typename tuple_cat_result<Tuples...>::type,
+        type_list<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuples>>>...>,
+        Tuples...
+    >;
 
     static constexpr bool nothrow = Base::template nothrow<>;
 
-    static constexpr typename tuple_cat_result<Tuples...>::type apply(Tuples&&... tuples) noexcept(nothrow)
+    static constexpr tuple_cat_result<Tuples...>::type apply(Tuples&&... tuples) noexcept(nothrow)
     {
         return Base::apply(std::forward<Tuples>(tuples)...);
     }
@@ -102,20 +120,20 @@ struct index_sequence_split : index_sequence_split_impl<N, std::index_sequence<>
 template<std::size_t N, class IndexSeq>
 struct index_sequence_take
 {
-    using type = typename index_sequence_split<N, IndexSeq>::head;
+    using type = index_sequence_split<N, IndexSeq>::head;
 };
 
 template<std::size_t N, class IndexSeq>
-using index_sequence_take_t = typename index_sequence_take<N, IndexSeq>::type;
+using index_sequence_take_t = index_sequence_take<N, IndexSeq>::type;
 
 template<std::size_t N, class IndexSeq>
 struct index_sequence_drop
 {
-    using type = typename index_sequence_split<N, IndexSeq>::tail;
+    using type = index_sequence_split<N, IndexSeq>::tail;
 };
 
 template<std::size_t N, class IndexSeq>
-using index_sequence_drop_t = typename index_sequence_drop<N, IndexSeq>::type;
+using index_sequence_drop_t = index_sequence_drop<N, IndexSeq>::type;
 
 template<std::size_t From, std::size_t To, class IndexSeq>
 struct index_sequence_subrange
@@ -124,7 +142,7 @@ struct index_sequence_subrange
 };
 
 template<std::size_t From, std::size_t To, class IndexSeq>
-using index_sequence_subrange_t = typename index_sequence_subrange<From, To, IndexSeq>::type;
+using index_sequence_subrange_t = index_sequence_subrange<From, To, IndexSeq>::type;
 
 template<class IndexSeq>
 struct index_sequence_sum;
@@ -152,7 +170,7 @@ struct index_sequence_cumulative_sum<std::index_sequence<Is...>>
     : index_sequence_cumulative_sum_impl<std::make_index_sequence<sizeof...(Is)>, std::index_sequence<Is...>> {};
 
 template<class IndexSeq>
-using index_sequence_cumulative_sum_t = typename index_sequence_cumulative_sum<IndexSeq>::type;
+using index_sequence_cumulative_sum_t = index_sequence_cumulative_sum<IndexSeq>::type;
 
 template<class IndexSeq, class FromIndexSeq, class ToIndexSeq>
 struct index_sequence_segment_impl;
@@ -171,12 +189,15 @@ struct index_sequence_segment<std::index_sequence<Is...>, Sizes...>
 {
     using CumSumIndexSeq = index_sequence_cumulative_sum_t<std::index_sequence<Sizes...>>;
 
-    using type = typename index_sequence_segment_impl<std::index_sequence<Is...>, index_sequence_take_t<sizeof...(Sizes), CumSumIndexSeq>,
-                                                      index_sequence_drop_t<1, CumSumIndexSeq>>::type;
+    using type = index_sequence_segment_impl<
+        std::index_sequence<Is...>,
+        index_sequence_take_t<sizeof...(Sizes), CumSumIndexSeq>,
+        index_sequence_drop_t<1, CumSumIndexSeq>
+    >::type;
 };
 
 template<class IndexSeq, std::size_t... Sizes>
-using index_sequence_segment_t = typename index_sequence_segment<IndexSeq, Sizes...>::type;
+using index_sequence_segment_t = index_sequence_segment<IndexSeq, Sizes...>::type;
 
 template<class Tuple, class IndexSeq>
 struct tuple_from_tuple_and_index_sequence;
@@ -188,7 +209,7 @@ struct tuple_from_tuple_and_index_sequence<Tuple, std::index_sequence<Is...>>
 };
 
 template<class Tuple, class IndexSeq>
-using tuple_from_tuple_and_index_sequence_t = typename tuple_from_tuple_and_index_sequence<Tuple, IndexSeq>::type;
+using tuple_from_tuple_and_index_sequence_t = tuple_from_tuple_and_index_sequence<Tuple, IndexSeq>::type;
 
 template<class Tuple, class SegmentedIndexSeqList>
 struct tuple_split_result_impl;
@@ -202,7 +223,7 @@ struct tuple_split_result_impl<Tuple, type_list<SegmentedIndexSeqs...>>
 template<class Tuple, std::size_t... Sizes>
 struct tuple_split_result
 {
-    using type = typename tuple_split_result_impl<Tuple, index_sequence_segment_t<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuple>>>, Sizes...>>::type;
+    using type = tuple_split_result_impl<Tuple, index_sequence_segment_t<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuple>>>, Sizes...>>::type;
 };
 
 template<class ResultInnerTuple, class Tuple, class IndexSeq>
@@ -237,8 +258,12 @@ struct tuple_split_make_outer<tuple<ResultInnerTuples...>, Tuple, type_list<Segm
 };
 
 template<class Tuple, std::size_t... Sizes>
-struct tuple_split_impl : tuple_split_make_outer<typename tuple_split_result<Tuple, Sizes...>::type, Tuple,
-                                                 index_sequence_segment_t<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuple>>>, Sizes...>> {};
+struct tuple_split_impl : tuple_split_make_outer<
+    typename tuple_split_result<Tuple, Sizes...>::type,
+    Tuple,
+    index_sequence_segment_t<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuple>>>, Sizes...>
+>
+{};
 
 template<class From, class To, class IndexSeq = std::make_index_sequence<tuple_size_v<std::remove_cvref_t<From>>>>
 struct tuple_assign_impl;
@@ -246,8 +271,10 @@ struct tuple_assign_impl;
 template<class From, class To, std::size_t... Is>
 struct tuple_assign_impl<From, To, std::index_sequence<Is...>>
 {
-    static constexpr bool nothrow = std::conjunction_v<std::conjunction<is_nothrow_gettable<Is, From>, is_nothrow_gettable<Is, To>>...,
-                                                       std::is_nothrow_assignable<tuple_get_t<Is, To>, tuple_get_t<Is, From>>...>;
+    static constexpr bool nothrow = std::conjunction_v<
+        std::conjunction<is_nothrow_gettable<Is, From>, is_nothrow_gettable<Is, To>>...,
+        std::is_nothrow_assignable<tuple_get_t<Is, To>, tuple_get_t<Is, From>>...
+    >;
 
     static constexpr void apply(From&& from, To&& to) noexcept(nothrow)
     {
@@ -274,21 +301,35 @@ template<std::size_t... Is>
 struct for_each_impl<std::index_sequence<Is...>>
 {
     template<class Tuple, class F>
-    static constexpr void apply(Tuple&& t, F&& f){
+    static constexpr void apply(Tuple&& t, F&& f)
+        noexcept(std::conjunction_v<
+            std::is_nothrow_invocable<F, tuple_get_t<Is, Tuple>>...
+        >)
+    {
         ((void)std::invoke(std::forward<F>(f), alloy::get<Is>(std::forward<Tuple>(t))), ...);
     }
+
+    template<class Tuple, class F>
+        requires std::invocable<F, std::integral_constant<std::size_t, 0>, tuple_get_t<0, Tuple>>
+    static constexpr void apply(Tuple&& t, F&& f)
+        noexcept(std::conjunction_v<
+            std::is_nothrow_invocable<F, std::integral_constant<std::size_t, Is>, tuple_get_t<Is, Tuple>>...
+        >)
+    {
+        ((void)std::invoke(std::forward<F>(f), std::integral_constant<std::size_t, Is>{}, alloy::get<Is>(std::forward<Tuple>(t))), ...);
+    }
 };
 
 } // detail
 
 template<class... Tuples>
-using tuple_cat_t = typename detail::tuple_cat_result<Tuples...>::type;
+using tuple_cat_t = detail::tuple_cat_result<Tuples...>::type;
 
 template<class Tuple, std::size_t... Sizes>
-using tuple_split_t = typename detail::tuple_split_result<Tuple, Sizes...>::type;
+using tuple_split_t = detail::tuple_split_result<Tuple, Sizes...>::type;
 
 template<class Tuple>
-using tuple_ref_t = typename detail::tuple_ref_result<Tuple>::type;
+using tuple_ref_t = detail::tuple_ref_result<Tuple>::type;
 
 template<TupleLike... Tuples>
 [[nodiscard]] constexpr tuple_cat_t<Tuples...> tuple_cat(Tuples&&... tuples) noexcept(detail::tuple_cat_impl<Tuples...>::nothrow)
@@ -318,10 +359,104 @@ template<TupleLike Tuple>
 
 template<TupleLike Tuple, class F>
 constexpr void for_each(Tuple&& t, F&& f)
+    noexcept(noexcept(detail::for_each_impl<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuple>>>>::apply(std::forward<Tuple>(t), std::forward<F>(f))))
 {
     return detail::for_each_impl<std::make_index_sequence<tuple_size_v<std::remove_cvref_t<Tuple>>>>::apply(std::forward<Tuple>(t), std::forward<F>(f));
 }
 
+namespace detail {
+
+template<class Tuple, class F>
+concept invocable_with_index =
+    std::invocable<F, std::integral_constant<std::size_t, 0>, tuple_get_t<0, Tuple>>;
+
+template<class Tuple, class F>
+struct visit_at_return_type
+{
+    using type = decltype(
+        std::invoke(std::declval<F>(), std::declval<tuple_get_t<0, Tuple>>())
+    );
+};
+
+template<class Tuple, class F>
+    requires invocable_with_index<Tuple, F>
+struct visit_at_return_type<Tuple, F>
+{
+    using type = decltype(
+        std::invoke(std::declval<F>(), std::declval<std::integral_constant<std::size_t, 0>>(), std::declval<tuple_get_t<0, Tuple>>())
+    );
+};
+
+template<class Tuple, std::size_t I, class F>
+struct visit_at_noexcept_impl
+{
+    static constexpr bool value = noexcept(
+        std::invoke(std::declval<F>(), std::declval<tuple_get_t<I, Tuple>>())
+    );
+};
+
+template<class Tuple, std::size_t I, class F>
+    requires invocable_with_index<Tuple, F>
+struct visit_at_noexcept_impl<Tuple, I, F>
+{
+    static constexpr bool value = noexcept(
+        std::invoke(std::declval<F>(), std::declval<std::integral_constant<std::size_t, I>>(), std::declval<tuple_get_t<I, Tuple>>())
+    );
+};
+
+template<class Tuple, class Seq, class F>
+struct visit_at_noexcept_impl_dispatch;
+
+template<class Tuple, class F, std::size_t... Is>
+struct visit_at_noexcept_impl_dispatch<Tuple, std::index_sequence<Is...>, F>
+    : std::conjunction<visit_at_noexcept_impl<Tuple, Is, F>...>
+{};
+
+template<class Tuple, class F>
+constexpr bool visit_at_all_noexcept = visit_at_noexcept_impl_dispatch<
+    Tuple,
+    std::make_index_sequence<tuple_size_v<Tuple>>,
+    F
+>::value;
+
+} // detail
+
+// `f(auto&& elem)`
+template<TupleLike Tuple, class F>
+    requires (!detail::invocable_with_index<Tuple, F>)
+IRIS_FORCEINLINE constexpr detail::visit_at_return_type<Tuple, F>::type
+visit_at(std::size_t const i, F&& f, Tuple&& tup)
+    noexcept(detail::visit_at_all_noexcept<Tuple, F>)
+{
+    return iris::invoke_with_index<tuple_size_v<Tuple>>(
+        i,
+        [&]<std::size_t I>(std::integral_constant<std::size_t, I>) constexpr
+            noexcept(noexcept(std::invoke(std::declval<F>(), std::declval<detail::tuple_get_t<I, Tuple>>())))
+            -> detail::visit_at_return_type<Tuple, F>::type
+        {
+            return std::invoke(std::forward<F>(f), alloy::get<I>(std::forward<Tuple>(tup)));
+        }
+    );
+}
+
+// `f<std::size_t I>(std::integral_constant<std::size_t, I>, auto&& elem)`
+template<TupleLike Tuple, class F>
+    requires detail::invocable_with_index<Tuple, F>
+IRIS_FORCEINLINE constexpr detail::visit_at_return_type<Tuple, F>::type
+visit_at(std::size_t const i, F&& f, Tuple&& tup)
+    noexcept(detail::visit_at_all_noexcept<Tuple, F>)
+{
+    return iris::invoke_with_index<tuple_size_v<Tuple>>(
+        i,
+        [&]<std::size_t I>(std::integral_constant<std::size_t, I>) constexpr
+            noexcept(noexcept(std::invoke(std::declval<F>(), std::declval<std::integral_constant<std::size_t, I>>(), std::declval<detail::tuple_get_t<I, Tuple>>())))
+            -> detail::visit_at_return_type<Tuple, F>::type
+        {
+            return std::invoke(std::forward<F>(f), std::integral_constant<std::size_t, I>{}, alloy::get<I>(std::forward<Tuple>(tup)));
+        }
+    );
+}
+
 } // iris::alloy
 
 #endif
diff --git a/include/iris/io_fwd.hpp b/include/iris/io_fwd.hpp
index a5ea198..f4d1ecb 100644
--- a/include/iris/io_fwd.hpp
+++ b/include/iris/io_fwd.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <concepts>
 #include <iosfwd>
 #include <type_traits>
diff --git a/include/iris/rvariant/detail/rvariant_fwd.hpp b/include/iris/rvariant/detail/rvariant_fwd.hpp
index 7d01ed6..5077324 100644
--- a/include/iris/rvariant/detail/rvariant_fwd.hpp
+++ b/include/iris/rvariant/detail/rvariant_fwd.hpp
@@ -3,7 +3,9 @@
 
 // SPDX-License-Identifier: MIT
 
-#include <cstddef>
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <cstddef> // IWYU pragma: keep
 
 #if !defined(IRIS_RVARIANT_VISIT_STRENGTHEN)
 # define IRIS_RVARIANT_VISIT_STRENGTHEN 1
diff --git a/include/iris/rvariant/recursive_wrapper.hpp b/include/iris/rvariant/recursive_wrapper.hpp
index c5b3e06..72a58d1 100644
--- a/include/iris/rvariant/recursive_wrapper.hpp
+++ b/include/iris/rvariant/recursive_wrapper.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#include <iris/config.hpp> // IWYU pragma: keep
+
 #include <iris/bits/specialization_of.hpp>
 
 #include <iris/hash.hpp>
diff --git a/include/iris/rvariant/rvariant.hpp b/include/iris/rvariant/rvariant.hpp
index 9d05b3b..a05b6ec 100644
--- a/include/iris/rvariant/rvariant.hpp
+++ b/include/iris/rvariant/rvariant.hpp
@@ -3,6 +3,8 @@
 
 // SPDX-License-Identifier: MIT
 
+#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>
diff --git a/include/iris/type_traits.hpp b/include/iris/type_traits.hpp
index fcce5ad..fde5bd8 100644
--- a/include/iris/type_traits.hpp
+++ b/include/iris/type_traits.hpp
@@ -61,6 +61,12 @@ struct type_list
     static constexpr std::size_t size = sizeof...(Ts);
 };
 
+template<auto... Vals>
+struct constant_list
+{
+    static constexpr std::size_t size = sizeof...(Vals);
+};
+
 template<auto...> using cvoid_t = void;
 
 namespace detail {
diff --git a/include/iris/utility.hpp b/include/iris/utility.hpp
new file mode 100644
index 0000000..2e2d3ce
--- /dev/null
+++ b/include/iris/utility.hpp
@@ -0,0 +1,173 @@
+#ifndef IRIS_ZZ_UTILITY_HPP
+#define IRIS_ZZ_UTILITY_HPP
+
+// SPDX-License-Identifier: MIT
+
+#include <iris/config.hpp> // IWYU pragma: keep
+
+#include <utility> // IWYU pragma: export
+#include <type_traits>
+#include <array>
+#include <functional> // std::invoke
+
+#include <cassert>
+
+namespace iris {
+
+namespace detail::adl_get {
+
+using std::get;
+
+template<std::size_t I, class T>
+concept gettable_impl = requires(T&& t) {
+    get<I>(std::forward<T>(t));
+};
+
+} // detail::adl_get
+
+template<std::size_t I, class T>
+concept gettable = detail::adl_get::gettable_impl<I, T>;
+
+
+namespace detail {
+
+template<class F>
+using invoke_with_index_result_t = decltype(
+    std::invoke(std::declval<F>(), std::declval<std::integral_constant<std::size_t, 0>>())
+);
+
+template<std::size_t I, class F>
+struct invoke_with_index_noexcept_impl
+{
+    static constexpr bool value = noexcept(
+        std::invoke(std::declval<F>(), std::declval<std::integral_constant<std::size_t, I>>())
+    );
+};
+
+template<class Seq, class F>
+struct invoke_with_index_noexcept_impl_dispatch;
+
+template<class F, std::size_t... Is>
+struct invoke_with_index_noexcept_impl_dispatch<std::index_sequence<Is...>, F>
+    : std::conjunction<invoke_with_index_noexcept_impl<Is, F>...>
+{};
+
+template<std::size_t N, class F>
+constexpr bool invoke_with_index_all_noexcept = invoke_with_index_noexcept_impl_dispatch<
+    std::make_index_sequence<N>,
+    F
+>::value;
+
+template<int Strategy>
+struct invoke_with_index_impl;
+
+template<class F, class Seq>
+struct invoke_with_index_table;
+
+template<class F, std::size_t... Is>
+struct invoke_with_index_table<F, std::index_sequence<Is...>>
+{
+    static constexpr bool all_noexcept = invoke_with_index_all_noexcept<sizeof...(Is), F>;
+
+    static constexpr auto table = std::array{
+        +[](F&& f) static constexpr noexcept(all_noexcept) -> invoke_with_index_result_t<F> {
+            return std::invoke(std::forward<F>(f), std::integral_constant<std::size_t, Is>{});
+        }...
+    };
+};
+
+template<>
+struct invoke_with_index_impl<-1>
+{
+    template<std::size_t N, class F>
+    [[nodiscard]] IRIS_FORCEINLINE static constexpr invoke_with_index_result_t<F>
+    apply(std::size_t const i, F&& f)
+        noexcept(invoke_with_index_all_noexcept<N, F>)
+    {
+        assert(i < N);
+        return std::invoke(
+            invoke_with_index_table<F, std::make_index_sequence<N>>::table[i],
+            std::forward<F>(f)
+        );
+    }
+};
+
+#define IRIS_INVOKE_WITH_INDEX_CASE(n) \
+    case (n): \
+        if constexpr ((n) < N) { \
+            return static_cast<F&&>(f)(std::integral_constant<std::size_t, (n)>{}); \
+        } else std::unreachable(); [[fallthrough]]
+
+#define IRIS_INVOKE_WITH_INDEX_DEF(strategy) \
+    template<> \
+    struct invoke_with_index_impl<(strategy)> \
+    { \
+        template<std::size_t N, class F> \
+        [[nodiscard]] IRIS_FORCEINLINE static constexpr invoke_with_index_result_t<F> \
+        apply(std::size_t const i, [[maybe_unused]] F&& f) \
+            noexcept(invoke_with_index_all_noexcept<N, F>) \
+        { \
+            switch (i) { \
+            IRIS_INVOKE_WITH_INDEX_CASES_ ## strategy (IRIS_INVOKE_WITH_INDEX_CASE, 0); \
+            default: std::unreachable(); \
+            } \
+        } \
+    };
+
+
+// We choose not to introduce the "256" branch, since we usually have a
+// limited amount of statically sized array (or tuple) to "dispatch",
+// in contrast to `variant` which ordinarily bloats the combination
+// count for multi-visits.
+template<std::size_t N>
+constexpr int invoke_with_index_strategy =
+    N <= 4 ? 0 :
+    N <= 16 ? 1 :
+    N <= 64 ? 2 :
+    -1;
+
+#define IRIS_INVOKE_WITH_INDEX_CASES_0(def, ofs) \
+    def(ofs); \
+    def((ofs) + 1); \
+    def((ofs) + 2); \
+    def((ofs) + 3)
+
+#define IRIS_INVOKE_WITH_INDEX_CASES_1(def, ofs) \
+    IRIS_INVOKE_WITH_INDEX_CASES_0(def, ofs); \
+    IRIS_INVOKE_WITH_INDEX_CASES_0(def, (ofs) + 4); \
+    IRIS_INVOKE_WITH_INDEX_CASES_0(def, (ofs) + 8); \
+    IRIS_INVOKE_WITH_INDEX_CASES_0(def, (ofs) + 12)
+
+#define IRIS_INVOKE_WITH_INDEX_CASES_2(def, ofs) \
+    IRIS_INVOKE_WITH_INDEX_CASES_1(def, ofs); \
+    IRIS_INVOKE_WITH_INDEX_CASES_1(def, (ofs) + 16); \
+    IRIS_INVOKE_WITH_INDEX_CASES_1(def, (ofs) + 32); \
+    IRIS_INVOKE_WITH_INDEX_CASES_1(def, (ofs) + 48)
+
+IRIS_INVOKE_WITH_INDEX_DEF(0);
+IRIS_INVOKE_WITH_INDEX_DEF(1);
+IRIS_INVOKE_WITH_INDEX_DEF(2);
+
+#undef IRIS_INVOKE_WITH_INDEX_CASES_0
+#undef IRIS_INVOKE_WITH_INDEX_CASES_1
+#undef IRIS_INVOKE_WITH_INDEX_CASES_2
+
+#undef IRIS_INVOKE_WITH_INDEX_CASE
+#undef IRIS_INVOKE_WITH_INDEX_DEF
+
+} // detail
+
+// Invokes `F` with static index `std::integral_constant<std::size_t, I>` deduced by runtime index `i`.
+template<std::size_t N, class F>
+IRIS_FORCEINLINE constexpr detail::invoke_with_index_result_t<F>
+invoke_with_index(std::size_t i, F&& f)
+    noexcept(detail::invoke_with_index_all_noexcept<N, F>)
+{
+    return detail::invoke_with_index_impl<detail::invoke_with_index_strategy<N>>::template apply<N>(
+        i, std::forward<F>(f)
+    );
+}
+
+} // iris
+
+#endif
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 2d4e6dd..aaa1f4d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -192,6 +192,7 @@ if(PROJECT_IS_TOP_LEVEL)
             interval_set
             snippet
             alloy
+            alloy_visit
         )
         foreach(test_name IN LISTS IRIS_TEST_IRIS_TESTS)
             iris_define_internal_test(${test_name} ${test_name}.cpp)
diff --git a/test/alloy.cpp b/test/alloy.cpp
index dc366e5..0794154 100644
--- a/test/alloy.cpp
+++ b/test/alloy.cpp
@@ -12,6 +12,8 @@
 #include <iris/alloy/tuple.hpp>
 #include <iris/alloy/utility.hpp>
 
+#include <concepts>
+
 namespace alloy = iris::alloy;
 
 struct NonAdaptedStruct
@@ -36,7 +38,7 @@ struct OldStyle
 template<>
 struct alloy::adaptor<OldStyle>
 {
-    using getters_list = make_getters_list<&OldStyle::get_int, &OldStyle::get_string>;
+    using getters_list = iris::constant_list<&OldStyle::get_int, &OldStyle::get_string>;
 };
 
 template<std::size_t I, class T>
@@ -60,15 +62,15 @@ TEST_CASE("adapt_struct")
 
         STATIC_CHECK(alloy::tuple_size_v<AdaptedStruct> == 2);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, AdaptedStruct&>, int&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, AdaptedStruct const&>, int const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, AdaptedStruct&&>, int&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, AdaptedStruct const&&>, int const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, AdaptedStruct&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, AdaptedStruct const&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, AdaptedStruct&&>, int&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, AdaptedStruct const&&>, int const&&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, AdaptedStruct&>, double&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, AdaptedStruct const&>, double const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, AdaptedStruct&&>, double&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, AdaptedStruct const&&>, double const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, AdaptedStruct&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, AdaptedStruct const&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, AdaptedStruct&&>, double&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, AdaptedStruct const&&>, double const&&>);
 
         constexpr AdaptedStruct a{42, 3.14};
 
@@ -81,10 +83,10 @@ TEST_CASE("adapt_struct")
 
         STATIC_CHECK(alloy::tuple_size_v<OldStyle> == 2);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, OldStyle&>, int>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, OldStyle&&>, int>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, OldStyle&>, std::string const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, OldStyle&&>, std::string const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, OldStyle&>, int>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, OldStyle&&>, int>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, OldStyle&>, std::string const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, OldStyle&&>, std::string const&>);
     }
 }
 
@@ -97,21 +99,46 @@ TEST_CASE("adapt_std_pair")
 
         STATIC_CHECK(alloy::tuple_size_v<Pair> == 2);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Pair&>, int&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Pair const&>, int const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Pair&&>, int&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Pair const&&>, int const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair const&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair&&>, int&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair const&&>, int const&&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Pair&>, double&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Pair const&>, double const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Pair&&>, double&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Pair const&&>, double const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair const&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair&&>, double&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair const&&>, double const&&>);
 
         constexpr Pair p(42, 3.14);
 
         STATIC_CHECK(alloy::get<0>(p) == 42);
         STATIC_CHECK(alloy::get<1>(p) == 3.14);
     }
+    {
+        using Pair = std::pair<int&, double&>;
+
+        STATIC_CHECK(alloy::TupleLike<Pair>);
+
+        STATIC_CHECK(alloy::tuple_size_v<Pair> == 2);
+
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair const&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair&&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Pair const&&>, int&>);
+
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair const&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair&&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Pair const&&>, double&>);
+
+        int i = -1;
+        double d = -2;
+        Pair p(i, d);
+        alloy::get<0>(p) = 42;
+        alloy::get<1>(p) = 3.14;
+        CHECK(alloy::get<0>(p) == 42);
+        CHECK(alloy::get<1>(p) == 3.14);
+    }
 }
 
 TEST_CASE("adapt_std_tuple")
@@ -123,20 +150,20 @@ TEST_CASE("adapt_std_tuple")
 
         STATIC_CHECK(alloy::tuple_size_v<Tuple> == 3);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&>, int&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&>, int const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&&>, int&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&&>, int const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&&>, int&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&&>, int const&&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&>, double&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&>, double const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&&>, double&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&&>, double const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&&>, double&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&&>, double const&&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&>, char&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&>, char const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&&>, char&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&&>, char const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&>, char&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&>, char const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&&>, char&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&&>, char const&&>);
 
         constexpr Tuple p(42, 3.14, 'A');
 
@@ -157,20 +184,20 @@ TEST_CASE("tuple")
 
         STATIC_CHECK(alloy::tuple_size_v<Tuple> == 3);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&>, int&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&>, int const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&&>, int&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&&>, int const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&&>, int&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&&>, int const&&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&>, double&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&>, double const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&&>, double&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&&>, double const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&&>, double&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&&>, double const&&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&>, char&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&>, char const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&&>, char&&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&&>, char const&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&>, char&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&>, char const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&&>, char&&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&&>, char const&&>);
 
         constexpr Tuple t(42, 3.14, 'A');
 
@@ -187,20 +214,20 @@ TEST_CASE("tuple")
 
         STATIC_CHECK(alloy::tuple_size_v<Tuple> == 3);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&>, int&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&>, int&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&&>, int&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&&>, int&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&&>, int&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&>, double&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&>, double&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&&>, double&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&&>, double&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&&>, double&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&>, char&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&>, char&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&&>, char&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&&>, char&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&>, char&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&>, char&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&&>, char&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&&>, char&>);
 
         int x = 42;
         double y = 3.14;
@@ -220,20 +247,20 @@ TEST_CASE("tuple")
 
         STATIC_CHECK(alloy::tuple_size_v<Tuple> == 3);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&>, int const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&>, int const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple&&>, int const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<0, Tuple const&&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple&&>, int const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<0, Tuple const&&>, int const&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&>, double const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&>, double const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple&&>, double const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<1, Tuple const&&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple&&>, double const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<1, Tuple const&&>, double const&>);
 
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&>, char const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&>, char const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple&&>, char const&>);
-        STATIC_CHECK(std::is_same_v<alloy_get_t<2, Tuple const&&>, char const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&>, char const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&>, char const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple&&>, char const&>);
+        STATIC_CHECK(std::same_as<alloy_get_t<2, Tuple const&&>, char const&>);
 
         int const x = 42;
         double const y = 3.14;
@@ -383,8 +410,8 @@ TEST_CASE("tuple")
         STATIC_CHECK(sizeof(b) == sizeof(OnlyChar));
     }
 
-    STATIC_CHECK(std::is_same_v<std::common_reference_t<alloy::tuple<int&, int&>, alloy::tuple<int, int>&>, alloy::tuple<int&, int&>>);
-    STATIC_CHECK(std::is_same_v<std::common_reference_t<AdaptedStruct&, alloy::tuple<int, double>&>, alloy::tuple<int&, double&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<alloy::tuple<int&, int&>, alloy::tuple<int, int>&>, alloy::tuple<int&, int&>>);
+    STATIC_CHECK(std::same_as<std::common_reference_t<AdaptedStruct&, alloy::tuple<int, double>&>, alloy::tuple<int&, double&>>);
 
 #if __cpp_lib_reference_from_temporary >= 202202L
     STATIC_CHECK(!std::is_constructible_v<alloy::tuple<int const&>, double>);
diff --git a/test/alloy_visit.cpp b/test/alloy_visit.cpp
new file mode 100644
index 0000000..825e35c
--- /dev/null
+++ b/test/alloy_visit.cpp
@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+
+#include "iris_test.hpp"
+
+#include <iris/alloy/adapted/std_tuple.hpp>
+#include <iris/alloy/utility.hpp>
+
+#include <tuple>
+#include <utility>
+
+namespace alloy = iris::alloy;
+
+namespace detail {
+
+template<class Seq>
+struct make_iota_tuple_impl;
+
+template<class T, T... Is>
+struct make_iota_tuple_impl<std::integer_sequence<T, Is...>>
+{
+    [[nodiscard]] static constexpr auto apply() noexcept
+    {
+        return std::tuple{Is...};
+    }
+};
+
+} // detail
+
+template<auto N>
+[[nodiscard]] consteval auto make_iota_tuple() noexcept
+{
+    return detail::make_iota_tuple_impl<std::make_integer_sequence<decltype(N), N>>::apply();
+}
+
+TEST_CASE("alloy: visit")
+{
+    {
+        constexpr auto f = [](auto&& elem) noexcept { return elem; };
+
+        #define IRIS_TEST_VISIT(N) \
+            STATIC_CHECK(alloy::visit_at(0, f, make_iota_tuple<N>()) == 0); \
+            STATIC_CHECK(noexcept(alloy::visit_at(0, f, make_iota_tuple<N>()))); \
+            STATIC_CHECK(alloy::visit_at(N - 1, f, make_iota_tuple<N>()) == N - 1); \
+            STATIC_CHECK(noexcept(alloy::visit_at(N - 1, f, make_iota_tuple<N>())))
+
+        // Strategy = 0
+        IRIS_TEST_VISIT(4);
+
+        // Strategy = 1
+        IRIS_TEST_VISIT(16);
+
+        // Strategy = 2
+        IRIS_TEST_VISIT(64);
+
+        // Strategy = -1 (table-based dispatch)
+        IRIS_TEST_VISIT(65);
+
+        #undef IRIS_TEST_VISIT
+    }
+
+    // Check "all noexcept" is working
+    {
+        constexpr auto conditionally_throwing_f = []<std::size_t I>(std::integral_constant<std::size_t, I>, auto&& elem)
+            noexcept(I == 1) // arbitrary
+        {
+            return elem;
+        };
+
+        #define IRIS_TEST_VISIT(N) \
+            STATIC_CHECK(alloy::visit_at(0, conditionally_throwing_f, make_iota_tuple<N>()) == 0); \
+            STATIC_CHECK(!noexcept(alloy::visit_at(0, conditionally_throwing_f, make_iota_tuple<N>()))); \
+            STATIC_CHECK(alloy::visit_at(N - 1, conditionally_throwing_f, make_iota_tuple<N>()) == N - 1); \
+            STATIC_CHECK(!noexcept(alloy::visit_at(N - 1, conditionally_throwing_f, make_iota_tuple<N>())))
+
+        // Strategy = 0
+        IRIS_TEST_VISIT(4);
+
+        // Strategy = 1
+        IRIS_TEST_VISIT(16);
+
+        // Strategy = 2
+        IRIS_TEST_VISIT(64);
+
+        // Strategy = -1 (table-based dispatch)
+        IRIS_TEST_VISIT(65);
+
+        #undef IRIS_TEST_VISIT
+    }
+}