diff --git a/core/base/dispatch_helper.hpp b/core/base/dispatch_helper.hpp
index 8fb104c084e..f01b2e960bb 100644
--- a/core/base/dispatch_helper.hpp
+++ b/core/base/dispatch_helper.hpp
@@ -25,7 +25,7 @@ using with_same_constness_t = std::conditional_t<
 /**
  *
  * @copydoc run<typename ReturnType, typename K, typename... Types, typename T,
- *              typename Func, typename... Args>
+ *              typename Func, typename... Args>(T*, Func&&, Args&&...)
  *
  * @note this is the end case
  */
@@ -36,8 +36,8 @@ ReturnType run_impl(T* obj, Func&&, Args&&...)
 }
 
 /**
- * @copydoc run<typename K, typename... Types, typename T, typename Func,
- *              typename... Args>
+ * @copydoc run<typename ReturnType, typename K, typename... Types, typename T,
+ *              typename Func, typename... Args>(T*, Func&&, Args&&...)
  *
  * @note This has additionally the return type encoded.
  */
@@ -55,71 +55,91 @@ ReturnType run_impl(T* obj, Func&& f, Args&&... args)
 
 
 /**
- * @copydoc run<typename K, typename... Types, typename T, typename Func,
- *              typename... Args>
- *
- * @note This handle the shared_ptr cases
- */
-template <typename ReturnType, typename K, typename... Types, typename T,
-          typename Func, typename... Args>
-ReturnType run_impl(std::shared_ptr<T> obj, Func&& f, Args&&... args)
-{
-    if (auto dobj = std::dynamic_pointer_cast<K>(obj)) {
-        return f(dobj, std::forward<Args>(args)...);
-    } else {
-        return run_impl<ReturnType, Types...>(obj, std::forward<Func>(f),
-                                              std::forward<Args>(args)...);
-    }
-}
-
-
-/**
- * run uses template to go through the list and select the valid
- * template and run it.
- *
- * @tparam Base  the Base class with one template
- * @tparam T  the type of input object waiting converted
- * @tparam Func  the validation
- * @tparam ...Args  the variadic arguments.
+ * @copydoc run<template <typename> class Base, typename T, typename Func,
+ *              typename... Args>(T, Func&&, Args&&... )
  *
- * @note this is the end case
+ * @note This is the end case for the smart pointer cases
  */
-template <typename ReturnType, template <typename> class Base, typename T,
-          typename Func, typename... Args>
+template <typename ReturnType, typename T, typename Func, typename... Args>
 ReturnType run_impl(T obj, Func, Args...)
 {
     GKO_NOT_SUPPORTED(obj);
 }
 
+
 /**
- * run uses template to go through the list and select the valid
- * template and run it.
- *
- * @tparam Base  the Base class with one template
- * @tparam K  the current template type of B. pointer of const Base<K> is tried
- *            in the conversion.
- * @tparam ...Types  the other types will be tried in the conversion if K fails
- * @tparam T  the type of input object waiting converted
- * @tparam Func  the function type that is invoked if the object can be
- *               converted to pointer of const Base<K>
- * @tparam ...Args  the additional arguments for the Func
+ * @copydoc run<template <typename> class Base, typename T, typename Func,
+ *              typename... Args>(T, Func&&, Args&&... )
  *
- * @param obj  the input object that should be converted
- * @param f  the function will get invoked if obj can be converted successfully
- * @param args  the additional arguments for the function
+ * @note This handles the smart pointer case, i.e. either unique or shared
+ *       pointer
  */
