diff --git a/immer/extra/persist/json/policy.hpp b/immer/extra/persist/json/policy.hpp
index f2a68b38..c1cf3a84 100644
--- a/immer/extra/persist/json/policy.hpp
+++ b/immer/extra/persist/json/policy.hpp
@@ -116,7 +116,7 @@ struct hana_struct_auto_policy
     template <class T>
     auto get_pool_types(const T& value) const
     {
-        return get_pools_for_type(boost::hana::typeid_(value));
+        return get_pools_for_type<T>();
     }
 };
 
@@ -127,14 +127,13 @@ struct hana_struct_auto_member_name_policy
     template <class T>
     auto get_pool_types(const T& value) const
     {
-        return get_pools_for_type(boost::hana::typeid_(value));
+        return get_pools_for_type<T>();
     }
 
     template <class T>
     auto get_pool_name_fn(const T& value) const
     {
-        using map_t =
-            decltype(get_named_pools_for_type(boost::hana::typeid_(value)));
+        using map_t = decltype(get_named_pools_for_type<T>());
         return name_from_map_fn<map_t>{};
     }
 };
diff --git a/immer/extra/persist/json/wrap.hpp b/immer/extra/persist/json/wrap.hpp
index c8f85ddd..26e13b15 100644
--- a/immer/extra/persist/json/wrap.hpp
+++ b/immer/extra/persist/json/wrap.hpp
@@ -115,14 +115,15 @@ constexpr auto wrap_for_loading = exclude_internal_pool_types(
  * Generate a hana set of types of persistable members for the given type,
  * recursively. Example: [type_c<immer::map<K, V>>]
  */
-auto get_pools_for_type(auto type)
+template <class T>
+auto get_pools_for_type()
 {
     namespace hana     = boost::hana;
-    auto all_types_set = util::get_inner_types(type);
+    auto all_types_set = util::get_inner_types(hana::type_c<T>);
     auto persistable =
-        hana::filter(hana::to_tuple(all_types_set), [&](auto type) {
-            using T = typename decltype(type)::type;
-            return is_persistable(T{});
+        hana::filter(hana::to_tuple(all_types_set), [](auto type) {
+            using Type = typename decltype(type)::type;
+            return is_persistable(Type{});
         });
     return hana::to_set(persistable);
 }
@@ -132,14 +133,15 @@ auto get_pools_for_type(auto type)
  * Example:
  * [(type_c<immer::map<K, V>>, "tracks")]
  */
-auto get_named_pools_for_type(auto type)
+template <class T>
+auto get_named_pools_for_type()
 {
     namespace hana     = boost::hana;
-    auto all_types_map = util::get_inner_types_map(type);
+    auto all_types_map = util::get_inner_types_map(hana::type_c<T>);
     auto persistable =
-        hana::filter(hana::to_tuple(all_types_map), [&](auto pair) {
-            using T = typename decltype(+hana::first(pair))::type;
-            return is_persistable(T{});
+        hana::filter(hana::to_tuple(all_types_map), [](auto pair) {
+            using Type = typename decltype(+hana::first(pair))::type;
+            return is_persistable(Type{});
         });
     return hana::to_map(persistable);
 }
diff --git a/test/extra/persist/test_circular_dependency_conversion.cpp b/test/extra/persist/test_circular_dependency_conversion.cpp
index 0b8fbf28..798ccbfe 100644
--- a/test/extra/persist/test_circular_dependency_conversion.cpp
+++ b/test/extra/persist/test_circular_dependency_conversion.cpp
@@ -238,8 +238,8 @@ TEST_CASE("Test exception while circular converting")
         };
     }();
 
-    const auto names = immer::persist::get_named_pools_for_type(
-        hana::type_c<model::value_one>);
+    const auto names =
+        immer::persist::get_named_pools_for_type<model::value_one>();
     const auto model_pool = immer::persist::get_auto_pool(value);
 
     SECTION("Try to load")
@@ -408,8 +408,8 @@ TEST_CASE("Test circular dependency pools", "[conversion]")
         };
     }();
 
-    const auto names = immer::persist::get_named_pools_for_type(
-        hana::type_c<model::value_one>);
+    const auto names =
+        immer::persist::get_named_pools_for_type<model::value_one>();
     const auto model_pools = immer::persist::get_auto_pool(value);
 
     /**
@@ -517,8 +517,8 @@ TEST_CASE("Test circular dependency pools", "[conversion]")
     (void) format_load_pools;
     // show_type<decltype(format_load_pools)> qwe;
 
-    const auto format_names = immer::persist::get_named_pools_for_type(
-        hana::type_c<format::value_one>);
+    const auto format_names =
+        immer::persist::get_named_pools_for_type<format::value_one>();
 
     SECTION("vector")
     {
diff --git a/test/extra/persist/test_conversion.cpp b/test/extra/persist/test_conversion.cpp
index 35451c2c..7934cb54 100644
--- a/test/extra/persist/test_conversion.cpp
+++ b/test/extra/persist/test_conversion.cpp
@@ -144,9 +144,9 @@ TEST_CASE("Convert between two hierarchies via JSON compatibility",
           "[conversion]")
 {
     const auto model_names =
-        immer::persist::get_named_pools_for_type(hana::type_c<model::history>);
+        immer::persist::get_named_pools_for_type<model::history>();
     const auto format_names =
-        immer::persist::get_named_pools_for_type(hana::type_c<format::history>);
+        immer::persist::get_named_pools_for_type<format::history>();
     (void) format_names;
 
     const auto value = model::make_example_history();
diff --git a/test/extra/persist/test_special_pool_auto.cpp b/test/extra/persist/test_special_pool_auto.cpp
index 16cc7ff2..ab5dc8e5 100644
--- a/test/extra/persist/test_special_pool_auto.cpp
+++ b/test/extra/persist/test_special_pool_auto.cpp
@@ -112,8 +112,7 @@ TEST_CASE("Auto-persisting")
 {
     constexpr auto names = [] {
         return hana::union_(
-            immer::persist::get_named_pools_for_type(
-                hana::type_c<test_data_with_immer>),
+            immer::persist::get_named_pools_for_type<test_data_with_immer>(),
             hana::make_map(hana::make_pair(hana::type_c<vector_one<meta_meta>>,
                                            BOOST_HANA_STRING("meta_meta"))));
     };
@@ -237,8 +236,8 @@ TEST_CASE("Test save and load small type")
     const auto value = test_data_with_one_immer_member{
         .ints = ints1,
     };
-    const auto pool_types =
-        immer::persist::get_named_pools_for_type(boost::hana::typeid_(value));
+    const auto pool_types = immer::persist::get_named_pools_for_type<
+        test_data_with_one_immer_member>();
     const auto json_str =
         immer::persist::to_json_with_auto_pool(value, pool_types);
     // REQUIRE(json_str == "");
@@ -439,8 +438,8 @@ TEST_CASE("Test table with a funny value")
         .twos_table = t1.insert(two2),
     };
 
-    const auto names = immer::persist::get_named_pools_for_type(
-        hana::type_c<champ_test::value_one>);
+    const auto names =
+        immer::persist::get_named_pools_for_type<champ_test::value_one>();
     const auto json_str = immer::persist::to_json_with_auto_pool(value, names);
     // REQUIRE(json_str == "");
 
@@ -479,8 +478,8 @@ TEST_CASE("Test loading broken table")
         .twos_table = t1.insert(two2),
     };
 
-    const auto names = immer::persist::get_named_pools_for_type(
-        hana::type_c<champ_test::value_one>);
+    const auto names =
+        immer::persist::get_named_pools_for_type<champ_test::value_one>();
 
     const auto json_str = immer::persist::to_json_with_auto_pool(value, names);
     // REQUIRE(json_str == "");
@@ -942,8 +941,8 @@ struct with_variant
 
 TEST_CASE("Test types traversal")
 {
-    auto names = immer::persist::get_named_pools_for_type(
-        hana::type_c<test_variant::with_variant>);
+    auto names =
+        immer::persist::get_named_pools_for_type<test_variant::with_variant>();
     SECTION("It goes inside variant")
     {
         using contains_t = decltype(names[hana::type_c<immer::vector<int>>] ==
@@ -965,8 +964,8 @@ TEST_CASE("Test types traversal")
                                hana::false_c)::value);
 
         // But it has the vector when we don't use names
-        auto only_types = immer::persist::get_pools_for_type(
-            hana::type_c<test_variant::with_variant>);
+        auto only_types =
+            immer::persist::get_pools_for_type<test_variant::with_variant>();
         static_assert(decltype(hana::contains(only_types, vector_type))::value);
     }
 }