diff --git a/src/libs/utils/algorithm.h b/src/libs/utils/algorithm.h
index 8541e71ed1e..3a8bdbd84e9 100644
--- a/src/libs/utils/algorithm.h
+++ b/src/libs/utils/algorithm.h
@@ -205,118 +205,90 @@ inserter(QSet<X> &container)
     return QSetInsertIterator<QSet<X>>(container);
 }
 
-// abstraction to treat Container<T> and QStringList similarly
-template<typename T>
-struct ContainerType
-{
+// Result type of transform operation
 
-};
+template<template<typename> class Container, template<typename> class InputContainer, typename IT, typename Function>
+using ResultContainer = Container<std::decay_t<std::result_of_t<Function(IT)>>>;
 
-// specialization for qt container T_Container<T_Type>
-template<template<typename> class T_Container, typename T_Type>
-struct ContainerType<T_Container<T_Type>>
-{
-    template<class F, template<typename> class C = T_Container>
-    using ResultOfTransform = C<std::decay_t<std::result_of_t<F (T_Type)>>>;
-
-    template<class R>
-    using ResultOfTransformPMF = T_Container<std::decay_t<R>>;
-};
-
-// specialization for QStringList
-template<>
-struct ContainerType<QStringList> : ContainerType<QList<QString>>
-{
-};
-
-}
-
-// actual implementation of transform
-template<typename C, // result container type
-         typename SC> // input container type
-struct TransformImpl {
-    template <typename F>
-    Q_REQUIRED_RESULT
-    static C call(const SC &container, F function)
-    {
-        C result;
-        result.reserve(container.size());
-        std::transform(container.begin(), container.end(),
-                       inserter(result),
-                       function);
-        return result;
-    }
-
-    template <typename R, typename S>
-    Q_REQUIRED_RESULT
-    static C call(const SC &container, R (S::*p)() const)
-    {
-        return call(container, std::mem_fn(p));
-    }
-
-};
-
-// same container type for input and output, e.g. transforming a QList<QString> into QList<int>
-// or QStringList -> QList<>
-template<typename C, // container
-         typename F>
-Q_REQUIRED_RESULT
-decltype(auto) transform(const C &container, F function)
-{
-    return TransformImpl<
-                typename ContainerType<C>::template ResultOfTransform<F>,
-                C
-            >::call(container, function);
-}
-
-// same container type for member function pointer
-template<typename C,
-        typename R,
-        typename S>
-Q_REQUIRED_RESULT
-decltype(auto) transform(const C &container, R (S::*p)() const)
-{
-    return TransformImpl<
-                typename ContainerType<C>::template ResultOfTransformPMF<R>,
-                C
-            >::call(container, p);
-}
-
-template<typename C,
-         typename R,
-         typename S>
-Q_REQUIRED_RESULT
-decltype(auto) transform(const C &container, R S::*member)
-{
-    return transform(container, std::mem_fn(member));
-}
+} // anonymous
 
 // different container types for input and output, e.g. transforming a QList into a QSet
 template<template<typename> class C, // result container type
-         typename SC, // input container type
+         template<typename> class SC, // input container type
+         typename T, // input value type
          typename F> // function type
 Q_REQUIRED_RESULT
-decltype(auto) transform(const SC &container, F function)
+decltype(auto) transform(const SC<T> &container, F function)
 {
-    return TransformImpl<
-                typename ContainerType<SC>::template ResultOfTransform<F, C>,
-                SC
-            >::call(container, function);
+    ResultContainer<C, SC, T, F> result;
+    result.reserve(container.size());
+    std::transform(container.begin(), container.end(),
+                   inserter(result),
+                   function);
+    return result;
 }
 
 // different container types for input and output, e.g. transforming a QList into a QSet
 // for member function pointers
 template<template<typename> class C, // result container type
-         typename SC, // input container type
+         template<typename> class SC, // input container type
+         typename T, // input value type
          typename R,
          typename S>
 Q_REQUIRED_RESULT
-decltype(auto) transform(const SC &container, R (S::*p)() const)
+decltype(auto) transform(const SC<T> &container, R (S::*p)() const)
 {
-    return TransformImpl<
-                C<std::decay_t<R>>,
-                SC
-            >::call(container, p);
+    return transform<C, SC, T>(container, std::mem_fn(p));
+}
+
+// same container type for input and output, e.g. transforming a QList<QString> into QList<int>
+// or QStringList -> QList<>
+template<template<typename> class C, // container
+         typename T, // container value type
+         typename F>
+Q_REQUIRED_RESULT
+decltype(auto) transform(const C<T> &container, F function)
+{
+    return transform<C, C, T>(container, function);
+}
+
+// same container type for member function pointer
+template<template<typename> class C, // container
+         typename T, // container value type
+         typename R,
+         typename S>
+Q_REQUIRED_RESULT
+decltype(auto) transform(const C<T> &container, R (S::*p)() const)
+{
+    return transform<C, C, T>(container, std::mem_fn(p));
+}
+
+// same container type for members
+template<template<typename> class C, // container
+         typename T, // container value type
+         typename R,
+         typename S>
+Q_REQUIRED_RESULT
+decltype(auto) transform(const C<T> &container, R S::*member)
+{
+    return transform<C, C, T>(container, std::mem_fn(member));
+}
+
+// QStringList different containers
+template<template<typename> class C, // result container type
+         typename F>
+Q_REQUIRED_RESULT
+decltype(auto) transform(const QStringList &container, F function)
+{
+    return transform<C, QList, QString>(container, function);
+}
+
+// QStringList -> QList
+template<typename F>
+Q_REQUIRED_RESULT
+decltype(auto) transform(const QStringList &container, F function)
+{
+    return Utils::transform<QList, QList, QString>(container, function);
 }
 
 //////////////////