-template <typename ReturnType, template <typename> class Base, typename K,
-          typename... Types, typename T, typename Func, typename... Args>
+template <typename ReturnType, typename K, typename... Types, typename T,
+          typename Func, typename... Args>
 ReturnType run_impl(T obj, Func&& f, Args&&... args)
 {
-    if (auto dobj = std::dynamic_pointer_cast<const Base<K>>(obj)) {
+    if (auto dobj = std::dynamic_pointer_cast<
+            with_same_constness_t<K, typename T::element_type>>(obj)) {
         return f(dobj, args...);
     } else {
-        return run_impl<ReturnType, Base, Types...>(
-            obj, std::forward<Func>(f), std::forward<Args>(args)...);
+        return run_impl<ReturnType, Types...>(obj, std::forward<Func>(f),
+                                              std::forward<Args>(args)...);
     }
 }
 
+/**
+ * Helper struct to get the result type of a function.
+ *
+ * @tparam T  Blueprint type for the function. This determines the
+ *            const-qualifier for K, as well as the pointer type
+ *            (either T*, unique_ptr<T>, or shared_ptr<T>) for K.
+ * @tparam K  The actual type to be used in the function.
+ * @tparam Func  The function to get the result from.
+ * @tparam Args  Additional arguments to the function.
+ */
+template <typename T, typename K, typename Func, typename... Args>
+struct result_of;
+
+template <typename T, typename K, typename Func, typename... Args>
+struct result_of<T*, K, Func, Args...> {
+#if __cplusplus < 201703L
+    // result_of_t is deprecated in C++17
+    using type =
+        std::result_of_t<Func(detail::with_same_constness_t<K, T>*, Args...)>;
+#else
+    using type =
+        std::invoke_result_t<Func, detail::with_same_constness_t<K, T>*,
+                             Args...>;
+#endif
+};
+
+template <typename T, typename K, typename Func, typename... Args>
+struct result_of<std::shared_ptr<T>, K, Func, Args...> {
+#if __cplusplus < 201703L
+    // result_of_t is deprecated in C++17
+    using type = std::result_of_t<Func(
+        std::shared_ptr<detail::with_same_constness_t<K, T>>, Args...)>;
+#else
+    using type = std::invoke_result_t<
+        Func, std::shared_ptr<detail::with_same_constness_t<K, T>>, Args...>;
+#endif
+};
+
+template <typename T, typename K, typename Func, typename... Args>
+struct result_of<std::unique_ptr<T>, K, Func, Args...> {
+#if __cplusplus < 201703L
+    // result_of_t is deprecated in C++17
+    using type = std::result_of_t<Func(
+        std::unique_ptr<detail::with_same_constness_t<K, T>>, Args...)>;
+#else
+    using type = std::invoke_result_t<
+        Func, std::unique_ptr<detail::with_same_constness_t<K, T>>, Args...>;
+#endif
+};
+
+template <typename T, typename K, typename Func, typename... Args>
+using result_of_t = typename result_of<T, K, Func, Args...>::type;
+
 
 }  // namespace detail
 
@@ -148,15 +168,7 @@ template <typename K, typename... Types, typename T, typename Func,
           typename... Args>
 auto run(T* obj, Func&& f, Args&&... args)
 {
-#if __cplusplus < 201703L
-    // result_of_t is deprecated in C++17
-    using ReturnType =
-        std::result_of_t<Func(detail::with_same_constness_t<K, T>*, Args...)>;
-#else
-    using ReturnType =
-        std::invoke_result_t<Func, detail::with_same_constness_t<K, T>*,
-                             Args...>;
-#endif
+    using ReturnType = detail::result_of_t<T*, K, Func, Args...>;
     return detail::run_impl<ReturnType, K, Types...>(
         obj, std::forward<Func>(f), std::forward<Args>(args)...);
 }
@@ -166,34 +178,25 @@ auto run(T* obj, Func&& f, Args&&... args)
  * run uses template to go through the list and select the valid
  * template and run it.
  *
- * @tparam K  the current shared_ptr type tried in the conversion
- * @tparam ...Types  the other types will be tried in the conversion if K fails
- * @tparam T  the type of input object
- * @tparam Func  the function type that is invoked if the object can be
- *               converted to std::shared_ptr<K>
+ * @tparam Base  the Base class with one template
+ * @tparam ...Types  the types that will be tried with Base, i.e. Base<Types>...
+ * @tparam T  the type of input object waiting converted
+ * @tparam Func  the function will run if the object can be converted to pointer
+ *               of const Base<K>
  * @tparam ...Args  the additional arguments for the Func
  *
- * @param obj  the input object that should be converted
- * @param f  the function will get invoked if obj can be converted successfully
+ * @param obj  the input object waiting converted
+ * @param f  the function will run if obj can be converted successfully
  * @param args  the additional arguments for the function
  *
- * @note  This assumes that the return type of f is independent of the input
- *        types (std::shared_ptr<K>, std::shared_ptr<Types>...)
- *
  * @return  the result of f invoked with obj cast to the first matching type
  */
