diff --git a/src/concurrent/qtconcurrentfunctionwrappers.h b/src/concurrent/qtconcurrentfunctionwrappers.h
index 194d020fb28..a00c1c6edc1 100644
--- a/src/concurrent/qtconcurrentfunctionwrappers.h
+++ b/src/concurrent/qtconcurrentfunctionwrappers.h
@@ -146,7 +146,13 @@ struct ReduceResultType<T(C::*)(U) noexcept>
 // -- MapSequenceResultType
 
 template <class InputSequence, class MapFunctor>
-struct MapSequenceResultType;
+struct MapSequenceResultType
+{
+    static_assert(std::is_same_v<typename InputSequence::value_type,
+                                 QtPrivate::MapResultType<InputSequence, MapFunctor>>,
+                  "Couldn't deduce the output sequence type, you must specify it explicitly.");
+    typedef InputSequence ResultType;
+};
 
 template <class MapFunctor>
 struct MapSequenceResultType<QStringList, MapFunctor>
diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
index 6c278849776..a6c575fd4d7 100644
--- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
+++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
@@ -102,6 +102,19 @@ void tst_QtConcurrentFilter::filter()
     CHECK_FAIL("member");
     testFilter(intList, intListEven, lambdaIsEven);
     CHECK_FAIL("lambda");
+
+    // non-template sequences
+    {
+
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        QtConcurrent::filter(list, keepEvenNumbers).waitForFinished();
+        QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        QtConcurrent::blockingFilter(list, keepEvenNumbers);
+        QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
+    }
 }
 
 static QSemaphore semaphore(1);
@@ -179,6 +192,19 @@ void tst_QtConcurrentFilter::filterThreadPool()
     CHECK_FAIL("function");
     testFilterThreadPool(&pool, intList, intListEven, lambdaIsOdd);
     CHECK_FAIL("lambda");
+
+    // non-template sequences
+    {
+
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        QtConcurrent::filter(list, keepEvenIntegers).waitForFinished();
+        QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        QtConcurrent::blockingFilter(list, keepEvenIntegers);
+        QCOMPARE(list, NonTemplateSequence({ 2, 4 }));
+    }
 }
 
 void tst_QtConcurrentFilter::filterWithMoveOnlyCallable()
@@ -254,6 +280,18 @@ void tst_QtConcurrentFilter::filtered()
     testFiltered(intList, intListEven, lambdaIsEven);
     CHECK_FAIL("lambda");
 
+    // non-template sequences
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto future = QtConcurrent::filtered(list, keepEvenIntegers);
+        QCOMPARE(future.results(), QList({ 2, 4 }));
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto result = QtConcurrent::blockingFiltered(list, keepEvenIntegers);
+        QCOMPARE(result, NonTemplateSequence({ 2, 4 }));
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::filtered(std::vector { 1, 2, 3, 4 }, keepEvenIntegers);
@@ -329,6 +367,18 @@ void tst_QtConcurrentFilter::filteredThreadPool()
     testFilteredThreadPool(&pool, intList, intListEven, lambdaIsOdd);
     CHECK_FAIL("lambda");
 
+    // non-template sequences
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto future = QtConcurrent::filtered(&pool, list, keepEvenIntegers);
+        QCOMPARE(future.results(), QList({ 2, 4 }));
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto result = QtConcurrent::blockingFiltered(&pool, list, keepEvenIntegers);
+        QCOMPARE(result, NonTemplateSequence({ 2, 4 }));
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::filtered(&pool, std::vector { 1, 2, 3, 4 }, keepEvenIntegers);
@@ -537,6 +587,18 @@ void tst_QtConcurrentFilter::filteredReduced()
     testFilteredReduced(intList, intSum, lambdaIsEven, lambdaIntSumReduce);
     CHECK_FAIL("lambda-lambda");
 
