diff --git a/src/concurrent/qtconcurrentfilter.h b/src/concurrent/qtconcurrentfilter.h
index 891eb4b9caa..dce4f35db69 100644
--- a/src/concurrent/qtconcurrentfilter.h
+++ b/src/concurrent/qtconcurrentfilter.h
@@ -148,8 +148,8 @@ QFuture<ResultType> filteredReduced(Sequence &&sequence,
 
 #ifndef Q_CLANG_QDOC
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> filteredReduced(QThreadPool *pool,
                                     Sequence &&sequence,
                                     KeepFunctor &&keep,
@@ -163,8 +163,8 @@ QFuture<ResultType> filteredReduced(QThreadPool *pool,
 }
 
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> filteredReduced(Sequence &&sequence,
                                     KeepFunctor &&keep,
                                     ReduceFunctor &&reduce,
@@ -177,9 +177,9 @@ QFuture<ResultType> filteredReduced(Sequence &&sequence,
 }
 
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
           typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 QFuture<ResultType> filteredReduced(QThreadPool *pool,
                                     Sequence &&sequence,
@@ -196,9 +196,9 @@ QFuture<ResultType> filteredReduced(QThreadPool *pool,
 }
 
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
           typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 QFuture<ResultType> filteredReduced(Sequence &&sequence,
                                     KeepFunctor &&keep,
@@ -287,8 +287,7 @@ QFuture<ResultType> filteredReduced(Iterator begin,
 
 #ifndef Q_CLANG_QDOC
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> filteredReduced(QThreadPool *pool,
                                     Iterator begin,
                                     Iterator end,
@@ -302,8 +301,7 @@ QFuture<ResultType> filteredReduced(QThreadPool *pool,
 }
 
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> filteredReduced(Iterator begin,
                                     Iterator end,
                                     KeepFunctor &&keep,
@@ -317,8 +315,7 @@ QFuture<ResultType> filteredReduced(Iterator begin,
 }
 
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 QFuture<ResultType> filteredReduced(QThreadPool *pool,
@@ -336,8 +333,8 @@ QFuture<ResultType> filteredReduced(QThreadPool *pool,
 }
 
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+          std::enable_if_t<QtPrivate::isIterator<Iterator>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 QFuture<ResultType> filteredReduced(Iterator begin,
@@ -480,8 +477,8 @@ ResultType blockingFilteredReduced(Sequence &&sequence,
 
 #ifndef Q_CLANG_QDOC
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingFilteredReduced(QThreadPool *pool,
                                    Sequence &&sequence,
                                    KeepFunctor &&keep,
@@ -496,8 +493,8 @@ ResultType blockingFilteredReduced(QThreadPool *pool,
 }
 
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingFilteredReduced(Sequence &&sequence,
                                    KeepFunctor &&keep,
                                    ReduceFunctor &&reduce,
@@ -511,9 +508,9 @@ ResultType blockingFilteredReduced(Sequence &&sequence,
 }
 
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
           typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 ResultType blockingFilteredReduced(QThreadPool *pool,
                                    Sequence &&sequence,
@@ -531,9 +528,9 @@ ResultType blockingFilteredReduced(QThreadPool *pool,
 }
 
 template <typename Sequence, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
           typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<KeepFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 ResultType blockingFilteredReduced(Sequence &&sequence,
                                    KeepFunctor &&keep,
@@ -627,8 +624,7 @@ ResultType blockingFilteredReduced(Iterator begin,
 
 #ifndef Q_CLANG_QDOC
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingFilteredReduced(QThreadPool *pool,
                                    Iterator begin,
                                    Iterator end,
@@ -644,8 +640,7 @@ ResultType blockingFilteredReduced(QThreadPool *pool,
 }
 
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingFilteredReduced(Iterator begin,
                                    Iterator end,
                                    KeepFunctor &&keep,
@@ -660,8 +655,7 @@ ResultType blockingFilteredReduced(Iterator begin,
 }
 
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                    typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 ResultType blockingFilteredReduced(QThreadPool *pool,
@@ -679,8 +673,8 @@ ResultType blockingFilteredReduced(QThreadPool *pool,
 }
 
 template <typename Iterator, typename KeepFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+          std::enable_if_t<QtPrivate::isIterator<Iterator>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 ResultType blockingFilteredReduced(Iterator begin,
diff --git a/src/concurrent/qtconcurrentfunctionwrappers.h b/src/concurrent/qtconcurrentfunctionwrappers.h
index 194d020fb28..59d2d61af68 100644
--- a/src/concurrent/qtconcurrentfunctionwrappers.h
+++ b/src/concurrent/qtconcurrentfunctionwrappers.h
@@ -41,6 +41,7 @@
 #define QTCONCURRENT_FUNCTIONWRAPPERS_H
 
 #include <QtConcurrent/qtconcurrentcompilertest.h>
+#include <QtCore/qfuture.h>
 #include <QtCore/QStringList>
 
 #include <tuple>
@@ -143,6 +144,50 @@ struct ReduceResultType<T(C::*)(U) noexcept>
 };
 #endif
 
+template<class T, class Enable = void>
+struct hasCallOperator : std::false_type
+{
+};
+
+template<class T>
+struct hasCallOperator<T, std::void_t<decltype(&T::operator())>> : std::true_type
+{
+};
+
+template<class T, class Enable = void>
+struct isIterator : std::false_type
+{
+};
+
+template<class T>
+struct isIterator<T, std::void_t<typename std::iterator_traits<T>::value_type>> : std::true_type
+{
+};
+
+template <class Callable, class Sequence>
+using isInvocable = std::is_invocable<Callable, typename std::decay_t<Sequence>::value_type>;
+
+template<class Callable, class Enable = void>
+struct ReduceResultTypeHelper
+{
+};
+
+template <class Callable>
+struct ReduceResultTypeHelper<Callable,
+        typename std::enable_if_t<std::is_function_v<std::remove_pointer_t<std::decay_t<Callable>>>
+                                  || std::is_member_function_pointer_v<std::decay_t<Callable>>>>
+{
+    using type = typename QtPrivate::ReduceResultType<std::decay_t<Callable>>::ResultType;
+};
+
+template <class Callable>
+struct ReduceResultTypeHelper<Callable,
+        typename std::enable_if_t<!std::is_function_v<std::remove_pointer_t<std::decay_t<Callable>>>
+                                  && hasCallOperator<std::decay_t<Callable>>::value>>
+{
+    using type = std::decay_t<typename QtPrivate::ArgResolver<Callable>::First>;
+};
+
 // -- MapSequenceResultType
 
 template <class InputSequence, class MapFunctor>
diff --git a/src/concurrent/qtconcurrentmap.h b/src/concurrent/qtconcurrentmap.h
index 4043ecd8a22..44a6caea4c3 100644
--- a/src/concurrent/qtconcurrentmap.h
+++ b/src/concurrent/qtconcurrentmap.h
@@ -151,8 +151,8 @@ QFuture<ResultType> mappedReduced(Sequence &&sequence,
 }
 
 template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> mappedReduced(QThreadPool *pool,
                                   Sequence &&sequence,
                                   MapFunctor &&map,
@@ -166,8 +166,8 @@ QFuture<ResultType> mappedReduced(QThreadPool *pool,
 }
 
 template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> mappedReduced(Sequence &&sequence,
                                   MapFunctor &&map,
                                   ReduceFunctor &&reduce,
@@ -183,10 +183,9 @@ QFuture<ResultType> mappedReduced(Sequence &&sequence,
 template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename ResultType,
           typename InitialValueType>
 #else
-template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
-          typename InitialValueType,
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
 QFuture<ResultType> mappedReduced(QThreadPool *pool,
@@ -207,10 +206,9 @@ QFuture<ResultType> mappedReduced(QThreadPool *pool,
 template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename ResultType,
           typename InitialValueType>
 #else
-template <typename Sequence, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
-          typename InitialValueType,
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
 QFuture<ResultType> mappedReduced(Sequence &&sequence,
@@ -299,8 +297,7 @@ QFuture<ResultType> mappedReduced(Iterator begin,
 }
 
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> mappedReduced(QThreadPool *pool,
                                   Iterator begin,
                                   Iterator end,
@@ -315,7 +312,7 @@ QFuture<ResultType> mappedReduced(QThreadPool *pool,
 }
 
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType = typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 QFuture<ResultType> mappedReduced(Iterator begin,
                                   Iterator end,
                                   MapFunctor &&map,
@@ -333,8 +330,7 @@ template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typena
           typename InitialValueType>
 #else
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
@@ -357,8 +353,8 @@ template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typena
           typename InitialValueType>
 #else
 template<typename Iterator, typename MapFunctor, typename ReduceFunctor,
-         typename ResultType =
-                 typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+         std::enable_if_t<QtPrivate::isIterator<Iterator>::value, int> = 0,
+         typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
          typename InitialValueType,
          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
@@ -528,8 +524,8 @@ ResultType blockingMappedReduced(Sequence &&sequence,
 }
 
 template <typename MapFunctor, typename ReduceFunctor, typename Sequence,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingMappedReduced(QThreadPool *pool,
                                  Sequence &&sequence,
                                  MapFunctor &&map,
@@ -545,8 +541,8 @@ ResultType blockingMappedReduced(QThreadPool *pool,
 }
 
 template <typename MapFunctor, typename ReduceFunctor, typename Sequence,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingMappedReduced(Sequence &&sequence,
                                  MapFunctor &&map,
                                  ReduceFunctor &&reduce,
@@ -564,10 +560,9 @@ ResultType blockingMappedReduced(Sequence &&sequence,
 template <typename MapFunctor, typename ReduceFunctor, typename Sequence, typename ResultType,
           typename InitialValueType>
 #else
-template <typename MapFunctor, typename ReduceFunctor, typename Sequence,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
-          typename InitialValueType,
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType,
+          std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
 ResultType blockingMappedReduced(QThreadPool *pool,
@@ -589,10 +584,9 @@ ResultType blockingMappedReduced(QThreadPool *pool,
 template <typename MapFunctor, typename ReduceFunctor, typename Sequence, typename ResultType,
           typename InitialValueType>
 #else
-template<typename MapFunctor, typename ReduceFunctor, typename Sequence,
-         typename ResultType =
-                 typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
-         typename InitialValueType,
+template<typename MapFunctor, typename ReduceFunctor, typename Sequence, typename InitialValueType,
+         std::enable_if_t<QtPrivate::isInvocable<MapFunctor, Sequence>::value, int> = 0,
+         typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
          std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
 ResultType blockingMappedReduced(Sequence &&sequence,
@@ -687,8 +681,7 @@ ResultType blockingMappedReduced(Iterator begin,
 }
 
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingMappedReduced(QThreadPool *pool,
                                  Iterator begin,
                                  Iterator end,
@@ -704,8 +697,7 @@ ResultType blockingMappedReduced(QThreadPool *pool,
 }
 
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType>
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type>
 ResultType blockingMappedReduced(Iterator begin,
                                  Iterator end,
                                  MapFunctor &&map,
@@ -724,8 +716,7 @@ template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typena
           typename InitialValueType>
 #else
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
@@ -749,8 +740,8 @@ template <typename Iterator, typename MapFunctor, typename ReduceFunctor, typena
           typename InitialValueType>
 #else
 template <typename Iterator, typename MapFunctor, typename ReduceFunctor,
-          typename ResultType =
-                  typename QtPrivate::ReduceResultType<std::decay_t<ReduceFunctor>>::ResultType,
+          std::enable_if_t<QtPrivate::isIterator<Iterator>::value, int> = 0,
+          typename ResultType = typename QtPrivate::ReduceResultTypeHelper<ReduceFunctor>::type,
           typename InitialValueType,
           std::enable_if_t<std::is_convertible_v<InitialValueType, ResultType>, int> = 0>
 #endif
diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
index 6c278849776..1a1ad6251aa 100644
--- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
+++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
@@ -410,23 +410,47 @@ void testFilteredReduced(const QList<SourceObject> &sourceObjectList,
                          FilterObject filterObject,
                          ReduceObject reduceObject)
 {
-    const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
-                                         sourceObjectList, filterObject, reduceObject).result();
-    QCOMPARE(result1, expectedResult);
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
+                    sourceObjectList, filterObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
 
-    const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>(
-                                         sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                                         filterObject, reduceObject).result();
-    QCOMPARE(result2, expectedResult);
+        const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject).result();
+        QCOMPARE(result2, expectedResult);
 
-    const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                sourceObjectList, filterObject, reduceObject);
-    QCOMPARE(result3, expectedResult);
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    sourceObjectList, filterObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
 
-    const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                filterObject, reduceObject);
-    QCOMPARE(result4, expectedResult);
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced(
+                    sourceObjectList, filterObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
+
+        const ResultObject result2 = QtConcurrent::filteredReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject).result();
+        QCOMPARE(result2, expectedResult);
+
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced(
+                    sourceObjectList, filterObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
+
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+    }
 }
 
 template <typename SourceObject,
@@ -570,28 +594,57 @@ void testFilteredReducedThreadPool(QThreadPool *pool,
                                    FilterObject filterObject,
                                    ReduceObject reduceObject)
 {
-    const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
-                pool, sourceObjectList, filterObject, reduceObject).result();
-    QCOMPARE(result1, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
+                    pool, sourceObjectList, filterObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result2 =
-            QtConcurrent::filteredReduced<ResultObject>(pool, sourceObjectList.constBegin(),
-                                                        sourceObjectList.constEnd(), filterObject,
-                                                        reduceObject).result();
-    QCOMPARE(result2, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result2 =
+                QtConcurrent::filteredReduced<ResultObject>(pool, sourceObjectList.constBegin(),
+                                                            sourceObjectList.constEnd(), filterObject,
+                                                            reduceObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                pool, sourceObjectList, filterObject, reduceObject);
-    QCOMPARE(result3, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    pool, sourceObjectList, filterObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                filterObject, reduceObject);
-    QCOMPARE(result4, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced(
+                    pool, sourceObjectList, filterObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result2 =
+                QtConcurrent::filteredReduced(pool, sourceObjectList.constBegin(),
+                                              sourceObjectList.constEnd(), filterObject,
+                                              reduceObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced(
+                    pool, sourceObjectList, filterObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
 }
 
 void tst_QtConcurrentFilter::filteredReducedThreadPool()
@@ -666,50 +719,50 @@ void tst_QtConcurrentFilter::filteredReducedWithMoveOnlyCallables()
     const auto sum = 6;
     {
         const auto result =
-                QtConcurrent::filteredReduced<int>(intList, KeepEvenIntegersMoveOnly(),
-                                                   IntSumReduceMoveOnly()).result();
+                QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(),
+                                              IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
         const auto result =
-                QtConcurrent::filteredReduced<int>(intList.begin(), intList.end(),
-                                                   KeepEvenIntegersMoveOnly(),
-                                                   IntSumReduceMoveOnly()).result();
+                QtConcurrent::filteredReduced(intList.begin(), intList.end(),
+                                              KeepEvenIntegersMoveOnly(),
+                                              IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly());
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly());
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
 
     QThreadPool pool;
     {
         const auto result =
-                QtConcurrent::filteredReduced<int>(&pool, intList, KeepEvenIntegersMoveOnly(),
-                                                   IntSumReduceMoveOnly()).result();
+                QtConcurrent::filteredReduced(&pool, intList, KeepEvenIntegersMoveOnly(),
+                                              IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::filteredReduced<int>(
-                                    &pool, intList.begin(), intList.end(),
-                                    KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()).result();
+        const auto result = QtConcurrent::filteredReduced(
+                    &pool, intList.begin(), intList.end(),
+                    KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly());
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(),
-                IntSumReduceMoveOnly());
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(),
+                    IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
 }
@@ -774,23 +827,47 @@ void testFilteredReducedInitialValue(const QList<SourceObject> &sourceObjectList
                                      ReduceObject reduceObject,
                                      InitialObject &&initialObject)
 {
-    const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
-                sourceObjectList, filterObject, reduceObject, initialObject).result();
-    QCOMPARE(result1, expectedResult);
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
+                    sourceObjectList, filterObject, reduceObject, initialObject).result();
+        QCOMPARE(result1, expectedResult);
 
-    const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>(
-                                         sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                                         filterObject, reduceObject, initialObject).result();
-    QCOMPARE(result2, expectedResult);
+        const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
 
-    const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                sourceObjectList, filterObject, reduceObject, initialObject);
-    QCOMPARE(result3, expectedResult);
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    sourceObjectList, filterObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
 
-    const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                filterObject, reduceObject, initialObject);
-    QCOMPARE(result4, expectedResult);
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced(
+                    sourceObjectList, filterObject, reduceObject, initialObject).result();
+        QCOMPARE(result1, expectedResult);
+
+        const ResultObject result2 = QtConcurrent::filteredReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
+
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced(
+                    sourceObjectList, filterObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
+
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+    }
 }
 
 template <typename SourceObject,
@@ -945,28 +1022,57 @@ void testFilteredReducedInitialValueThreadPool(QThreadPool *pool,
                                                ReduceObject reduceObject,
                                                InitialObject &&initialObject)
 {
-    const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
-                pool, sourceObjectList, filterObject, reduceObject, initialObject).result();
-    QCOMPARE(result1, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
+                    pool, sourceObjectList, filterObject, reduceObject, initialObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result2 =
-            QtConcurrent::filteredReduced<ResultObject>(pool, sourceObjectList.constBegin(),
-                                                        sourceObjectList.constEnd(), filterObject,
-                                                        reduceObject, initialObject).result();
-    QCOMPARE(result2, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result2 =
+                QtConcurrent::filteredReduced<ResultObject>(pool, sourceObjectList.constBegin(),
+                                                            sourceObjectList.constEnd(), filterObject,
+                                                            reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                pool, sourceObjectList, filterObject, reduceObject, initialObject);
-    QCOMPARE(result3, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    pool, sourceObjectList, filterObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
-                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                filterObject, reduceObject, initialObject);
-    QCOMPARE(result4, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 = QtConcurrent::filteredReduced(
+                    pool, sourceObjectList, filterObject, reduceObject, initialObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result2 =
+                QtConcurrent::filteredReduced(pool, sourceObjectList.constBegin(),
+                                              sourceObjectList.constEnd(), filterObject,
+                                              reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result3 = QtConcurrent::blockingFilteredReduced(
+                    pool, sourceObjectList, filterObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result4 = QtConcurrent::blockingFilteredReduced(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    filterObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
 }
 
 void tst_QtConcurrentFilter::filteredReducedInitialValueThreadPool()
@@ -1053,52 +1159,52 @@ void tst_QtConcurrentFilter::filteredReducedInitialValueWithMoveOnlyCallables()
     const auto sum = 16;
     {
         const auto result =
-                QtConcurrent::filteredReduced<int>(intList, KeepEvenIntegersMoveOnly(),
-                                                   IntSumReduceMoveOnly(), initial).result();
+                QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(),
+                                              IntSumReduceMoveOnly(), initial).result();
         QCOMPARE(result, sum);
     }
     {
         const auto result =
-                QtConcurrent::filteredReduced<int>(intList.begin(), intList.end(),
-                                                   KeepEvenIntegersMoveOnly(),
-                                                   IntSumReduceMoveOnly(), initial).result();
+                QtConcurrent::filteredReduced(intList.begin(), intList.end(),
+                                              KeepEvenIntegersMoveOnly(),
+                                              IntSumReduceMoveOnly(), initial).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial);
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial);
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(),
-                initial);
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(),
+                    initial);
         QCOMPARE(result, sum);
     }
 
     QThreadPool pool;
     {
         const auto result =
-                QtConcurrent::filteredReduced<int>(&pool, intList, KeepEvenIntegersMoveOnly(),
-                                                   IntSumReduceMoveOnly(), initial).result();
+                QtConcurrent::filteredReduced(&pool, intList, KeepEvenIntegersMoveOnly(),
+                                              IntSumReduceMoveOnly(), initial).result();
         QCOMPARE(result, sum);
     }
     {
         const auto result =
-                QtConcurrent::filteredReduced<int>(
+                QtConcurrent::filteredReduced(
                     &pool, intList.begin(), intList.end(),
                     KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial);
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial);
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingFilteredReduced<int>(
-                &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(),
-                IntSumReduceMoveOnly(), initial);
+        const auto result = QtConcurrent::blockingFilteredReduced(
+                    &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(),
+                    IntSumReduceMoveOnly(), initial);
         QCOMPARE(result, sum);
     }
 }
diff --git a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
index 5bcf90c0d6d..93cf1bf99e8 100644
--- a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
+++ b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
@@ -761,22 +761,45 @@ public:
 template <typename SourceObject, typename ResultObject, typename MapObject, typename ReduceObject>
 void testMappedReduced(const QList<SourceObject> &sourceObjectList, const ResultObject &expectedResult, MapObject mapObject, ReduceObject reduceObject)
 {
-    const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(
-                sourceObjectList, mapObject, reduceObject).result();
-    QCOMPARE(result1, expectedResult);
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(
+                    sourceObjectList, mapObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
 
-    const ResultObject result2 = QtConcurrent::mappedReduced<ResultObject>(
-                                         sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                                         mapObject, reduceObject).result();
-    QCOMPARE(result2, expectedResult);
+        const ResultObject result2 = QtConcurrent::mappedReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject).result();
+        QCOMPARE(result2, expectedResult);
 
-    const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
-                sourceObjectList, mapObject, reduceObject);
-    QCOMPARE(result3, expectedResult);
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    sourceObjectList, mapObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
 
-    const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
-                sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject);
-    QCOMPARE(result4, expectedResult);
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 = QtConcurrent::mappedReduced(
+                    sourceObjectList, mapObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
+
+        const ResultObject result2 = QtConcurrent::mappedReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject).result();
+        QCOMPARE(result2, expectedResult);
+
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced(
+                    sourceObjectList, mapObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
+
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+    }
 }
 
 template <typename SourceObject, typename ResultObject, typename MapObject, typename ReduceObject>
@@ -886,27 +909,57 @@ void testMappedReducedThreadPool(QThreadPool *pool,
                                  MapObject mapObject,
                                  ReduceObject reduceObject)
 {
-    const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(
-                pool, sourceObjectList, mapObject, reduceObject).result();
-    QCOMPARE(result1, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(
+                    pool, sourceObjectList, mapObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result2 =
-            QtConcurrent::mappedReduced<ResultObject>(pool, sourceObjectList.constBegin(),
-                                                      sourceObjectList.constEnd(), mapObject,
-                                                      reduceObject).result();
-    QCOMPARE(result2, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result2 =
+                QtConcurrent::mappedReduced<ResultObject>(pool, sourceObjectList.constBegin(),
+                                                          sourceObjectList.constEnd(), mapObject,
+                                                          reduceObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(pool,
-                sourceObjectList, mapObject, reduceObject);
-    QCOMPARE(result3, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    pool, sourceObjectList, mapObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(pool,
-                sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject);
-    QCOMPARE(result4, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 = QtConcurrent::mappedReduced(
+                    pool, sourceObjectList, mapObject, reduceObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result2 =
+                QtConcurrent::mappedReduced(pool, sourceObjectList.constBegin(),
+                                            sourceObjectList.constEnd(), mapObject,
+                                            reduceObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced(
+                    pool, sourceObjectList, mapObject, reduceObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
 }
 
 int intCube(int x)
@@ -994,46 +1047,46 @@ void tst_QtConcurrentMap::mappedReducedWithMoveOnlyCallable()
     const QList<int> intList { 1, 2, 3 };
     const auto sum = 12;
     {
-        const auto result = QtConcurrent::mappedReduced<int>(
+        const auto result = QtConcurrent::mappedReduced(
                     intList, MultiplyBy2(), IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
         const auto result =
-                QtConcurrent::mappedReduced<int>(intList.begin(), intList.end(),
-                                                 MultiplyBy2(), IntSumReduceMoveOnly()).result();
+                QtConcurrent::mappedReduced(intList.begin(), intList.end(),
+                                            MultiplyBy2(), IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(intList, MultiplyBy2(),
-                                                                     IntSumReduceMoveOnly());
+        const auto result = QtConcurrent::blockingMappedReduced(intList, MultiplyBy2(),
+                                                                IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(
+        const auto result = QtConcurrent::blockingMappedReduced(
                 intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
 
     QThreadPool pool;
     {
-        const auto result = QtConcurrent::mappedReduced<int>(&pool, intList, MultiplyBy2(),
-                                                             IntSumReduceMoveOnly()).result();
+        const auto result = QtConcurrent::mappedReduced(&pool, intList, MultiplyBy2(),
+                                                        IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
         const auto result =
-                QtConcurrent::mappedReduced<int>(&pool, intList.begin(), intList.end(),
-                                                 MultiplyBy2(), IntSumReduceMoveOnly()).result();
+                QtConcurrent::mappedReduced(&pool, intList.begin(), intList.end(),
+                                            MultiplyBy2(), IntSumReduceMoveOnly()).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(&pool, intList, MultiplyBy2(),
-                                                                     IntSumReduceMoveOnly());
+        const auto result = QtConcurrent::blockingMappedReduced(&pool, intList, MultiplyBy2(),
+                                                                IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(
+        const auto result = QtConcurrent::blockingMappedReduced(
                 &pool, intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly());
         QCOMPARE(result, sum);
     }
@@ -1096,23 +1149,49 @@ void testMappedReducedInitialValue(const QList<SourceObject> &sourceObjectList,
                                    ReduceObject reduceObject,
                                    InitialObject &&initialObject)
 {
-    const ResultObject result1 =
-            QtConcurrent::mappedReduced<ResultObject>(sourceObjectList, mapObject, reduceObject,
-                                                      initialObject).result();
-    QCOMPARE(result1, expectedResult);
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 =
+                QtConcurrent::mappedReduced<ResultObject>(sourceObjectList, mapObject, reduceObject,
+                                                          initialObject).result();
+        QCOMPARE(result1, expectedResult);
 
-    const ResultObject result2 = QtConcurrent::mappedReduced<ResultObject>(
-                                         sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                                         mapObject, reduceObject, initialObject).result();
-    QCOMPARE(result2, expectedResult);
+        const ResultObject result2 = QtConcurrent::mappedReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
 
-    const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
-                sourceObjectList, mapObject, reduceObject, initialObject);
-    QCOMPARE(result3, expectedResult);
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    sourceObjectList, mapObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
 
-    const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
-                sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject, initialObject);
-    QCOMPARE(result4, expectedResult);
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 =
+                QtConcurrent::mappedReduced(sourceObjectList, mapObject, reduceObject,
+                                            initialObject).result();
+        QCOMPARE(result1, expectedResult);
+
+        const ResultObject result2 = QtConcurrent::mappedReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
+
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced(
+                    sourceObjectList, mapObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
+
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced(
+                    sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+    }
 }
 
 template <typename SourceObject, typename ResultObject, typename InitialObject, typename MapObject, typename ReduceObject>
@@ -1234,28 +1313,57 @@ void testMappedReducedInitialValueThreadPool(QThreadPool *pool,
                                              ReduceObject reduceObject,
                                              InitialObject &&initialObject)
 {
-    const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(
-                pool, sourceObjectList, mapObject, reduceObject, initialObject).result();
-    QCOMPARE(result1, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    // Result type is passed explicitly
+    {
+        const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(
+                    pool, sourceObjectList, mapObject, reduceObject, initialObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result2 =
-            QtConcurrent::mappedReduced<ResultObject>(pool, sourceObjectList.constBegin(),
-                                                      sourceObjectList.constEnd(), mapObject,
-                                                      reduceObject, initialObject).result();
-    QCOMPARE(result2, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result2 =
+                QtConcurrent::mappedReduced<ResultObject>(pool, sourceObjectList.constBegin(),
+                                                          sourceObjectList.constEnd(), mapObject,
+                                                          reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
-                pool, sourceObjectList, mapObject, reduceObject, initialObject);
-    QCOMPARE(result3, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    pool, sourceObjectList, mapObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
 
-    const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
-                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
-                mapObject, reduceObject, initialObject);
-    QCOMPARE(result4, expectedResult);
-    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
+
+    // Result type is deduced
+    {
+        const ResultObject result1 = QtConcurrent::mappedReduced(
+                    pool, sourceObjectList, mapObject, reduceObject, initialObject).result();
+        QCOMPARE(result1, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result2 =
+                QtConcurrent::mappedReduced(pool, sourceObjectList.constBegin(),
+                                            sourceObjectList.constEnd(), mapObject,
+                                            reduceObject, initialObject).result();
+        QCOMPARE(result2, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result3 = QtConcurrent::blockingMappedReduced(
+                    pool, sourceObjectList, mapObject, reduceObject, initialObject);
+        QCOMPARE(result3, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+        const ResultObject result4 = QtConcurrent::blockingMappedReduced(
+                    pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                    mapObject, reduceObject, initialObject);
+        QCOMPARE(result4, expectedResult);
+        QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+    }
 }
 
 void tst_QtConcurrentMap::mappedReducedInitialValueThreadPool()
@@ -1341,50 +1449,50 @@ void tst_QtConcurrentMap::mappedReducedInitialValueWithMoveOnlyCallable()
     const auto sum = 22;
     {
         const auto result =
-                QtConcurrent::mappedReduced<int>(intList, MultiplyBy2(),
-                                                 IntSumReduceMoveOnly(), initialValue).result();
+                QtConcurrent::mappedReduced(intList, MultiplyBy2(),
+                                            IntSumReduceMoveOnly(), initialValue).result();
         QCOMPARE(result, sum);
     }
     {
         const auto result =
-                QtConcurrent::mappedReduced<int>(intList.begin(), intList.end(), MultiplyBy2(),
-                                                 IntSumReduceMoveOnly(), initialValue).result();
+                QtConcurrent::mappedReduced(intList.begin(), intList.end(), MultiplyBy2(),
+                                            IntSumReduceMoveOnly(), initialValue).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(
-                intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue);
+        const auto result = QtConcurrent::blockingMappedReduced(
+                    intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue);
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(
-                intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(),
-                initialValue);
+        const auto result = QtConcurrent::blockingMappedReduced(
+                    intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(),
+                    initialValue);
         QCOMPARE(result, sum);
     }
 
     QThreadPool pool;
     {
         const auto result =
-                QtConcurrent::mappedReduced<int>(&pool, intList, MultiplyBy2(),
-                                                 IntSumReduceMoveOnly(), initialValue).result();
+                QtConcurrent::mappedReduced(&pool, intList, MultiplyBy2(),
+                                            IntSumReduceMoveOnly(), initialValue).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::mappedReduced<int>(&pool, intList.begin(), intList.end(),
-                                                             MultiplyBy2(), IntSumReduceMoveOnly(),
-                                                             initialValue).result();
+        const auto result = QtConcurrent::mappedReduced(&pool, intList.begin(), intList.end(),
+                                                        MultiplyBy2(), IntSumReduceMoveOnly(),
+                                                        initialValue).result();
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(
-                &pool, intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue);
+        const auto result = QtConcurrent::blockingMappedReduced(
+                    &pool, intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue);
         QCOMPARE(result, sum);
     }
     {
-        const auto result = QtConcurrent::blockingMappedReduced<int>(
-                &pool, intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(),
-                initialValue);
+        const auto result = QtConcurrent::blockingMappedReduced(
+                    &pool, intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(),
+                    initialValue);
         QCOMPARE(result, sum);
     }
 }