-template <typename K, typename... Types, typename T, typename Func,
-          typename... Args>
-auto run(std::shared_ptr<T> obj, Func&& f, Args&&... args)
+template <template <class> class Base, typename... Types, typename T,
+          typename Func, typename... Args>
+auto run(T* obj, Func&& f, Args&&... args)
 {
-#if __cplusplus < 201703L
-    // result_of_t is deprecated in C++17
-    using ReturnType = std::result_of_t<Func(std::shared_ptr<K>, Args...)>;
-#else
-    using ReturnType = std::invoke_result_t<Func, std::shared_ptr<K>, Args...>;
-#endif
-    return detail::run_impl<ReturnType, K, Types...>(
-        obj, std::forward<Func>(f), std::forward<Args>(args)...);
+    return run<Base<Types>...>(obj, std::forward<Func>(f),
+                               std::forward<Args>(args)...);
 }
 
 
@@ -201,27 +204,30 @@ auto run(std::shared_ptr<T> obj, Func&& f, Args&&... args)
  * run uses template to go through the list and select the valid
  * template and run it.
  *
- * @tparam Base  the Base class with one template
- * @tparam K  the current template type of B. pointer of const Base<K> is tried
- *            in the conversion.
+ * @tparam K  the current type to try in the conversion
  * @tparam ...Types  the other types will be tried in the conversion if K fails
- * @tparam T  the type of input object waiting converted
- * @tparam Func  the function will run if the object can be converted to pointer
- *               of const Base<K>
+ * @tparam T  the type of input object waiting converted, has to be either
+ *            unique_ptr or shared_ptr
+ * @tparam Func  the function type that is invoked if the object can be
+ *               converted to pointer of const Base<K>
  * @tparam ...Args  the additional arguments for the Func
  *
- * @param obj  the input object waiting converted
- * @param f  the function will run if obj can be converted successfully
+ * @param obj  the input object that should be converted
+ * @param f  the function will get invoked if obj can be converted successfully
  * @param args  the additional arguments for the function
  *
+ * @note   This assumes that the return type of f is independent of the input
+ *         types (smart_ptr<K>, smart_ptr<Types>...)
+ *
  * @return  the result of f invoked with obj cast to the first matching type
  */
-template <template <class> class K, typename... Types, typename T,
-          typename Func, typename... Args>
-auto run(T* obj, Func&& f, Args&&... args)
+template <typename K, typename... Types, typename T, typename Func,
+          typename... Args>
+auto run(T obj, Func&& f, Args&&... args)
 {
-    return run<K<Types>...>(obj, std::forward<Func>(f),
-                            std::forward<Args>(args)...);
+    using ReturnType = detail::result_of_t<T, K, Func, Args...>;
+    return detail::run_impl<ReturnType, K, Types...>(
+        obj, std::forward<Func>(f), std::forward<Args>(args)...);
 }
 
 
@@ -230,10 +236,9 @@ auto run(T* obj, Func&& f, Args&&... args)
  * template and run it.
  *
  * @tparam Base  the Base class with one template
- * @tparam K  the current template type of B. pointer of const Base<K> is tried
- *            in the conversion.
- * @tparam ...Types  the other types will be tried in the conversion if K fails
- * @tparam T  the type of input object waiting converted
+ * @tparam ...Types  the types that will be tried with Base, i.e. Base<Types>...
+ * @tparam T  the type of input object waiting converted, has to be either
+ *            unique_ptr or shared_ptr
  * @tparam Func  the function type that is invoked if the object can be
  *               converted to pointer of const Base<K>
  * @tparam ...Args  the additional arguments for the Func
@@ -247,23 +252,12 @@ auto run(T* obj, Func&& f, Args&&... args)
  *
  * @return  the result of f invoked with obj cast to the first matching type
  */
-template <template <typename> class Base, typename K, typename... Types,
-          typename T, typename Func, typename... Args>
+template <template <typename> class Base, typename... Types, typename T,
+          typename Func, typename... Args>
 auto run(T obj, Func&& f, Args&&... args)
 {
-    // Since T is a smart pointer, the type used to invoke f also has to be a
-    // smart pointer. unique_ptr is used because it can be converted into a
-    // shared_ptr, but not the other way around.
-#if __cplusplus < 201703L
-    // result_of_t is deprecated in C++17
-    using ReturnType =
-        std::result_of_t<Func(std::unique_ptr<Base<K>>, Args...)>;
-#else
-    using ReturnType =
-        std::invoke_result_t<Func, std::unique_ptr<Base<K>>, Args...>;
-#endif
-    return detail::run_impl<ReturnType, Base, K, Types...>(
-        obj, std::forward<Func>(f), std::forward<Args>(args)...);
+    return run<Base<Types>...>(obj, std::forward<Func>(f),
+                               std::forward<Args>(args)...);
 }