+    // non-template sequences
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto future = QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce);
+        QCOMPARE(future.result(), intSum);
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto result = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce);
+        QCOMPARE(result, intSum);
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::filteredReduced(std::vector { 1, 2, 3, 4 }, keepEvenIntegers,
@@ -636,6 +698,19 @@ void tst_QtConcurrentFilter::filteredReducedThreadPool()
     testFilteredReducedThreadPool(&pool, intList, intSum, lambdaIsOdd, lambdaSumReduce);
     CHECK_FAIL("lambda-lambda");
 
+    // non-template sequences
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto future = QtConcurrent::filteredReduced(&pool, list, keepOddIntegers, intSumReduce);
+        QCOMPARE(future.result(), intSum);
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto result =
+                QtConcurrent::blockingFilteredReduced(&pool, list, keepOddIntegers, intSumReduce);
+        QCOMPARE(result, intSum);
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::filteredReduced(&pool, std::vector { 1, 2, 3, 4 },
@@ -910,6 +985,20 @@ void tst_QtConcurrentFilter::filteredReducedInitialValue()
                                     lambdaIntSumReduce, intInitial);
     CHECK_FAIL("lambda-lambda");
 
+    // non-template sequences
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto future =
+                QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce, intInitial);
+        QCOMPARE(future.result(), intSum);
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto result = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce,
+                                                            intInitial);
+        QCOMPARE(result, intSum);
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::filteredReduced(std::vector { 1, 2, 3, 4 }, keepEvenIntegers,
@@ -1021,6 +1110,20 @@ void tst_QtConcurrentFilter::filteredReducedInitialValueThreadPool()
                                               lambdaSumReduce, intInitial);
     CHECK_FAIL("lambda-lambda");
 
