diff --git a/include/stdx/type_traits.hpp b/include/stdx/type_traits.hpp
index 11d2ce0..350296d 100644
--- a/include/stdx/type_traits.hpp
+++ b/include/stdx/type_traits.hpp
@@ -228,12 +228,43 @@ template <typename T>
 constexpr auto is_cx_value_v<T, std::void_t<typename T::cx_value_t>> = true;
 
 #if __cplusplus >= 202002L
+namespace detail {
+template <typename T> struct shrinkwrap {
+    using is_shrinkwrapped = void;
+    using type = T;
+};
+
 template <typename T>
-using shrink_t = decltype([]() -> T (*)() { return nullptr; });
+concept is_shrinkwrapped = requires { typename T::is_shrinkwrapped; };
 
-template <typename T> using expand_t = decltype(T{}()());
+template <typename T,
+          auto F = []()->auto (*)() -> shrinkwrap<T> { return nullptr; }>
+CONSTEVAL auto shrink() {
+    return F;
+}
+
+template <typename T>
+concept is_shrunk = requires(T t) {
+    { t()() } -> is_shrinkwrapped;
+};
+
+template <typename T> CONSTEVAL auto maybe_expand() -> T;
+template <is_shrunk T>
+CONSTEVAL auto maybe_expand() -> typename decltype(T{}()())::type;
+} // namespace detail
+
+template <typename T> CONSTEVAL auto shrink() -> decltype(detail::shrink<T>());
+
+template <typename T>
+CONSTEVAL auto expand() -> decltype(detail::maybe_expand<T>());
+#else
+template <typename T> CONSTEVAL auto shrink() -> T;
+template <typename T> CONSTEVAL auto expand() -> T;
 #endif
 
+template <typename T> using shrink_t = decltype(shrink<T>());
+template <typename T> using expand_t = decltype(expand<T>());
+
 STDX_PRAGMA(diagnostic push)
 #ifdef __clang__
 STDX_PRAGMA(diagnostic ignored "-Wunknown-warning-option")
diff --git a/include/stdx/utility.hpp b/include/stdx/utility.hpp
index 0f6ff37..18ebd01 100644
--- a/include/stdx/utility.hpp
+++ b/include/stdx/utility.hpp
@@ -29,6 +29,8 @@ namespace detail {
 template <auto V> struct value_t {
     constexpr static inline auto value = V;
 };
+
+template <typename... Ts> struct type_map : Ts... {};
 } // namespace detail
 
 template <typename K, typename V> struct type_pair {
@@ -43,7 +45,7 @@ template <typename K, auto V> using tv_pair = tt_pair<K, detail::value_t<V>>;
 template <auto K, auto V>
 using vv_pair = tt_pair<detail::value_t<K>, detail::value_t<V>>;
 
-template <typename... Ts> struct type_map : Ts... {};
+template <typename... Ts> using type_map = shrink_t<detail::type_map<Ts...>>;
 
 namespace detail {
 template <typename K, typename Default>
@@ -58,20 +60,19 @@ constexpr static auto reverse_lookup(type_pair<K, V>) -> K;
 } // namespace detail
 
 template <typename M, typename K, typename Default = void>
-using type_lookup_t = decltype(detail::lookup<K, Default>(std::declval<M>()));
+using type_lookup_t = decltype(detail::lookup<K, Default>(expand<M>()));
 
 template <typename M, typename V, typename Default = void>
 using reverse_type_lookup_t =
-    decltype(detail::reverse_lookup<V, Default>(std::declval<M>()));
+    decltype(detail::reverse_lookup<V, Default>(expand<M>()));
 
 template <typename M, auto K, typename Default = void>
 using value_lookup_t =
-    decltype(detail::lookup<detail::value_t<K>, Default>(std::declval<M>()));
+    decltype(detail::lookup<detail::value_t<K>, Default>(expand<M>()));
 
 template <typename M, auto V, typename Default = void>
 using reverse_value_lookup_t =
-    decltype(detail::reverse_lookup<detail::value_t<V>, Default>(
-        std::declval<M>()));
+    decltype(detail::reverse_lookup<detail::value_t<V>, Default>(expand<M>()));
 
 namespace detail {
 template <typename T>
@@ -81,27 +82,26 @@ using is_not_void = std::bool_constant<not std::is_void_v<T>>;
 template <typename M, typename K, auto Default = 0>
 constexpr static auto type_lookup_v =
     type_or_t<detail::is_not_void,
-              decltype(detail::lookup<K, void>(std::declval<M>())),
+              decltype(detail::lookup<K, void>(expand<M>())),
               detail::value_t<Default>>::value;
 
 template <typename M, typename V, auto Default = 0>
 constexpr static auto reverse_type_lookup_v =
     type_or_t<detail::is_not_void,
-              decltype(detail::reverse_lookup<V, void>(std::declval<M>())),
+              decltype(detail::reverse_lookup<V, void>(expand<M>())),
               detail::value_t<Default>>::value;
 
 template <typename M, auto K, auto Default = 0>
 constexpr static auto value_lookup_v =
     type_or_t<detail::is_not_void,
-              decltype(detail::lookup<detail::value_t<K>, void>(
-                  std::declval<M>())),
+              decltype(detail::lookup<detail::value_t<K>, void>(expand<M>())),
               detail::value_t<Default>>::value;
 
 template <typename M, auto V, auto Default = 0>
 constexpr static auto reverse_value_lookup_v =
     type_or_t<detail::is_not_void,
               decltype(detail::reverse_lookup<detail::value_t<V>, void>(
-                  std::declval<M>())),
+                  expand<M>())),
               detail::value_t<Default>>::value;
 
 #if __cpp_lib_forward_like < 202207L
diff --git a/test/type_traits.cpp b/test/type_traits.cpp
index ff9b9ec..026210b 100644
--- a/test/type_traits.cpp
+++ b/test/type_traits.cpp
@@ -255,9 +255,9 @@ TEST_CASE("type shrinkage", "[type_traits]") {
     using B = long_type_name<A, A, A, A, A, A, A, A>;
     using C = long_type_name<B, B, B, B, B, B, B, B>;
     using X = stdx::shrink_t<C>;
-    STATIC_REQUIRE(stdx::type_as_string<X>().size() <
-                   stdx::type_as_string<C>().size());
-    STATIC_REQUIRE(std::same_as<stdx::expand_t<X>, C>);
+    STATIC_CHECK(stdx::type_as_string<X>().size() <
+                 stdx::type_as_string<C>().size());
+    STATIC_CHECK(std::same_as<stdx::expand_t<X>, C>);
 }
 #endif