+    // non-template sequences
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto future =
+                QtConcurrent::filteredReduced(list, keepOddIntegers, intSumReduce, intInitial);
+        QCOMPARE(future.result(), intSum);
+    }
+    {
+        NonTemplateSequence list({ 1, 2, 3, 4 });
+        auto result = QtConcurrent::blockingFilteredReduced(list, keepOddIntegers, intSumReduce,
+                                                            intInitial);
+        QCOMPARE(result, intSum);
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::filteredReduced(&pool, std::vector { 1, 2, 3, 4 },
diff --git a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
index 5bcf90c0d6d..8fdfd0ccc29 100644
--- a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
+++ b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
@@ -201,6 +201,13 @@ void tst_QtConcurrentMap::map()
         QCOMPARE(moveOnlyVector, MoveOnlyVector<int>({ 2, 4, 6 }));
     }
 
+    // non-template sequences
+    {
+        NonTemplateSequence list { 1, 2, 3 };
+        QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished();
+        QCOMPARE(list, NonTemplateSequence({ 2, 4, 6 }));
+    }
+
 #if 0
     // not allowed: map() with immutable sequences makes no sense
     {
@@ -331,6 +338,13 @@ void tst_QtConcurrentMap::blockingMap()
         QCOMPARE(list, QList<int>() << 1 << 2 << 3);
     }
 
+    // non-template sequences
+    {
+        NonTemplateSequence list { 1, 2, 3 };
+        QtConcurrent::blockingMap(list, multiplyBy2InPlace);
+        QCOMPARE(list, NonTemplateSequence({ 2, 4, 6 }));
+    }
+
 #if 0
     // not allowed: map() with immutable sequences makes no sense
     {
@@ -563,6 +577,17 @@ void tst_QtConcurrentMap::mapped()
     CHECK_FAIL("member");
 #endif
 
+    {
+        // non-template sequences
+        NonTemplateSequence list { 1, 2, 3 };
+
+        auto future = QtConcurrent::mapped(list, multiplyBy2);
+        QCOMPARE(future.results(), QList({ 2, 4, 6 }));
+
+        auto result = QtConcurrent::blockingMapped(list, multiplyBy2);
+        QCOMPARE(result, NonTemplateSequence({ 2, 4, 6 }));
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::mapped(std::vector { 1, 2, 3 }, multiplyBy2);
@@ -666,6 +691,17 @@ void tst_QtConcurrentMap::mappedThreadPool()
     testMappedThreadPool(&pool, intList, intListMultipiedBy3, lambdaMultiplyBy3);
     CHECK_FAIL("lambda");
 
+    {
+        // non-template sequences
+        NonTemplateSequence list { 1, 2, 3 };
+
+        auto future = QtConcurrent::mapped(&pool, list, multiplyBy2);
+        QCOMPARE(future.results(), QList({ 2, 4, 6 }));
+
+        auto result = QtConcurrent::blockingMapped(&pool, list, multiplyBy2);
+        QCOMPARE(result, NonTemplateSequence({ 2, 4, 6 }));
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::mapped(&pool, std::vector { 1, 2, 3 }, multiplyBy2);
@@ -857,6 +893,17 @@ void tst_QtConcurrentMap::mappedReduced()
     testMappedReduced(intList, sumOfSquares, lambdaSquare, lambdaSumReduce);
     CHECK_FAIL("lambda-lambda");
 
+    {
+        // non-template sequences
+        NonTemplateSequence list { 1, 2, 3 };
+
+        auto future = QtConcurrent::mappedReduced(list, multiplyBy2, intSumReduce);
+        QCOMPARE(future.result(), 12);
+
+        auto result = QtConcurrent::blockingMappedReduced(list, multiplyBy2, intSumReduce);
+        QCOMPARE(result, 12);
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::mappedReduced(std::vector { 1, 2, 3 }, intSquare, intSumReduce);
@@ -966,6 +1013,17 @@ void tst_QtConcurrentMap::mappedReducedThreadPool()
     testMappedReducedThreadPool(&pool, intList, sumOfCubes, lambdaCube, lambdaSumReduce);
     CHECK_FAIL("lambda-lambda");
 
+    {
+        // non-template sequences
+        NonTemplateSequence list { 1, 2, 3 };
+
+        auto future = QtConcurrent::mappedReduced(&pool, list, multiplyBy2, intSumReduce);
+        QCOMPARE(future.result(), 12);
+
+        auto result = QtConcurrent::blockingMappedReduced(&pool, list, multiplyBy2, intSumReduce);
+        QCOMPARE(result, 12);
+    }
+
     {
         // rvalue sequences
         auto future =
@@ -1203,6 +1261,18 @@ void tst_QtConcurrentMap::mappedReducedInitialValue()
     testMappedReducedInitialValue(intList, sumOfSquares, lambdaSquare, lambdaSumReduce, intInitial);
     CHECK_FAIL("lambda-lambda");
 
+    {
+        // non-template sequences
+        NonTemplateSequence list { 1, 2, 3 };
+
+        auto future = QtConcurrent::mappedReduced(list, multiplyBy2, intSumReduce, intInitial);
+        QCOMPARE(future.result(), intInitial + 12);
+
+        auto result =
+                QtConcurrent::blockingMappedReduced(list, multiplyBy2, intSumReduce, intInitial);
+        QCOMPARE(result, intInitial + 12);
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::mappedReduced(std::vector { 1, 2, 3 }, intSquare, intSumReduce,
@@ -1311,6 +1381,19 @@ void tst_QtConcurrentMap::mappedReducedInitialValueThreadPool()
                                             lambdaSumReduce, intInitial);
     CHECK_FAIL("lambda-lambda");
 
+    {
+        // non-template sequences
+        NonTemplateSequence list { 1, 2, 3 };
+
+        auto future =
+                QtConcurrent::mappedReduced(&pool, list, multiplyBy2, intSumReduce, intInitial);
+        QCOMPARE(future.result(), intInitial + 12);
+
+        auto result = QtConcurrent::blockingMappedReduced(&pool, list, multiplyBy2, intSumReduce,
+                                                          intInitial);
+        QCOMPARE(result, intInitial + 12);
+    }
+
     {
         // rvalue sequences
         auto future = QtConcurrent::mappedReduced(&pool, std::vector { 1, 2, 3 }, intCube,
diff --git a/tests/auto/concurrent/testhelper_functions.h b/tests/auto/concurrent/testhelper_functions.h
index e890053e5ca..a34e0f4ce9d 100644
--- a/tests/auto/concurrent/testhelper_functions.h
+++ b/tests/auto/concurrent/testhelper_functions.h
@@ -28,6 +28,8 @@
 #ifndef FUNCTIONS_H
 #define FUNCTIONS_H
 
+#include <QList>
+
 #include <vector>
 
 bool keepEvenIntegers(const int &x)
@@ -196,4 +198,11 @@ private:
     std::vector<T> data;
 };
 
+struct NonTemplateSequence : public QList<int>
+{
+    NonTemplateSequence() = default;
+
+    NonTemplateSequence(std::initializer_list<int> args) : QList(args) { }
+};
+
 #endif